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