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