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