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