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 "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\n", pInfo->cbSize);
 785         ok(!pInfo->dwFlags, "pInfo->dwFlags=%08lx, expected 0\n", pInfo->dwFlags);
 786         pInfo->dwFlags = DOCHOSTUIFLAG_DISABLE_HELP_MENU | DOCHOSTUIFLAG_DISABLE_SCRIPT_INACTIVE
 787             | DOCHOSTUIFLAG_ACTIVATE_CLIENTHIT_ONLY | DOCHOSTUIFLAG_ENABLE_INPLACE_NAVIGATION
 788             | DOCHOSTUIFLAG_IME_ENABLE_RECONVERSION;
 789         ok(!pInfo->dwDoubleClick, "pInfo->dwDoubleClick=%08lx, expected 0\n", pInfo->dwDoubleClick);
 790         ok(!pInfo->pchHostCss, "pInfo->pchHostCss=%p, expected NULL\n", pInfo->pchHostCss);
 791         ok(!pInfo->pchHostNS, "pInfo->pchhostNS=%p, expected NULL\n", pInfo->pchHostNS);
 792     }
 793     return S_OK;
 794 }
 795
 796 static HRESULT WINAPI DocHostUIHandler_ShowUI(IDocHostUIHandler2 *iface, DWORD dwID,
 797         IOleInPlaceActiveObject *pActiveObject, IOleCommandTarget *pCommandTarget,
 798         IOleInPlaceFrame *pFrame, IOleInPlaceUIWindow *pDoc)
 799 {
 800     CHECK_EXPECT(ShowUI);
 801
 802     ok(dwID == 0, "dwID=%ld, expected 0\n", dwID);
 803     ok(pActiveObject != NULL, "pActiveObject = NULL\n");
 804     ok(pCommandTarget != NULL, "pCommandTarget = NULL\n");
 805     ok(pFrame == &InPlaceFrame, "pFrame=%p, expected %p\n", pFrame, &InPlaceFrame);
 806     ok(pDoc == NULL, "pDoc=%p, expected NULL\n", pDoc);
 807
 808     return S_OK;
 809 }
 810
 811 static HRESULT WINAPI DocHostUIHandler_HideUI(IDocHostUIHandler2 *iface)
 812 {
 813     CHECK_EXPECT(HideUI);
 814     return S_OK;
 815 }
 816
 817 static HRESULT WINAPI DocHostUIHandler_UpdateUI(IDocHostUIHandler2 *iface)
 818 {
 819     CHECK_EXPECT(UpdateUI);
 820     return S_OK;
 821 }
 822
 823 static HRESULT WINAPI DocHostUIHandler_EnableModeless(IDocHostUIHandler2 *iface, BOOL fEnable)
 824 {
 825     ok(0, "unexpected call\n");
 826     return E_NOTIMPL;
 827 }
 828
 829 static HRESULT WINAPI DocHostUIHandler_OnDocWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
 830 {
 831     ok(0, "unexpected call\n");
 832     return E_NOTIMPL;
 833 }
 834
 835 static HRESULT WINAPI DocHostUIHandler_OnFrameWindowActivate(IDocHostUIHandler2 *iface, BOOL fActivate)
 836 {
 837     ok(0, "unexpected call\n");
 838     return E_NOTIMPL;
 839 }
 840
 841 static HRESULT WINAPI DocHostUIHandler_ResizeBorder(IDocHostUIHandler2 *iface, LPCRECT prcBorder,
 842         IOleInPlaceUIWindow *pUIWindow, BOOL fRameWindow)
 843 {
 844     ok(0, "unexpected call\n");
 845     return E_NOTIMPL;
 846 }
 847
 848 static HRESULT WINAPI DocHostUIHandler_TranslateAccelerator(IDocHostUIHandler2 *iface, LPMSG lpMsg,
 849         const GUID *pguidCmdGroup, DWORD nCmdID)
 850 {
 851     ok(0, "unexpected call\n");
 852     return E_NOTIMPL;
 853 }
 854
 855 static HRESULT WINAPI DocHostUIHandler_GetOptionKeyPath(IDocHostUIHandler2 *iface,
 856         LPOLESTR *pchKey, DWORD dw)
 857 {
 858     CHECK_EXPECT(GetOptionKeyPath);
 859     ok(pchKey != NULL, "pchKey = NULL\n");
 860     ok(!dw, "dw=%ld, expected 0\n", dw);
 861     if(pchKey)
 862         ok(!*pchKey, "*pchKey=%p, expected NULL\n", *pchKey);
 863     return S_OK;
 864 }
 865
 866 static HRESULT WINAPI DocHostUIHandler_GetDropTarget(IDocHostUIHandler2 *iface,
 867         IDropTarget *pDropTarget, IDropTarget **ppDropTarget)
 868 {
 869     CHECK_EXPECT(GetDropTarget);
 870     /* TODO */
 871     return E_NOTIMPL;
 872 }
 873
 874 static HRESULT WINAPI DocHostUIHandler_GetExternal(IDocHostUIHandler2 *iface, IDispatch **ppDispatch)
 875 {
 876     ok(0, "unexpected call\n");
 877     return E_NOTIMPL;
 878 }
 879
 880 static HRESULT WINAPI DocHostUIHandler_TranslateUrl(IDocHostUIHandler2 *iface, DWORD dwTranslate,
 881         OLECHAR *pchURLIn, OLECHAR **ppchURLOut)
 882 {
 883     ok(0, "unexpected call\n");
 884     return E_NOTIMPL;
 885 }
 886
 887 static HRESULT WINAPI DocHostUIHandler_FilterDataObject(IDocHostUIHandler2 *iface, IDataObject *pDO,
 888         IDataObject **ppPORet)
 889 {
 890     ok(0, "unexpected call\n");
 891     return E_NOTIMPL;
 892 }
 893
 894 static HRESULT WINAPI DocHostUIHandler_GetOverrideKeyPath(IDocHostUIHandler2 *iface,
 895         LPOLESTR *pchKey, DWORD dw)
 896 {
 897     CHECK_EXPECT(GetOverrideKeyPath);
 898     ok(pchKey != NULL, "pchKey = NULL\n");
 899     if(pchKey)
 900         ok(!*pchKey, "*pchKey=%p, expected NULL\n", *pchKey);
 901     ok(!dw, "dw=%ld, xepected 0\n", dw);
 902     return S_OK;
 903 }
 904
 905 static const IDocHostUIHandler2Vtbl DocHostUIHandlerVtbl = {
 906     DocHostUIHandler_QueryInterface,
 907     DocHostUIHandler_AddRef,
 908     DocHostUIHandler_Release,
 909     DocHostUIHandler_ShowContextMenu,
 910     DocHostUIHandler_GetHostInfo,
 911     DocHostUIHandler_ShowUI,
 912     DocHostUIHandler_HideUI,
 913     DocHostUIHandler_UpdateUI,
 914     DocHostUIHandler_EnableModeless,
 915     DocHostUIHandler_OnDocWindowActivate,
 916     DocHostUIHandler_OnFrameWindowActivate,
 917     DocHostUIHandler_ResizeBorder,
 918     DocHostUIHandler_TranslateAccelerator,
 919     DocHostUIHandler_GetOptionKeyPath,
 920     DocHostUIHandler_GetDropTarget,
 921     DocHostUIHandler_GetExternal,
 922     DocHostUIHandler_TranslateUrl,
 923     DocHostUIHandler_FilterDataObject,
 924     DocHostUIHandler_GetOverrideKeyPath
 925 };
 926
 927 static IDocHostUIHandler2 DocHostUIHandler = { &DocHostUIHandlerVtbl };
 928
 929 static HRESULT WINAPI OleCommandTarget_QueryInterface(IOleCommandTarget *iface,
 930         REFIID riid, void **ppv)
 931 {
 932     return QueryInterface(riid, ppv);
 933 }
 934
 935 static ULONG WINAPI OleCommandTarget_AddRef(IOleCommandTarget *iface)
 936 {
 937     return 2;
 938 }
 939
 940 static ULONG WINAPI OleCommandTarget_Release(IOleCommandTarget *iface)
 941 {
 942     return 1;
 943 }
 944
 945 static HRESULT WINAPI OleCommandTarget_QueryStatus(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
 946         ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
 947 {
 948     ok(!pguidCmdGroup, "pguidCmdGroup != MULL\n");
 949     ok(cCmds == 1, "cCmds=%ld, expected 1\n", cCmds);
 950     ok(!pCmdText, "pCmdText != NULL\n");
 951
 952     switch(prgCmds[0].cmdID) {
 953     case OLECMDID_SETPROGRESSTEXT:
 954         CHECK_EXPECT(QueryStatus_SETPROGRESSTEXT);
 955         prgCmds[0].cmdf = OLECMDF_ENABLED;
 956         return S_OK;
 957     case OLECMDID_OPEN:
 958         CHECK_EXPECT(QueryStatus_OPEN);
 959         prgCmds[0].cmdf = 0;
 960         return S_OK;
 961     case OLECMDID_NEW:
 962         CHECK_EXPECT(QueryStatus_NEW);
 963         prgCmds[0].cmdf = 0;
 964         return S_OK;
 965     default:
 966         ok(0, "unexpected command %ld\n", prgCmds[0].cmdID);
 967     };
 968
 969     return E_FAIL;
 970 }
 971
 972 static HRESULT WINAPI OleCommandTarget_Exec(IOleCommandTarget *iface, const GUID *pguidCmdGroup,
 973         DWORD nCmdID, DWORD nCmdexecopt, VARIANT *pvaIn, VARIANT *pvaOut)
 974 {
 975     if(!pguidCmdGroup) {
 976         switch(nCmdID) {
 977         case OLECMDID_SETPROGRESSMAX:
 978             CHECK_EXPECT2(Exec_SETPROGRESSMAX);
 979             ok(pvaIn != NULL, "pvaIn == NULL\n");
 980             if(pvaIn) {
 981                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
 982                 if(load_state == LD_NO)
 983                     ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%ld, expected 0\n", V_I4(pvaIn));
 984             }
 985             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
 986             return S_OK;
 987         case OLECMDID_SETPROGRESSPOS:
 988             CHECK_EXPECT2(Exec_SETPROGRESSPOS);
 989             ok(pvaIn != NULL, "pvaIn == NULL\n");
 990             if(pvaIn) {
 991                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
 992                 if(load_state == LD_NO)
 993                     ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%ld, expected 0\n", V_I4(pvaIn));
 994             }
 995             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
 996             return S_OK;
 997         case OLECMDID_HTTPEQUIV_DONE:
 998             CHECK_EXPECT(Exec_HTTPEQUIV_DONE);
 999             /* TODO */
1000             return S_OK;
1001         case OLECMDID_SETDOWNLOADSTATE:
1002             CHECK_EXPECT2(Exec_SETDOWNLOADSTATE);
1003             /* TODO */
1004             return S_OK;
1005         case OLECMDID_UPDATECOMMANDS:
1006             CHECK_EXPECT(Exec_UPDATECOMMANDS);
1007             /* TODO */
1008             return S_OK;
1009         case OLECMDID_SETTITLE:
1010             CHECK_EXPECT2(Exec_SETTITLE);
1011             /* TODO */
1012             return S_OK;
1013         case OLECMDID_HTTPEQUIV:
1014             CHECK_EXPECT2(Exec_HTTPEQUIV);
1015             /* TODO */
1016             return S_OK;
1017         default:
1018             ok(0, "unexpected command %ld\n", nCmdID);
1019             return E_FAIL;
1020         };
1021     }
1022
1023     if(IsEqualGUID(&CGID_ShellDocView, pguidCmdGroup)) {
1024         switch(nCmdID) {
1025         case 37:
1026             CHECK_EXPECT(Exec_ShellDocView_37);
1027             ok(pvaOut == NULL, "pvaOut=%p, expected NULL\n", pvaOut);
1028             ok(pvaIn != NULL, "pvaIn == NULL\n");
1029             if(pvaIn) {
1030                 ok(V_VT(pvaIn) == VT_I4, "V_VT(pvaIn)=%d, expected VT_I4\n", V_VT(pvaIn));
1031                 ok(V_I4(pvaIn) == 0, "V_I4(pvaIn)=%ld, expected 0\n", V_I4(pvaIn));
1032             }
1033             return S_OK;
1034         default:
1035             ok(0, "unexpected command %ld\n", nCmdID);
1036             return E_FAIL;
1037         };
1038     }
1039
1040     if(IsEqualGUID(&CGID_MSHTML, pguidCmdGroup)) {
1041         switch(nCmdID) {
1042         case 2315:
1043             CHECK_EXPECT(Exec_MSHTML_2315);
1044             /* TODO */
1045             return S_OK;
1046         default:
1047             ok(0, "unexpected command %ld\n", nCmdID);
1048         };
1049     }
1050
1051     if(IsEqualGUID(&CGID_Undocumented, pguidCmdGroup))
1052         return E_FAIL; /* TODO */
1053
1054     ok(0, "unexpected call\n");
1055     return E_NOTIMPL;
1056 }
1057
1058 static IOleCommandTargetVtbl OleCommandTargetVtbl = {
1059     OleCommandTarget_QueryInterface,
1060     OleCommandTarget_AddRef,
1061     OleCommandTarget_Release,
1062     OleCommandTarget_QueryStatus,
1063     OleCommandTarget_Exec
1064 };
1065
1066 static IOleCommandTarget OleCommandTarget = { &OleCommandTargetVtbl };
1067
1068 static HRESULT WINAPI Dispatch_QueryInterface(IDispatch *iface, REFIID riid, void **ppv)
1069 {
1070     return QueryInterface(riid, ppv);
1071 }
1072
1073 static ULONG WINAPI Dispatch_AddRef(IDispatch *iface)
1074 {
1075     return 2;
1076 }
1077
1078 static ULONG WINAPI Dispatch_Release(IDispatch *iface)
1079 {
1080     return 1;
1081 }
1082
1083 static HRESULT WINAPI Dispatch_GetTypeInfoCount(IDispatch *iface, UINT *pctinfo)
1084 {
1085     ok(0, "unexpected call\n");
1086     return E_NOTIMPL;
1087 }
1088
1089 static HRESULT WINAPI Dispatch_GetTypeInfo(IDispatch *iface, UINT iTInfo, LCID lcid,
1090         ITypeInfo **ppTInfo)
1091 {
1092     ok(0, "unexpected call\n");
1093     return E_NOTIMPL;
1094 }
1095
1096 static HRESULT WINAPI Dispatch_GetIDsOfNames(IDispatch *iface, REFIID riid, LPOLESTR *rgszNames,
1097         UINT cNames, LCID lcid, DISPID *rgDispId)
1098 {
1099     ok(0, "unexpected call\n");
1100     return E_NOTIMPL;
1101 }
1102
1103 static HRESULT WINAPI Dispatch_Invoke(IDispatch *iface, DISPID dispIdMember, REFIID riid,
1104         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1105         EXCEPINFO *pExcepInfo, UINT *puArgErr)
1106 {
1107     ok(IsEqualGUID(&IID_NULL, riid), "riid != IID_NULL\n");
1108     ok(pDispParams != NULL, "pDispParams == NULL\n");
1109     ok(pExcepInfo == NULL, "pExcepInfo=%p, expected NULL\n", pExcepInfo);
1110     ok(puArgErr != NULL, "puArgErr == NULL\n");
1111     ok(V_VT(pVarResult) == 0, "V_VT(pVarResult)=%d, expected 0\n", V_VT(pVarResult));
1112     ok(wFlags == DISPATCH_PROPERTYGET, "wFlags=%08x, expected DISPATCH_PROPERTYGET\n", wFlags);
1113
1114     switch(dispIdMember) {
1115     case DISPID_AMBIENT_USERMODE:
1116         CHECK_EXPECT2(Invoke_AMBIENT_USERMODE);
1117         V_VT(pVarResult) = VT_BOOL;
1118         V_BOOL(pVarResult) = VARIANT_TRUE;
1119         return S_OK;
1120     case DISPID_AMBIENT_DLCONTROL:
1121         CHECK_EXPECT2(Invoke_AMBIENT_DLCONTROL);
1122         return E_FAIL;
1123     case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED:
1124         CHECK_EXPECT2(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1125         return E_FAIL;
1126     case DISPID_AMBIENT_SILENT:
1127         CHECK_EXPECT2(Invoke_AMBIENT_SILENT);
1128         V_VT(pVarResult) = VT_BOOL;
1129         V_BOOL(pVarResult) = VARIANT_FALSE;
1130         return S_OK;
1131     case DISPID_AMBIENT_USERAGENT:
1132         CHECK_EXPECT(Invoke_AMBIENT_USERAGENT);
1133         return E_FAIL;
1134     case DISPID_AMBIENT_PALETTE:
1135         CHECK_EXPECT(Invoke_AMBIENT_PALETTE);
1136         return E_FAIL;
1137     };
1138
1139     ok(0, "unexpected dispid %ld\n", dispIdMember);
1140     return E_FAIL;
1141 }
1142
1143 static IDispatchVtbl DispatchVtbl = {
1144     Dispatch_QueryInterface,
1145     Dispatch_AddRef,
1146     Dispatch_Release,
1147     Dispatch_GetTypeInfoCount,
1148     Dispatch_GetTypeInfo,
1149     Dispatch_GetIDsOfNames,
1150     Dispatch_Invoke
1151 };
1152
1153 static IDispatch Dispatch = { &DispatchVtbl };
1154
1155 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface,
1156                                                      REFIID riid, void **ppv)
1157 {
1158     return QueryInterface(riid, ppv);
1159 }
1160
1161 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
1162 {
1163     return 2;
1164 }
1165
1166 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
1167 {
1168     return 1;
1169 }
1170
1171 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
1172                                     REFIID riid, void **ppv)
1173 {
1174     /*
1175      * Services used by HTMLDocument:
1176      *
1177      * IOleUndoManager
1178      * IInternetSecurityManager
1179      * ITargetFrame
1180      * {D5F78C80-5252-11CF-90FA-00AA0042106E}
1181      * HTMLFrameBase
1182      * IShellObject
1183      * {3050F312-98B5-11CF-BB82-00AA00BDCE0B}
1184      * {53A2D5B1-D2FC-11D0-84E0-006097C9987D}
1185      * {AD7F6C62-F6BD-11D2-959B-006097C553C8}
1186      * DefView (?)
1187      * {6D12FE80-7911-11CF-9534-0000C05BAE0B}
1188      * IElementBehaviorFactory
1189      * {3050F429-98B5-11CF-BB82-00AA00BDCE0B}
1190      * STopLevelBrowser
1191      * IHTMLWindow2
1192      * IInternetProtocol
1193      * IWebBrowserApp
1194      * UrlHostory
1195      * IHTMLEditHost
1196      * IHlinkFrame
1197      */
1198
1199     if(IsEqualGUID(&IID_IHlinkFrame, guidService)) {
1200         ok(IsEqualGUID(&IID_IHlinkFrame, riid), "unexpected riid\n");
1201         *ppv = &HlinkFrame;
1202         return S_OK;
1203     }
1204
1205     return E_NOINTERFACE;
1206 }
1207
1208 static const IServiceProviderVtbl ServiceProviderVtbl = {
1209     ServiceProvider_QueryInterface,
1210     ServiceProvider_AddRef,
1211     ServiceProvider_Release,
1212     ServiceProvider_QueryService
1213 };
1214
1215 static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
1216
1217 static HRESULT QueryInterface(REFIID riid, void **ppv)
1218 {
1219     *ppv = NULL;
1220
1221     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IOleClientSite, riid))
1222         *ppv = &ClientSite;
1223     else if(IsEqualGUID(&IID_IOleDocumentSite, riid))
1224         *ppv = &DocumentSite;
1225     else if(IsEqualGUID(&IID_IDocHostUIHandler, riid) || IsEqualGUID(&IID_IDocHostUIHandler2, riid))
1226         *ppv = &DocHostUIHandler;
1227     else if(IsEqualGUID(&IID_IOleContainer, riid))
1228         *ppv = &OleContainer;
1229     else if(IsEqualGUID(&IID_IOleWindow, riid) || IsEqualGUID(&IID_IOleInPlaceSite, riid))
1230         *ppv = &InPlaceSite;
1231     else if(IsEqualGUID(&IID_IOleInPlaceUIWindow, riid) || IsEqualGUID(&IID_IOleInPlaceFrame, riid))
1232         *ppv = &InPlaceFrame;
1233     else if(IsEqualGUID(&IID_IOleCommandTarget , riid))
1234         *ppv = &OleCommandTarget;
1235     else if(IsEqualGUID(&IID_IDispatch, riid))
1236         *ppv = &Dispatch;
1237     else if(IsEqualGUID(&IID_IServiceProvider, riid))
1238         *ppv = &ServiceProvider;
1239
1240     /* TODO:
1241      * IOleInPlaceSiteEx
1242      * {D48A6EC6-6A4A-11CF-94A7-444553540000}
1243      * {7BB0B520-B1A7-11D2-BB23-00C04F79ABCD}
1244      * {000670BA-0000-0000-C000-000000000046}
1245      */
1246
1247     if(*ppv)
1248         return S_OK;
1249     return E_NOINTERFACE;
1250 }
1251
1252 static LRESULT WINAPI wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
1253 {
1254     return DefWindowProc(hwnd, msg, wParam, lParam);
1255 }
1256
1257 static void test_ConnectionPoint(IConnectionPointContainer *container, REFIID riid)
1258 {
1259     IConnectionPointContainer *tmp_container = NULL;
1260     IConnectionPoint *cp;
1261     IID iid;
1262     HRESULT hres;
1263
1264     hres = IConnectionPointContainer_FindConnectionPoint(container, riid, &cp);
1265     ok(hres == S_OK, "FindConnectionPoint failed: %08lx\n", hres);
1266     if(FAILED(hres))
1267         return;
1268
1269     hres = IConnectionPoint_GetConnectionInterface(cp, &iid);
1270     ok(hres == S_OK, "GetConnectionInterface failed: %08lx\n", hres);
1271     ok(IsEqualGUID(riid, &iid), "wrong iid\n");
1272
1273     hres = IConnectionPoint_GetConnectionInterface(cp, NULL);
1274     ok(hres == E_POINTER, "GetConnectionInterface failed: %08lx, expected E_POINTER\n", hres);
1275
1276     hres = IConnectionPoint_GetConnectionPointContainer(cp, &tmp_container);
1277     ok(hres == S_OK, "GetConnectionPointContainer failed: %08lx\n", hres);
1278     ok(tmp_container == container, "container != tmp_container\n");
1279     if(SUCCEEDED(hres))
1280         IConnectionPointContainer_Release(tmp_container);
1281
1282     hres = IConnectionPoint_GetConnectionPointContainer(cp, NULL);
1283     ok(hres == E_POINTER, "GetConnectionPointContainer failed: %08lx, expected E_POINTER\n", hres);
1284
1285     IConnectionPoint_Release(cp);
1286 }
1287
1288 static void test_ConnectionPointContainer(IUnknown *unk)
1289 {
1290     IConnectionPointContainer *container;
1291     HRESULT hres;
1292
1293     hres = IUnknown_QueryInterface(unk, &IID_IConnectionPointContainer, (void**)&container);
1294     ok(hres == S_OK, "QueryInterface(IID_IConnectionPointContainer) failed: %08lx\n", hres);
1295     if(FAILED(hres))
1296         return;
1297
1298     test_ConnectionPoint(container, &IID_IPropertyNotifySink);
1299     test_ConnectionPoint(container, &DIID_HTMLDocumentEvents);
1300     test_ConnectionPoint(container, &DIID_HTMLDocumentEvents2);
1301
1302     IConnectionPointContainer_Release(container);
1303 }
1304
1305 static void test_Load(IPersistMoniker *persist)
1306 {
1307     IMoniker *mon;
1308     IBindCtx *bind;
1309     HRESULT hres;
1310
1311     static const WCHAR wszWineHQ[] =
1312         {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q','.','o','r','g','/',0};
1313
1314     hres = CreateURLMoniker(NULL, wszWineHQ, &mon);
1315     ok(hres == S_OK, "CreateURLMoniker failed: %08lx\n", hres);
1316     if(FAILED(hres))
1317         return;
1318
1319     CreateBindCtx(0, &bind);
1320     IBindCtx_RegisterObjectParam(bind, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM,
1321                                  (IUnknown*)&ClientSite);
1322
1323     SET_EXPECT(GetHostInfo);
1324     SET_EXPECT(GetOptionKeyPath);
1325     SET_EXPECT(GetOverrideKeyPath);
1326     SET_EXPECT(GetWindow);
1327     SET_EXPECT(QueryStatus_SETPROGRESSTEXT);
1328     SET_EXPECT(Exec_SETPROGRESSMAX);
1329     SET_EXPECT(Exec_SETPROGRESSPOS);
1330     SET_EXPECT(Invoke_AMBIENT_USERMODE);
1331     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1332     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1333     SET_EXPECT(Invoke_AMBIENT_SILENT);
1334     SET_EXPECT(Invoke_AMBIENT_USERAGENT);
1335     SET_EXPECT(Invoke_AMBIENT_PALETTE);
1336     SET_EXPECT(GetContainer);
1337     SET_EXPECT(LockContainer);
1338     SET_EXPECT(Exec_ShellDocView_37);
1339     expect_LockContainer_fLock = TRUE;
1340
1341     hres = IPersistMoniker_Load(persist, FALSE, mon, bind, 0x12);
1342 #if 0
1343     ok(hres == S_OK, "Load failed: %08lx\n", hres);
1344 #endif
1345
1346     CHECK_CALLED(GetHostInfo);
1347     CHECK_CALLED(GetOptionKeyPath);
1348     CHECK_CALLED(GetOverrideKeyPath);
1349     CHECK_CALLED(GetWindow);
1350     CHECK_CALLED(QueryStatus_SETPROGRESSTEXT);
1351     CHECK_CALLED(Exec_SETPROGRESSMAX);
1352     CHECK_CALLED(Exec_SETPROGRESSPOS);
1353     CHECK_CALLED(Invoke_AMBIENT_USERMODE);
1354     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1355     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1356     CHECK_CALLED(Invoke_AMBIENT_SILENT);
1357     CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
1358     CHECK_CALLED(Invoke_AMBIENT_PALETTE);
1359     CHECK_CALLED(GetContainer);
1360     CHECK_CALLED(LockContainer);
1361     CHECK_CALLED(Exec_ShellDocView_37);
1362
1363     set_clientsite = container_locked = TRUE;
1364
1365     IBindCtx_Release(bind);
1366     IMoniker_Release(mon);
1367 }
1368
1369 #ifdef DOWNLOAD_TEST
1370
1371 static void test_download(void)
1372 {
1373     MSG msg;
1374
1375     load_state = LD_LOADING;
1376
1377     SET_EXPECT(Exec_SETDOWNLOADSTATE);
1378     SET_EXPECT(GetDropTarget);
1379     SET_EXPECT(SetStatusText);
1380     SET_EXPECT(UpdateUI);
1381     SET_EXPECT(Exec_UPDATECOMMANDS);
1382     SET_EXPECT(Exec_SETTITLE);
1383     SET_EXPECT(Exec_HTTPEQUIV);
1384     SET_EXPECT(Exec_SETPROGRESSMAX);
1385     SET_EXPECT(Exec_SETPROGRESSPOS);
1386     SET_EXPECT(Exec_MSHTML_2315);
1387     SET_EXPECT(Exec_HTTPEQUIV_DONE);
1388     expect_status_text = (LPCOLESTR)0xdeadbeef; /* TODO */
1389
1390     while(!called_Exec_HTTPEQUIV_DONE && GetMessage(&msg, NULL, 0, 0)) {
1391         TranslateMessage(&msg);
1392         DispatchMessage(&msg);
1393     }
1394
1395     CHECK_CALLED(Exec_SETDOWNLOADSTATE);
1396     CHECK_CALLED(GetDropTarget);
1397     CHECK_CALLED(SetStatusText);
1398     CHECK_CALLED(UpdateUI);
1399     CHECK_CALLED(Exec_UPDATECOMMANDS);
1400     CHECK_CALLED(Exec_SETTITLE);
1401     CHECK_CALLED(Exec_HTTPEQUIV);
1402     CHECK_CALLED(Exec_SETPROGRESSMAX);
1403     CHECK_CALLED(Exec_SETPROGRESSPOS);
1404     CHECK_CALLED(Exec_MSHTML_2315);
1405     CHECK_CALLED(Exec_HTTPEQUIV_DONE);
1406
1407     load_state = LD_LOADED;
1408 }
1409
1410 #endif
1411
1412 static void test_Persist(IUnknown *unk)
1413 {
1414     IPersistMoniker *persist_mon;
1415     IPersistFile *persist_file;
1416     GUID guid;
1417     HRESULT hres;
1418
1419     hres = IUnknown_QueryInterface(unk, &IID_IPersistFile, (void**)&persist_file);
1420     ok(hres == S_OK, "QueryInterface(IID_IPersist) failed: %08lx\n", hres);
1421     if(SUCCEEDED(hres)) {
1422         hres = IPersist_GetClassID(persist_file, NULL);
1423         ok(hres == E_INVALIDARG, "GetClassID returned: %08lx, expected E_INVALIDARG\n", hres);
1424
1425         hres = IPersist_GetClassID(persist_file, &guid);
1426         ok(hres == S_OK, "GetClassID failed: %08lx\n", hres);
1427         ok(IsEqualGUID(&CLSID_HTMLDocument, &guid), "guid != CLSID_HTMLDocument\n");
1428
1429         IPersist_Release(persist_file);
1430     }
1431
1432     hres = IUnknown_QueryInterface(unk, &IID_IPersistMoniker, (void**)&persist_mon);
1433     ok(hres == S_OK, "QueryInterface(IID_IPersistMoniker) failed: %08lx\n", hres);
1434     if(SUCCEEDED(hres)) {
1435         hres = IPersistMoniker_GetClassID(persist_mon, NULL);
1436         ok(hres == E_INVALIDARG, "GetClassID returned: %08lx, expected E_INVALIDARG\n", hres);
1437
1438         hres = IPersistMoniker_GetClassID(persist_mon, &guid);
1439         ok(hres == S_OK, "GetClassID failed: %08lx\n", hres);
1440         ok(IsEqualGUID(&CLSID_HTMLDocument, &guid), "guid != CLSID_HTMLDocument\n");
1441
1442         if(load_state == LD_DOLOAD)
1443             test_Load(persist_mon);
1444
1445         IPersistMoniker_Release(persist_mon);
1446     }
1447 }
1448
1449 static const OLECMDF expect_cmds[OLECMDID_GETPRINTTEMPLATE+1] = {
1450     0,
1451     OLECMDF_SUPPORTED,                  /* OLECMDID_OPEN */
1452     OLECMDF_SUPPORTED,                  /* OLECMDID_NEW */
1453     OLECMDF_SUPPORTED,                  /* OLECMDID_SAVE */
1454     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_SAVEAS */
1455     OLECMDF_SUPPORTED,                  /* OLECMDID_SAVECOPYAS */
1456     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PRINT */
1457     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PRINTPREVIEW */
1458     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PAGESETUP */
1459     OLECMDF_SUPPORTED,                  /* OLECMDID_SPELL */
1460     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PROPERTIES */
1461     OLECMDF_SUPPORTED,                  /* OLECMDID_CUT */
1462     OLECMDF_SUPPORTED,                  /* OLECMDID_COPY */
1463     OLECMDF_SUPPORTED,                  /* OLECMDID_PASTE */
1464     OLECMDF_SUPPORTED,                  /* OLECMDID_PASTESPECIAL */
1465     OLECMDF_SUPPORTED,                  /* OLECMDID_UNDO */
1466     OLECMDF_SUPPORTED,                  /* OLECMDID_REDO */
1467     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_SELECTALL */
1468     OLECMDF_SUPPORTED,                  /* OLECMDID_CLEARSELECTION */
1469     OLECMDF_SUPPORTED,                  /* OLECMDID_ZOOM */
1470     OLECMDF_SUPPORTED,                  /* OLECMDID_GETZOOMRANGE */
1471     0,
1472     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_REFRESH */
1473     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_STOP */
1474     0,0,0,0,0,0,
1475     OLECMDF_SUPPORTED,                  /* OLECMDID_STOPDOWNLOAD */
1476     0,0,
1477     OLECMDF_SUPPORTED,                  /* OLECMDID_DELETE */
1478     0,0,
1479     OLECMDF_SUPPORTED,                  /* OLECMDID_ENABLE_INTERACTION */
1480     OLECMDF_SUPPORTED,                  /* OLECMDID_ONUNLOAD */
1481     0,0,0,0,0,
1482     OLECMDF_SUPPORTED,                  /* OLECMDID_SHOWPAGESETUP */
1483     OLECMDF_SUPPORTED,                  /* OLECMDID_SHOWPRINT */
1484     0,0,
1485     OLECMDF_SUPPORTED,                  /* OLECMDID_CLOSE */
1486     0,0,0,
1487     OLECMDF_SUPPORTED,                  /* OLECMDID_SETPRINTTEMPLATE */
1488     OLECMDF_SUPPORTED                   /* OLECMDID_GETPRINTTEMPLATE */
1489 };
1490
1491 static void test_OleCommandTarget(IUnknown *unk)
1492 {
1493     IOleCommandTarget *cmdtrg;
1494     OLECMD cmds[OLECMDID_GETPRINTTEMPLATE];
1495     int i;
1496     HRESULT hres;
1497
1498     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
1499     ok(hres == S_OK, "QueryInterface(IIDIOleM=CommandTarget failed: %08lx\n", hres);
1500     if(FAILED(hres))
1501         return;
1502
1503     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
1504         cmds[i].cmdID = i+1;
1505         cmds[i].cmdf = 0xf0f0;
1506     }
1507
1508     SET_EXPECT(QueryStatus_OPEN);
1509     SET_EXPECT(QueryStatus_NEW);
1510     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, sizeof(cmds)/sizeof(cmds[0]), cmds, NULL);
1511     ok(hres == S_OK, "QueryStatus failed: %08lx\n", hres);
1512     CHECK_CALLED(QueryStatus_OPEN);
1513     CHECK_CALLED(QueryStatus_NEW);
1514
1515     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
1516         ok(cmds[i].cmdID == i+1, "cmds[%d].cmdID canged to %lx\n", i, cmds[i].cmdID);
1517         ok(cmds[i].cmdf == expect_cmds[i+1], "cmds[%d].cmdf=%lx, expected %x\n",
1518                 i+1, cmds[i].cmdf, expect_cmds[i+1]);
1519     }
1520
1521     IOleCommandTarget_Release(cmdtrg);
1522 }
1523
1524 static void test_OleCommandTarget_fail(IUnknown *unk)
1525 {
1526     IOleCommandTarget *cmdtrg;
1527     int i;
1528     HRESULT hres;
1529
1530     OLECMD cmd[2] = {
1531         {OLECMDID_OPEN, 0xf0f0},
1532         {OLECMDID_GETPRINTTEMPLATE+1, 0xf0f0}
1533     };
1534
1535     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
1536     ok(hres == S_OK, "QueryInterface(IIDIOleM=CommandTarget failed: %08lx\n", hres);
1537     if(FAILED(hres))
1538         return;
1539
1540     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 0, NULL, NULL);
1541     ok(hres == S_OK, "QueryStatus failed: %08lx\n", hres);
1542
1543     SET_EXPECT(QueryStatus_OPEN);
1544     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 2, cmd, NULL);
1545     CHECK_CALLED(QueryStatus_OPEN);
1546
1547     ok(hres == OLECMDERR_E_NOTSUPPORTED,
1548             "QueryStatus failed: %08lx, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
1549     ok(cmd[1].cmdID == OLECMDID_GETPRINTTEMPLATE+1,
1550             "cmd[0].cmdID=%ld, expected OLECMDID_GETPRINTTEMPLATE+1\n", cmd[0].cmdID);
1551     ok(cmd[1].cmdf == 0, "cmd[0].cmdf=%lx, expected 0\n", cmd[0].cmdf);
1552     ok(cmd[0].cmdf == OLECMDF_SUPPORTED,
1553             "cmd[1].cmdf=%lx, expected OLECMDF_SUPPORTED\n", cmd[1].cmdf);
1554
1555     hres = IOleCommandTarget_QueryStatus(cmdtrg, &IID_IHTMLDocument2, 2, cmd, NULL);
1556     ok(hres == OLECMDERR_E_UNKNOWNGROUP,
1557             "QueryStatus failed: %08lx, expected OLECMDERR_E_UNKNOWNGROUP\n", hres);
1558
1559     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
1560         if(!expect_cmds[i]) {
1561             hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_UPDATECOMMANDS,
1562                     OLECMDEXECOPT_DODEFAULT, NULL, NULL);
1563             ok(hres == OLECMDERR_E_NOTSUPPORTED,
1564                     "Exec failed: %08lx, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
1565         }
1566     }
1567
1568     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_GETPRINTTEMPLATE+1,
1569             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
1570     ok(hres == OLECMDERR_E_NOTSUPPORTED,
1571             "Exec failed: %08lx, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
1572
1573     IOleCommandTarget_Release(cmdtrg);
1574 }
1575
1576 static void test_exec_onunload(IUnknown *unk)
1577 {
1578     IOleCommandTarget *cmdtrg;
1579     VARIANT var;
1580     HRESULT hres;
1581
1582     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
1583     ok(hres == S_OK, "QueryInterface(IID_IOleCommandTarget) failed: %08lx\n", hres);
1584     if(FAILED(hres))
1585         return;
1586
1587     memset(&var, 0x0a, sizeof(var));
1588     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_ONUNLOAD,
1589             OLECMDEXECOPT_DODEFAULT, NULL, &var);
1590     ok(hres == S_OK, "Exec(..., OLECMDID_ONUNLOAD, ...) failed: %08lx\n", hres);
1591     ok(V_VT(&var) == VT_BOOL, "V_VT(var)=%d, expected VT_BOOL\n", V_VT(&var));
1592     ok(V_BOOL(&var) == VARIANT_TRUE, "V_BOOL(var)=%x, expected VARIANT_TRUE\n", V_BOOL(&var));
1593
1594     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_ONUNLOAD,
1595             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
1596     ok(hres == S_OK, "Exec(..., OLECMDID_ONUNLOAD, ...) failed: %08lx\n", hres);
1597
1598     IOleCommandTarget_Release(cmdtrg);
1599 }
1600
1601 static HWND create_container_window(void)
1602 {
1603     static const WCHAR wszHTMLDocumentTest[] =
1604         {'H','T','M','L','D','o','c','u','m','e','n','t','T','e','s','t',0};
1605     static WNDCLASSEXW wndclass = {
1606         sizeof(WNDCLASSEXW),
1607         0,
1608         wnd_proc,
1609         0, 0, NULL, NULL, NULL, NULL, NULL,
1610         wszHTMLDocumentTest,
1611         NULL
1612     };
1613
1614     RegisterClassExW(&wndclass);
1615     return CreateWindowW(wszHTMLDocumentTest, wszHTMLDocumentTest,
1616             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
1617             CW_USEDEFAULT, NULL, NULL, NULL, NULL);
1618 }
1619
1620 static HRESULT test_DoVerb(IOleObject *oleobj)
1621 {
1622     RECT rect = {0,0,500,500};
1623     HRESULT hres;
1624
1625     if(!container_locked) {
1626         SET_EXPECT(GetContainer);
1627         SET_EXPECT(LockContainer);
1628     }
1629     SET_EXPECT(ActivateMe);
1630     expect_LockContainer_fLock = TRUE;
1631
1632     hres = IOleObject_DoVerb(oleobj, OLEIVERB_SHOW, NULL, &ClientSite, -1, container_hwnd, &rect);
1633     if(FAILED(hres))
1634         return hres;
1635     ok(hres == S_OK, "DoVerb failed: %08lx\n", hres);
1636
1637     if(!container_locked) {
1638         CHECK_CALLED(GetContainer);
1639         CHECK_CALLED(LockContainer);
1640         container_locked = TRUE;
1641     }
1642     CHECK_CALLED(ActivateMe);
1643
1644     return hres;
1645 }
1646
1647 #define CLIENTSITE_EXPECTPATH 0x00000001
1648 #define CLIENTSITE_SETNULL    0x00000002
1649 #define CLIENTSITE_DONTSET    0x00000004
1650
1651 static void test_ClientSite(IOleObject *oleobj, DWORD flags)
1652 {
1653     IOleClientSite *clientsite;
1654     HRESULT hres;
1655
1656     if(flags & CLIENTSITE_SETNULL) {
1657         hres = IOleObject_GetClientSite(oleobj, &clientsite);
1658         ok(clientsite == &ClientSite, "clientsite=%p, expected %p\n", clientsite, &ClientSite);
1659
1660         hres = IOleObject_SetClientSite(oleobj, NULL);
1661         ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
1662
1663         set_clientsite = FALSE;
1664     }
1665
1666     if(flags & CLIENTSITE_DONTSET)
1667         return;
1668
1669     hres = IOleObject_GetClientSite(oleobj, &clientsite);
1670     ok(hres == S_OK, "GetClientSite failed: %08lx\n", hres);
1671     ok(clientsite == (set_clientsite ? &ClientSite : NULL), "GetClientSite() = %p, expected %p\n",
1672             clientsite, set_clientsite ? &ClientSite : NULL);
1673
1674     if(!set_clientsite) {
1675         SET_EXPECT(GetHostInfo);
1676         if(flags & CLIENTSITE_EXPECTPATH) {
1677             SET_EXPECT(GetOptionKeyPath);
1678             SET_EXPECT(GetOverrideKeyPath);
1679         }
1680         SET_EXPECT(GetWindow);
1681         SET_EXPECT(QueryStatus_SETPROGRESSTEXT);
1682         SET_EXPECT(Exec_SETPROGRESSMAX);
1683         SET_EXPECT(Exec_SETPROGRESSPOS);
1684         SET_EXPECT(Invoke_AMBIENT_USERMODE);
1685         SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1686         SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1687         SET_EXPECT(Invoke_AMBIENT_SILENT);
1688         SET_EXPECT(Invoke_AMBIENT_USERAGENT);
1689         SET_EXPECT(Invoke_AMBIENT_PALETTE);
1690
1691         hres = IOleObject_SetClientSite(oleobj, &ClientSite);
1692         ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
1693
1694         CHECK_CALLED(GetHostInfo);
1695         if(flags & CLIENTSITE_EXPECTPATH) {
1696             CHECK_CALLED(GetOptionKeyPath);
1697             CHECK_CALLED(GetOverrideKeyPath);
1698         }
1699         CHECK_CALLED(GetWindow);
1700         CHECK_CALLED(QueryStatus_SETPROGRESSTEXT);
1701         CHECK_CALLED(Exec_SETPROGRESSMAX);
1702         CHECK_CALLED(Exec_SETPROGRESSPOS);
1703         CHECK_CALLED(Invoke_AMBIENT_USERMODE);
1704         CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1705         CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1706         CHECK_CALLED(Invoke_AMBIENT_SILENT);
1707         CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
1708         CHECK_CALLED(Invoke_AMBIENT_PALETTE);
1709
1710         set_clientsite = TRUE;
1711     }
1712
1713     hres = IOleObject_SetClientSite(oleobj, &ClientSite);
1714     ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
1715
1716     hres = IOleObject_GetClientSite(oleobj, &clientsite);
1717     ok(hres == S_OK, "GetClientSite failed: %08lx\n", hres);
1718     ok(clientsite == &ClientSite, "GetClientSite() = %p, expected %p\n", clientsite, &ClientSite);
1719 }
1720
1721 static void test_OnAmbientPropertyChange(IUnknown *unk)
1722 {
1723     IOleControl *control = NULL;
1724     HRESULT hres;
1725
1726     hres = IUnknown_QueryInterface(unk, &IID_IOleControl, (void**)&control);
1727     ok(hres == S_OK, "QueryInterface(IID_IOleControl failed: %08lx\n", hres);
1728     if(FAILED(hres))
1729         return;
1730
1731     SET_EXPECT(Invoke_AMBIENT_USERMODE);
1732     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_USERMODE);
1733     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1734     CHECK_CALLED(Invoke_AMBIENT_USERMODE);
1735
1736     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1737     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_DLCONTROL);
1738     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1739     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1740
1741     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1742     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1743     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_OFFLINEIFNOTCONNECTED);
1744     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1745     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1746     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1747
1748     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1749     SET_EXPECT(Invoke_AMBIENT_SILENT);
1750     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_SILENT);
1751     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1752     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1753     CHECK_CALLED(Invoke_AMBIENT_SILENT);
1754
1755     SET_EXPECT(Invoke_AMBIENT_USERAGENT);
1756     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_USERAGENT);
1757     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1758     CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
1759
1760     SET_EXPECT(Invoke_AMBIENT_PALETTE);
1761     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_PALETTE);
1762     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1763     CHECK_CALLED(Invoke_AMBIENT_PALETTE);
1764
1765     IOleControl_Release(control);
1766 }
1767
1768
1769
1770 static void test_OnAmbientPropertyChange2(IUnknown *unk)
1771 {
1772     IOleControl *control = NULL;
1773     HRESULT hres;
1774
1775     hres = IUnknown_QueryInterface(unk, &IID_IOleControl, (void**)&control);
1776     ok(hres == S_OK, "QueryInterface(IID_IOleControl failed: %08lx\n", hres);
1777     if(FAILED(hres))
1778         return;
1779
1780     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_PALETTE);
1781     ok(hres == S_OK, "OnAmbientPropertyChange failed: %08lx\n", hres);
1782
1783     IOleControl_Release(control);
1784 }
1785
1786 static void test_Close(IUnknown *unk, BOOL set_client)
1787 {
1788     IOleObject *oleobj = NULL;
1789     HRESULT hres;
1790
1791     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
1792     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08lx\n", hres);
1793     if(FAILED(hres))
1794         return;
1795
1796     SET_EXPECT(GetContainer);
1797     SET_EXPECT(LockContainer);
1798     expect_LockContainer_fLock = FALSE;
1799     hres = IOleObject_Close(oleobj, OLECLOSE_NOSAVE);
1800     ok(hres == S_OK, "Close failed: %08lx\n", hres);
1801     CHECK_CALLED(GetContainer);
1802     CHECK_CALLED(LockContainer);
1803     container_locked = FALSE;
1804
1805     if(set_client)
1806         test_ClientSite(oleobj, CLIENTSITE_SETNULL|CLIENTSITE_DONTSET);
1807
1808     IOleObject_Release(oleobj);
1809 }
1810
1811 static void test_InPlaceDeactivate(IUnknown *unk, BOOL expect_call)
1812 {
1813     IOleInPlaceObjectWindowless *windowlessobj = NULL;
1814     HRESULT hres;
1815
1816     hres = IUnknown_QueryInterface(unk, &IID_IOleInPlaceObjectWindowless,
1817             (void**)&windowlessobj);
1818     ok(hres == S_OK, "QueryInterface(IID_IOleInPlaceObjectWindowless) failed: %08lx\n", hres);
1819     if(FAILED(hres))
1820         return;
1821
1822     if(expect_call) SET_EXPECT(OnInPlaceDeactivate);
1823     hres = IOleInPlaceObjectWindowless_InPlaceDeactivate(windowlessobj);
1824     ok(hres == S_OK, "InPlaceDeactivate failed: %08lx\n", hres);
1825     if(expect_call) CHECK_CALLED(OnInPlaceDeactivate);
1826
1827     IOleInPlaceObjectWindowless_Release(windowlessobj);
1828 }
1829
1830 static HRESULT test_Activate(IUnknown *unk, DWORD flags)
1831 {
1832     IOleObject *oleobj = NULL;
1833     GUID guid;
1834     HRESULT hres;
1835
1836     last_hwnd = hwnd;
1837
1838     if(view)
1839         IOleDocumentView_Release(view);
1840     view = NULL;
1841
1842     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
1843     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08lx\n", hres);
1844     if(FAILED(hres))
1845         return hres;
1846
1847     hres = IOleObject_GetUserClassID(oleobj, NULL);
1848     ok(hres == E_INVALIDARG, "GetUserClassID returned: %08lx, expected E_INVALIDARG\n", hres);
1849
1850     hres = IOleObject_GetUserClassID(oleobj, &guid);
1851     ok(hres == S_OK, "GetUserClassID failed: %08lx\n", hres);
1852     ok(IsEqualGUID(&guid, &CLSID_HTMLDocument), "guid != CLSID_HTMLDocument\n");
1853
1854     test_ClientSite(oleobj, flags);
1855     test_InPlaceDeactivate(unk, FALSE);
1856
1857     hres = test_DoVerb(oleobj);
1858
1859     IOleObject_Release(oleobj);
1860     return hres;
1861 }
1862
1863 static void test_Window(IUnknown *unk, BOOL expect_success)
1864 {
1865     IOleInPlaceActiveObject *activeobject = NULL;
1866     HWND tmp_hwnd;
1867     HRESULT hres;
1868
1869     hres = IOleDocumentView_QueryInterface(view, &IID_IOleInPlaceActiveObject, (void**)&activeobject);
1870     ok(hres == S_OK, "Could not get IOleInPlaceActiveObject interface: %08lx\n", hres);
1871     if(FAILED(hres))
1872         return;
1873
1874     hres = IOleInPlaceActiveObject_GetWindow(activeobject, &tmp_hwnd);
1875
1876     if(expect_success) {
1877         ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
1878         ok(tmp_hwnd == hwnd, "tmp_hwnd=%p, expected %p\n", tmp_hwnd, hwnd);
1879     }else {
1880         ok(hres == E_FAIL, "GetWindow returned %08lx, expected E_FAIL\n", hres);
1881         ok(IsWindow(hwnd), "hwnd is destroyed\n");
1882     }
1883
1884     IOleInPlaceActiveObject_Release(activeobject);
1885 }
1886
1887 static void test_CloseView(void)
1888 {
1889     IOleInPlaceSite *inplacesite = (IOleInPlaceSite*)0xff00ff00;
1890     HRESULT hres;
1891
1892     if(!view)
1893         return;
1894
1895     hres = IOleDocumentView_Show(view, FALSE);
1896     ok(hres == S_OK, "Show failed: %08lx\n", hres);
1897
1898     hres = IOleDocumentView_CloseView(view, 0);
1899     ok(hres == S_OK, "CloseView failed: %08lx\n", hres);
1900
1901     hres = IOleDocumentView_SetInPlaceSite(view, NULL);
1902     ok(hres == S_OK, "SetInPlaceSite failed: %08lx\n", hres);
1903
1904     hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
1905     ok(hres == S_OK, "SetInPlaceSite failed: %08lx\n", hres);
1906     ok(inplacesite == NULL, "inplacesite=%p, expected NULL\n", inplacesite);
1907 }
1908
1909 static void test_UIDeactivate(void)
1910 {
1911     HRESULT hres;
1912
1913     if(call_UIActivate) {
1914         SET_EXPECT(SetActiveObject);
1915         SET_EXPECT(HideUI);
1916         SET_EXPECT(OnUIDeactivate);
1917     }
1918
1919     expect_SetActiveObject_active = FALSE;
1920     hres = IOleDocumentView_UIActivate(view, FALSE);
1921     ok(hres == S_OK, "UIActivate failed: %08lx\n", hres);
1922
1923     if(call_UIActivate) {
1924         CHECK_CALLED(SetActiveObject);
1925         CHECK_CALLED(HideUI);
1926         CHECK_CALLED(OnUIDeactivate);
1927     }
1928 }
1929
1930 static void test_Hide(void)
1931 {
1932     HRESULT hres;
1933
1934     if(!view)
1935         return;
1936
1937     hres = IOleDocumentView_Show(view, FALSE);
1938     ok(hres == S_OK, "Show failed: %08lx\n", hres);
1939 }
1940
1941 static HRESULT create_document(IUnknown **unk)
1942 {
1943     HRESULT hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
1944             &IID_IUnknown, (void**)unk);
1945     ok(hres == S_OK, "CoCreateInstance failed: %08lx\n", hres);
1946     return hres;
1947 }
1948
1949 static void test_Navigate(IUnknown *unk)
1950 {
1951     IHlinkTarget *hlink;
1952     HRESULT hres;
1953
1954     hres = IUnknown_QueryInterface(unk, &IID_IHlinkTarget, (void**)&hlink);
1955     ok(hres == S_OK, "QueryInterface(IID_IHlinkTarget) failed: %08lx\n", hres);
1956
1957     SET_EXPECT(ActivateMe);
1958     hres = IHlinkTarget_Navigate(hlink, 0, NULL);
1959     ok(hres == S_OK, "Navigate failed: %08lx\n", hres);
1960     CHECK_CALLED(ActivateMe);
1961
1962     IHlinkTarget_Release(hlink);
1963 }
1964
1965 static void test_HTMLDocument(void)
1966 {
1967     IUnknown *unk;
1968     HRESULT hres;
1969     ULONG ref;
1970
1971     hwnd = last_hwnd = NULL;
1972
1973     hres = create_document(&unk);
1974     if(FAILED(hres))
1975         return;
1976
1977     test_ConnectionPointContainer(unk);
1978     test_Persist(unk);
1979     if(load_state == LD_NO)
1980         test_OnAmbientPropertyChange2(unk);
1981
1982     hres = test_Activate(unk, CLIENTSITE_EXPECTPATH);
1983     if(FAILED(hres)) {
1984         IUnknown_Release(unk);
1985         return;
1986     }
1987
1988 #ifdef DOWNLOAD_TEST
1989     if(load_state == LD_DOLOAD)
1990         test_download();
1991 #endif
1992
1993     test_OleCommandTarget_fail(unk);
1994     test_OleCommandTarget(unk);
1995     test_OnAmbientPropertyChange(unk);
1996     test_Window(unk, TRUE);
1997     test_UIDeactivate();
1998     test_OleCommandTarget(unk);
1999     test_Window(unk, TRUE);
2000     test_InPlaceDeactivate(unk, TRUE);
2001
2002     /* Calling test_OleCommandTarget here couses Segmentation Fault with native
2003      * MSHTML. It doesn't with Wine. */
2004
2005     test_Window(unk, FALSE);
2006     test_Hide();
2007     test_InPlaceDeactivate(unk, FALSE);
2008     test_CloseView();
2009     test_Close(unk, FALSE);
2010
2011     /* Activate HTMLDocument again */
2012     test_Activate(unk, CLIENTSITE_SETNULL);
2013     test_Window(unk, TRUE);
2014     test_OleCommandTarget(unk);
2015     test_UIDeactivate();
2016     test_InPlaceDeactivate(unk, TRUE);
2017     test_Close(unk, FALSE);
2018
2019     /* Activate HTMLDocument again, this time without UIActivate */
2020     call_UIActivate = FALSE;
2021     test_Activate(unk, CLIENTSITE_SETNULL);
2022     test_Window(unk, TRUE);
2023     test_UIDeactivate();
2024     test_InPlaceDeactivate(unk, TRUE);
2025     test_CloseView();
2026     test_CloseView();
2027     test_Close(unk, TRUE);
2028     test_OnAmbientPropertyChange2(unk);
2029
2030     if(view)
2031         IOleDocumentView_Release(view);
2032     view = NULL;
2033
2034     ok(IsWindow(hwnd), "hwnd is destroyed\n");
2035
2036     ref = IUnknown_Release(unk);
2037     ok(ref == 0, "ref=%ld, expected 0\n", ref);
2038
2039     ok(!IsWindow(hwnd), "hwnd is not destroyed\n");
2040
2041 }
2042
2043 static void test_HTMLDocument_hlink(void)
2044 {
2045     IUnknown *unk;
2046     HRESULT hres;
2047     ULONG ref;
2048
2049     hwnd = last_hwnd = NULL;
2050
2051     hres = create_document(&unk);
2052     if(FAILED(hres))
2053         return;
2054
2055     test_Persist(unk);
2056     test_Navigate(unk);
2057
2058 #ifdef DOWNLOAD_TEST
2059     test_download();
2060 #endif
2061
2062     test_exec_onunload(unk);
2063     test_Window(unk, TRUE);
2064     test_InPlaceDeactivate(unk, TRUE);
2065     test_Close(unk, FALSE);
2066
2067     if(view)
2068         IOleDocumentView_Release(view);
2069     view = NULL;
2070
2071     ref = IUnknown_Release(unk);
2072     ok(ref == 0, "ref=%ld, expected 0\n", ref);
2073 }
2074
2075 static void gecko_installer_workaround(BOOL disable)
2076 {
2077     HKEY hkey;
2078     DWORD res;
2079
2080     static BOOL has_url = FALSE;
2081     static char url[2048];
2082
2083     if(!disable && !has_url)
2084         return;
2085
2086     res = RegOpenKey(HKEY_CURRENT_USER, "Software\\Wine\\MSHTML", &hkey);
2087     if(res != ERROR_SUCCESS)
2088         return;
2089
2090     if(disable) {
2091         DWORD type, size = sizeof(url);
2092
2093         res = RegQueryValueEx(hkey, "GeckoUrl", NULL, &type, (PVOID)url, &size);
2094         if(res == ERROR_SUCCESS && type == REG_SZ)
2095             has_url = TRUE;
2096
2097         RegDeleteValue(hkey, "GeckoUrl");
2098     }else {
2099         RegSetValueEx(hkey, "GeckoUrl", 0, REG_SZ, (PVOID)url, lstrlenA(url)+1);
2100     }
2101
2102     RegCloseKey(hkey);
2103 }
2104
2105 START_TEST(htmldoc)
2106 {
2107     gecko_installer_workaround(TRUE);
2108
2109     CoInitialize(NULL);
2110     container_hwnd = create_container_window();
2111
2112     load_state = LD_NO;
2113     test_HTMLDocument();
2114     load_state = LD_DOLOAD;
2115     test_HTMLDocument();
2116     load_state = LD_DOLOAD;
2117     test_HTMLDocument_hlink();
2118
2119     DestroyWindow(container_hwnd);
2120     CoUninitialize();
2121
2122     gecko_installer_workaround(FALSE);
2123 }