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