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