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 "config.h"
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23
  24 #define COBJMACROS
  25 #define NONAMELESSUNION
  26 #define NONAMELESSSTRUCT
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winuser.h"
  31 #include "ole2.h"
  32 #include "shlguid.h"
  33 #include "idispids.h"
  34
  35 #define NO_SHLWAPI_REG
  36 #include "shlwapi.h"
  37
  38 #include "wine/debug.h"
  39
  40 #include "mshtml_private.h"
  41 #include "htmlevent.h"
  42 #include "binding.h"
  43 #include "resource.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  46
  47 typedef struct {
  48     task_t header;
  49     HTMLDocumentObj *doc;
  50     BOOL set_download;
  51     LPOLESTR url;
  52 } download_proc_task_t;
  53
  54 static BOOL use_gecko_script(HTMLWindow *window)
  55 {
  56     DWORD zone, scheme;
  57     HRESULT hres;
  58
  59     hres = IInternetSecurityManager_MapUrlToZone(window->secmgr, window->url, &zone, 0);
  60     if(FAILED(hres)) {
  61         WARN("Could not map %s to zone: %08x\n", debugstr_w(window->url), hres);
  62         return TRUE;
  63     }
  64
  65     TRACE("zone %d\n", zone);
  66     if(zone == URLZONE_LOCAL_MACHINE || zone == URLZONE_TRUSTED || !window->uri)
  67         return FALSE;
  68
  69     hres = IUri_GetScheme(window->uri, &scheme);
  70     return FAILED(hres) || scheme != URL_SCHEME_ABOUT;
  71 }
  72
  73 void set_current_uri(HTMLWindow *window, IUri *uri)
  74 {
  75     if(window->uri) {
  76         IUri_Release(window->uri);
  77         window->uri = NULL;
  78     }
  79
  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     IUri_GetDisplayUri(uri, &window->url);
  90 }
  91
  92 void set_current_mon(HTMLWindow *This, IMoniker *mon)
  93 {
  94     IUriContainer *uri_container;
  95     IUri *uri = NULL;
  96     HRESULT hres;
  97
  98     if(This->mon) {
  99         IMoniker_Release(This->mon);
 100         This->mon = NULL;
 101     }
 102
 103
 104     if(!mon)
 105         return;
 106
 107     IMoniker_AddRef(mon);
 108     This->mon = mon;
 109
 110     hres = IMoniker_QueryInterface(mon, &IID_IUriContainer, (void**)&uri_container);
 111     if(SUCCEEDED(hres)) {
 112         hres = IUriContainer_GetIUri(uri_container, &uri);
 113         IUriContainer_Release(uri_container);
 114         if(hres != S_OK) {
 115             WARN("GetIUri failed: %08x\n", hres);
 116             uri = NULL;
 117         }
 118     }
 119
 120     if(!uri) {
 121         WCHAR *url;
 122
 123         hres = IMoniker_GetDisplayName(mon, NULL, NULL, &url);
 124         if(SUCCEEDED(hres)) {
 125             hres = CreateUri(url, 0, 0, &uri);
 126             if(FAILED(hres)) {
 127                 WARN("CrateUri failed: %08x\n", hres);
 128                 set_current_uri(This, NULL);
 129                 This->url = SysAllocString(url);
 130                 CoTaskMemFree(url);
 131                 return;
 132             }
 133             CoTaskMemFree(url);
 134         }else {
 135             WARN("GetDisplayName failed: %08x\n", hres);
 136         }
 137     }
 138
 139     set_current_uri(This, uri);
 140     if(uri)
 141         IUri_Release(uri);
 142     set_script_mode(This, use_gecko_script(This) ? SCRIPTMODE_GECKO : SCRIPTMODE_ACTIVESCRIPT);
 143 }
 144
 145 void set_download_state(HTMLDocumentObj *doc, int state)
 146 {
 147     if(doc->client) {
 148         IOleCommandTarget *olecmd;
 149         HRESULT hres;
 150
 151         hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
 152         if(SUCCEEDED(hres)) {
 153             VARIANT var;
 154
 155             V_VT(&var) = VT_I4;
 156             V_I4(&var) = state;
 157
 158             IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETDOWNLOADSTATE,
 159                     OLECMDEXECOPT_DONTPROMPTUSER, &var, NULL);
 160             IOleCommandTarget_Release(olecmd);
 161         }
 162     }
 163
 164     doc->download_state = state;
 165 }
 166
 167 static void set_progress_proc(task_t *_task)
 168 {
 169     docobj_task_t *task = (docobj_task_t*)_task;
 170     IOleCommandTarget *olecmd = NULL;
 171     HTMLDocumentObj *doc = task->doc;
 172     HRESULT hres;
 173
 174     TRACE("(%p)\n", doc);
 175
 176     if(doc->client)
 177         IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
 178
 179     if(olecmd) {
 180         VARIANT progress_max, progress;
 181
 182         V_VT(&progress_max) = VT_I4;
 183         V_I4(&progress_max) = 0; /* FIXME */
 184         IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETPROGRESSMAX, OLECMDEXECOPT_DONTPROMPTUSER,
 185                                &progress_max, NULL);
 186
 187         V_VT(&progress) = VT_I4;
 188         V_I4(&progress) = 0; /* FIXME */
 189         IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETPROGRESSPOS, OLECMDEXECOPT_DONTPROMPTUSER,
 190                                &progress, NULL);
 191         IOleCommandTarget_Release(olecmd);
 192     }
 193
 194     if(doc->usermode == EDITMODE && doc->hostui) {
 195         DOCHOSTUIINFO hostinfo;
 196
 197         memset(&hostinfo, 0, sizeof(DOCHOSTUIINFO));
 198         hostinfo.cbSize = sizeof(DOCHOSTUIINFO);
 199         hres = IDocHostUIHandler_GetHostInfo(doc->hostui, &hostinfo);
 200         if(SUCCEEDED(hres))
 201             /* FIXME: use hostinfo */
 202             TRACE("hostinfo = {%u %08x %08x %s %s}\n",
 203                     hostinfo.cbSize, hostinfo.dwFlags, hostinfo.dwDoubleClick,
 204                     debugstr_w(hostinfo.pchHostCss), debugstr_w(hostinfo.pchHostNS));
 205     }
 206 }
 207
 208 static void set_downloading_proc(task_t *_task)
 209 {
 210     download_proc_task_t *task = (download_proc_task_t*)_task;
 211     HTMLDocumentObj *doc = task->doc;
 212     HRESULT hres;
 213
 214     TRACE("(%p)\n", doc);
 215
 216     set_statustext(doc, IDS_STATUS_DOWNLOADINGFROM, task->url);
 217
 218     if(task->set_download)
 219         set_download_state(doc, 1);
 220
 221     if(!doc->client)
 222         return;
 223
 224     if(doc->view_sink)
 225         IAdviseSink_OnViewChange(doc->view_sink, DVASPECT_CONTENT, -1);
 226
 227     if(doc->hostui) {
 228         IDropTarget *drop_target = NULL;
 229
 230         hres = IDocHostUIHandler_GetDropTarget(doc->hostui, NULL /* FIXME */, &drop_target);
 231         if(SUCCEEDED(hres)) {
 232             FIXME("Use IDropTarget\n");
 233             IDropTarget_Release(drop_target);
 234         }
 235     }
 236 }
 237
 238 static void set_downloading_task_destr(task_t *_task)
 239 {
 240     download_proc_task_t *task = (download_proc_task_t*)_task;
 241
 242     CoTaskMemFree(task->url);
 243     heap_free(task);
 244 }
 245
 246 void prepare_for_binding(HTMLDocument *This, IMoniker *mon, BOOL navigated_binding)
 247 {
 248     HRESULT hres;
 249
 250     if(This->doc_obj->client) {
 251         VARIANT silent, offline;
 252
 253         hres = get_client_disp_property(This->doc_obj->client, DISPID_AMBIENT_SILENT, &silent);
 254         if(SUCCEEDED(hres)) {
 255             if(V_VT(&silent) != VT_BOOL)
 256                 WARN("V_VT(silent) = %d\n", V_VT(&silent));
 257             else if(V_BOOL(&silent))
 258                 FIXME("silent == true\n");
 259         }
 260
 261         hres = get_client_disp_property(This->doc_obj->client,
 262                 DISPID_AMBIENT_OFFLINEIFNOTCONNECTED, &offline);
 263         if(SUCCEEDED(hres)) {
 264             if(V_VT(&offline) != VT_BOOL)
 265                 WARN("V_VT(offline) = %d\n", V_VT(&offline));
 266             else if(V_BOOL(&offline))
 267                 FIXME("offline == true\n");
 268         }
 269     }
 270
 271     if(This->window->mon) {
 272         update_doc(This, UPDATE_TITLE|UPDATE_UI);
 273     }else {
 274         update_doc(This, UPDATE_TITLE);
 275         set_current_mon(This->window, mon);
 276     }
 277
 278     if(This->doc_obj->client) {
 279         IOleCommandTarget *cmdtrg = NULL;
 280
 281         hres = IOleClientSite_QueryInterface(This->doc_obj->client, &IID_IOleCommandTarget,
 282                 (void**)&cmdtrg);
 283         if(SUCCEEDED(hres)) {
 284             VARIANT var, out;
 285
 286             if(!navigated_binding) {
 287                 V_VT(&var) = VT_I4;
 288                 V_I4(&var) = 0;
 289                 IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 37, 0, &var, NULL);
 290             }else {
 291                 V_VT(&var) = VT_UNKNOWN;
 292                 V_UNKNOWN(&var) = (IUnknown*)&This->window->IHTMLWindow2_iface;
 293                 V_VT(&out) = VT_EMPTY;
 294                 hres = IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 63, 0, &var, &out);
 295                 if(SUCCEEDED(hres))
 296                     VariantClear(&out);
 297             }
 298
 299             IOleCommandTarget_Release(cmdtrg);
 300         }
 301     }
 302 }
 303
 304 HRESULT set_moniker(HTMLDocument *This, IMoniker *mon, IBindCtx *pibc, nsChannelBSC *async_bsc, BOOL set_download)
 305 {
 306     download_proc_task_t *download_task;
 307     nsChannelBSC *bscallback;
 308     nsWineURI *nsuri;
 309     LPOLESTR url;
 310     HRESULT hres;
 311
 312     hres = IMoniker_GetDisplayName(mon, pibc, NULL, &url);
 313     if(FAILED(hres)) {
 314         WARN("GetDiaplayName failed: %08x\n", hres);
 315         return hres;
 316     }
 317
 318     TRACE("got url: %s\n", debugstr_w(url));
 319
 320     set_ready_state(This->window, READYSTATE_LOADING);
 321
 322     hres = create_doc_uri(This->window, url, &nsuri);
 323     if(SUCCEEDED(hres)) {
 324         if(async_bsc)
 325             bscallback = async_bsc;
 326         else
 327             hres = create_channelbsc(mon, NULL, NULL, 0, &bscallback);
 328     }
 329
 330     if(SUCCEEDED(hres)) {
 331         remove_target_tasks(This->task_magic);
 332         abort_document_bindings(This->doc_node);
 333
 334         hres = load_nsuri(This->window, nsuri, bscallback, 0/*LOAD_INITIAL_DOCUMENT_URI*/);
 335         nsISupports_Release((nsISupports*)nsuri); /* FIXME */
 336         if(SUCCEEDED(hres))
 337             set_window_bscallback(This->window, bscallback);
 338         if(bscallback != async_bsc)
 339             IUnknown_Release((IUnknown*)bscallback);
 340     }
 341
 342     if(FAILED(hres)) {
 343         CoTaskMemFree(url);
 344         return hres;
 345     }
 346
 347     HTMLDocument_LockContainer(This->doc_obj, TRUE);
 348
 349     if(This->doc_obj->frame) {
 350         docobj_task_t *task;
 351
 352         task = heap_alloc(sizeof(docobj_task_t));
 353         task->doc = This->doc_obj;
 354         push_task(&task->header, set_progress_proc, NULL, This->doc_obj->basedoc.task_magic);
 355     }
 356
 357     download_task = heap_alloc(sizeof(download_proc_task_t));
 358     download_task->doc = This->doc_obj;
 359     download_task->set_download = set_download;
 360     download_task->url = url;
 361     push_task(&download_task->header, set_downloading_proc, set_downloading_task_destr, This->doc_obj->basedoc.task_magic);
 362
 363     return S_OK;
 364 }
 365
 366 void set_ready_state(HTMLWindow *window, READYSTATE readystate)
 367 {
 368     window->readystate = readystate;
 369
 370     if(window->doc_obj && window->doc_obj->basedoc.window == window)
 371         call_property_onchanged(&window->doc_obj->basedoc.cp_propnotif, DISPID_READYSTATE);
 372
 373     fire_event(window->doc, EVENTID_READYSTATECHANGE, FALSE, window->doc->node.nsnode, NULL);
 374
 375     if(window->frame_element)
 376         fire_event(window->frame_element->element.node.doc, EVENTID_READYSTATECHANGE,
 377                    TRUE, window->frame_element->element.node.nsnode, NULL);
 378 }
 379
 380 static HRESULT get_doc_string(HTMLDocumentNode *This, char **str)
 381 {
 382     nsIDOMNode *nsnode;
 383     LPCWSTR strw;
 384     nsAString nsstr;
 385     nsresult nsres;
 386     HRESULT hres;
 387
 388     if(!This->nsdoc) {
 389         WARN("NULL nsdoc\n");
 390         return E_UNEXPECTED;
 391     }
 392
 393     nsres = nsIDOMHTMLDocument_QueryInterface(This->nsdoc, &IID_nsIDOMNode, (void**)&nsnode);
 394     if(NS_FAILED(nsres)) {
 395         ERR("Could not get nsIDOMNode failed: %08x\n", nsres);
 396         return E_FAIL;
 397     }
 398
 399     nsAString_Init(&nsstr, NULL);
 400     hres = nsnode_to_nsstring(nsnode, &nsstr);
 401     nsIDOMNode_Release(nsnode);
 402     if(FAILED(hres)) {
 403         nsAString_Finish(&nsstr);
 404         return hres;
 405     }
 406
 407     nsAString_GetData(&nsstr, &strw);
 408     TRACE("%s\n", debugstr_w(strw));
 409
 410     *str = heap_strdupWtoA(strw);
 411
 412     nsAString_Finish(&nsstr);
 413
 414     if(!*str)
 415         return E_OUTOFMEMORY;
 416     return S_OK;
 417 }
 418
 419
 420 /**********************************************************
 421  * IPersistMoniker implementation
 422  */
 423
 424 static inline HTMLDocument *impl_from_IPersistMoniker(IPersistMoniker *iface)
 425 {
 426     return CONTAINING_RECORD(iface, HTMLDocument, IPersistMoniker_iface);
 427 }
 428
 429 static HRESULT WINAPI PersistMoniker_QueryInterface(IPersistMoniker *iface, REFIID riid, void **ppv)
 430 {
 431     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 432     return htmldoc_query_interface(This, riid, ppv);
 433 }
 434
 435 static ULONG WINAPI PersistMoniker_AddRef(IPersistMoniker *iface)
 436 {
 437     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 438     return htmldoc_addref(This);
 439 }
 440
 441 static ULONG WINAPI PersistMoniker_Release(IPersistMoniker *iface)
 442 {
 443     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 444     return htmldoc_release(This);
 445 }
 446
 447 static HRESULT WINAPI PersistMoniker_GetClassID(IPersistMoniker *iface, CLSID *pClassID)
 448 {
 449     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 450     return IPersist_GetClassID(&This->IPersistFile_iface, pClassID);
 451 }
 452
 453 static HRESULT WINAPI PersistMoniker_IsDirty(IPersistMoniker *iface)
 454 {
 455     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 456
 457     TRACE("(%p)\n", This);
 458
 459     return IPersistStreamInit_IsDirty(&This->IPersistStreamInit_iface);
 460 }
 461
 462 static HRESULT WINAPI PersistMoniker_Load(IPersistMoniker *iface, BOOL fFullyAvailable,
 463         IMoniker *pimkName, LPBC pibc, DWORD grfMode)
 464 {
 465     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 466     HRESULT hres;
 467
 468     TRACE("(%p)->(%x %p %p %08x)\n", This, fFullyAvailable, pimkName, pibc, grfMode);
 469
 470     if(pibc) {
 471         IUnknown *unk = NULL;
 472
 473         /* FIXME:
 474          * Use params:
 475          * "__PrecreatedObject"
 476          * "BIND_CONTEXT_PARAM"
 477          * "__HTMLLOADOPTIONS"
 478          * "__DWNBINDINFO"
 479          * "URL Context"
 480          * "_ITransData_Object_"
 481          * "_EnumFORMATETC_"
 482          */
 483
 484         IBindCtx_GetObjectParam(pibc, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM, &unk);
 485         if(unk) {
 486             IOleClientSite *client = NULL;
 487
 488             hres = IUnknown_QueryInterface(unk, &IID_IOleClientSite, (void**)&client);
 489             if(SUCCEEDED(hres)) {
 490                 TRACE("Got client site %p\n", client);
 491                 IOleObject_SetClientSite(&This->IOleObject_iface, client);
 492                 IOleClientSite_Release(client);
 493             }
 494
 495             IUnknown_Release(unk);
 496         }
 497     }
 498
 499     prepare_for_binding(This, pimkName, FALSE);
 500     hres = set_moniker(This, pimkName, pibc, NULL, TRUE);
 501     if(FAILED(hres))
 502         return hres;
 503
 504     return start_binding(This->window, NULL, (BSCallback*)This->window->bscallback, pibc);
 505 }
 506
 507 static HRESULT WINAPI PersistMoniker_Save(IPersistMoniker *iface, IMoniker *pimkName,
 508         LPBC pbc, BOOL fRemember)
 509 {
 510     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 511     FIXME("(%p)->(%p %p %x)\n", This, pimkName, pbc, fRemember);
 512     return E_NOTIMPL;
 513 }
 514
 515 static HRESULT WINAPI PersistMoniker_SaveCompleted(IPersistMoniker *iface, IMoniker *pimkName, LPBC pibc)
 516 {
 517     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 518     FIXME("(%p)->(%p %p)\n", This, pimkName, pibc);
 519     return E_NOTIMPL;
 520 }
 521
 522 static HRESULT WINAPI PersistMoniker_GetCurMoniker(IPersistMoniker *iface, IMoniker **ppimkName)
 523 {
 524     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 525
 526     TRACE("(%p)->(%p)\n", This, ppimkName);
 527
 528     if(!This->window || !This->window->mon)
 529         return E_UNEXPECTED;
 530
 531     IMoniker_AddRef(This->window->mon);
 532     *ppimkName = This->window->mon;
 533     return S_OK;
 534 }
 535
 536 static const IPersistMonikerVtbl PersistMonikerVtbl = {
 537     PersistMoniker_QueryInterface,
 538     PersistMoniker_AddRef,
 539     PersistMoniker_Release,
 540     PersistMoniker_GetClassID,
 541     PersistMoniker_IsDirty,
 542     PersistMoniker_Load,
 543     PersistMoniker_Save,
 544     PersistMoniker_SaveCompleted,
 545     PersistMoniker_GetCurMoniker
 546 };
 547
 548 /**********************************************************
 549  * IMonikerProp implementation
 550  */
 551
 552 static inline HTMLDocument *impl_from_IMonikerProp(IMonikerProp *iface)
 553 {
 554     return CONTAINING_RECORD(iface, HTMLDocument, IMonikerProp_iface);
 555 }
 556
 557 static HRESULT WINAPI MonikerProp_QueryInterface(IMonikerProp *iface, REFIID riid, void **ppv)
 558 {
 559     HTMLDocument *This = impl_from_IMonikerProp(iface);
 560     return htmldoc_query_interface(This, riid, ppv);
 561 }
 562
 563 static ULONG WINAPI MonikerProp_AddRef(IMonikerProp *iface)
 564 {
 565     HTMLDocument *This = impl_from_IMonikerProp(iface);
 566     return htmldoc_addref(This);
 567 }
 568
 569 static ULONG WINAPI MonikerProp_Release(IMonikerProp *iface)
 570 {
 571     HTMLDocument *This = impl_from_IMonikerProp(iface);
 572     return htmldoc_release(This);
 573 }
 574
 575 static HRESULT WINAPI MonikerProp_PutProperty(IMonikerProp *iface, MONIKERPROPERTY mkp, LPCWSTR val)
 576 {
 577     HTMLDocument *This = impl_from_IMonikerProp(iface);
 578
 579     TRACE("(%p)->(%d %s)\n", This, mkp, debugstr_w(val));
 580
 581     switch(mkp) {
 582     case MIMETYPEPROP:
 583         heap_free(This->doc_obj->mime);
 584         This->doc_obj->mime = heap_strdupW(val);
 585         break;
 586
 587     case CLASSIDPROP:
 588         break;
 589
 590     default:
 591         FIXME("mkp %d\n", mkp);
 592         return E_NOTIMPL;
 593     }
 594
 595     return S_OK;
 596 }
 597
 598 static const IMonikerPropVtbl MonikerPropVtbl = {
 599     MonikerProp_QueryInterface,
 600     MonikerProp_AddRef,
 601     MonikerProp_Release,
 602     MonikerProp_PutProperty
 603 };
 604
 605 /**********************************************************
 606  * IPersistFile implementation
 607  */
 608
 609 static inline HTMLDocument *impl_from_IPersistFile(IPersistFile *iface)
 610 {
 611     return CONTAINING_RECORD(iface, HTMLDocument, IPersistFile_iface);
 612 }
 613
 614 static HRESULT WINAPI PersistFile_QueryInterface(IPersistFile *iface, REFIID riid, void **ppv)
 615 {
 616     HTMLDocument *This = impl_from_IPersistFile(iface);
 617     return htmldoc_query_interface(This, riid, ppv);
 618 }
 619
 620 static ULONG WINAPI PersistFile_AddRef(IPersistFile *iface)
 621 {
 622     HTMLDocument *This = impl_from_IPersistFile(iface);
 623     return htmldoc_addref(This);
 624 }
 625
 626 static ULONG WINAPI PersistFile_Release(IPersistFile *iface)
 627 {
 628     HTMLDocument *This = impl_from_IPersistFile(iface);
 629     return htmldoc_release(This);
 630 }
 631
 632 static HRESULT WINAPI PersistFile_GetClassID(IPersistFile *iface, CLSID *pClassID)
 633 {
 634     HTMLDocument *This = impl_from_IPersistFile(iface);
 635
 636     TRACE("(%p)->(%p)\n", This, pClassID);
 637
 638     if(!pClassID)
 639         return E_INVALIDARG;
 640
 641     *pClassID = CLSID_HTMLDocument;
 642     return S_OK;
 643 }
 644
 645 static HRESULT WINAPI PersistFile_IsDirty(IPersistFile *iface)
 646 {
 647     HTMLDocument *This = impl_from_IPersistFile(iface);
 648
 649     TRACE("(%p)\n", This);
 650
 651     return IPersistStreamInit_IsDirty(&This->IPersistStreamInit_iface);
 652 }
 653
 654 static HRESULT WINAPI PersistFile_Load(IPersistFile *iface, LPCOLESTR pszFileName, DWORD dwMode)
 655 {
 656     HTMLDocument *This = impl_from_IPersistFile(iface);
 657     FIXME("(%p)->(%s %08x)\n", This, debugstr_w(pszFileName), dwMode);
 658     return E_NOTIMPL;
 659 }
 660
 661 static HRESULT WINAPI PersistFile_Save(IPersistFile *iface, LPCOLESTR pszFileName, BOOL fRemember)
 662 {
 663     HTMLDocument *This = impl_from_IPersistFile(iface);
 664     char *str;
 665     DWORD written=0;
 666     HANDLE file;
 667     HRESULT hres;
 668
 669     TRACE("(%p)->(%s %x)\n", This, debugstr_w(pszFileName), fRemember);
 670
 671     file = CreateFileW(pszFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 672                        FILE_ATTRIBUTE_NORMAL, NULL);
 673     if(file == INVALID_HANDLE_VALUE) {
 674         WARN("Could not create file: %u\n", GetLastError());
 675         return E_FAIL;
 676     }
 677
 678     hres = get_doc_string(This->doc_node, &str);
 679     if(SUCCEEDED(hres))
 680         WriteFile(file, str, strlen(str), &written, NULL);
 681
 682     CloseHandle(file);
 683     return hres;
 684 }
 685
 686 static HRESULT WINAPI PersistFile_SaveCompleted(IPersistFile *iface, LPCOLESTR pszFileName)
 687 {
 688     HTMLDocument *This = impl_from_IPersistFile(iface);
 689     FIXME("(%p)->(%s)\n", This, debugstr_w(pszFileName));
 690     return E_NOTIMPL;
 691 }
 692
 693 static HRESULT WINAPI PersistFile_GetCurFile(IPersistFile *iface, LPOLESTR *pszFileName)
 694 {
 695     HTMLDocument *This = impl_from_IPersistFile(iface);
 696     FIXME("(%p)->(%p)\n", This, pszFileName);
 697     return E_NOTIMPL;
 698 }
 699
 700 static const IPersistFileVtbl PersistFileVtbl = {
 701     PersistFile_QueryInterface,
 702     PersistFile_AddRef,
 703     PersistFile_Release,
 704     PersistFile_GetClassID,
 705     PersistFile_IsDirty,
 706     PersistFile_Load,
 707     PersistFile_Save,
 708     PersistFile_SaveCompleted,
 709     PersistFile_GetCurFile
 710 };
 711
 712 static inline HTMLDocument *impl_from_IPersistStreamInit(IPersistStreamInit *iface)
 713 {
 714     return CONTAINING_RECORD(iface, HTMLDocument, IPersistStreamInit_iface);
 715 }
 716
 717 static HRESULT WINAPI PersistStreamInit_QueryInterface(IPersistStreamInit *iface,
 718                                                        REFIID riid, void **ppv)
 719 {
 720     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 721     return htmldoc_query_interface(This, riid, ppv);
 722 }
 723
 724 static ULONG WINAPI PersistStreamInit_AddRef(IPersistStreamInit *iface)
 725 {
 726     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 727     return htmldoc_addref(This);
 728 }
 729
 730 static ULONG WINAPI PersistStreamInit_Release(IPersistStreamInit *iface)
 731 {
 732     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 733     return htmldoc_release(This);
 734 }
 735
 736 static HRESULT WINAPI PersistStreamInit_GetClassID(IPersistStreamInit *iface, CLSID *pClassID)
 737 {
 738     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 739     return IPersist_GetClassID(&This->IPersistFile_iface, pClassID);
 740 }
 741
 742 static HRESULT WINAPI PersistStreamInit_IsDirty(IPersistStreamInit *iface)
 743 {
 744     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 745
 746     TRACE("(%p)\n", This);
 747
 748     if(This->doc_obj->usermode == EDITMODE)
 749         return editor_is_dirty(This);
 750
 751     return S_FALSE;
 752 }
 753
 754 static HRESULT WINAPI PersistStreamInit_Load(IPersistStreamInit *iface, LPSTREAM pStm)
 755 {
 756     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 757     IMoniker *mon;
 758     HRESULT hres;
 759
 760     static const WCHAR about_blankW[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
 761
 762     TRACE("(%p)->(%p)\n", This, pStm);
 763
 764     hres = CreateURLMoniker(NULL, about_blankW, &mon);
 765     if(FAILED(hres)) {
 766         WARN("CreateURLMoniker failed: %08x\n", hres);
 767         return hres;
 768     }
 769
 770     prepare_for_binding(This, mon, FALSE);
 771     hres = set_moniker(This, mon, NULL, NULL, TRUE);
 772     IMoniker_Release(mon);
 773     if(FAILED(hres))
 774         return hres;
 775
 776     return channelbsc_load_stream(This->window->bscallback, pStm);
 777 }
 778
 779 static HRESULT WINAPI PersistStreamInit_Save(IPersistStreamInit *iface, LPSTREAM pStm,
 780                                              BOOL fClearDirty)
 781 {
 782     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 783     char *str;
 784     DWORD written=0;
 785     HRESULT hres;
 786
 787     TRACE("(%p)->(%p %x)\n", This, pStm, fClearDirty);
 788
 789     hres = get_doc_string(This->doc_node, &str);
 790     if(FAILED(hres))
 791         return hres;
 792
 793     hres = IStream_Write(pStm, str, strlen(str), &written);
 794     if(FAILED(hres))
 795         FIXME("Write failed: %08x\n", hres);
 796
 797     heap_free(str);
 798
 799     if(fClearDirty)
 800         set_dirty(This, VARIANT_FALSE);
 801
 802     return S_OK;
 803 }
 804
 805 static HRESULT WINAPI PersistStreamInit_GetSizeMax(IPersistStreamInit *iface,
 806                                                    ULARGE_INTEGER *pcbSize)
 807 {
 808     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 809     FIXME("(%p)->(%p)\n", This, pcbSize);
 810     return E_NOTIMPL;
 811 }
 812
 813 static HRESULT WINAPI PersistStreamInit_InitNew(IPersistStreamInit *iface)
 814 {
 815     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 816     IMoniker *mon;
 817     HRESULT hres;
 818
 819     static const WCHAR about_blankW[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
 820
 821     TRACE("(%p)\n", This);
 822
 823     hres = CreateURLMoniker(NULL, about_blankW, &mon);
 824     if(FAILED(hres)) {
 825         WARN("CreateURLMoniker failed: %08x\n", hres);
 826         return hres;
 827     }
 828
 829     prepare_for_binding(This, mon, FALSE);
 830     hres = set_moniker(This, mon, NULL, NULL, FALSE);
 831     IMoniker_Release(mon);
 832     if(FAILED(hres))
 833         return hres;
 834
 835     return channelbsc_load_stream(This->window->bscallback, NULL);
 836 }
 837
 838 static const IPersistStreamInitVtbl PersistStreamInitVtbl = {
 839     PersistStreamInit_QueryInterface,
 840     PersistStreamInit_AddRef,
 841     PersistStreamInit_Release,
 842     PersistStreamInit_GetClassID,
 843     PersistStreamInit_IsDirty,
 844     PersistStreamInit_Load,
 845     PersistStreamInit_Save,
 846     PersistStreamInit_GetSizeMax,
 847     PersistStreamInit_InitNew
 848 };
 849
 850 /**********************************************************
 851  * IPersistHistory implementation
 852  */
 853
 854 static inline HTMLDocument *impl_from_IPersistHistory(IPersistHistory *iface)
 855 {
 856     return CONTAINING_RECORD(iface, HTMLDocument, IPersistHistory_iface);
 857 }
 858
 859 static HRESULT WINAPI PersistHistory_QueryInterface(IPersistHistory *iface, REFIID riid, void **ppv)
 860 {
 861     HTMLDocument *This = impl_from_IPersistHistory(iface);
 862     return htmldoc_query_interface(This, riid, ppv);
 863 }
 864
 865 static ULONG WINAPI PersistHistory_AddRef(IPersistHistory *iface)
 866 {
 867     HTMLDocument *This = impl_from_IPersistHistory(iface);
 868     return htmldoc_addref(This);
 869 }
 870
 871 static ULONG WINAPI PersistHistory_Release(IPersistHistory *iface)
 872 {
 873     HTMLDocument *This = impl_from_IPersistHistory(iface);
 874     return htmldoc_release(This);
 875 }
 876
 877 static HRESULT WINAPI PersistHistory_GetClassID(IPersistHistory *iface, CLSID *pClassID)
 878 {
 879     HTMLDocument *This = impl_from_IPersistHistory(iface);
 880     return IPersist_GetClassID(&This->IPersistFile_iface, pClassID);
 881 }
 882
 883 static HRESULT WINAPI PersistHistory_LoadHistory(IPersistHistory *iface, IStream *pStream, IBindCtx *pbc)
 884 {
 885     HTMLDocument *This = impl_from_IPersistHistory(iface);
 886     FIXME("(%p)->(%p %p)\n", This, pStream, pbc);
 887     return E_NOTIMPL;
 888 }
 889
 890 static HRESULT WINAPI PersistHistory_SaveHistory(IPersistHistory *iface, IStream *pStream)
 891 {
 892     HTMLDocument *This = impl_from_IPersistHistory(iface);
 893     FIXME("(%p)->(%p)\n", This, pStream);
 894     return E_NOTIMPL;
 895 }
 896
 897 static HRESULT WINAPI PersistHistory_SetPositionCookie(IPersistHistory *iface, DWORD dwPositioncookie)
 898 {
 899     HTMLDocument *This = impl_from_IPersistHistory(iface);
 900     FIXME("(%p)->(%x)\n", This, dwPositioncookie);
 901     return E_NOTIMPL;
 902 }
 903
 904 static HRESULT WINAPI PersistHistory_GetPositionCookie(IPersistHistory *iface, DWORD *pdwPositioncookie)
 905 {
 906     HTMLDocument *This = impl_from_IPersistHistory(iface);
 907     FIXME("(%p)->(%p)\n", This, pdwPositioncookie);
 908     return E_NOTIMPL;
 909 }
 910
 911 static const IPersistHistoryVtbl PersistHistoryVtbl = {
 912     PersistHistory_QueryInterface,
 913     PersistHistory_AddRef,
 914     PersistHistory_Release,
 915     PersistHistory_GetClassID,
 916     PersistHistory_LoadHistory,
 917     PersistHistory_SaveHistory,
 918     PersistHistory_SetPositionCookie,
 919     PersistHistory_GetPositionCookie
 920 };
 921
 922 void HTMLDocument_Persist_Init(HTMLDocument *This)
 923 {
 924     This->IPersistMoniker_iface.lpVtbl = &PersistMonikerVtbl;
 925     This->IPersistFile_iface.lpVtbl = &PersistFileVtbl;
 926     This->IMonikerProp_iface.lpVtbl = &MonikerPropVtbl;
 927     This->IPersistStreamInit_iface.lpVtbl = &PersistStreamInitVtbl;
 928     This->IPersistHistory_iface.lpVtbl = &PersistHistoryVtbl;
 929 }