dll/win32/mshtml/persist.c

   1 /*
   2  * Copyright 2005 Jacek Caban
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "mshtml_private.h"
  20
  21 /* Undocumented notification, see tests */
  22 #define CMDID_EXPLORER_UPDATEHISTORY 38
  23
  24 static const WCHAR about_blankW[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
  25
  26 typedef struct {
  27     task_t header;
  28     HTMLDocumentObj *doc;
  29     BOOL set_download;
  30     LPOLESTR url;
  31 } download_proc_task_t;
  32
  33 static BOOL use_gecko_script(HTMLOuterWindow *window)
  34 {
  35     DWORD zone;
  36     HRESULT hres;
  37
  38     hres = IInternetSecurityManager_MapUrlToZone(window->secmgr, window->url, &zone, 0);
  39     if(FAILED(hres)) {
  40         WARN("Could not map %s to zone: %08x\n", debugstr_w(window->url), hres);
  41         return TRUE;
  42     }
  43
  44     TRACE("zone %d\n", zone);
  45     return zone == URLZONE_UNTRUSTED;
  46 }
  47
  48 static void notify_travellog_update(HTMLDocumentObj *doc)
  49 {
  50     IOleCommandTarget *cmdtrg;
  51     HRESULT hres;
  52
  53     if(!doc->webbrowser)
  54         return;
  55
  56     hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&cmdtrg);
  57     if(SUCCEEDED(hres)) {
  58         VARIANT vin;
  59
  60         V_VT(&vin) = VT_I4;
  61         V_I4(&vin) = 0;
  62
  63         IOleCommandTarget_Exec(cmdtrg, &CGID_Explorer, CMDID_EXPLORER_UPDATEHISTORY, 0, &vin, NULL);
  64         IOleCommandTarget_Release(cmdtrg);
  65     }
  66 }
  67
  68 void set_current_uri(HTMLOuterWindow *window, IUri *uri)
  69 {
  70     if(window->uri) {
  71         IUri_Release(window->uri);
  72         window->uri = NULL;
  73     }
  74
  75     if(window->uri_nofrag) {
  76         IUri_Release(window->uri_nofrag);
  77         window->uri_nofrag = NULL;
  78     }
  79
  80     SysFreeString(window->url);
  81     window->url = NULL;
  82
  83     if(!uri)
  84         return;
  85
  86     IUri_AddRef(uri);
  87     window->uri = uri;
  88
  89     window->uri_nofrag = get_uri_nofrag(uri);
  90     if(!window->uri_nofrag) {
  91         FIXME("get_uri_nofrag failed\n");
  92         IUri_AddRef(uri);
  93         window->uri_nofrag = uri;
  94     }
  95
  96     IUri_GetDisplayUri(uri, &window->url);
  97 }
  98
  99 void set_current_mon(HTMLOuterWindow *This, IMoniker *mon, DWORD flags)
 100 {
 101     IUriContainer *uri_container;
 102     IUri *uri = NULL;
 103     HRESULT hres;
 104
 105     if(This->mon) {
 106         if(This->doc_obj && !(flags & (BINDING_REPLACE|BINDING_REFRESH))) {
 107             if(This == This->doc_obj->basedoc.window)
 108                 notify_travellog_update(This->doc_obj);
 109             else
 110                 TRACE("Skipping travellog update for frame navigation.\n");
 111         }
 112         IMoniker_Release(This->mon);
 113         This->mon = NULL;
 114     }
 115
 116     This->load_flags = flags;
 117     if(!mon)
 118         return;
 119
 120     IMoniker_AddRef(mon);
 121     This->mon = mon;
 122
 123     hres = IMoniker_QueryInterface(mon, &IID_IUriContainer, (void**)&uri_container);
 124     if(SUCCEEDED(hres)) {
 125         hres = IUriContainer_GetIUri(uri_container, &uri);
 126         IUriContainer_Release(uri_container);
 127         if(hres != S_OK) {
 128             WARN("GetIUri failed: %08x\n", hres);
 129             uri = NULL;
 130         }
 131     }
 132
 133     if(!uri) {
 134         WCHAR *url;
 135
 136         hres = IMoniker_GetDisplayName(mon, NULL, NULL, &url);
 137         if(SUCCEEDED(hres)) {
 138             hres = create_uri(url, 0, &uri);
 139             if(FAILED(hres)) {
 140                 WARN("CrateUri failed: %08x\n", hres);
 141                 set_current_uri(This, NULL);
 142                 This->url = SysAllocString(url);
 143                 CoTaskMemFree(url);
 144                 return;
 145             }
 146             CoTaskMemFree(url);
 147         }else {
 148             WARN("GetDisplayName failed: %08x\n", hres);
 149         }
 150     }
 151
 152     set_current_uri(This, uri);
 153     if(uri)
 154         IUri_Release(uri);
 155     set_script_mode(This, use_gecko_script(This) ? SCRIPTMODE_GECKO : SCRIPTMODE_ACTIVESCRIPT);
 156 }
 157
 158 HRESULT create_uri(const WCHAR *uri_str, DWORD flags, IUri **uri)
 159 {
 160     return CreateUri(uri_str, flags | Uri_CREATE_ALLOW_IMPLICIT_FILE_SCHEME, 0, uri);
 161 }
 162
 163 HRESULT create_relative_uri(HTMLOuterWindow *window, const WCHAR *rel_uri, IUri **uri)
 164 {
 165     return window->uri
 166         ? CoInternetCombineUrlEx(window->uri, rel_uri, URL_ESCAPE_SPACES_ONLY|URL_DONT_ESCAPE_EXTRA_INFO, uri, 0)
 167         : create_uri(rel_uri, 0, uri);
 168 }
 169
 170 void set_download_state(HTMLDocumentObj *doc, int state)
 171 {
 172     if(doc->client) {
 173         IOleCommandTarget *olecmd;
 174         HRESULT hres;
 175
 176         hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
 177         if(SUCCEEDED(hres)) {
 178             VARIANT var;
 179
 180             V_VT(&var) = VT_I4;
 181             V_I4(&var) = state;
 182
 183             IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETDOWNLOADSTATE,
 184                     OLECMDEXECOPT_DONTPROMPTUSER, &var, NULL);
 185             IOleCommandTarget_Release(olecmd);
 186         }
 187     }
 188
 189     doc->download_state = state;
 190 }
 191
 192 static void set_progress_proc(task_t *_task)
 193 {
 194     docobj_task_t *task = (docobj_task_t*)_task;
 195     IOleCommandTarget *olecmd = NULL;
 196     HTMLDocumentObj *doc = task->doc;
 197     HRESULT hres;
 198
 199     TRACE("(%p)\n", doc);
 200
 201     if(doc->client)
 202         IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
 203
 204     if(olecmd) {
 205         VARIANT progress_max, progress;
 206
 207         V_VT(&progress_max) = VT_I4;
 208         V_I4(&progress_max) = 0; /* FIXME */
 209         IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETPROGRESSMAX, OLECMDEXECOPT_DONTPROMPTUSER,
 210                                &progress_max, NULL);
 211
 212         V_VT(&progress) = VT_I4;
 213         V_I4(&progress) = 0; /* FIXME */
 214         IOleCommandTarget_Exec(olecmd, NULL, OLECMDID_SETPROGRESSPOS, OLECMDEXECOPT_DONTPROMPTUSER,
 215                                &progress, NULL);
 216         IOleCommandTarget_Release(olecmd);
 217     }
 218
 219     if(doc->usermode == EDITMODE && doc->hostui) {
 220         DOCHOSTUIINFO hostinfo;
 221
 222         memset(&hostinfo, 0, sizeof(DOCHOSTUIINFO));
 223         hostinfo.cbSize = sizeof(DOCHOSTUIINFO);
 224         hres = IDocHostUIHandler_GetHostInfo(doc->hostui, &hostinfo);
 225         if(SUCCEEDED(hres))
 226             /* FIXME: use hostinfo */
 227             TRACE("hostinfo = {%u %08x %08x %s %s}\n",
 228                     hostinfo.cbSize, hostinfo.dwFlags, hostinfo.dwDoubleClick,
 229                     debugstr_w(hostinfo.pchHostCss), debugstr_w(hostinfo.pchHostNS));
 230     }
 231 }
 232
 233 static void set_downloading_proc(task_t *_task)
 234 {
 235     download_proc_task_t *task = (download_proc_task_t*)_task;
 236     HTMLDocumentObj *doc = task->doc;
 237     HRESULT hres;
 238
 239     TRACE("(%p)\n", doc);
 240
 241     set_statustext(doc, IDS_STATUS_DOWNLOADINGFROM, task->url);
 242
 243     if(task->set_download)
 244         set_download_state(doc, 1);
 245
 246     if(!doc->client)
 247         return;
 248
 249     if(doc->view_sink)
 250         IAdviseSink_OnViewChange(doc->view_sink, DVASPECT_CONTENT, -1);
 251
 252     if(doc->hostui) {
 253         IDropTarget *drop_target = NULL;
 254
 255         hres = IDocHostUIHandler_GetDropTarget(doc->hostui, NULL /* FIXME */, &drop_target);
 256         if(SUCCEEDED(hres) && drop_target) {
 257             FIXME("Use IDropTarget\n");
 258             IDropTarget_Release(drop_target);
 259         }
 260     }
 261 }
 262
 263 static void set_downloading_task_destr(task_t *_task)
 264 {
 265     download_proc_task_t *task = (download_proc_task_t*)_task;
 266
 267     CoTaskMemFree(task->url);
 268     heap_free(task);
 269 }
 270
 271 void prepare_for_binding(HTMLDocument *This, IMoniker *mon, DWORD flags)
 272 {
 273     HRESULT hres;
 274
 275     if(This->doc_obj->client) {
 276         VARIANT silent, offline;
 277
 278         hres = get_client_disp_property(This->doc_obj->client, DISPID_AMBIENT_SILENT, &silent);
 279         if(SUCCEEDED(hres)) {
 280             if(V_VT(&silent) != VT_BOOL)
 281                 WARN("silent = %s\n", debugstr_variant(&silent));
 282             else if(V_BOOL(&silent))
 283                 FIXME("silent == true\n");
 284         }
 285
 286         hres = get_client_disp_property(This->doc_obj->client,
 287                 DISPID_AMBIENT_OFFLINEIFNOTCONNECTED, &offline);
 288         if(SUCCEEDED(hres)) {
 289             if(V_VT(&offline) != VT_BOOL)
 290                 WARN("offline = %s\n", debugstr_variant(&offline));
 291             else if(V_BOOL(&offline))
 292                 FIXME("offline == true\n");
 293         }
 294     }
 295
 296     if(This->window->mon) {
 297         update_doc(This, UPDATE_TITLE|UPDATE_UI);
 298     }else {
 299         update_doc(This, UPDATE_TITLE);
 300         set_current_mon(This->window, mon, flags);
 301     }
 302
 303     if(This->doc_obj->client) {
 304         IOleCommandTarget *cmdtrg = NULL;
 305
 306         hres = IOleClientSite_QueryInterface(This->doc_obj->client, &IID_IOleCommandTarget,
 307                 (void**)&cmdtrg);
 308         if(SUCCEEDED(hres)) {
 309             VARIANT var, out;
 310
 311             if(flags & BINDING_NAVIGATED) {
 312                 V_VT(&var) = VT_UNKNOWN;
 313                 V_UNKNOWN(&var) = (IUnknown*)&This->window->base.IHTMLWindow2_iface;
 314                 V_VT(&out) = VT_EMPTY;
 315                 hres = IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 63, 0, &var, &out);
 316                 if(SUCCEEDED(hres))
 317                     VariantClear(&out);
 318             }else if(!(flags & BINDING_FROMHIST)) {
 319                 V_VT(&var) = VT_I4;
 320                 V_I4(&var) = 0;
 321                 IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 37, 0, &var, NULL);
 322             }
 323
 324             IOleCommandTarget_Release(cmdtrg);
 325         }
 326     }
 327 }
 328
 329 HRESULT set_moniker(HTMLOuterWindow *window, IMoniker *mon, IUri *nav_uri, IBindCtx *pibc, nsChannelBSC *async_bsc,
 330         BOOL set_download)
 331 {
 332     download_proc_task_t *download_task;
 333     HTMLDocumentObj *doc_obj = NULL;
 334     nsChannelBSC *bscallback;
 335     nsWineURI *nsuri;
 336     LPOLESTR url;
 337     IUri *uri;
 338     HRESULT hres;
 339
 340     if(window->doc_obj && window->doc_obj->basedoc.window == window)
 341         doc_obj = window->doc_obj;
 342
 343     hres = IMoniker_GetDisplayName(mon, pibc, NULL, &url);
 344     if(FAILED(hres)) {
 345         WARN("GetDiaplayName failed: %08x\n", hres);
 346         return hres;
 347     }
 348
 349     if(nav_uri) {
 350         uri = nav_uri;
 351     }else {
 352         hres = create_uri(url, 0, &uri);
 353         if(FAILED(hres)) {
 354             CoTaskMemFree(url);
 355             return hres;
 356         }
 357     }
 358
 359     TRACE("got url: %s\n", debugstr_w(url));
 360
 361     set_ready_state(window, READYSTATE_LOADING);
 362
 363     hres = create_doc_uri(window, uri, &nsuri);
 364     if(!nav_uri)
 365         IUri_Release(uri);
 366     if(SUCCEEDED(hres)) {
 367         if(async_bsc)
 368             bscallback = async_bsc;
 369         else
 370             hres = create_channelbsc(mon, NULL, NULL, 0, TRUE, &bscallback);
 371     }
 372
 373     if(SUCCEEDED(hres)) {
 374         if(window->base.inner_window->doc)
 375             remove_target_tasks(window->base.inner_window->task_magic);
 376         abort_window_bindings(window->base.inner_window);
 377
 378         hres = load_nsuri(window, nsuri, NULL, bscallback, LOAD_FLAGS_BYPASS_CACHE);
 379         nsISupports_Release((nsISupports*)nsuri); /* FIXME */
 380         if(SUCCEEDED(hres)) {
 381             hres = create_pending_window(window, bscallback);
 382             TRACE("pending window for %p %p %p\n", window, bscallback, window->pending_window);
 383         }
 384         if(bscallback != async_bsc)
 385             IBindStatusCallback_Release(&bscallback->bsc.IBindStatusCallback_iface);
 386     }
 387
 388     if(FAILED(hres)) {
 389         CoTaskMemFree(url);
 390         return hres;
 391     }
 392
 393     if(doc_obj) {
 394         HTMLDocument_LockContainer(doc_obj, TRUE);
 395
 396         if(doc_obj->frame) {
 397             docobj_task_t *task;
 398
 399             task = heap_alloc(sizeof(docobj_task_t));
 400             task->doc = doc_obj;
 401             hres = push_task(&task->header, set_progress_proc, NULL, doc_obj->basedoc.task_magic);
 402             if(FAILED(hres)) {
 403                 CoTaskMemFree(url);
 404                 return hres;
 405             }
 406         }
 407
 408         download_task = heap_alloc(sizeof(download_proc_task_t));
 409         download_task->doc = doc_obj;
 410         download_task->set_download = set_download;
 411         download_task->url = url;
 412         return push_task(&download_task->header, set_downloading_proc, set_downloading_task_destr, doc_obj->basedoc.task_magic);
 413     }
 414
 415     return S_OK;
 416 }
 417
 418 static void notif_readystate(HTMLOuterWindow *window)
 419 {
 420     window->readystate_pending = FALSE;
 421
 422     if(window->doc_obj && window->doc_obj->basedoc.window == window)
 423         call_property_onchanged(&window->doc_obj->basedoc.cp_container, DISPID_READYSTATE);
 424
 425     fire_event(window->base.inner_window->doc, EVENTID_READYSTATECHANGE, FALSE,
 426             window->base.inner_window->doc->node.nsnode, NULL, NULL);
 427
 428     if(window->frame_element)
 429         fire_event(window->frame_element->element.node.doc, EVENTID_READYSTATECHANGE,
 430                    TRUE, window->frame_element->element.node.nsnode, NULL, NULL);
 431 }
 432
 433 typedef struct {
 434     task_t header;
 435     HTMLOuterWindow *window;
 436 } readystate_task_t;
 437
 438 static void notif_readystate_proc(task_t *_task)
 439 {
 440     readystate_task_t *task = (readystate_task_t*)_task;
 441     notif_readystate(task->window);
 442 }
 443
 444 static void notif_readystate_destr(task_t *_task)
 445 {
 446     readystate_task_t *task = (readystate_task_t*)_task;
 447     IHTMLWindow2_Release(&task->window->base.IHTMLWindow2_iface);
 448 }
 449
 450 void set_ready_state(HTMLOuterWindow *window, READYSTATE readystate)
 451 {
 452     READYSTATE prev_state = window->readystate;
 453
 454     window->readystate = readystate;
 455
 456     if(window->readystate_locked) {
 457         readystate_task_t *task;
 458         HRESULT hres;
 459
 460         if(window->readystate_pending || prev_state == readystate)
 461             return;
 462
 463         task = heap_alloc(sizeof(*task));
 464         if(!task)
 465             return;
 466
 467         IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
 468         task->window = window;
 469
 470         hres = push_task(&task->header, notif_readystate_proc, notif_readystate_destr, window->task_magic);
 471         if(SUCCEEDED(hres))
 472             window->readystate_pending = TRUE;
 473         return;
 474     }
 475
 476     notif_readystate(window);
 477 }
 478
 479 static HRESULT get_doc_string(HTMLDocumentNode *This, char **str)
 480 {
 481     nsIDOMNode *nsnode;
 482     LPCWSTR strw;
 483     nsAString nsstr;
 484     nsresult nsres;
 485     HRESULT hres;
 486
 487     if(!This->nsdoc) {
 488         WARN("NULL nsdoc\n");
 489         return E_UNEXPECTED;
 490     }
 491
 492     nsres = nsIDOMHTMLDocument_QueryInterface(This->nsdoc, &IID_nsIDOMNode, (void**)&nsnode);
 493     if(NS_FAILED(nsres)) {
 494         ERR("Could not get nsIDOMNode failed: %08x\n", nsres);
 495         return E_FAIL;
 496     }
 497
 498     nsAString_Init(&nsstr, NULL);
 499     hres = nsnode_to_nsstring(nsnode, &nsstr);
 500     nsIDOMNode_Release(nsnode);
 501     if(FAILED(hres)) {
 502         nsAString_Finish(&nsstr);
 503         return hres;
 504     }
 505
 506     nsAString_GetData(&nsstr, &strw);
 507     TRACE("%s\n", debugstr_w(strw));
 508
 509     *str = heap_strdupWtoA(strw);
 510
 511     nsAString_Finish(&nsstr);
 512
 513     if(!*str)
 514         return E_OUTOFMEMORY;
 515     return S_OK;
 516 }
 517
 518
 519 /**********************************************************
 520  * IPersistMoniker implementation
 521  */
 522
 523 static inline HTMLDocument *impl_from_IPersistMoniker(IPersistMoniker *iface)
 524 {
 525     return CONTAINING_RECORD(iface, HTMLDocument, IPersistMoniker_iface);
 526 }
 527
 528 static HRESULT WINAPI PersistMoniker_QueryInterface(IPersistMoniker *iface, REFIID riid, void **ppv)
 529 {
 530     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 531     return htmldoc_query_interface(This, riid, ppv);
 532 }
 533
 534 static ULONG WINAPI PersistMoniker_AddRef(IPersistMoniker *iface)
 535 {
 536     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 537     return htmldoc_addref(This);
 538 }
 539
 540 static ULONG WINAPI PersistMoniker_Release(IPersistMoniker *iface)
 541 {
 542     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 543     return htmldoc_release(This);
 544 }
 545
 546 static HRESULT WINAPI PersistMoniker_GetClassID(IPersistMoniker *iface, CLSID *pClassID)
 547 {
 548     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 549     return IPersistFile_GetClassID(&This->IPersistFile_iface, pClassID);
 550 }
 551
 552 static HRESULT WINAPI PersistMoniker_IsDirty(IPersistMoniker *iface)
 553 {
 554     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 555
 556     TRACE("(%p)\n", This);
 557
 558     return IPersistStreamInit_IsDirty(&This->IPersistStreamInit_iface);
 559 }
 560
 561 static HRESULT WINAPI PersistMoniker_Load(IPersistMoniker *iface, BOOL fFullyAvailable,
 562         IMoniker *pimkName, LPBC pibc, DWORD grfMode)
 563 {
 564     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 565     HRESULT hres;
 566
 567     TRACE("(%p)->(%x %p %p %08x)\n", This, fFullyAvailable, pimkName, pibc, grfMode);
 568
 569     if(pibc) {
 570         IUnknown *unk = NULL;
 571
 572         /* FIXME:
 573          * Use params:
 574          * "__PrecreatedObject"
 575          * "BIND_CONTEXT_PARAM"
 576          * "__HTMLLOADOPTIONS"
 577          * "__DWNBINDINFO"
 578          * "URL Context"
 579          * "_ITransData_Object_"
 580          * "_EnumFORMATETC_"
 581          */
 582
 583         hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM, &unk);
 584         if(SUCCEEDED(hres) && unk) {
 585             IOleClientSite *client = NULL;
 586
 587             hres = IUnknown_QueryInterface(unk, &IID_IOleClientSite, (void**)&client);
 588             if(SUCCEEDED(hres)) {
 589                 TRACE("Got client site %p\n", client);
 590                 IOleObject_SetClientSite(&This->IOleObject_iface, client);
 591                 IOleClientSite_Release(client);
 592             }
 593
 594             IUnknown_Release(unk);
 595         }
 596     }
 597
 598     prepare_for_binding(This, pimkName, FALSE);
 599     call_docview_84(This->doc_obj);
 600     hres = set_moniker(This->window, pimkName, NULL, pibc, NULL, TRUE);
 601     if(FAILED(hres))
 602         return hres;
 603
 604     return start_binding(This->window->pending_window, (BSCallback*)This->window->pending_window->bscallback, pibc);
 605 }
 606
 607 static HRESULT WINAPI PersistMoniker_Save(IPersistMoniker *iface, IMoniker *pimkName,
 608         LPBC pbc, BOOL fRemember)
 609 {
 610     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 611     FIXME("(%p)->(%p %p %x)\n", This, pimkName, pbc, fRemember);
 612     return E_NOTIMPL;
 613 }
 614
 615 static HRESULT WINAPI PersistMoniker_SaveCompleted(IPersistMoniker *iface, IMoniker *pimkName, LPBC pibc)
 616 {
 617     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 618     FIXME("(%p)->(%p %p)\n", This, pimkName, pibc);
 619     return E_NOTIMPL;
 620 }
 621
 622 static HRESULT WINAPI PersistMoniker_GetCurMoniker(IPersistMoniker *iface, IMoniker **ppimkName)
 623 {
 624     HTMLDocument *This = impl_from_IPersistMoniker(iface);
 625
 626     TRACE("(%p)->(%p)\n", This, ppimkName);
 627
 628     if(!This->window || !This->window->mon)
 629         return E_UNEXPECTED;
 630
 631     IMoniker_AddRef(This->window->mon);
 632     *ppimkName = This->window->mon;
 633     return S_OK;
 634 }
 635
 636 static const IPersistMonikerVtbl PersistMonikerVtbl = {
 637     PersistMoniker_QueryInterface,
 638     PersistMoniker_AddRef,
 639     PersistMoniker_Release,
 640     PersistMoniker_GetClassID,
 641     PersistMoniker_IsDirty,
 642     PersistMoniker_Load,
 643     PersistMoniker_Save,
 644     PersistMoniker_SaveCompleted,
 645     PersistMoniker_GetCurMoniker
 646 };
 647
 648 /**********************************************************
 649  * IMonikerProp implementation
 650  */
 651
 652 static inline HTMLDocument *impl_from_IMonikerProp(IMonikerProp *iface)
 653 {
 654     return CONTAINING_RECORD(iface, HTMLDocument, IMonikerProp_iface);
 655 }
 656
 657 static HRESULT WINAPI MonikerProp_QueryInterface(IMonikerProp *iface, REFIID riid, void **ppv)
 658 {
 659     HTMLDocument *This = impl_from_IMonikerProp(iface);
 660     return htmldoc_query_interface(This, riid, ppv);
 661 }
 662
 663 static ULONG WINAPI MonikerProp_AddRef(IMonikerProp *iface)
 664 {
 665     HTMLDocument *This = impl_from_IMonikerProp(iface);
 666     return htmldoc_addref(This);
 667 }
 668
 669 static ULONG WINAPI MonikerProp_Release(IMonikerProp *iface)
 670 {
 671     HTMLDocument *This = impl_from_IMonikerProp(iface);
 672     return htmldoc_release(This);
 673 }
 674
 675 static HRESULT WINAPI MonikerProp_PutProperty(IMonikerProp *iface, MONIKERPROPERTY mkp, LPCWSTR val)
 676 {
 677     HTMLDocument *This = impl_from_IMonikerProp(iface);
 678
 679     TRACE("(%p)->(%d %s)\n", This, mkp, debugstr_w(val));
 680
 681     switch(mkp) {
 682     case MIMETYPEPROP:
 683         heap_free(This->doc_obj->mime);
 684         This->doc_obj->mime = heap_strdupW(val);
 685         break;
 686
 687     case CLASSIDPROP:
 688         break;
 689
 690     default:
 691         FIXME("mkp %d\n", mkp);
 692         return E_NOTIMPL;
 693     }
 694
 695     return S_OK;
 696 }
 697
 698 static const IMonikerPropVtbl MonikerPropVtbl = {
 699     MonikerProp_QueryInterface,
 700     MonikerProp_AddRef,
 701     MonikerProp_Release,
 702     MonikerProp_PutProperty
 703 };
 704
 705 /**********************************************************
 706  * IPersistFile implementation
 707  */
 708
 709 static inline HTMLDocument *impl_from_IPersistFile(IPersistFile *iface)
 710 {
 711     return CONTAINING_RECORD(iface, HTMLDocument, IPersistFile_iface);
 712 }
 713
 714 static HRESULT WINAPI PersistFile_QueryInterface(IPersistFile *iface, REFIID riid, void **ppv)
 715 {
 716     HTMLDocument *This = impl_from_IPersistFile(iface);
 717     return htmldoc_query_interface(This, riid, ppv);
 718 }
 719
 720 static ULONG WINAPI PersistFile_AddRef(IPersistFile *iface)
 721 {
 722     HTMLDocument *This = impl_from_IPersistFile(iface);
 723     return htmldoc_addref(This);
 724 }
 725
 726 static ULONG WINAPI PersistFile_Release(IPersistFile *iface)
 727 {
 728     HTMLDocument *This = impl_from_IPersistFile(iface);
 729     return htmldoc_release(This);
 730 }
 731
 732 static HRESULT WINAPI PersistFile_GetClassID(IPersistFile *iface, CLSID *pClassID)
 733 {
 734     HTMLDocument *This = impl_from_IPersistFile(iface);
 735
 736     TRACE("(%p)->(%p)\n", This, pClassID);
 737
 738     if(!pClassID)
 739         return E_INVALIDARG;
 740
 741     *pClassID = CLSID_HTMLDocument;
 742     return S_OK;
 743 }
 744
 745 static HRESULT WINAPI PersistFile_IsDirty(IPersistFile *iface)
 746 {
 747     HTMLDocument *This = impl_from_IPersistFile(iface);
 748
 749     TRACE("(%p)\n", This);
 750
 751     return IPersistStreamInit_IsDirty(&This->IPersistStreamInit_iface);
 752 }
 753
 754 static HRESULT WINAPI PersistFile_Load(IPersistFile *iface, LPCOLESTR pszFileName, DWORD dwMode)
 755 {
 756     HTMLDocument *This = impl_from_IPersistFile(iface);
 757     FIXME("(%p)->(%s %08x)\n", This, debugstr_w(pszFileName), dwMode);
 758     return E_NOTIMPL;
 759 }
 760
 761 static HRESULT WINAPI PersistFile_Save(IPersistFile *iface, LPCOLESTR pszFileName, BOOL fRemember)
 762 {
 763     HTMLDocument *This = impl_from_IPersistFile(iface);
 764     char *str;
 765     DWORD written=0;
 766     HANDLE file;
 767     HRESULT hres;
 768
 769     TRACE("(%p)->(%s %x)\n", This, debugstr_w(pszFileName), fRemember);
 770
 771     file = CreateFileW(pszFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 772                        FILE_ATTRIBUTE_NORMAL, NULL);
 773     if(file == INVALID_HANDLE_VALUE) {
 774         WARN("Could not create file: %u\n", GetLastError());
 775         return E_FAIL;
 776     }
 777
 778     hres = get_doc_string(This->doc_node, &str);
 779     if(SUCCEEDED(hres))
 780         WriteFile(file, str, strlen(str), &written, NULL);
 781
 782     CloseHandle(file);
 783     return hres;
 784 }
 785
 786 static HRESULT WINAPI PersistFile_SaveCompleted(IPersistFile *iface, LPCOLESTR pszFileName)
 787 {
 788     HTMLDocument *This = impl_from_IPersistFile(iface);
 789     FIXME("(%p)->(%s)\n", This, debugstr_w(pszFileName));
 790     return E_NOTIMPL;
 791 }
 792
 793 static HRESULT WINAPI PersistFile_GetCurFile(IPersistFile *iface, LPOLESTR *pszFileName)
 794 {
 795     HTMLDocument *This = impl_from_IPersistFile(iface);
 796     FIXME("(%p)->(%p)\n", This, pszFileName);
 797     return E_NOTIMPL;
 798 }
 799
 800 static const IPersistFileVtbl PersistFileVtbl = {
 801     PersistFile_QueryInterface,
 802     PersistFile_AddRef,
 803     PersistFile_Release,
 804     PersistFile_GetClassID,
 805     PersistFile_IsDirty,
 806     PersistFile_Load,
 807     PersistFile_Save,
 808     PersistFile_SaveCompleted,
 809     PersistFile_GetCurFile
 810 };
 811
 812 static inline HTMLDocument *impl_from_IPersistStreamInit(IPersistStreamInit *iface)
 813 {
 814     return CONTAINING_RECORD(iface, HTMLDocument, IPersistStreamInit_iface);
 815 }
 816
 817 static HRESULT WINAPI PersistStreamInit_QueryInterface(IPersistStreamInit *iface,
 818                                                        REFIID riid, void **ppv)
 819 {
 820     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 821     return htmldoc_query_interface(This, riid, ppv);
 822 }
 823
 824 static ULONG WINAPI PersistStreamInit_AddRef(IPersistStreamInit *iface)
 825 {
 826     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 827     return htmldoc_addref(This);
 828 }
 829
 830 static ULONG WINAPI PersistStreamInit_Release(IPersistStreamInit *iface)
 831 {
 832     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 833     return htmldoc_release(This);
 834 }
 835
 836 static HRESULT WINAPI PersistStreamInit_GetClassID(IPersistStreamInit *iface, CLSID *pClassID)
 837 {
 838     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 839     return IPersistFile_GetClassID(&This->IPersistFile_iface, pClassID);
 840 }
 841
 842 static HRESULT WINAPI PersistStreamInit_IsDirty(IPersistStreamInit *iface)
 843 {
 844     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 845
 846     TRACE("(%p)\n", This);
 847
 848     if(This->doc_obj->usermode == EDITMODE)
 849         return editor_is_dirty(This);
 850
 851     return S_FALSE;
 852 }
 853
 854 static HRESULT WINAPI PersistStreamInit_Load(IPersistStreamInit *iface, LPSTREAM pStm)
 855 {
 856     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 857     IMoniker *mon;
 858     HRESULT hres;
 859
 860     TRACE("(%p)->(%p)\n", This, pStm);
 861
 862     hres = CreateURLMoniker(NULL, about_blankW, &mon);
 863     if(FAILED(hres)) {
 864         WARN("CreateURLMoniker failed: %08x\n", hres);
 865         return hres;
 866     }
 867
 868     prepare_for_binding(This, mon, FALSE);
 869     hres = set_moniker(This->window, mon, NULL, NULL, NULL, TRUE);
 870     if(FAILED(hres))
 871         return hres;
 872
 873     hres = channelbsc_load_stream(This->window->pending_window, mon, pStm);
 874     IMoniker_Release(mon);
 875     return hres;
 876 }
 877
 878 static HRESULT WINAPI PersistStreamInit_Save(IPersistStreamInit *iface, LPSTREAM pStm,
 879                                              BOOL fClearDirty)
 880 {
 881     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 882     char *str;
 883     DWORD written=0;
 884     HRESULT hres;
 885
 886     TRACE("(%p)->(%p %x)\n", This, pStm, fClearDirty);
 887
 888     hres = get_doc_string(This->doc_node, &str);
 889     if(FAILED(hres))
 890         return hres;
 891
 892     hres = IStream_Write(pStm, str, strlen(str), &written);
 893     if(FAILED(hres))
 894         FIXME("Write failed: %08x\n", hres);
 895
 896     heap_free(str);
 897
 898     if(fClearDirty)
 899         set_dirty(This, VARIANT_FALSE);
 900
 901     return S_OK;
 902 }
 903
 904 static HRESULT WINAPI PersistStreamInit_GetSizeMax(IPersistStreamInit *iface,
 905                                                    ULARGE_INTEGER *pcbSize)
 906 {
 907     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 908     FIXME("(%p)->(%p)\n", This, pcbSize);
 909     return E_NOTIMPL;
 910 }
 911
 912 static HRESULT WINAPI PersistStreamInit_InitNew(IPersistStreamInit *iface)
 913 {
 914     HTMLDocument *This = impl_from_IPersistStreamInit(iface);
 915     IMoniker *mon;
 916     HRESULT hres;
 917
 918     TRACE("(%p)\n", This);
 919
 920     hres = CreateURLMoniker(NULL, about_blankW, &mon);
 921     if(FAILED(hres)) {
 922         WARN("CreateURLMoniker failed: %08x\n", hres);
 923         return hres;
 924     }
 925
 926     prepare_for_binding(This, mon, FALSE);
 927     hres = set_moniker(This->window, mon, NULL, NULL, NULL, FALSE);
 928     if(FAILED(hres))
 929         return hres;
 930
 931     hres = channelbsc_load_stream(This->window->pending_window, mon, NULL);
 932     IMoniker_Release(mon);
 933     return hres;
 934 }
 935
 936 static const IPersistStreamInitVtbl PersistStreamInitVtbl = {
 937     PersistStreamInit_QueryInterface,
 938     PersistStreamInit_AddRef,
 939     PersistStreamInit_Release,
 940     PersistStreamInit_GetClassID,
 941     PersistStreamInit_IsDirty,
 942     PersistStreamInit_Load,
 943     PersistStreamInit_Save,
 944     PersistStreamInit_GetSizeMax,
 945     PersistStreamInit_InitNew
 946 };
 947
 948 /**********************************************************
 949  * IPersistHistory implementation
 950  */
 951
 952 static inline HTMLDocument *impl_from_IPersistHistory(IPersistHistory *iface)
 953 {
 954     return CONTAINING_RECORD(iface, HTMLDocument, IPersistHistory_iface);
 955 }
 956
 957 static HRESULT WINAPI PersistHistory_QueryInterface(IPersistHistory *iface, REFIID riid, void **ppv)
 958 {
 959     HTMLDocument *This = impl_from_IPersistHistory(iface);
 960     return htmldoc_query_interface(This, riid, ppv);
 961 }
 962
 963 static ULONG WINAPI PersistHistory_AddRef(IPersistHistory *iface)
 964 {
 965     HTMLDocument *This = impl_from_IPersistHistory(iface);
 966     return htmldoc_addref(This);
 967 }
 968
 969 static ULONG WINAPI PersistHistory_Release(IPersistHistory *iface)
 970 {
 971     HTMLDocument *This = impl_from_IPersistHistory(iface);
 972     return htmldoc_release(This);
 973 }
 974
 975 static HRESULT WINAPI PersistHistory_GetClassID(IPersistHistory *iface, CLSID *pClassID)
 976 {
 977     HTMLDocument *This = impl_from_IPersistHistory(iface);
 978     return IPersistFile_GetClassID(&This->IPersistFile_iface, pClassID);
 979 }
 980
 981 static HRESULT WINAPI PersistHistory_LoadHistory(IPersistHistory *iface, IStream *pStream, IBindCtx *pbc)
 982 {
 983     HTMLDocument *This = impl_from_IPersistHistory(iface);
 984     ULONG str_len, read;
 985     WCHAR *uri_str;
 986     IUri *uri;
 987     HRESULT hres;
 988
 989     TRACE("(%p)->(%p %p)\n", This, pStream, pbc);
 990
 991     if(!This->window) {
 992         FIXME("No current window\n");
 993         return E_UNEXPECTED;
 994     }
 995
 996     if(pbc)
 997         FIXME("pbc not supported\n");
 998
 999     if(This->doc_obj->client) {
1000         IOleCommandTarget *cmdtrg = NULL;
1001
1002         hres = IOleClientSite_QueryInterface(This->doc_obj->client, &IID_IOleCommandTarget,
1003                 (void**)&cmdtrg);
1004         if(SUCCEEDED(hres)) {
1005             IOleCommandTarget_Exec(cmdtrg, &CGID_ShellDocView, 138, 0, NULL, NULL);
1006             IOleCommandTarget_Release(cmdtrg);
1007         }
1008     }
1009
1010     hres = IStream_Read(pStream, &str_len, sizeof(str_len), &read);
1011     if(FAILED(hres))
1012         return hres;
1013     if(read != sizeof(str_len))
1014         return E_FAIL;
1015
1016     uri_str = heap_alloc((str_len+1)*sizeof(WCHAR));
1017     if(!uri_str)
1018         return E_OUTOFMEMORY;
1019
1020     hres = IStream_Read(pStream, uri_str, str_len*sizeof(WCHAR), &read);
1021     if(SUCCEEDED(hres) && read != str_len*sizeof(WCHAR))
1022         hres = E_FAIL;
1023     if(SUCCEEDED(hres)) {
1024         uri_str[str_len] = 0;
1025         hres = create_uri(uri_str, 0, &uri);
1026     }
1027     heap_free(uri_str);
1028     if(FAILED(hres))
1029         return hres;
1030
1031     hres = load_uri(This->window, uri, BINDING_FROMHIST);
1032     IUri_Release(uri);
1033     return hres;
1034 }
1035
1036 static HRESULT WINAPI PersistHistory_SaveHistory(IPersistHistory *iface, IStream *pStream)
1037 {
1038     HTMLDocument *This = impl_from_IPersistHistory(iface);
1039     ULONG len, written;
1040     BSTR display_uri;
1041     HRESULT hres;
1042
1043     TRACE("(%p)->(%p)\n", This, pStream);
1044
1045     if(!This->window || !This->window->uri) {
1046         FIXME("No current URI\n");
1047         return E_FAIL;
1048     }
1049
1050     /* NOTE: The format we store is *not* compatible with native MSHTML. We currently
1051      * store only URI of the page (as a length followed by a string) */
1052     hres = IUri_GetDisplayUri(This->window->uri, &display_uri);
1053     if(FAILED(hres))
1054         return hres;
1055
1056     len = SysStringLen(display_uri);
1057     hres = IStream_Write(pStream, &len, sizeof(len), &written);
1058     if(SUCCEEDED(hres))
1059         hres = IStream_Write(pStream, display_uri, len*sizeof(WCHAR), &written);
1060     SysFreeString(display_uri);
1061     return hres;
1062 }
1063
1064 static HRESULT WINAPI PersistHistory_SetPositionCookie(IPersistHistory *iface, DWORD dwPositioncookie)
1065 {
1066     HTMLDocument *This = impl_from_IPersistHistory(iface);
1067     FIXME("(%p)->(%x)\n", This, dwPositioncookie);
1068     return E_NOTIMPL;
1069 }
1070
1071 static HRESULT WINAPI PersistHistory_GetPositionCookie(IPersistHistory *iface, DWORD *pdwPositioncookie)
1072 {
1073     HTMLDocument *This = impl_from_IPersistHistory(iface);
1074     FIXME("(%p)->(%p)\n", This, pdwPositioncookie);
1075     return E_NOTIMPL;
1076 }
1077
1078 static const IPersistHistoryVtbl PersistHistoryVtbl = {
1079     PersistHistory_QueryInterface,
1080     PersistHistory_AddRef,
1081     PersistHistory_Release,
1082     PersistHistory_GetClassID,
1083     PersistHistory_LoadHistory,
1084     PersistHistory_SaveHistory,
1085     PersistHistory_SetPositionCookie,
1086     PersistHistory_GetPositionCookie
1087 };
1088
1089 void HTMLDocument_Persist_Init(HTMLDocument *This)
1090 {
1091     This->IPersistMoniker_iface.lpVtbl = &PersistMonikerVtbl;
1092     This->IPersistFile_iface.lpVtbl = &PersistFileVtbl;
1093     This->IMonikerProp_iface.lpVtbl = &MonikerPropVtbl;
1094     This->IPersistStreamInit_iface.lpVtbl = &PersistStreamInitVtbl;
1095     This->IPersistHistory_iface.lpVtbl = &PersistHistoryVtbl;
1096 }