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