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