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., 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, &DIID_HTMLDocumentEvents);
1299     test_ConnectionPoint(container, &DIID_HTMLDocumentEvents2);
1300
1301     IConnectionPointContainer_Release(container);
1302 }
1303
1304 static void test_Load(IPersistMoniker *persist)
1305 {
1306     IMoniker *mon;
1307     IBindCtx *bind;
1308     HRESULT hres;
1309
1310     static const WCHAR wszWineHQ[] =
1311         {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q','.','o','r','g','/',0};
1312
1313     hres = CreateURLMoniker(NULL, wszWineHQ, &mon);
1314     ok(hres == S_OK, "CreateURLMoniker failed: %08lx\n", hres);
1315     if(FAILED(hres))
1316         return;
1317
1318     CreateBindCtx(0, &bind);
1319     IBindCtx_RegisterObjectParam(bind, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM,
1320                                  (IUnknown*)&ClientSite);
1321
1322     SET_EXPECT(GetHostInfo);
1323     SET_EXPECT(GetOptionKeyPath);
1324     SET_EXPECT(GetOverrideKeyPath);
1325     SET_EXPECT(GetWindow);
1326     SET_EXPECT(QueryStatus_SETPROGRESSTEXT);
1327     SET_EXPECT(Exec_SETPROGRESSMAX);
1328     SET_EXPECT(Exec_SETPROGRESSPOS);
1329     SET_EXPECT(Invoke_AMBIENT_USERMODE);
1330     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1331     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1332     SET_EXPECT(Invoke_AMBIENT_SILENT);
1333     SET_EXPECT(Invoke_AMBIENT_USERAGENT);
1334     SET_EXPECT(Invoke_AMBIENT_PALETTE);
1335     SET_EXPECT(GetContainer);
1336     SET_EXPECT(LockContainer);
1337     SET_EXPECT(Exec_ShellDocView_37);
1338     expect_LockContainer_fLock = TRUE;
1339
1340     hres = IPersistMoniker_Load(persist, FALSE, mon, bind, 0x12);
1341 #if 0
1342     ok(hres == S_OK, "Load failed: %08lx\n", hres);
1343 #endif
1344
1345     CHECK_CALLED(GetHostInfo);
1346     CHECK_CALLED(GetOptionKeyPath);
1347     CHECK_CALLED(GetOverrideKeyPath);
1348     CHECK_CALLED(GetWindow);
1349     CHECK_CALLED(QueryStatus_SETPROGRESSTEXT);
1350     CHECK_CALLED(Exec_SETPROGRESSMAX);
1351     CHECK_CALLED(Exec_SETPROGRESSPOS);
1352     CHECK_CALLED(Invoke_AMBIENT_USERMODE);
1353     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1354     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1355     CHECK_CALLED(Invoke_AMBIENT_SILENT);
1356     CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
1357     CHECK_CALLED(Invoke_AMBIENT_PALETTE);
1358     CHECK_CALLED(GetContainer);
1359     CHECK_CALLED(LockContainer);
1360     CHECK_CALLED(Exec_ShellDocView_37);
1361
1362     set_clientsite = container_locked = TRUE;
1363
1364     IBindCtx_Release(bind);
1365     IMoniker_Release(mon);
1366 }
1367
1368 #ifdef DOWNLOAD_TEST
1369
1370 static void test_download(void)
1371 {
1372     MSG msg;
1373
1374     load_state = LD_LOADING;
1375
1376     SET_EXPECT(Exec_SETDOWNLOADSTATE);
1377     SET_EXPECT(GetDropTarget);
1378     SET_EXPECT(SetStatusText);
1379     SET_EXPECT(UpdateUI);
1380     SET_EXPECT(Exec_UPDATECOMMANDS);
1381     SET_EXPECT(Exec_SETTITLE);
1382     SET_EXPECT(Exec_HTTPEQUIV);
1383     SET_EXPECT(Exec_SETPROGRESSMAX);
1384     SET_EXPECT(Exec_SETPROGRESSPOS);
1385     SET_EXPECT(Exec_MSHTML_2315);
1386     SET_EXPECT(Exec_HTTPEQUIV_DONE);
1387     expect_status_text = (LPCOLESTR)0xdeadbeef; /* TODO */
1388
1389     while(!called_Exec_HTTPEQUIV_DONE && GetMessage(&msg, NULL, 0, 0)) {
1390         TranslateMessage(&msg);
1391         DispatchMessage(&msg);
1392     }
1393
1394     CHECK_CALLED(Exec_SETDOWNLOADSTATE);
1395     CHECK_CALLED(GetDropTarget);
1396     CHECK_CALLED(SetStatusText);
1397     CHECK_CALLED(UpdateUI);
1398     CHECK_CALLED(Exec_UPDATECOMMANDS);
1399     CHECK_CALLED(Exec_SETTITLE);
1400     CHECK_CALLED(Exec_HTTPEQUIV);
1401     CHECK_CALLED(Exec_SETPROGRESSMAX);
1402     CHECK_CALLED(Exec_SETPROGRESSPOS);
1403     CHECK_CALLED(Exec_MSHTML_2315);
1404     CHECK_CALLED(Exec_HTTPEQUIV_DONE);
1405
1406     load_state = LD_LOADED;
1407 }
1408
1409 #endif
1410
1411 static void test_Persist(IUnknown *unk)
1412 {
1413     IPersistMoniker *persist_mon;
1414     IPersistFile *persist_file;
1415     GUID guid;
1416     HRESULT hres;
1417
1418     hres = IUnknown_QueryInterface(unk, &IID_IPersistFile, (void**)&persist_file);
1419     ok(hres == S_OK, "QueryInterface(IID_IPersist) failed: %08lx\n", hres);
1420     if(SUCCEEDED(hres)) {
1421         hres = IPersist_GetClassID(persist_file, NULL);
1422         ok(hres == E_INVALIDARG, "GetClassID returned: %08lx, expected E_INVALIDARG\n", hres);
1423
1424         hres = IPersist_GetClassID(persist_file, &guid);
1425         ok(hres == S_OK, "GetClassID failed: %08lx\n", hres);
1426         ok(IsEqualGUID(&CLSID_HTMLDocument, &guid), "guid != CLSID_HTMLDocument\n");
1427
1428         IPersist_Release(persist_file);
1429     }
1430
1431     hres = IUnknown_QueryInterface(unk, &IID_IPersistMoniker, (void**)&persist_mon);
1432     ok(hres == S_OK, "QueryInterface(IID_IPersistMoniker) failed: %08lx\n", hres);
1433     if(SUCCEEDED(hres)) {
1434         hres = IPersistMoniker_GetClassID(persist_mon, NULL);
1435         ok(hres == E_INVALIDARG, "GetClassID returned: %08lx, expected E_INVALIDARG\n", hres);
1436
1437         hres = IPersistMoniker_GetClassID(persist_mon, &guid);
1438         ok(hres == S_OK, "GetClassID failed: %08lx\n", hres);
1439         ok(IsEqualGUID(&CLSID_HTMLDocument, &guid), "guid != CLSID_HTMLDocument\n");
1440
1441         if(load_state == LD_DOLOAD)
1442             test_Load(persist_mon);
1443
1444         IPersistMoniker_Release(persist_mon);
1445     }
1446 }
1447
1448 static const OLECMDF expect_cmds[OLECMDID_GETPRINTTEMPLATE+1] = {
1449     0,
1450     OLECMDF_SUPPORTED,                  /* OLECMDID_OPEN */
1451     OLECMDF_SUPPORTED,                  /* OLECMDID_NEW */
1452     OLECMDF_SUPPORTED,                  /* OLECMDID_SAVE */
1453     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_SAVEAS */
1454     OLECMDF_SUPPORTED,                  /* OLECMDID_SAVECOPYAS */
1455     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PRINT */
1456     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PRINTPREVIEW */
1457     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PAGESETUP */
1458     OLECMDF_SUPPORTED,                  /* OLECMDID_SPELL */
1459     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_PROPERTIES */
1460     OLECMDF_SUPPORTED,                  /* OLECMDID_CUT */
1461     OLECMDF_SUPPORTED,                  /* OLECMDID_COPY */
1462     OLECMDF_SUPPORTED,                  /* OLECMDID_PASTE */
1463     OLECMDF_SUPPORTED,                  /* OLECMDID_PASTESPECIAL */
1464     OLECMDF_SUPPORTED,                  /* OLECMDID_UNDO */
1465     OLECMDF_SUPPORTED,                  /* OLECMDID_REDO */
1466     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_SELECTALL */
1467     OLECMDF_SUPPORTED,                  /* OLECMDID_CLEARSELECTION */
1468     OLECMDF_SUPPORTED,                  /* OLECMDID_ZOOM */
1469     OLECMDF_SUPPORTED,                  /* OLECMDID_GETZOOMRANGE */
1470     0,
1471     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_REFRESH */
1472     OLECMDF_SUPPORTED|OLECMDF_ENABLED,  /* OLECMDID_STOP */
1473     0,0,0,0,0,0,
1474     OLECMDF_SUPPORTED,                  /* OLECMDID_STOPDOWNLOAD */
1475     0,0,
1476     OLECMDF_SUPPORTED,                  /* OLECMDID_DELETE */
1477     0,0,
1478     OLECMDF_SUPPORTED,                  /* OLECMDID_ENABLE_INTERACTION */
1479     OLECMDF_SUPPORTED,                  /* OLECMDID_ONUNLOAD */
1480     0,0,0,0,0,
1481     OLECMDF_SUPPORTED,                  /* OLECMDID_SHOWPAGESETUP */
1482     OLECMDF_SUPPORTED,                  /* OLECMDID_SHOWPRINT */
1483     0,0,
1484     OLECMDF_SUPPORTED,                  /* OLECMDID_CLOSE */
1485     0,0,0,
1486     OLECMDF_SUPPORTED,                  /* OLECMDID_SETPRINTTEMPLATE */
1487     OLECMDF_SUPPORTED                   /* OLECMDID_GETPRINTTEMPLATE */
1488 };
1489
1490 static void test_OleCommandTarget(IUnknown *unk)
1491 {
1492     IOleCommandTarget *cmdtrg;
1493     OLECMD cmds[OLECMDID_GETPRINTTEMPLATE];
1494     int i;
1495     HRESULT hres;
1496
1497     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
1498     ok(hres == S_OK, "QueryInterface(IIDIOleM=CommandTarget failed: %08lx\n", hres);
1499     if(FAILED(hres))
1500         return;
1501
1502     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
1503         cmds[i].cmdID = i+1;
1504         cmds[i].cmdf = 0xf0f0;
1505     }
1506
1507     SET_EXPECT(QueryStatus_OPEN);
1508     SET_EXPECT(QueryStatus_NEW);
1509     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, sizeof(cmds)/sizeof(cmds[0]), cmds, NULL);
1510     ok(hres == S_OK, "QueryStatus failed: %08lx\n", hres);
1511     CHECK_CALLED(QueryStatus_OPEN);
1512     CHECK_CALLED(QueryStatus_NEW);
1513
1514     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
1515         ok(cmds[i].cmdID == i+1, "cmds[%d].cmdID canged to %lx\n", i, cmds[i].cmdID);
1516         ok(cmds[i].cmdf == expect_cmds[i+1], "cmds[%d].cmdf=%lx, expected %x\n",
1517                 i+1, cmds[i].cmdf, expect_cmds[i+1]);
1518     }
1519
1520     IOleCommandTarget_Release(cmdtrg);
1521 }
1522
1523 static void test_OleCommandTarget_fail(IUnknown *unk)
1524 {
1525     IOleCommandTarget *cmdtrg;
1526     int i;
1527     HRESULT hres;
1528
1529     OLECMD cmd[2] = {
1530         {OLECMDID_OPEN, 0xf0f0},
1531         {OLECMDID_GETPRINTTEMPLATE+1, 0xf0f0}
1532     };
1533
1534     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
1535     ok(hres == S_OK, "QueryInterface(IIDIOleM=CommandTarget failed: %08lx\n", hres);
1536     if(FAILED(hres))
1537         return;
1538
1539     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 0, NULL, NULL);
1540     ok(hres == S_OK, "QueryStatus failed: %08lx\n", hres);
1541
1542     SET_EXPECT(QueryStatus_OPEN);
1543     hres = IOleCommandTarget_QueryStatus(cmdtrg, NULL, 2, cmd, NULL);
1544     CHECK_CALLED(QueryStatus_OPEN);
1545
1546     ok(hres == OLECMDERR_E_NOTSUPPORTED,
1547             "QueryStatus failed: %08lx, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
1548     ok(cmd[1].cmdID == OLECMDID_GETPRINTTEMPLATE+1,
1549             "cmd[0].cmdID=%ld, expected OLECMDID_GETPRINTTEMPLATE+1\n", cmd[0].cmdID);
1550     ok(cmd[1].cmdf == 0, "cmd[0].cmdf=%lx, expected 0\n", cmd[0].cmdf);
1551     ok(cmd[0].cmdf == OLECMDF_SUPPORTED,
1552             "cmd[1].cmdf=%lx, expected OLECMDF_SUPPORTED\n", cmd[1].cmdf);
1553
1554     hres = IOleCommandTarget_QueryStatus(cmdtrg, &IID_IHTMLDocument2, 2, cmd, NULL);
1555     ok(hres == OLECMDERR_E_UNKNOWNGROUP,
1556             "QueryStatus failed: %08lx, expected OLECMDERR_E_UNKNOWNGROUP\n", hres);
1557
1558     for(i=0; i<OLECMDID_GETPRINTTEMPLATE; i++) {
1559         if(!expect_cmds[i]) {
1560             hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_UPDATECOMMANDS,
1561                     OLECMDEXECOPT_DODEFAULT, NULL, NULL);
1562             ok(hres == OLECMDERR_E_NOTSUPPORTED,
1563                     "Exec failed: %08lx, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
1564         }
1565     }
1566
1567     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_GETPRINTTEMPLATE+1,
1568             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
1569     ok(hres == OLECMDERR_E_NOTSUPPORTED,
1570             "Exec failed: %08lx, expected OLECMDERR_E_NOTSUPPORTED\n", hres);
1571
1572     IOleCommandTarget_Release(cmdtrg);
1573 }
1574
1575 static void test_exec_onunload(IUnknown *unk)
1576 {
1577     IOleCommandTarget *cmdtrg;
1578     VARIANT var;
1579     HRESULT hres;
1580
1581     hres = IUnknown_QueryInterface(unk, &IID_IOleCommandTarget, (void**)&cmdtrg);
1582     ok(hres == S_OK, "QueryInterface(IID_IOleCommandTarget) failed: %08lx\n", hres);
1583     if(FAILED(hres))
1584         return;
1585
1586     memset(&var, 0x0a, sizeof(var));
1587     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_ONUNLOAD,
1588             OLECMDEXECOPT_DODEFAULT, NULL, &var);
1589     ok(hres == S_OK, "Exec(..., OLECMDID_ONUNLOAD, ...) failed: %08lx\n", hres);
1590     ok(V_VT(&var) == VT_BOOL, "V_VT(var)=%d, expected VT_BOOL\n", V_VT(&var));
1591     ok(V_BOOL(&var) == VARIANT_TRUE, "V_BOOL(var)=%x, expected VARIANT_TRUE\n", V_BOOL(&var));
1592
1593     hres = IOleCommandTarget_Exec(cmdtrg, NULL, OLECMDID_ONUNLOAD,
1594             OLECMDEXECOPT_DODEFAULT, NULL, NULL);
1595     ok(hres == S_OK, "Exec(..., OLECMDID_ONUNLOAD, ...) failed: %08lx\n", hres);
1596
1597     IOleCommandTarget_Release(cmdtrg);
1598 }
1599
1600 static HWND create_container_window(void)
1601 {
1602     static const WCHAR wszHTMLDocumentTest[] =
1603         {'H','T','M','L','D','o','c','u','m','e','n','t','T','e','s','t',0};
1604     static WNDCLASSEXW wndclass = {
1605         sizeof(WNDCLASSEXW),
1606         0,
1607         wnd_proc,
1608         0, 0, NULL, NULL, NULL, NULL, NULL,
1609         wszHTMLDocumentTest,
1610         NULL
1611     };
1612
1613     RegisterClassExW(&wndclass);
1614     return CreateWindowW(wszHTMLDocumentTest, wszHTMLDocumentTest,
1615             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
1616             CW_USEDEFAULT, NULL, NULL, NULL, NULL);
1617 }
1618
1619 static HRESULT test_DoVerb(IOleObject *oleobj)
1620 {
1621     RECT rect = {0,0,500,500};
1622     HRESULT hres;
1623
1624     if(!container_locked) {
1625         SET_EXPECT(GetContainer);
1626         SET_EXPECT(LockContainer);
1627     }
1628     SET_EXPECT(ActivateMe);
1629     expect_LockContainer_fLock = TRUE;
1630
1631     hres = IOleObject_DoVerb(oleobj, OLEIVERB_SHOW, NULL, &ClientSite, -1, container_hwnd, &rect);
1632     if(FAILED(hres))
1633         return hres;
1634     ok(hres == S_OK, "DoVerb failed: %08lx\n", hres);
1635
1636     if(!container_locked) {
1637         CHECK_CALLED(GetContainer);
1638         CHECK_CALLED(LockContainer);
1639         container_locked = TRUE;
1640     }
1641     CHECK_CALLED(ActivateMe);
1642
1643     return hres;
1644 }
1645
1646 #define CLIENTSITE_EXPECTPATH 0x00000001
1647 #define CLIENTSITE_SETNULL    0x00000002
1648 #define CLIENTSITE_DONTSET    0x00000004
1649
1650 static void test_ClientSite(IOleObject *oleobj, DWORD flags)
1651 {
1652     IOleClientSite *clientsite;
1653     HRESULT hres;
1654
1655     if(flags & CLIENTSITE_SETNULL) {
1656         hres = IOleObject_GetClientSite(oleobj, &clientsite);
1657         ok(clientsite == &ClientSite, "clientsite=%p, expected %p\n", clientsite, &ClientSite);
1658
1659         hres = IOleObject_SetClientSite(oleobj, NULL);
1660         ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
1661
1662         set_clientsite = FALSE;
1663     }
1664
1665     if(flags & CLIENTSITE_DONTSET)
1666         return;
1667
1668     hres = IOleObject_GetClientSite(oleobj, &clientsite);
1669     ok(hres == S_OK, "GetClientSite failed: %08lx\n", hres);
1670     ok(clientsite == (set_clientsite ? &ClientSite : NULL), "GetClientSite() = %p, expected %p\n",
1671             clientsite, set_clientsite ? &ClientSite : NULL);
1672
1673     if(!set_clientsite) {
1674         SET_EXPECT(GetHostInfo);
1675         if(flags & CLIENTSITE_EXPECTPATH) {
1676             SET_EXPECT(GetOptionKeyPath);
1677             SET_EXPECT(GetOverrideKeyPath);
1678         }
1679         SET_EXPECT(GetWindow);
1680         SET_EXPECT(QueryStatus_SETPROGRESSTEXT);
1681         SET_EXPECT(Exec_SETPROGRESSMAX);
1682         SET_EXPECT(Exec_SETPROGRESSPOS);
1683         SET_EXPECT(Invoke_AMBIENT_USERMODE);
1684         SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1685         SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1686         SET_EXPECT(Invoke_AMBIENT_SILENT);
1687         SET_EXPECT(Invoke_AMBIENT_USERAGENT);
1688         SET_EXPECT(Invoke_AMBIENT_PALETTE);
1689
1690         hres = IOleObject_SetClientSite(oleobj, &ClientSite);
1691         ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
1692
1693         CHECK_CALLED(GetHostInfo);
1694         if(flags & CLIENTSITE_EXPECTPATH) {
1695             CHECK_CALLED(GetOptionKeyPath);
1696             CHECK_CALLED(GetOverrideKeyPath);
1697         }
1698         CHECK_CALLED(GetWindow);
1699         CHECK_CALLED(QueryStatus_SETPROGRESSTEXT);
1700         CHECK_CALLED(Exec_SETPROGRESSMAX);
1701         CHECK_CALLED(Exec_SETPROGRESSPOS);
1702         CHECK_CALLED(Invoke_AMBIENT_USERMODE);
1703         CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1704         CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1705         CHECK_CALLED(Invoke_AMBIENT_SILENT);
1706         CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
1707         CHECK_CALLED(Invoke_AMBIENT_PALETTE);
1708
1709         set_clientsite = TRUE;
1710     }
1711
1712     hres = IOleObject_SetClientSite(oleobj, &ClientSite);
1713     ok(hres == S_OK, "SetClientSite failed: %08lx\n", hres);
1714
1715     hres = IOleObject_GetClientSite(oleobj, &clientsite);
1716     ok(hres == S_OK, "GetClientSite failed: %08lx\n", hres);
1717     ok(clientsite == &ClientSite, "GetClientSite() = %p, expected %p\n", clientsite, &ClientSite);
1718 }
1719
1720 static void test_OnAmbientPropertyChange(IUnknown *unk)
1721 {
1722     IOleControl *control = NULL;
1723     HRESULT hres;
1724
1725     hres = IUnknown_QueryInterface(unk, &IID_IOleControl, (void**)&control);
1726     ok(hres == S_OK, "QueryInterface(IID_IOleControl failed: %08lx\n", hres);
1727     if(FAILED(hres))
1728         return;
1729
1730     SET_EXPECT(Invoke_AMBIENT_USERMODE);
1731     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_USERMODE);
1732     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1733     CHECK_CALLED(Invoke_AMBIENT_USERMODE);
1734
1735     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1736     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_DLCONTROL);
1737     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1738     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1739
1740     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1741     SET_EXPECT(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1742     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_OFFLINEIFNOTCONNECTED);
1743     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1744     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1745     CHECK_CALLED(Invoke_AMBIENT_OFFLINEIFNOTCONNECTED);
1746
1747     SET_EXPECT(Invoke_AMBIENT_DLCONTROL);
1748     SET_EXPECT(Invoke_AMBIENT_SILENT);
1749     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_SILENT);
1750     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1751     CHECK_CALLED(Invoke_AMBIENT_DLCONTROL);
1752     CHECK_CALLED(Invoke_AMBIENT_SILENT);
1753
1754     SET_EXPECT(Invoke_AMBIENT_USERAGENT);
1755     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_USERAGENT);
1756     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1757     CHECK_CALLED(Invoke_AMBIENT_USERAGENT);
1758
1759     SET_EXPECT(Invoke_AMBIENT_PALETTE);
1760     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_PALETTE);
1761     ok(hres == S_OK, "OnAmbientChange failed: %08lx\n", hres);
1762     CHECK_CALLED(Invoke_AMBIENT_PALETTE);
1763
1764     IOleControl_Release(control);
1765 }
1766
1767
1768
1769 static void test_OnAmbientPropertyChange2(IUnknown *unk)
1770 {
1771     IOleControl *control = NULL;
1772     HRESULT hres;
1773
1774     hres = IUnknown_QueryInterface(unk, &IID_IOleControl, (void**)&control);
1775     ok(hres == S_OK, "QueryInterface(IID_IOleControl failed: %08lx\n", hres);
1776     if(FAILED(hres))
1777         return;
1778
1779     hres = IOleControl_OnAmbientPropertyChange(control, DISPID_AMBIENT_PALETTE);
1780     ok(hres == S_OK, "OnAmbientPropertyChange failed: %08lx\n", hres);
1781
1782     IOleControl_Release(control);
1783 }
1784
1785 static void test_Close(IUnknown *unk, BOOL set_client)
1786 {
1787     IOleObject *oleobj = NULL;
1788     HRESULT hres;
1789
1790     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
1791     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08lx\n", hres);
1792     if(FAILED(hres))
1793         return;
1794
1795     SET_EXPECT(GetContainer);
1796     SET_EXPECT(LockContainer);
1797     expect_LockContainer_fLock = FALSE;
1798     hres = IOleObject_Close(oleobj, OLECLOSE_NOSAVE);
1799     ok(hres == S_OK, "Close failed: %08lx\n", hres);
1800     CHECK_CALLED(GetContainer);
1801     CHECK_CALLED(LockContainer);
1802     container_locked = FALSE;
1803
1804     if(set_client)
1805         test_ClientSite(oleobj, CLIENTSITE_SETNULL|CLIENTSITE_DONTSET);
1806
1807     IOleObject_Release(oleobj);
1808 }
1809
1810 static void test_InPlaceDeactivate(IUnknown *unk, BOOL expect_call)
1811 {
1812     IOleInPlaceObjectWindowless *windowlessobj = NULL;
1813     HRESULT hres;
1814
1815     hres = IUnknown_QueryInterface(unk, &IID_IOleInPlaceObjectWindowless,
1816             (void**)&windowlessobj);
1817     ok(hres == S_OK, "QueryInterface(IID_IOleInPlaceObjectWindowless) failed: %08lx\n", hres);
1818     if(FAILED(hres))
1819         return;
1820
1821     if(expect_call) SET_EXPECT(OnInPlaceDeactivate);
1822     hres = IOleInPlaceObjectWindowless_InPlaceDeactivate(windowlessobj);
1823     ok(hres == S_OK, "InPlaceDeactivate failed: %08lx\n", hres);
1824     if(expect_call) CHECK_CALLED(OnInPlaceDeactivate);
1825
1826     IOleInPlaceObjectWindowless_Release(windowlessobj);
1827 }
1828
1829 static HRESULT test_Activate(IUnknown *unk, DWORD flags)
1830 {
1831     IOleObject *oleobj = NULL;
1832     GUID guid;
1833     HRESULT hres;
1834
1835     last_hwnd = hwnd;
1836
1837     if(view)
1838         IOleDocumentView_Release(view);
1839     view = NULL;
1840
1841     hres = IUnknown_QueryInterface(unk, &IID_IOleObject, (void**)&oleobj);
1842     ok(hres == S_OK, "QueryInterface(IID_IOleObject) failed: %08lx\n", hres);
1843     if(FAILED(hres))
1844         return hres;
1845
1846     hres = IOleObject_GetUserClassID(oleobj, NULL);
1847     ok(hres == E_INVALIDARG, "GetUserClassID returned: %08lx, expected E_INVALIDARG\n", hres);
1848
1849     hres = IOleObject_GetUserClassID(oleobj, &guid);
1850     ok(hres == S_OK, "GetUserClassID failed: %08lx\n", hres);
1851     ok(IsEqualGUID(&guid, &CLSID_HTMLDocument), "guid != CLSID_HTMLDocument\n");
1852
1853     test_ClientSite(oleobj, flags);
1854     test_InPlaceDeactivate(unk, FALSE);
1855
1856     hres = test_DoVerb(oleobj);
1857
1858     IOleObject_Release(oleobj);
1859     return hres;
1860 }
1861
1862 static void test_Window(IUnknown *unk, BOOL expect_success)
1863 {
1864     IOleInPlaceActiveObject *activeobject = NULL;
1865     HWND tmp_hwnd;
1866     HRESULT hres;
1867
1868     hres = IOleDocumentView_QueryInterface(view, &IID_IOleInPlaceActiveObject, (void**)&activeobject);
1869     ok(hres == S_OK, "Could not get IOleInPlaceActiveObject interface: %08lx\n", hres);
1870     if(FAILED(hres))
1871         return;
1872
1873     hres = IOleInPlaceActiveObject_GetWindow(activeobject, &tmp_hwnd);
1874
1875     if(expect_success) {
1876         ok(hres == S_OK, "GetWindow failed: %08lx\n", hres);
1877         ok(tmp_hwnd == hwnd, "tmp_hwnd=%p, expected %p\n", tmp_hwnd, hwnd);
1878     }else {
1879         ok(hres == E_FAIL, "GetWindow returned %08lx, expected E_FAIL\n", hres);
1880         ok(IsWindow(hwnd), "hwnd is destroyed\n");
1881     }
1882
1883     IOleInPlaceActiveObject_Release(activeobject);
1884 }
1885
1886 static void test_CloseView(void)
1887 {
1888     IOleInPlaceSite *inplacesite = (IOleInPlaceSite*)0xff00ff00;
1889     HRESULT hres;
1890
1891     if(!view)
1892         return;
1893
1894     hres = IOleDocumentView_Show(view, FALSE);
1895     ok(hres == S_OK, "Show failed: %08lx\n", hres);
1896
1897     hres = IOleDocumentView_CloseView(view, 0);
1898     ok(hres == S_OK, "CloseView failed: %08lx\n", hres);
1899
1900     hres = IOleDocumentView_SetInPlaceSite(view, NULL);
1901     ok(hres == S_OK, "SetInPlaceSite failed: %08lx\n", hres);
1902
1903     hres = IOleDocumentView_GetInPlaceSite(view, &inplacesite);
1904     ok(hres == S_OK, "SetInPlaceSite failed: %08lx\n", hres);
1905     ok(inplacesite == NULL, "inplacesite=%p, expected NULL\n", inplacesite);
1906 }
1907
1908 static void test_UIDeactivate(void)
1909 {
1910     HRESULT hres;
1911
1912     if(call_UIActivate) {
1913         SET_EXPECT(SetActiveObject);
1914         SET_EXPECT(HideUI);
1915         SET_EXPECT(OnUIDeactivate);
1916     }
1917
1918     expect_SetActiveObject_active = FALSE;
1919     hres = IOleDocumentView_UIActivate(view, FALSE);
1920     ok(hres == S_OK, "UIActivate failed: %08lx\n", hres);
1921
1922     if(call_UIActivate) {
1923         CHECK_CALLED(SetActiveObject);
1924         CHECK_CALLED(HideUI);
1925         CHECK_CALLED(OnUIDeactivate);
1926     }
1927 }
1928
1929 static void test_Hide(void)
1930 {
1931     HRESULT hres;
1932
1933     if(!view)
1934         return;
1935
1936     hres = IOleDocumentView_Show(view, FALSE);
1937     ok(hres == S_OK, "Show failed: %08lx\n", hres);
1938 }
1939
1940 static HRESULT create_document(IUnknown **unk)
1941 {
1942     HRESULT hres = CoCreateInstance(&CLSID_HTMLDocument, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
1943             &IID_IUnknown, (void**)unk);
1944     ok(hres == S_OK, "CoCreateInstance failed: %08lx\n", hres);
1945     return hres;
1946 }
1947
1948 static void test_Navigate(IUnknown *unk)
1949 {
1950     IHlinkTarget *hlink;
1951     HRESULT hres;
1952
1953     hres = IUnknown_QueryInterface(unk, &IID_IHlinkTarget, (void**)&hlink);
1954     ok(hres == S_OK, "QueryInterface(IID_IHlinkTarget) failed: %08lx\n", hres);
1955
1956     SET_EXPECT(ActivateMe);
1957     hres = IHlinkTarget_Navigate(hlink, 0, NULL);
1958     ok(hres == S_OK, "Navigate failed: %08lx\n", hres);
1959     CHECK_CALLED(ActivateMe);
1960
1961     IHlinkTarget_Release(hlink);
1962 }
1963
1964 static void test_HTMLDocument(void)
1965 {
1966     IUnknown *unk;
1967     HRESULT hres;
1968     ULONG ref;
1969
1970     hwnd = last_hwnd = NULL;
1971
1972     hres = create_document(&unk);
1973     if(FAILED(hres))
1974         return;
1975
1976     test_ConnectionPointContainer(unk);
1977     test_Persist(unk);
1978     if(load_state == LD_NO)
1979         test_OnAmbientPropertyChange2(unk);
1980
1981     hres = test_Activate(unk, CLIENTSITE_EXPECTPATH);
1982     if(FAILED(hres)) {
1983         IUnknown_Release(unk);
1984         return;
1985     }
1986
1987 #ifdef DOWNLOAD_TEST
1988     if(load_state == LD_DOLOAD)
1989         test_download();
1990 #endif
1991
1992     test_OleCommandTarget_fail(unk);
1993     test_OleCommandTarget(unk);
1994     test_OnAmbientPropertyChange(unk);
1995     test_Window(unk, TRUE);
1996     test_UIDeactivate();
1997     test_OleCommandTarget(unk);
1998     test_Window(unk, TRUE);
1999     test_InPlaceDeactivate(unk, TRUE);
2000
2001     /* Calling test_OleCommandTarget here couses Segmentation Fault with native
2002      * MSHTML. It doesn't with Wine. */
2003
2004     test_Window(unk, FALSE);
2005     test_Hide();
2006     test_InPlaceDeactivate(unk, FALSE);
2007     test_CloseView();
2008     test_Close(unk, FALSE);
2009
2010     /* Activate HTMLDocument again */
2011     test_Activate(unk, CLIENTSITE_SETNULL);
2012     test_Window(unk, TRUE);
2013     test_OleCommandTarget(unk);
2014     test_UIDeactivate();
2015     test_InPlaceDeactivate(unk, TRUE);
2016     test_Close(unk, FALSE);
2017
2018     /* Activate HTMLDocument again, this time without UIActivate */
2019     call_UIActivate = FALSE;
2020     test_Activate(unk, CLIENTSITE_SETNULL);
2021     test_Window(unk, TRUE);
2022     test_UIDeactivate();
2023     test_InPlaceDeactivate(unk, TRUE);
2024     test_CloseView();
2025     test_CloseView();
2026     test_Close(unk, TRUE);
2027     test_OnAmbientPropertyChange2(unk);
2028
2029     if(view)
2030         IOleDocumentView_Release(view);
2031     view = NULL;
2032
2033     ok(IsWindow(hwnd), "hwnd is destroyed\n");
2034
2035     ref = IUnknown_Release(unk);
2036     ok(ref == 0, "ref=%ld, expected 0\n", ref);
2037
2038     ok(!IsWindow(hwnd), "hwnd is not destroyed\n");
2039
2040 }
2041
2042 static void test_HTMLDocument_hlink(void)
2043 {
2044     IUnknown *unk;
2045     HRESULT hres;
2046     ULONG ref;
2047
2048     hwnd = last_hwnd = NULL;
2049
2050     hres = create_document(&unk);
2051     if(FAILED(hres))
2052         return;
2053
2054     test_Persist(unk);
2055     test_Navigate(unk);
2056
2057 #ifdef DOWNLOAD_TEST
2058     test_download();
2059 #endif
2060
2061     test_exec_onunload(unk);
2062     test_Window(unk, TRUE);
2063     test_InPlaceDeactivate(unk, TRUE);
2064     test_Close(unk, FALSE);
2065
2066     if(view)
2067         IOleDocumentView_Release(view);
2068     view = NULL;
2069
2070     ref = IUnknown_Release(unk);
2071     ok(ref == 0, "ref=%ld, expected 0\n", ref);
2072 }
2073
2074 static void gecko_installer_workaround(BOOL disable)
2075 {
2076     HKEY hkey;
2077     DWORD res;
2078
2079     static BOOL has_url = FALSE;
2080     static char url[2048];
2081
2082     if(!disable && !has_url)
2083         return;
2084
2085     res = RegOpenKey(HKEY_CURRENT_USER, "Software\\Wine\\MSHTML", &hkey);
2086     if(res != ERROR_SUCCESS)
2087         return;
2088
2089     if(disable) {
2090         DWORD type, size = sizeof(url);
2091
2092         res = RegQueryValueEx(hkey, "GeckoUrl", NULL, &type, (PVOID)url, &size);
2093         if(res == ERROR_SUCCESS && type == REG_SZ)
2094             has_url = TRUE;
2095
2096         RegDeleteValue(hkey, "GeckoUrl");
2097     }else {
2098         RegSetValueEx(hkey, "GeckoUrl", 0, REG_SZ, (PVOID)url, lstrlenA(url)+1);
2099     }
2100
2101     RegCloseKey(hkey);
2102 }
2103
2104 START_TEST(htmldoc)
2105 {
2106     gecko_installer_workaround(TRUE);
2107
2108     CoInitialize(NULL);
2109     container_hwnd = create_container_window();
2110
2111     load_state = LD_NO;
2112     test_HTMLDocument();
2113     load_state = LD_DOLOAD;
2114     test_HTMLDocument();
2115     load_state = LD_DOLOAD;
2116     test_HTMLDocument_hlink();
2117
2118     DestroyWindow(container_hwnd);
2119     CoUninitialize();
2120
2121     gecko_installer_workaround(FALSE);
2122 }