dlls/mshtml/persist.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 #include <stdarg.h>
  20 #include <stdio.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "ole2.h"
  28 #include "shlguid.h"
  29 #include "idispids.h"
  30 #include "mimeole.h"
  31 #include "shellapi.h"
  32
  33 #define NO_SHLWAPI_REG
  34 #include "shlwapi.h"
  35
  36 #include "wine/debug.h"
  37
  38 #include "mshtml_private.h"
  39 #include "htmlscript.h"
  40 #include "htmlevent.h"
  41 #include "binding.h"
  42 #include "resource.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  45
  46 /* Undocumented notification, see tests */
  47 #define CMDID_EXPLORER_UPDATEHISTORY 38
  48
  49 typedef struct {
  50     task_t header;
  51     HTMLDocumentObj *doc;
  52     BOOL set_download;
  53     LPOLESTR url;
  54 } download_proc_task_t;
  55
  56 static void notify_travellog_update(HTMLDocumentObj *doc)
  57 {
  58     IOleCommandTarget *cmdtrg;
  59     HRESULT hres;
  60
  61     if(!doc->webbrowser)
  62         return;
  63
  64     hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&cmdtrg);
  65     if(SUCCEEDED(hres)) {
  66         VARIANT vin;
  67
  68         V_VT(&vin) = VT_I4;
  69         V_I4(&vin) = 0;
  70
  71         IOleCommandTarget_Exec(cmdtrg, &CGID_Explorer, CMDID_EXPLORER_UPDATEHISTORY, 0, &vin, NULL);
  72         IOleCommandTarget_Release(cmdtrg);
  73     }
  74 }
  75
  76 void set_current_uri(HTMLOuterWindow *window, IUri *uri)
  77 {
  78     if(window->uri) {
  79         IUri_Release(window->uri);
  80         window->uri = NULL;
  81     }
  82
  83     if(window->uri_nofrag) {
  84         IUri_Release(window->uri_nofrag);
  85         window->uri_nofrag = NULL;
  86     }
  87
  88     SysFreeString(window->url);
  89     window->url = NULL;
  90
  91     if(!uri)
  92         return;
  93
  94     IUri_AddRef(uri);
  95     window->uri = uri;
  96
  97     window->uri_nofrag = get_uri_nofrag(uri);
  98     if(!window->uri_nofrag) {
  99         FIXME("get_uri_nofrag failed\n");
 100         IUri_AddRef(uri);
 101         window->uri_nofrag = uri;
 102     }
 103
 104     IUri_GetDisplayUri(uri, &window->url);
 105 }
 106
 107 void set_current_mon(HTMLOuterWindow *This, IMoniker *mon, DWORD flags)
 108 {
 109     IUriContainer *uri_container;
 110     IUri *uri = NULL;
 111     HRESULT hres;
 112
 113     if(This->mon) {
 114         if(This->browser && !(flags & (BINDING_REPLACE|BINDING_REFRESH))) {
 115             if(is_main_content_window(This))
 116                 notify_travellog_update(This->browser->doc);
 117             else
 118                 TRACE("Skipping travellog update for frame navigation.\n");
 119         }
 120         IMoniker_Release(This->mon);
 121         This->mon = NULL;
 122     }
 123
 124     This->load_flags = flags;
 125     if(!mon)
 126         return;
 127
 128     IMoniker_AddRef(mon);
 129     This->mon = mon;
 130
 131     hres = IMoniker_QueryInterface(mon, &IID_IUriContainer, (void**)&uri_container);
 132     if(SUCCEEDED(hres)) {
 133         hres = IUriContainer_GetIUri(uri_container, &uri);
 134         IUriContainer_Release(uri_container);
 135         if(hres != S_OK) {
 136             WARN("GetIUri failed: %08lx\n", hres);
 137             uri = NULL;
 138         }
 139     }
 140
 141     if(!uri) {
 142         WCHAR *url;
 143
 144         hres = IMoniker_GetDisplayName(mon, NULL, NULL, &url);
 145         if(SUCCEEDED(hres)) {
 146             hres = create_uri(url, 0, &uri);
 147             if(FAILED(hres)) {
 148                 WARN("CreateUri failed: %08lx\n", hres);
 149                 set_current_uri(This, NULL);
 150                 This->url = SysAllocString(url);
 151                 CoTaskMemFree(url);
 152                 return;
 153             }
 154             CoTaskMemFree(url);
 155         }else {
 156             WARN("GetDisplayName failed: %08lx\n", hres);
 157         }
 158     }
 159
 160     set_current_uri(This, uri);
 161     if(uri)
 162         IUri_Release(uri);
 163
 164     if(is_main_content_window(This))
 165         update_browser_script_mode(This->browser, uri);
 166 }
 167
 168 HRESULT create_uri(const WCHAR *uri_str, DWORD flags, IUri **uri)
 169 {
 170     return CreateUri(uri_str, flags | Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME, 0, uri);
 171 }
 172
 173 HRESULT create_relative_uri(HTMLOuterWindow *window, const WCHAR *rel_uri, IUri **uri)
 174 {
 175     return window->uri
 176         ? CoInternetCombineUrlEx(window->uri, rel_uri, URL_ESCAPE_SPACES_ONLY|URL_DONT_ESCAPE_EXTRA_INFO, uri, 0)
 177         : create_uri(rel_uri, 0, uri);
 178 }
 179
 180 void set_download_state(HTMLDocumentObj *doc, int state)
 181 {
 182     if(doc->client) {
 183         IOleCommandTarget *olecmd;
 184         HRESULT hres;
 185
 186         hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
 187         if(SUCCEEDED(hres)) {
 188             VARIANT var;
 189
 190             V_VT(&var) = VT_I4;
 191             V_I4(&var) = state;
 192
 193             IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETDOWNLOADSTATE,
 194                     OLECMDEXECOPT_DONTPROMPTUSER, &var, NULL);
 195             IOleCommandTarget_Release(olecmd);
 196         }
 197     }
 198
 199     doc->download_state = state;
 200 }
 201
 202 static void set_progress_proc(task_t *_task)
 203 {
 204     docobj_task_t *task = (docobj_task_t*)_task;
 205     IOleCommandTarget *olecmd = NULL;
 206     HTMLDocumentObj *doc = task->doc;
 207     HRESULT hres;
 208
 209     TRACE("(%p)\n", doc);
 210
 211     if(doc->client)
 212         IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
 213
 214     if(olecmd) {
 215         VARIANT progress_max, progress;
 216
 217         V_VT(&progress_max) = VT_I4;
 218         V_I4(&progress_max) = 0; /* FIXME */
 219         IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETPROGRESSMAX, OLECMDEXECOPT_DONTPROMPTUSER,
 220                                &progress_max, NULL);
 221
 222         V_VT(&progress) = VT_I4;
 223         V_I4(&progress) = 0; /* FIXME */
 224         IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETPROGRESSPOS, OLECMDEXECOPT_DONTPROMPTUSER,
 225                                &progress, NULL);
 226         IOleCommandTarget_Release(olecmd);
 227     }
 228
 229     if(doc->nscontainer->usermode == EDITMODE && doc->hostui) {
 230         DOCHOSTUIINFO hostinfo;
 231
 232         memset(&hostinfo, 0, sizeof(DOCHOSTUIINFO));
 233         hostinfo.cbSize = sizeof(DOCHOSTUIINFO);
 234         hres = IDocHostUIHandler_GetHostInfo(doc->hostui, &hostinfo);
 235         if(SUCCEEDED(hres))
 236             /* FIXME: use hostinfo */
 237             TRACE("hostinfo = {%lu %08lx %08lx %s %s}\n",
 238                     hostinfo.cbSize, hostinfo.dwFlags, hostinfo.dwDoubleClick,
 239                     debugstr_w(hostinfo.pchHostCss), debugstr_w(hostinfo.pchHostNS));
 240     }
 241 }
 242
 243 static void set_downloading_proc(task_t *_task)
 244 {
 245     download_proc_task_t *task = (download_proc_task_t*)_task;
 246     HTMLDocumentObj *doc = task->doc;
 247     HRESULT hres;
 248
 249     TRACE("(%p)\n", doc);
 250
 251     set_statustext(doc, IDS_STATUS_DOWNLOADINGFROM, task->url);
 252
 253     if(task->set_download)
 254         set_download_state(doc, 1);
 255
 256     if(!doc->client)
 257         return;
 258
 259     if(doc->view_sink)
 260         IAdviseSink_OnViewChange(doc->view_sink, DVASPECT_CONTENT, -1);
 261
 262     if(doc->hostui) {
 263         IDropTarget *drop_target = NULL;
 264
 265         hres = IDocHostUIHandler_GetDropTarget(doc->hostui, NULL /* FIXME */, &drop_target);
 266         if(SUCCEEDED(hres) && drop_target) {
 267             FIXME("Use IDropTarget\n");
 268             IDropTarget_Release(drop_target);
 269         }
 270     }
 271 }
 272
 273 static void set_downloading_task_destr(task_t *_task)
 274 {
 275     download_proc_task_t *task = (download_proc_task_t*)_task;
 276
 277     CoTaskMemFree(task->url);
 278     free(task);
 279 }
 280
 281 void prepare_for_binding(HTMLDocumentObj *This, IMoniker *mon, DWORD flags)
 282 {
 283     HRESULT hres;
 284
 285     if(This->client) {
 286         VARIANT silent, offline;
 287
 288         hres = get_client_disp_property(This->client, DISPID_AMBIENT_SILENT, &silent);
 289         if(SUCCEEDED(hres)) {
 290             if(V_VT(&silent) != VT_BOOL)
 291                 WARN("silent = %s\n", debugstr_variant(&silent));
 292             else if(V_BOOL(&silent))
 293                 FIXME("silent == true\n");
 294         }
 295
 296         hres = get_client_disp_property(This->client, DISPID_AMBIENT_OFFLINEIFNOTCONNECTED, &offline);
 297         if(SUCCEEDED(hres)) {
 298             if(V_VT(&offline) != VT_BOOL)
 299                 WARN("offline = %s\n", debugstr_variant(&offline));
 300             else if(V_BOOL(&offline))
 301                 FIXME("offline == true\n");
 302         }
 303     }
 304
 305     if(This->window->mon) {
 306         update_doc(This, UPDATE_TITLE|UPDATE_UI);
 307     }else {
 308         update_doc(This, UPDATE_TITLE);
 309         set_current_mon(This->window, mon, flags);
 310     }
 311
 312     if(This->client) {
 313         IOleCommandTarget *cmdtrg = NULL;
 314
 315         hres = IOleClientSite_QueryInterface(This->client, &IID_IOleCommandTarget, (void**)&cmdtrg);
 316         if(SUCCEEDED(hres)) {
 317             VARIANT var, out;
 318
 319             if(flags & BINDING_NAVIGATED) {
 320                 V_VT(&var) = VT_UNKNOWN;
 321                 V_UNKNOWN(&var) = (IUnknown*)&This->window->base.IHTMLWindow2_iface;
 322                 V_VT(&out) = VT_EMPTY;
 323                 hres = IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 63, 0, &var, &out);
 324                 if(SUCCEEDED(hres))
 325                     VariantClear(&out);
 326             }else if(!(flags & BINDING_FROMHIST)) {
 327                 V_VT(&var) = VT_I4;
 328                 V_I4(&var) = 0;
 329                 IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 37, 0, &var, NULL);
 330             }
 331
 332             IOleCommandTarget_Release(cmdtrg);
 333         }
 334     }
 335 }
 336
 337 HRESULT set_moniker(HTMLOuterWindow *window, IMoniker *mon, IUri *nav_uri, IBindCtx *pibc, nsChannelBSC *async_bsc,
 338         BOOL set_download)
 339 {
 340     download_proc_task_t *download_task;
 341     HTMLDocumentObj *doc_obj = NULL;
 342     nsChannelBSC *bscallback;
 343     nsWineURI *nsuri;
 344     LPOLESTR url;
 345     IUri *uri;
 346     HRESULT hres;
 347
 348     if(is_main_content_window(window))
 349         doc_obj = window->browser->doc;
 350
 351     hres = IMoniker_GetDisplayName(mon, pibc, NULL, &url);
 352     if(FAILED(hres)) {
 353         WARN("GetDisplayName failed: %08lx\n", hres);
 354         return hres;
 355     }
 356
 357     if(nav_uri) {
 358         uri = nav_uri;
 359     }else {
 360         hres = create_uri(url, 0, &uri);
 361         if(FAILED(hres)) {
 362             CoTaskMemFree(url);
 363             return hres;
 364         }
 365     }
 366
 367     TRACE("got url: %s\n", debugstr_w(url));
 368
 369     set_ready_state(window, READYSTATE_LOADING);
 370
 371     hres = create_doc_uri(uri, &nsuri);
 372     if(!nav_uri)
 373         IUri_Release(uri);
 374     if(SUCCEEDED(hres)) {
 375         if(async_bsc)
 376             bscallback = async_bsc;
 377         else
 378             hres = create_channelbsc(mon, NULL, NULL, 0, TRUE, &bscallback);
 379     }
 380
 381     if(SUCCEEDED(hres)) {
 382         if(window->base.inner_window->doc)
 383             remove_target_tasks(window->base.inner_window->task_magic);
 384         abort_window_bindings(window->base.inner_window);
 385
 386         hres = load_nsuri(window, nsuri, NULL, bscallback, LOAD_FLAGS_BYPASS_CACHE);
 387         nsISupports_Release((nsISupports*)nsuri); /* FIXME */
 388         if(SUCCEEDED(hres)) {
 389             hres = create_pending_window(window, bscallback);
 390             TRACE("pending window for %p %p %p\n", window, bscallback, window->pending_window);
 391         }
 392         if(bscallback != async_bsc)
 393             IBindStatusCallback_Release(&bscallback->bsc.IBindStatusCallback_iface);
 394     }
 395
 396     if(FAILED(hres)) {
 397         CoTaskMemFree(url);
 398         return hres;
 399     }
 400
 401     if(doc_obj) {
 402         HTMLDocument_LockContainer(doc_obj, TRUE);
 403
 404         if(doc_obj->frame) {
 405             docobj_task_t *task;
 406
 407             task = malloc(sizeof(docobj_task_t));
 408             task->doc = doc_obj;
 409             hres = push_task(&task->header, set_progress_proc, NULL, doc_obj->task_magic);
 410             if(FAILED(hres)) {
 411                 CoTaskMemFree(url);
 412                 return hres;
 413             }
 414         }
 415
 416         if(doc_obj->nscontainer->usermode == EDITMODE)
 417             window->load_flags = BINDING_REFRESH;
 418
 419         download_task = malloc(sizeof(download_proc_task_t));
 420         download_task->doc = doc_obj;
 421         download_task->set_download = set_download;
 422         download_task->url = url;
 423         return push_task(&download_task->header, set_downloading_proc, set_downloading_task_destr, doc_obj->task_magic);
 424     }
 425
 426     return S_OK;
 427 }
 428
 429 static void notif_readystate(HTMLOuterWindow *window)
 430 {
 431     DOMEvent *event;
 432     HRESULT hres;
 433
 434     window->readystate_pending = FALSE;
 435
 436     if(is_main_content_window(window))
 437         call_property_onchanged(&window->browser->doc->cp_container, DISPID_READYSTATE);
 438
 439     hres = create_document_event(window->base.inner_window->doc, EVENTID_READYSTATECHANGE, &event);
 440     if(SUCCEEDED(hres)) {
 441         event->no_event_obj = TRUE;
 442         dispatch_event(&window->base.inner_window->doc->node.event_target, event);
 443         IDOMEvent_Release(&event->IDOMEvent_iface);
 444     }
 445
 446     if(window->frame_element) {
 447         hres = create_document_event(window->frame_element->element.node.doc, EVENTID_READYSTATECHANGE, &event);
 448         if(SUCCEEDED(hres)) {
 449             dispatch_event(&window->frame_element->element.node.event_target, event);
 450             IDOMEvent_Release(&event->IDOMEvent_iface);
 451         }
 452     }
 453 }
 454
 455 typedef struct {
 456     task_t header;
 457     HTMLOuterWindow *window;
 458 } readystate_task_t;
 459
 460 static void notif_readystate_proc(task_t *_task)
 461 {
 462     readystate_task_t *task = (readystate_task_t*)_task;
 463     notif_readystate(task->window);
 464 }
 465
 466 static void notif_readystate_destr(task_t *_task)
 467 {
 468     readystate_task_t *task = (readystate_task_t*)_task;
 469     IHTMLWindow2_Release(&task->window->base.IHTMLWindow2_iface);
 470 }
 471
 472 void set_ready_state(HTMLOuterWindow *window, READYSTATE readystate)
 473 {
 474     READYSTATE prev_state = window->readystate;
 475
 476     window->readystate = readystate;
 477
 478     if(window->readystate_locked) {
 479         readystate_task_t *task;
 480         HRESULT hres;
 481
 482         if(window->readystate_pending || prev_state == readystate)
 483             return;
 484
 485         task = malloc(sizeof(*task));
 486         if(!task)
 487             return;
 488
 489         IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
 490         task->window = window;
 491
 492         hres = push_task(&task->header, notif_readystate_proc, notif_readystate_destr, window->task_magic);
 493         if(SUCCEEDED(hres))
 494             window->readystate_pending = TRUE;
 495         return;
 496     }
 497
 498     notif_readystate(window);
 499 }
 500
 501 static HRESULT get_doc_string(HTMLDocumentNode *This, char **str)
 502 {
 503     nsIDOMNode *nsnode;
 504     LPCWSTR strw;
 505     nsAString nsstr;
 506     nsresult nsres;
 507     HRESULT hres;
 508
 509     if(!This->dom_document) {
 510         WARN("NULL dom_document\n");
 511         return E_UNEXPECTED;
 512     }
 513
 514     nsres = nsIDOMDocument_QueryInterface(This->dom_document, &IID_nsIDOMNode, (void**)&nsnode);
 515     if(NS_FAILED(nsres)) {
 516         ERR("Could not get nsIDOMNode failed: %08lx\n", nsres);
 517         return E_FAIL;
 518     }
 519
 520     nsAString_Init(&nsstr, NULL);
 521     hres = nsnode_to_nsstring(nsnode, &nsstr);
 522     nsIDOMNode_Release(nsnode);
 523     if(FAILED(hres)) {
 524         nsAString_Finish(&nsstr);
 525         return hres;
 526     }
 527
 528     nsAString_GetData(&nsstr, &strw);
 529     TRACE("%s\n", debugstr_w(strw));
 530
 531     *str = strdupWtoA(strw);
 532
 533     nsAString_Finish(&nsstr);
 534
 535     if(!*str)
 536         return E_OUTOFMEMORY;
 537     return S_OK;
 538 }
 539
 540
 541 /**********************************************************
 542  * IPersistMoniker implementation
 543  */
 544
 545 static inline HTMLDocumentNode *HTMLDocumentNode_from_IPersistMoniker(IPersistMoniker *iface)
 546 {
 547     return CONTAINING_RECORD(iface, HTMLDocumentNode, IPersistMoniker_iface);
 548 }
 549
 550 static HRESULT WINAPI DocNodePersistMoniker_QueryInterface(IPersistMoniker *iface, REFIID riid, void **ppv)
 551 {
 552     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistMoniker(iface);
 553     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
 554 }
 555
 556 static ULONG WINAPI DocNodePersistMoniker_AddRef(IPersistMoniker *iface)
 557 {
 558     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistMoniker(iface);
 559     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
 560 }
 561
 562 static ULONG WINAPI DocNodePersistMoniker_Release(IPersistMoniker *iface)
 563 {
 564     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistMoniker(iface);
 565     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
 566 }
 567
 568 static HRESULT WINAPI DocNodePersistMoniker_GetClassID(IPersistMoniker *iface, CLSID *pClassID)
 569 {
 570     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistMoniker(iface);
 571     return IPersistFile_GetClassID(&This->IPersistFile_iface, pClassID);
 572 }
 573
 574 static HRESULT WINAPI DocNodePersistMoniker_IsDirty(IPersistMoniker *iface)
 575 {
 576     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistMoniker(iface);
 577
 578     TRACE("(%p)\n", This);
 579
 580     return IPersistStreamInit_IsDirty(&This->IPersistStreamInit_iface);
 581 }
 582
 583 static HRESULT WINAPI DocNodePersistMoniker_Load(IPersistMoniker *iface, BOOL fFullyAvailable,
 584         IMoniker *pimkName, LPBC pibc, DWORD grfMode)
 585 {
 586     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistMoniker(iface);
 587     return IPersistMoniker_Load(&This->doc_obj->IPersistMoniker_iface, fFullyAvailable, pimkName, pibc, grfMode);
 588 }
 589
 590 static HRESULT WINAPI DocNodePersistMoniker_Save(IPersistMoniker *iface, IMoniker *pimkName,
 591         LPBC pbc, BOOL fRemember)
 592 {
 593     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistMoniker(iface);
 594     FIXME("(%p)->(%p %p %x)\n", This, pimkName, pbc, fRemember);
 595     return E_NOTIMPL;
 596 }
 597
 598 static HRESULT WINAPI DocNodePersistMoniker_SaveCompleted(IPersistMoniker *iface, IMoniker *pimkName, LPBC pibc)
 599 {
 600     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistMoniker(iface);
 601     FIXME("(%p)->(%p %p)\n", This, pimkName, pibc);
 602     return E_NOTIMPL;
 603 }
 604
 605 static HRESULT WINAPI DocNodePersistMoniker_GetCurMoniker(IPersistMoniker *iface, IMoniker **ppimkName)
 606 {
 607     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistMoniker(iface);
 608     return IPersistMoniker_GetCurMoniker(&This->doc_obj->IPersistMoniker_iface, ppimkName);
 609 }
 610
 611 static const IPersistMonikerVtbl DocNodePersistMonikerVtbl = {
 612     DocNodePersistMoniker_QueryInterface,
 613     DocNodePersistMoniker_AddRef,
 614     DocNodePersistMoniker_Release,
 615     DocNodePersistMoniker_GetClassID,
 616     DocNodePersistMoniker_IsDirty,
 617     DocNodePersistMoniker_Load,
 618     DocNodePersistMoniker_Save,
 619     DocNodePersistMoniker_SaveCompleted,
 620     DocNodePersistMoniker_GetCurMoniker
 621 };
 622
 623 static inline HTMLDocumentObj *HTMLDocumentObj_from_IPersistMoniker(IPersistMoniker *iface)
 624 {
 625     return CONTAINING_RECORD(iface, HTMLDocumentObj, IPersistMoniker_iface);
 626 }
 627
 628 static HRESULT WINAPI DocObjPersistMoniker_QueryInterface(IPersistMoniker *iface, REFIID riid, void **ppv)
 629 {
 630     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistMoniker(iface);
 631     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
 632 }
 633
 634 static ULONG WINAPI DocObjPersistMoniker_AddRef(IPersistMoniker *iface)
 635 {
 636     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistMoniker(iface);
 637     return IUnknown_AddRef(This->outer_unk);
 638 }
 639
 640 static ULONG WINAPI DocObjPersistMoniker_Release(IPersistMoniker *iface)
 641 {
 642     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistMoniker(iface);
 643     return IUnknown_Release(This->outer_unk);
 644 }
 645
 646 static HRESULT WINAPI DocObjPersistMoniker_GetClassID(IPersistMoniker *iface, CLSID *pClassID)
 647 {
 648     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistMoniker(iface);
 649     return IPersistFile_GetClassID(&This->IPersistFile_iface, pClassID);
 650 }
 651
 652 static HRESULT WINAPI DocObjPersistMoniker_IsDirty(IPersistMoniker *iface)
 653 {
 654     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistMoniker(iface);
 655
 656     TRACE("(%p)\n", This);
 657
 658     return IPersistStreamInit_IsDirty(&This->IPersistStreamInit_iface);
 659 }
 660
 661 static HRESULT WINAPI DocObjPersistMoniker_Load(IPersistMoniker *iface, BOOL fFullyAvailable,
 662         IMoniker *pimkName, LPBC pibc, DWORD grfMode)
 663 {
 664     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistMoniker(iface);
 665     IMoniker *mon;
 666     HRESULT hres;
 667
 668     TRACE("(%p)->(%x %p %p %08lx)\n", This, fFullyAvailable, pimkName, pibc, grfMode);
 669
 670     if(pibc) {
 671         IUnknown *unk = NULL;
 672
 673         /* FIXME:
 674          * Use params:
 675          * "__PrecreatedObject"
 676          * "BIND_CONTEXT_PARAM"
 677          * "__HTMLLOADOPTIONS"
 678          * "__DWNBINDINFO"
 679          * "URL Context"
 680          * "_ITransData_Object_"
 681          * "_EnumFORMATETC_"
 682          */
 683
 684         hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM, &unk);
 685         if(SUCCEEDED(hres) && unk) {
 686             IOleClientSite *client = NULL;
 687
 688             hres = IUnknown_QueryInterface(unk, &IID_IOleClientSite, (void**)&client);
 689             if(SUCCEEDED(hres)) {
 690                 TRACE("Got client site %p\n", client);
 691                 IOleObject_SetClientSite(&This->IOleObject_iface, client);
 692                 IOleClientSite_Release(client);
 693             }
 694
 695             IUnknown_Release(unk);
 696         }
 697     }
 698
 699     if(This->is_mhtml) {
 700         IUnknown *unk;
 701
 702         hres = MimeOleObjectFromMoniker(0, pimkName, pibc, &IID_IUnknown, (void**)&unk, &mon);
 703         if(FAILED(hres))
 704             return hres;
 705         IUnknown_Release(unk);
 706         pibc = NULL;
 707     }else {
 708         IMoniker_AddRef(mon = pimkName);
 709     }
 710
 711     prepare_for_binding(This, mon, FALSE);
 712     call_docview_84(This);
 713     hres = set_moniker(This->window, mon, NULL, pibc, NULL, TRUE);
 714     IMoniker_Release(mon);
 715     if(FAILED(hres))
 716         return hres;
 717
 718     return start_binding(This->window->pending_window, (BSCallback*)This->window->pending_window->bscallback, pibc);
 719 }
 720
 721 static HRESULT WINAPI DocObjPersistMoniker_Save(IPersistMoniker *iface, IMoniker *pimkName,
 722         LPBC pbc, BOOL fRemember)
 723 {
 724     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistMoniker(iface);
 725     FIXME("(%p)->(%p %p %x)\n", This, pimkName, pbc, fRemember);
 726     return E_NOTIMPL;
 727 }
 728
 729 static HRESULT WINAPI DocObjPersistMoniker_SaveCompleted(IPersistMoniker *iface, IMoniker *pimkName, LPBC pibc)
 730 {
 731     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistMoniker(iface);
 732     FIXME("(%p)->(%p %p)\n", This, pimkName, pibc);
 733     return E_NOTIMPL;
 734 }
 735
 736 static HRESULT WINAPI DocObjPersistMoniker_GetCurMoniker(IPersistMoniker *iface, IMoniker **ppimkName)
 737 {
 738     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistMoniker(iface);
 739
 740     TRACE("(%p)->(%p)\n", This, ppimkName);
 741
 742     if(!This->window || !This->window->mon)
 743         return E_UNEXPECTED;
 744
 745     IMoniker_AddRef(This->window->mon);
 746     *ppimkName = This->window->mon;
 747     return S_OK;
 748 }
 749
 750 static const IPersistMonikerVtbl DocObjPersistMonikerVtbl = {
 751     DocObjPersistMoniker_QueryInterface,
 752     DocObjPersistMoniker_AddRef,
 753     DocObjPersistMoniker_Release,
 754     DocObjPersistMoniker_GetClassID,
 755     DocObjPersistMoniker_IsDirty,
 756     DocObjPersistMoniker_Load,
 757     DocObjPersistMoniker_Save,
 758     DocObjPersistMoniker_SaveCompleted,
 759     DocObjPersistMoniker_GetCurMoniker
 760 };
 761
 762 /**********************************************************
 763  * IMonikerProp implementation
 764  */
 765
 766 static inline HTMLDocumentNode *HTMLDocumentNode_from_IMonikerProp(IMonikerProp *iface)
 767 {
 768     return CONTAINING_RECORD(iface, HTMLDocumentNode, IMonikerProp_iface);
 769 }
 770
 771 static HRESULT WINAPI DocNodeMonikerProp_QueryInterface(IMonikerProp *iface, REFIID riid, void **ppv)
 772 {
 773     HTMLDocumentNode *This = HTMLDocumentNode_from_IMonikerProp(iface);
 774     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
 775 }
 776
 777 static ULONG WINAPI DocNodeMonikerProp_AddRef(IMonikerProp *iface)
 778 {
 779     HTMLDocumentNode *This = HTMLDocumentNode_from_IMonikerProp(iface);
 780     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
 781 }
 782
 783 static ULONG WINAPI DocNodeMonikerProp_Release(IMonikerProp *iface)
 784 {
 785     HTMLDocumentNode *This = HTMLDocumentNode_from_IMonikerProp(iface);
 786     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
 787 }
 788
 789 static HRESULT WINAPI DocNodeMonikerProp_PutProperty(IMonikerProp *iface, MONIKERPROPERTY mkp, LPCWSTR val)
 790 {
 791     HTMLDocumentNode *This = HTMLDocumentNode_from_IMonikerProp(iface);
 792     return IMonikerProp_PutProperty(&This->doc_obj->IMonikerProp_iface, mkp, val);
 793 }
 794
 795 static const IMonikerPropVtbl DocNodeMonikerPropVtbl = {
 796     DocNodeMonikerProp_QueryInterface,
 797     DocNodeMonikerProp_AddRef,
 798     DocNodeMonikerProp_Release,
 799     DocNodeMonikerProp_PutProperty
 800 };
 801
 802 static inline HTMLDocumentObj *HTMLDocumentObj_from_IMonikerProp(IMonikerProp *iface)
 803 {
 804     return CONTAINING_RECORD(iface, HTMLDocumentObj, IMonikerProp_iface);
 805 }
 806
 807 static HRESULT WINAPI DocObjMonikerProp_QueryInterface(IMonikerProp *iface, REFIID riid, void **ppv)
 808 {
 809     HTMLDocumentObj *This = HTMLDocumentObj_from_IMonikerProp(iface);
 810     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
 811 }
 812
 813 static ULONG WINAPI DocObjMonikerProp_AddRef(IMonikerProp *iface)
 814 {
 815     HTMLDocumentObj *This = HTMLDocumentObj_from_IMonikerProp(iface);
 816     return IUnknown_AddRef(This->outer_unk);
 817 }
 818
 819 static ULONG WINAPI DocObjMonikerProp_Release(IMonikerProp *iface)
 820 {
 821     HTMLDocumentObj *This = HTMLDocumentObj_from_IMonikerProp(iface);
 822     return IUnknown_Release(This->outer_unk);
 823 }
 824
 825 static HRESULT WINAPI DocObjMonikerProp_PutProperty(IMonikerProp *iface, MONIKERPROPERTY mkp, LPCWSTR val)
 826 {
 827     HTMLDocumentObj *This = HTMLDocumentObj_from_IMonikerProp(iface);
 828
 829     TRACE("(%p)->(%d %s)\n", This, mkp, debugstr_w(val));
 830
 831     switch(mkp) {
 832     case MIMETYPEPROP:
 833         free(This->mime);
 834         This->mime = wcsdup(val);
 835         break;
 836
 837     case CLASSIDPROP:
 838         break;
 839
 840     default:
 841         FIXME("mkp %d\n", mkp);
 842         return E_NOTIMPL;
 843     }
 844
 845     return S_OK;
 846 }
 847
 848 static const IMonikerPropVtbl DocObjMonikerPropVtbl = {
 849     DocObjMonikerProp_QueryInterface,
 850     DocObjMonikerProp_AddRef,
 851     DocObjMonikerProp_Release,
 852     DocObjMonikerProp_PutProperty
 853 };
 854
 855 /**********************************************************
 856  * IPersistFile implementation
 857  */
 858
 859 static inline HTMLDocumentNode *HTMLDocumentNode_from_IPersistFile(IPersistFile *iface)
 860 {
 861     return CONTAINING_RECORD(iface, HTMLDocumentNode, IPersistFile_iface);
 862 }
 863
 864 static HRESULT WINAPI DocNodePersistFile_QueryInterface(IPersistFile *iface, REFIID riid, void **ppv)
 865 {
 866     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistFile(iface);
 867     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
 868 }
 869
 870 static ULONG WINAPI DocNodePersistFile_AddRef(IPersistFile *iface)
 871 {
 872     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistFile(iface);
 873     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
 874 }
 875
 876 static ULONG WINAPI DocNodePersistFile_Release(IPersistFile *iface)
 877 {
 878     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistFile(iface);
 879     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
 880 }
 881
 882 static HRESULT WINAPI DocNodePersistFile_GetClassID(IPersistFile *iface, CLSID *pClassID)
 883 {
 884     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistFile(iface);
 885     return IPersistFile_GetClassID(&This->doc_obj->IPersistFile_iface, pClassID);
 886 }
 887
 888 static HRESULT WINAPI DocNodePersistFile_IsDirty(IPersistFile *iface)
 889 {
 890     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistFile(iface);
 891
 892     TRACE("(%p)\n", This);
 893
 894     return IPersistStreamInit_IsDirty(&This->IPersistStreamInit_iface);
 895 }
 896
 897 static HRESULT WINAPI DocNodePersistFile_Load(IPersistFile *iface, LPCOLESTR pszFileName, DWORD dwMode)
 898 {
 899     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistFile(iface);
 900     FIXME("(%p)->(%s %08lx)\n", This, debugstr_w(pszFileName), dwMode);
 901     return E_NOTIMPL;
 902 }
 903
 904 static HRESULT WINAPI DocNodePersistFile_Save(IPersistFile *iface, LPCOLESTR pszFileName, BOOL fRemember)
 905 {
 906     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistFile(iface);
 907     char *str;
 908     DWORD written=0;
 909     HANDLE file;
 910     HRESULT hres;
 911
 912     TRACE("(%p)->(%s %x)\n", This, debugstr_w(pszFileName), fRemember);
 913
 914     file = CreateFileW(pszFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 915                        FILE_ATTRIBUTE_NORMAL, NULL);
 916     if(file == INVALID_HANDLE_VALUE) {
 917         WARN("Could not create file: %lu\n", GetLastError());
 918         return E_FAIL;
 919     }
 920
 921     hres = get_doc_string(This, &str);
 922     if(SUCCEEDED(hres))
 923         WriteFile(file, str, strlen(str), &written, NULL);
 924
 925     CloseHandle(file);
 926     return hres;
 927 }
 928
 929 static HRESULT WINAPI DocNodePersistFile_SaveCompleted(IPersistFile *iface, LPCOLESTR pszFileName)
 930 {
 931     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistFile(iface);
 932     FIXME("(%p)->(%s)\n", This, debugstr_w(pszFileName));
 933     return E_NOTIMPL;
 934 }
 935
 936 static HRESULT WINAPI DocNodePersistFile_GetCurFile(IPersistFile *iface, LPOLESTR *pszFileName)
 937 {
 938     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistFile(iface);
 939     FIXME("(%p)->(%p)\n", This, pszFileName);
 940     return E_NOTIMPL;
 941 }
 942
 943 static const IPersistFileVtbl DocNodePersistFileVtbl = {
 944     DocNodePersistFile_QueryInterface,
 945     DocNodePersistFile_AddRef,
 946     DocNodePersistFile_Release,
 947     DocNodePersistFile_GetClassID,
 948     DocNodePersistFile_IsDirty,
 949     DocNodePersistFile_Load,
 950     DocNodePersistFile_Save,
 951     DocNodePersistFile_SaveCompleted,
 952     DocNodePersistFile_GetCurFile
 953 };
 954
 955 static inline HTMLDocumentObj *HTMLDocumentObj_from_IPersistFile(IPersistFile *iface)
 956 {
 957     return CONTAINING_RECORD(iface, HTMLDocumentObj, IPersistFile_iface);
 958 }
 959
 960 static HRESULT WINAPI DocObjPersistFile_QueryInterface(IPersistFile *iface, REFIID riid, void **ppv)
 961 {
 962     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistFile(iface);
 963     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
 964 }
 965
 966 static ULONG WINAPI DocObjPersistFile_AddRef(IPersistFile *iface)
 967 {
 968     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistFile(iface);
 969     return IUnknown_AddRef(This->outer_unk);
 970 }
 971
 972 static ULONG WINAPI DocObjPersistFile_Release(IPersistFile *iface)
 973 {
 974     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistFile(iface);
 975     return IUnknown_Release(This->outer_unk);
 976 }
 977
 978 static HRESULT WINAPI DocObjPersistFile_GetClassID(IPersistFile *iface, CLSID *pClassID)
 979 {
 980     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistFile(iface);
 981
 982     TRACE("(%p)->(%p)\n", This, pClassID);
 983
 984     if(!pClassID)
 985         return E_INVALIDARG;
 986
 987     *pClassID = CLSID_HTMLDocument;
 988     return S_OK;
 989 }
 990
 991 static HRESULT WINAPI DocObjPersistFile_IsDirty(IPersistFile *iface)
 992 {
 993     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistFile(iface);
 994
 995     TRACE("(%p)\n", This);
 996
 997     return IPersistStreamInit_IsDirty(&This->IPersistStreamInit_iface);
 998 }
 999
1000 static HRESULT WINAPI DocObjPersistFile_Load(IPersistFile *iface, LPCOLESTR pszFileName, DWORD dwMode)
1001 {
1002     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistFile(iface);
1003     FIXME("(%p)->(%s %08lx)\n", This, debugstr_w(pszFileName), dwMode);
1004     return E_NOTIMPL;
1005 }
1006
1007 static HRESULT WINAPI DocObjPersistFile_Save(IPersistFile *iface, LPCOLESTR pszFileName, BOOL fRemember)
1008 {
1009     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistFile(iface);
1010
1011     return IPersistFile_Save(&This->doc_node->IPersistFile_iface, pszFileName, fRemember);
1012 }
1013
1014 static HRESULT WINAPI DocObjPersistFile_SaveCompleted(IPersistFile *iface, LPCOLESTR pszFileName)
1015 {
1016     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistFile(iface);
1017     FIXME("(%p)->(%s)\n", This, debugstr_w(pszFileName));
1018     return E_NOTIMPL;
1019 }
1020
1021 static HRESULT WINAPI DocObjPersistFile_GetCurFile(IPersistFile *iface, LPOLESTR *pszFileName)
1022 {
1023     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistFile(iface);
1024     FIXME("(%p)->(%p)\n", This, pszFileName);
1025     return E_NOTIMPL;
1026 }
1027
1028 static const IPersistFileVtbl DocObjPersistFileVtbl = {
1029     DocObjPersistFile_QueryInterface,
1030     DocObjPersistFile_AddRef,
1031     DocObjPersistFile_Release,
1032     DocObjPersistFile_GetClassID,
1033     DocObjPersistFile_IsDirty,
1034     DocObjPersistFile_Load,
1035     DocObjPersistFile_Save,
1036     DocObjPersistFile_SaveCompleted,
1037     DocObjPersistFile_GetCurFile
1038 };
1039
1040 static inline HTMLDocumentNode *HTMLDocumentNode_from_IPersistStreamInit(IPersistStreamInit *iface)
1041 {
1042     return CONTAINING_RECORD(iface, HTMLDocumentNode, IPersistStreamInit_iface);
1043 }
1044
1045 static HRESULT WINAPI DocNodePersistStreamInit_QueryInterface(IPersistStreamInit *iface,
1046                                                               REFIID riid, void **ppv)
1047 {
1048     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistStreamInit(iface);
1049     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
1050 }
1051
1052 static ULONG WINAPI DocNodePersistStreamInit_AddRef(IPersistStreamInit *iface)
1053 {
1054     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistStreamInit(iface);
1055     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
1056 }
1057
1058 static ULONG WINAPI DocNodePersistStreamInit_Release(IPersistStreamInit *iface)
1059 {
1060     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistStreamInit(iface);
1061     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
1062 }
1063
1064 static HRESULT WINAPI DocNodePersistStreamInit_GetClassID(IPersistStreamInit *iface, CLSID *pClassID)
1065 {
1066     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistStreamInit(iface);
1067     return IPersistFile_GetClassID(&This->IPersistFile_iface, pClassID);
1068 }
1069
1070 static HRESULT WINAPI DocNodePersistStreamInit_IsDirty(IPersistStreamInit *iface)
1071 {
1072     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistStreamInit(iface);
1073     return IPersistStreamInit_IsDirty(&This->doc_obj->IPersistStreamInit_iface);
1074 }
1075
1076 static HRESULT WINAPI DocNodePersistStreamInit_Load(IPersistStreamInit *iface, IStream *pStm)
1077 {
1078     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistStreamInit(iface);
1079     return IPersistStreamInit_Load(&This->doc_obj->IPersistStreamInit_iface, pStm);
1080 }
1081
1082 static HRESULT WINAPI DocNodePersistStreamInit_Save(IPersistStreamInit *iface, IStream *pStm,
1083                                                     BOOL fClearDirty)
1084 {
1085     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistStreamInit(iface);
1086     char *str;
1087     DWORD written=0;
1088     HRESULT hres;
1089
1090     TRACE("(%p)->(%p %x)\n", This, pStm, fClearDirty);
1091
1092     hres = get_doc_string(This, &str);
1093     if(FAILED(hres))
1094         return hres;
1095
1096     hres = IStream_Write(pStm, str, strlen(str), &written);
1097     if(FAILED(hres))
1098         FIXME("Write failed: %08lx\n", hres);
1099
1100     free(str);
1101
1102     if(fClearDirty)
1103         set_dirty(This->doc_obj->nscontainer, VARIANT_FALSE);
1104
1105     return S_OK;
1106 }
1107
1108 static HRESULT WINAPI DocNodePersistStreamInit_GetSizeMax(IPersistStreamInit *iface,
1109                                                           ULARGE_INTEGER *pcbSize)
1110 {
1111     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistStreamInit(iface);
1112     FIXME("(%p)->(%p)\n", This, pcbSize);
1113     return E_NOTIMPL;
1114 }
1115
1116 static HRESULT WINAPI DocNodePersistStreamInit_InitNew(IPersistStreamInit *iface)
1117 {
1118     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistStreamInit(iface);
1119     return IPersistStreamInit_InitNew(&This->doc_obj->IPersistStreamInit_iface);
1120 }
1121
1122 static const IPersistStreamInitVtbl DocNodePersistStreamInitVtbl = {
1123     DocNodePersistStreamInit_QueryInterface,
1124     DocNodePersistStreamInit_AddRef,
1125     DocNodePersistStreamInit_Release,
1126     DocNodePersistStreamInit_GetClassID,
1127     DocNodePersistStreamInit_IsDirty,
1128     DocNodePersistStreamInit_Load,
1129     DocNodePersistStreamInit_Save,
1130     DocNodePersistStreamInit_GetSizeMax,
1131     DocNodePersistStreamInit_InitNew
1132 };
1133
1134 static inline HTMLDocumentObj *HTMLDocumentObj_from_IPersistStreamInit(IPersistStreamInit *iface)
1135 {
1136     return CONTAINING_RECORD(iface, HTMLDocumentObj, IPersistStreamInit_iface);
1137 }
1138
1139 static HRESULT WINAPI DocObjPersistStreamInit_QueryInterface(IPersistStreamInit *iface,
1140                                                              REFIID riid, void **ppv)
1141 {
1142     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistStreamInit(iface);
1143     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
1144 }
1145
1146 static ULONG WINAPI DocObjPersistStreamInit_AddRef(IPersistStreamInit *iface)
1147 {
1148     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistStreamInit(iface);
1149     return IUnknown_AddRef(This->outer_unk);
1150 }
1151
1152 static ULONG WINAPI DocObjPersistStreamInit_Release(IPersistStreamInit *iface)
1153 {
1154     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistStreamInit(iface);
1155     return IUnknown_Release(This->outer_unk);
1156 }
1157
1158 static HRESULT WINAPI DocObjPersistStreamInit_GetClassID(IPersistStreamInit *iface, CLSID *pClassID)
1159 {
1160     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistStreamInit(iface);
1161     return IPersistFile_GetClassID(&This->IPersistFile_iface, pClassID);
1162 }
1163
1164 static HRESULT WINAPI DocObjPersistStreamInit_IsDirty(IPersistStreamInit *iface)
1165 {
1166     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistStreamInit(iface);
1167
1168     TRACE("(%p)\n", This);
1169
1170     return browser_is_dirty(This->nscontainer);
1171 }
1172
1173 static HRESULT WINAPI DocObjPersistStreamInit_Load(IPersistStreamInit *iface, IStream *pStm)
1174 {
1175     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistStreamInit(iface);
1176     IMoniker *mon;
1177     HRESULT hres;
1178
1179     TRACE("(%p)->(%p)\n", This, pStm);
1180
1181     hres = CreateURLMoniker(NULL, L"about:blank", &mon);
1182     if(FAILED(hres)) {
1183         WARN("CreateURLMoniker failed: %08lx\n", hres);
1184         return hres;
1185     }
1186
1187     prepare_for_binding(This, mon, FALSE);
1188     hres = set_moniker(This->window, mon, NULL, NULL, NULL, TRUE);
1189     if(SUCCEEDED(hres))
1190         hres = channelbsc_load_stream(This->window->pending_window, mon, pStm);
1191
1192     IMoniker_Release(mon);
1193     return hres;
1194 }
1195
1196 static HRESULT WINAPI DocObjPersistStreamInit_Save(IPersistStreamInit *iface, IStream *pStm,
1197                                                    BOOL fClearDirty)
1198 {
1199     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistStreamInit(iface);
1200
1201     return IPersistStreamInit_Save(&This->doc_node->IPersistStreamInit_iface, pStm, fClearDirty);
1202 }
1203
1204 static HRESULT WINAPI DocObjPersistStreamInit_GetSizeMax(IPersistStreamInit *iface,
1205                                                          ULARGE_INTEGER *pcbSize)
1206 {
1207     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistStreamInit(iface);
1208     FIXME("(%p)->(%p)\n", This, pcbSize);
1209     return E_NOTIMPL;
1210 }
1211
1212 static HRESULT WINAPI DocObjPersistStreamInit_InitNew(IPersistStreamInit *iface)
1213 {
1214     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistStreamInit(iface);
1215     IMoniker *mon;
1216     HRESULT hres;
1217
1218     TRACE("(%p)\n", This);
1219
1220     hres = CreateURLMoniker(NULL, L"about:blank", &mon);
1221     if(FAILED(hres)) {
1222         WARN("CreateURLMoniker failed: %08lx\n", hres);
1223         return hres;
1224     }
1225
1226     prepare_for_binding(This, mon, FALSE);
1227     hres = set_moniker(This->window, mon, NULL, NULL, NULL, FALSE);
1228     if(SUCCEEDED(hres))
1229         hres = channelbsc_load_stream(This->window->pending_window, mon, NULL);
1230
1231     IMoniker_Release(mon);
1232     return hres;
1233 }
1234
1235 static const IPersistStreamInitVtbl DocObjPersistStreamInitVtbl = {
1236     DocObjPersistStreamInit_QueryInterface,
1237     DocObjPersistStreamInit_AddRef,
1238     DocObjPersistStreamInit_Release,
1239     DocObjPersistStreamInit_GetClassID,
1240     DocObjPersistStreamInit_IsDirty,
1241     DocObjPersistStreamInit_Load,
1242     DocObjPersistStreamInit_Save,
1243     DocObjPersistStreamInit_GetSizeMax,
1244     DocObjPersistStreamInit_InitNew
1245 };
1246
1247 /**********************************************************
1248  * IPersistHistory implementation
1249  */
1250
1251 static inline HTMLDocumentNode *HTMLDocumentNode_from_IPersistHistory(IPersistHistory *iface)
1252 {
1253     return CONTAINING_RECORD(iface, HTMLDocumentNode, IPersistHistory_iface);
1254 }
1255
1256 static HRESULT WINAPI DocNodePersistHistory_QueryInterface(IPersistHistory *iface, REFIID riid, void **ppv)
1257 {
1258     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistHistory(iface);
1259     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
1260 }
1261
1262 static ULONG WINAPI DocNodePersistHistory_AddRef(IPersistHistory *iface)
1263 {
1264     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistHistory(iface);
1265     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
1266 }
1267
1268 static ULONG WINAPI DocNodePersistHistory_Release(IPersistHistory *iface)
1269 {
1270     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistHistory(iface);
1271     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
1272 }
1273
1274 static HRESULT WINAPI DocNodePersistHistory_GetClassID(IPersistHistory *iface, CLSID *pClassID)
1275 {
1276     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistHistory(iface);
1277     return IPersistFile_GetClassID(&This->IPersistFile_iface, pClassID);
1278 }
1279
1280 static HRESULT WINAPI DocNodePersistHistory_LoadHistory(IPersistHistory *iface, IStream *pStream, IBindCtx *pbc)
1281 {
1282     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistHistory(iface);
1283     return IPersistHistory_LoadHistory(&This->doc_obj->IPersistHistory_iface, pStream, pbc);
1284 }
1285
1286 static HRESULT WINAPI DocNodePersistHistory_SaveHistory(IPersistHistory *iface, IStream *pStream)
1287 {
1288     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistHistory(iface);
1289     return IPersistHistory_SaveHistory(&This->doc_obj->IPersistHistory_iface, pStream);
1290 }
1291
1292 static HRESULT WINAPI DocNodePersistHistory_SetPositionCookie(IPersistHistory *iface, DWORD dwPositioncookie)
1293 {
1294     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistHistory(iface);
1295     FIXME("(%p)->(%lx)\n", This, dwPositioncookie);
1296     return E_NOTIMPL;
1297 }
1298
1299 static HRESULT WINAPI DocNodePersistHistory_GetPositionCookie(IPersistHistory *iface, DWORD *pdwPositioncookie)
1300 {
1301     HTMLDocumentNode *This = HTMLDocumentNode_from_IPersistHistory(iface);
1302     FIXME("(%p)->(%p)\n", This, pdwPositioncookie);
1303     return E_NOTIMPL;
1304 }
1305
1306 static const IPersistHistoryVtbl DocNodePersistHistoryVtbl = {
1307     DocNodePersistHistory_QueryInterface,
1308     DocNodePersistHistory_AddRef,
1309     DocNodePersistHistory_Release,
1310     DocNodePersistHistory_GetClassID,
1311     DocNodePersistHistory_LoadHistory,
1312     DocNodePersistHistory_SaveHistory,
1313     DocNodePersistHistory_SetPositionCookie,
1314     DocNodePersistHistory_GetPositionCookie
1315 };
1316
1317 static inline HTMLDocumentObj *HTMLDocumentObj_from_IPersistHistory(IPersistHistory *iface)
1318 {
1319     return CONTAINING_RECORD(iface, HTMLDocumentObj, IPersistHistory_iface);
1320 }
1321
1322 static HRESULT WINAPI DocObjPersistHistory_QueryInterface(IPersistHistory *iface, REFIID riid, void **ppv)
1323 {
1324     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistHistory(iface);
1325     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
1326 }
1327
1328 static ULONG WINAPI DocObjPersistHistory_AddRef(IPersistHistory *iface)
1329 {
1330     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistHistory(iface);
1331     return IUnknown_AddRef(This->outer_unk);
1332 }
1333
1334 static ULONG WINAPI DocObjPersistHistory_Release(IPersistHistory *iface)
1335 {
1336     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistHistory(iface);
1337     return IUnknown_Release(This->outer_unk);
1338 }
1339
1340 static HRESULT WINAPI DocObjPersistHistory_GetClassID(IPersistHistory *iface, CLSID *pClassID)
1341 {
1342     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistHistory(iface);
1343     return IPersistFile_GetClassID(&This->IPersistFile_iface, pClassID);
1344 }
1345
1346 static HRESULT WINAPI DocObjPersistHistory_LoadHistory(IPersistHistory *iface, IStream *pStream, IBindCtx *pbc)
1347 {
1348     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistHistory(iface);
1349     ULONG str_len, read;
1350     WCHAR *uri_str;
1351     IUri *uri;
1352     HRESULT hres;
1353
1354     TRACE("(%p)->(%p %p)\n", This, pStream, pbc);
1355
1356     if(!This->window) {
1357         FIXME("No current window\n");
1358         return E_UNEXPECTED;
1359     }
1360
1361     if(pbc)
1362         FIXME("pbc not supported\n");
1363
1364     if(This->client) {
1365         IOleCommandTarget *cmdtrg = NULL;
1366
1367         hres = IOleClientSite_QueryInterface(This->client, &IID_IOleCommandTarget, (void**)&cmdtrg);
1368         if(SUCCEEDED(hres)) {
1369             IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 138, 0, NULL, NULL);
1370             IOleCommandTarget_Release(cmdtrg);
1371         }
1372     }
1373
1374     hres = IStream_Read(pStream, &str_len, sizeof(str_len), &read);
1375     if(FAILED(hres))
1376         return hres;
1377     if(read != sizeof(str_len))
1378         return E_FAIL;
1379
1380     uri_str = malloc((str_len + 1) * sizeof(WCHAR));
1381     if(!uri_str)
1382         return E_OUTOFMEMORY;
1383
1384     hres = IStream_Read(pStream, uri_str, str_len*sizeof(WCHAR), &read);
1385     if(SUCCEEDED(hres) && read != str_len*sizeof(WCHAR))
1386         hres = E_FAIL;
1387     if(SUCCEEDED(hres)) {
1388         uri_str[str_len] = 0;
1389         hres = create_uri(uri_str, 0, &uri);
1390     }
1391     free(uri_str);
1392     if(FAILED(hres))
1393         return hres;
1394
1395     hres = load_uri(This->window, uri, BINDING_FROMHIST);
1396     IUri_Release(uri);
1397     return hres;
1398 }
1399
1400 static HRESULT WINAPI DocObjPersistHistory_SaveHistory(IPersistHistory *iface, IStream *pStream)
1401 {
1402     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistHistory(iface);
1403     ULONG len, written;
1404     BSTR display_uri;
1405     HRESULT hres;
1406
1407     TRACE("(%p)->(%p)\n", This, pStream);
1408
1409     if(!This->window || !This->window->uri) {
1410         FIXME("No current URI\n");
1411         return E_FAIL;
1412     }
1413
1414     /* NOTE: The format we store is *not* compatible with native MSHTML. We currently
1415      * store only URI of the page (as a length followed by a string) */
1416     hres = IUri_GetDisplayUri(This->window->uri, &display_uri);
1417     if(FAILED(hres))
1418         return hres;
1419
1420     len = SysStringLen(display_uri);
1421     hres = IStream_Write(pStream, &len, sizeof(len), &written);
1422     if(SUCCEEDED(hres))
1423         hres = IStream_Write(pStream, display_uri, len*sizeof(WCHAR), &written);
1424     SysFreeString(display_uri);
1425     return hres;
1426 }
1427
1428 static HRESULT WINAPI DocObjPersistHistory_SetPositionCookie(IPersistHistory *iface, DWORD dwPositioncookie)
1429 {
1430     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistHistory(iface);
1431     FIXME("(%p)->(%lx)\n", This, dwPositioncookie);
1432     return E_NOTIMPL;
1433 }
1434
1435 static HRESULT WINAPI DocObjPersistHistory_GetPositionCookie(IPersistHistory *iface, DWORD *pdwPositioncookie)
1436 {
1437     HTMLDocumentObj *This = HTMLDocumentObj_from_IPersistHistory(iface);
1438     FIXME("(%p)->(%p)\n", This, pdwPositioncookie);
1439     return E_NOTIMPL;
1440 }
1441
1442 static const IPersistHistoryVtbl DocObjPersistHistoryVtbl = {
1443     DocObjPersistHistory_QueryInterface,
1444     DocObjPersistHistory_AddRef,
1445     DocObjPersistHistory_Release,
1446     DocObjPersistHistory_GetClassID,
1447     DocObjPersistHistory_LoadHistory,
1448     DocObjPersistHistory_SaveHistory,
1449     DocObjPersistHistory_SetPositionCookie,
1450     DocObjPersistHistory_GetPositionCookie
1451 };
1452
1453 /**********************************************************
1454  * IHlinkTarget implementation
1455  */
1456
1457 static inline HTMLDocumentNode *HTMLDocumentNode_from_IHlinkTarget(IHlinkTarget *iface)
1458 {
1459     return CONTAINING_RECORD(iface, HTMLDocumentNode, IHlinkTarget_iface);
1460 }
1461
1462 static HRESULT WINAPI DocNodeHlinkTarget_QueryInterface(IHlinkTarget *iface, REFIID riid, void **ppv)
1463 {
1464     HTMLDocumentNode *This = HTMLDocumentNode_from_IHlinkTarget(iface);
1465     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
1466 }
1467
1468 static ULONG WINAPI DocNodeHlinkTarget_AddRef(IHlinkTarget *iface)
1469 {
1470     HTMLDocumentNode *This = HTMLDocumentNode_from_IHlinkTarget(iface);
1471     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
1472 }
1473
1474 static ULONG WINAPI DocNodeHlinkTarget_Release(IHlinkTarget *iface)
1475 {
1476     HTMLDocumentNode *This = HTMLDocumentNode_from_IHlinkTarget(iface);
1477     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
1478 }
1479
1480 static HRESULT WINAPI DocNodeHlinkTarget_SetBrowseContext(IHlinkTarget *iface, IHlinkBrowseContext *pihlbc)
1481 {
1482     HTMLDocumentNode *This = HTMLDocumentNode_from_IHlinkTarget(iface);
1483     FIXME("(%p)->(%p)\n", This, pihlbc);
1484     return E_NOTIMPL;
1485 }
1486
1487 static HRESULT WINAPI DocNodeHlinkTarget_GetBrowseContext(IHlinkTarget *iface, IHlinkBrowseContext **ppihlbc)
1488 {
1489     HTMLDocumentNode *This = HTMLDocumentNode_from_IHlinkTarget(iface);
1490     FIXME("(%p)->(%p)\n", This, ppihlbc);
1491     return E_NOTIMPL;
1492 }
1493
1494 static HRESULT WINAPI DocNodeHlinkTarget_Navigate(IHlinkTarget *iface, DWORD grfHLNF, LPCWSTR pwzJumpLocation)
1495 {
1496     HTMLDocumentNode *This = HTMLDocumentNode_from_IHlinkTarget(iface);
1497
1498     TRACE("(%p)->(%08lx %s)\n", This, grfHLNF, debugstr_w(pwzJumpLocation));
1499
1500     if(grfHLNF)
1501         FIXME("Unsupported grfHLNF=%08lx\n", grfHLNF);
1502     if(pwzJumpLocation)
1503         FIXME("JumpLocation not supported\n");
1504
1505     if(This->doc_obj->client)
1506         return IOleObject_DoVerb(&This->IOleObject_iface, OLEIVERB_SHOW, NULL, NULL, -1, NULL, NULL);
1507
1508     return IHlinkTarget_Navigate(&This->doc_obj->IHlinkTarget_iface, grfHLNF, pwzJumpLocation);
1509 }
1510
1511 static HRESULT WINAPI DocNodeHlinkTarget_GetMoniker(IHlinkTarget *iface, LPCWSTR pwzLocation, DWORD dwAssign,
1512         IMoniker **ppimkLocation)
1513 {
1514     HTMLDocumentNode *This = HTMLDocumentNode_from_IHlinkTarget(iface);
1515     FIXME("(%p)->(%s %08lx %p)\n", This, debugstr_w(pwzLocation), dwAssign, ppimkLocation);
1516     return E_NOTIMPL;
1517 }
1518
1519 static HRESULT WINAPI DocNodeHlinkTarget_GetFriendlyName(IHlinkTarget *iface, LPCWSTR pwzLocation,
1520         LPWSTR *ppwzFriendlyName)
1521 {
1522     HTMLDocumentNode *This = HTMLDocumentNode_from_IHlinkTarget(iface);
1523     FIXME("(%p)->(%s %p)\n", This, debugstr_w(pwzLocation), ppwzFriendlyName);
1524     return E_NOTIMPL;
1525 }
1526
1527 static const IHlinkTargetVtbl DocNodeHlinkTargetVtbl = {
1528     DocNodeHlinkTarget_QueryInterface,
1529     DocNodeHlinkTarget_AddRef,
1530     DocNodeHlinkTarget_Release,
1531     DocNodeHlinkTarget_SetBrowseContext,
1532     DocNodeHlinkTarget_GetBrowseContext,
1533     DocNodeHlinkTarget_Navigate,
1534     DocNodeHlinkTarget_GetMoniker,
1535     DocNodeHlinkTarget_GetFriendlyName
1536 };
1537
1538 static inline HTMLDocumentObj *HTMLDocumentObj_from_IHlinkTarget(IHlinkTarget *iface)
1539 {
1540     return CONTAINING_RECORD(iface, HTMLDocumentObj, IHlinkTarget_iface);
1541 }
1542
1543 static HRESULT WINAPI DocObjHlinkTarget_QueryInterface(IHlinkTarget *iface, REFIID riid, void **ppv)
1544 {
1545     HTMLDocumentObj *This = HTMLDocumentObj_from_IHlinkTarget(iface);
1546     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
1547 }
1548
1549 static ULONG WINAPI DocObjHlinkTarget_AddRef(IHlinkTarget *iface)
1550 {
1551     HTMLDocumentObj *This = HTMLDocumentObj_from_IHlinkTarget(iface);
1552     return IUnknown_AddRef(This->outer_unk);
1553 }
1554
1555 static ULONG WINAPI DocObjHlinkTarget_Release(IHlinkTarget *iface)
1556 {
1557     HTMLDocumentObj *This = HTMLDocumentObj_from_IHlinkTarget(iface);
1558     return IUnknown_Release(This->outer_unk);
1559 }
1560
1561 static HRESULT WINAPI DocObjHlinkTarget_SetBrowseContext(IHlinkTarget *iface, IHlinkBrowseContext *pihlbc)
1562 {
1563     HTMLDocumentObj *This = HTMLDocumentObj_from_IHlinkTarget(iface);
1564     FIXME("(%p)->(%p)\n", This, pihlbc);
1565     return E_NOTIMPL;
1566 }
1567
1568 static HRESULT WINAPI DocObjHlinkTarget_GetBrowseContext(IHlinkTarget *iface, IHlinkBrowseContext **ppihlbc)
1569 {
1570     HTMLDocumentObj *This = HTMLDocumentObj_from_IHlinkTarget(iface);
1571     FIXME("(%p)->(%p)\n", This, ppihlbc);
1572     return E_NOTIMPL;
1573 }
1574
1575 static HRESULT WINAPI DocObjHlinkTarget_Navigate(IHlinkTarget *iface, DWORD grfHLNF, LPCWSTR pwzJumpLocation)
1576 {
1577     HTMLDocumentObj *This = HTMLDocumentObj_from_IHlinkTarget(iface);
1578
1579     TRACE("(%p)->(%08lx %s)\n", This, grfHLNF, debugstr_w(pwzJumpLocation));
1580
1581     if(grfHLNF)
1582         FIXME("Unsupported grfHLNF=%08lx\n", grfHLNF);
1583     if(pwzJumpLocation)
1584         FIXME("JumpLocation not supported\n");
1585
1586     if(!This->client) {
1587         HRESULT hres;
1588         BSTR uri;
1589
1590         hres = IUri_GetAbsoluteUri(This->window->uri, &uri);
1591         if(FAILED(hres))
1592             return hres;
1593
1594         if(hres == S_OK)
1595             ShellExecuteW(NULL, L"open", uri, NULL, NULL, SW_SHOW);
1596         SysFreeString(uri);
1597         return S_OK;
1598     }
1599
1600     return IOleObject_DoVerb(&This->IOleObject_iface, OLEIVERB_SHOW, NULL, NULL, -1, NULL, NULL);
1601 }
1602
1603 static HRESULT WINAPI DocObjHlinkTarget_GetMoniker(IHlinkTarget *iface, LPCWSTR pwzLocation, DWORD dwAssign,
1604         IMoniker **ppimkLocation)
1605 {
1606     HTMLDocumentObj *This = HTMLDocumentObj_from_IHlinkTarget(iface);
1607     FIXME("(%p)->(%s %08lx %p)\n", This, debugstr_w(pwzLocation), dwAssign, ppimkLocation);
1608     return E_NOTIMPL;
1609 }
1610
1611 static HRESULT WINAPI DocObjHlinkTarget_GetFriendlyName(IHlinkTarget *iface, LPCWSTR pwzLocation,
1612         LPWSTR *ppwzFriendlyName)
1613 {
1614     HTMLDocumentObj *This = HTMLDocumentObj_from_IHlinkTarget(iface);
1615     FIXME("(%p)->(%s %p)\n", This, debugstr_w(pwzLocation), ppwzFriendlyName);
1616     return E_NOTIMPL;
1617 }
1618
1619 static const IHlinkTargetVtbl DocObjHlinkTargetVtbl = {
1620     DocObjHlinkTarget_QueryInterface,
1621     DocObjHlinkTarget_AddRef,
1622     DocObjHlinkTarget_Release,
1623     DocObjHlinkTarget_SetBrowseContext,
1624     DocObjHlinkTarget_GetBrowseContext,
1625     DocObjHlinkTarget_Navigate,
1626     DocObjHlinkTarget_GetMoniker,
1627     DocObjHlinkTarget_GetFriendlyName
1628 };
1629
1630 void HTMLDocumentNode_Persist_Init(HTMLDocumentNode *This)
1631 {
1632     This->IPersistMoniker_iface.lpVtbl = &DocNodePersistMonikerVtbl;
1633     This->IPersistFile_iface.lpVtbl = &DocNodePersistFileVtbl;
1634     This->IMonikerProp_iface.lpVtbl = &DocNodeMonikerPropVtbl;
1635     This->IPersistStreamInit_iface.lpVtbl = &DocNodePersistStreamInitVtbl;
1636     This->IPersistHistory_iface.lpVtbl = &DocNodePersistHistoryVtbl;
1637     This->IHlinkTarget_iface.lpVtbl = &DocNodeHlinkTargetVtbl;
1638 }
1639
1640 void HTMLDocumentObj_Persist_Init(HTMLDocumentObj *This)
1641 {
1642     This->IPersistMoniker_iface.lpVtbl = &DocObjPersistMonikerVtbl;
1643     This->IPersistFile_iface.lpVtbl = &DocObjPersistFileVtbl;
1644     This->IMonikerProp_iface.lpVtbl = &DocObjMonikerPropVtbl;
1645     This->IPersistStreamInit_iface.lpVtbl = &DocObjPersistStreamInitVtbl;
1646     This->IPersistHistory_iface.lpVtbl = &DocObjPersistHistoryVtbl;
1647     This->IHlinkTarget_iface.lpVtbl = &DocObjHlinkTargetVtbl;
1648 }