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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
  33 #include "wine/debug.h"
  34
  35 #include "mshtml_private.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  38
  39 struct BindStatusCallback {
  40     const IBindStatusCallbackVtbl *lpBindStatusCallbackVtbl;
  41
  42     LONG ref;
  43
  44     HTMLDocument *doc;
  45     IBinding *binding;
  46     IStream *stream;
  47     LPOLESTR url;
  48 };
  49
  50 #define STATUSCLB_THIS(iface) DEFINE_THIS(BindStatusCallback, BindStatusCallback, iface)
  51
  52 static HRESULT WINAPI BindStatusCallback_QueryInterface(IBindStatusCallback *iface,
  53         REFIID riid, void **ppv)
  54 {
  55     BindStatusCallback *This = STATUSCLB_THIS(iface);
  56
  57     *ppv = NULL;
  58     if(IsEqualGUID(&IID_IUnknown, riid)) {
  59         TRACE("(%p)->(IID_IUnknown, %p)\n", This, ppv);
  60         *ppv = STATUSCLB(This);
  61     }else if(IsEqualGUID(&IID_IBindStatusCallback, riid)) {
  62         TRACE("(%p)->(IID_IBindStatusCallback, %p)\n", This, ppv);
  63         *ppv = STATUSCLB(This);
  64     }
  65
  66     if(*ppv) {
  67         IBindStatusCallback_AddRef(STATUSCLB(This));
  68         return S_OK;
  69     }
  70
  71     TRACE("Unsupported riid = %s\n", debugstr_guid(riid));
  72     return E_NOINTERFACE;
  73 }
  74
  75 static ULONG WINAPI BindStatusCallback_AddRef(IBindStatusCallback *iface)
  76 {
  77     BindStatusCallback *This = STATUSCLB_THIS(iface);
  78     LONG ref = InterlockedIncrement(&This->ref);
  79
  80     TRACE("(%p) ref = %ld\n", This, ref);
  81
  82     return ref;
  83 }
  84
  85 static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallback *iface)
  86 {
  87     BindStatusCallback *This = STATUSCLB_THIS(iface);
  88     LONG ref = InterlockedDecrement(&This->ref);
  89
  90     TRACE("(%p) ref = %ld\n", This, ref);
  91
  92     if(!ref) {
  93         if(This->doc->status_callback == This)
  94             This->doc->status_callback = NULL;
  95         IHTMLDocument2_Release(HTMLDOC(This->doc));
  96         if(This->stream)
  97             IStream_Release(This->stream);
  98         CoTaskMemFree(This->url);
  99         HeapFree(GetProcessHeap(), 0, This);
 100     }
 101
 102     return ref;
 103 }
 104
 105 static HRESULT WINAPI BindStatusCallback_OnStartBinding(IBindStatusCallback *iface,
 106         DWORD dwReserved, IBinding *pbind)
 107 {
 108     BindStatusCallback *This = STATUSCLB_THIS(iface);
 109
 110     TRACE("(%p)->(%ld %p)\n", This, dwReserved, pbind);
 111
 112     This->binding = pbind;
 113     IBinding_AddRef(pbind);
 114
 115     if(This->doc->nscontainer && This->doc->nscontainer->stream) {
 116         nsACString *strTextHtml;
 117         nsresult nsres;
 118         nsIURI *uri = get_nsIURI(This->url);
 119
 120         strTextHtml = nsACString_Create();
 121         /* FIXME: Set it correctly */
 122         nsACString_SetData(strTextHtml, "text/html");
 123
 124         nsres = nsIWebBrowserStream_OpenStream(This->doc->nscontainer->stream, uri, strTextHtml);
 125         if(NS_FAILED(nsres))
 126             ERR("OpenStream failed: %08lx\n", nsres);
 127
 128         nsIURI_Release(uri);
 129     }
 130
 131     return S_OK;
 132 }
 133
 134 static HRESULT WINAPI BindStatusCallback_GetPriority(IBindStatusCallback *iface, LONG *pnPriority)
 135 {
 136     BindStatusCallback *This = STATUSCLB_THIS(iface);
 137     FIXME("(%p)->(%p)\n", This, pnPriority);
 138     return E_NOTIMPL;
 139 }
 140
 141 static HRESULT WINAPI BindStatusCallback_OnLowResource(IBindStatusCallback *iface, DWORD reserved)
 142 {
 143     BindStatusCallback *This = STATUSCLB_THIS(iface);
 144     FIXME("(%p)->(%ld)\n", This, reserved);
 145     return E_NOTIMPL;
 146 }
 147
 148 static HRESULT WINAPI BindStatusCallback_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
 149         ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
 150 {
 151     BindStatusCallback *This = STATUSCLB_THIS(iface);
 152     TRACE("%p)->(%lu %lu %lu %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
 153             debugstr_w(szStatusText));
 154     return S_OK;
 155 }
 156
 157 static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallback *iface,
 158         HRESULT hresult, LPCWSTR szError)
 159 {
 160     BindStatusCallback *This = STATUSCLB_THIS(iface);
 161
 162     TRACE("(%p)->(%08lx %s)\n", This, hresult, debugstr_w(szError));
 163
 164     if(This->doc->nscontainer && This->doc->nscontainer->stream)
 165         nsIWebBrowserStream_CloseStream(This->doc->nscontainer->stream);
 166
 167     IBinding_Release(This->binding);
 168     This->binding = NULL;
 169     return S_OK;
 170 }
 171
 172 static HRESULT WINAPI BindStatusCallback_GetBindInfo(IBindStatusCallback *iface,
 173         DWORD *grfBINDF, BINDINFO *pbindinfo)
 174 {
 175     BindStatusCallback *This = STATUSCLB_THIS(iface);
 176     DWORD size;
 177
 178     TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
 179
 180     *grfBINDF = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA;
 181     size = pbindinfo->cbSize;
 182     memset(pbindinfo, 0, size);
 183     pbindinfo->cbSize = size;
 184
 185     return S_OK;
 186 }
 187
 188 static HRESULT WINAPI BindStatusCallback_OnDataAvailable(IBindStatusCallback *iface,
 189         DWORD grfBSCF, DWORD dwSize, FORMATETC *pformatetc, STGMEDIUM *pstgmed)
 190 {
 191     BindStatusCallback *This = STATUSCLB_THIS(iface);
 192
 193     TRACE("(%p)->(%08lx %ld %p %p)\n", This, grfBSCF, dwSize, pformatetc, pstgmed);
 194
 195     if(!This->stream) {
 196         This->stream = pstgmed->u.pstm;
 197         IStream_AddRef(This->stream);
 198     }
 199
 200     if(This->doc->nscontainer && This->doc->nscontainer->stream) {
 201         BYTE buf[1024];
 202         DWORD size;
 203         HRESULT hres;
 204
 205         do {
 206             size = sizeof(buf);
 207             hres = IStream_Read(This->stream, buf, size, &size);
 208             nsIWebBrowserStream_AppendToStream(This->doc->nscontainer->stream, buf, size);
 209         }while(hres == S_OK);
 210     }
 211
 212     return S_OK;
 213 }
 214
 215 static HRESULT WINAPI BindStatusCallback_OnObjectAvailable(IBindStatusCallback *iface,
 216         REFIID riid, IUnknown *punk)
 217 {
 218     BindStatusCallback *This = STATUSCLB_THIS(iface);
 219     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), punk);
 220     return E_NOTIMPL;
 221 }
 222
 223 static const IBindStatusCallbackVtbl BindStatusCallbackVtbl = {
 224     BindStatusCallback_QueryInterface,
 225     BindStatusCallback_AddRef,
 226     BindStatusCallback_Release,
 227     BindStatusCallback_OnStartBinding,
 228     BindStatusCallback_GetPriority,
 229     BindStatusCallback_OnLowResource,
 230     BindStatusCallback_OnProgress,
 231     BindStatusCallback_OnStopBinding,
 232     BindStatusCallback_GetBindInfo,
 233     BindStatusCallback_OnDataAvailable,
 234     BindStatusCallback_OnObjectAvailable
 235 };
 236
 237 static BindStatusCallback *BindStatusCallback_Create(HTMLDocument *doc, LPOLESTR url)
 238 {
 239     BindStatusCallback *ret = HeapAlloc(GetProcessHeap(), 0, sizeof(BindStatusCallback));
 240     ret->lpBindStatusCallbackVtbl = &BindStatusCallbackVtbl;
 241     ret->ref = 0;
 242     ret->url = url;
 243     ret->doc = doc;
 244     ret->stream = NULL;
 245     IHTMLDocument2_AddRef(HTMLDOC(doc));
 246     return ret;
 247 }
 248
 249 /**********************************************************
 250  * IPersistMoniker implementation
 251  */
 252
 253 #define PERSISTMON_THIS(iface) DEFINE_THIS(HTMLDocument, PersistMoniker, iface)
 254
 255 static HRESULT WINAPI PersistMoniker_QueryInterface(IPersistMoniker *iface, REFIID riid,
 256                                                             void **ppvObject)
 257 {
 258     HTMLDocument *This = PERSISTMON_THIS(iface);
 259     return IHTMLDocument2_QueryInterface(HTMLDOC(This), riid, ppvObject);
 260 }
 261
 262 static ULONG WINAPI PersistMoniker_AddRef(IPersistMoniker *iface)
 263 {
 264     HTMLDocument *This = PERSISTMON_THIS(iface);
 265     return IHTMLDocument2_AddRef(HTMLDOC(This));
 266 }
 267
 268 static ULONG WINAPI PersistMoniker_Release(IPersistMoniker *iface)
 269 {
 270     HTMLDocument *This = PERSISTMON_THIS(iface);
 271     return IHTMLDocument2_Release(HTMLDOC(This));
 272 }
 273
 274 static HRESULT WINAPI PersistMoniker_GetClassID(IPersistMoniker *iface, CLSID *pClassID)
 275 {
 276     HTMLDocument *This = PERSISTMON_THIS(iface);
 277     return IPersist_GetClassID(PERSIST(This), pClassID);
 278 }
 279
 280 static HRESULT WINAPI PersistMoniker_IsDirty(IPersistMoniker *iface)
 281 {
 282     HTMLDocument *This = PERSISTMON_THIS(iface);
 283     FIXME("(%p)\n", This);
 284     return E_NOTIMPL;
 285 }
 286
 287 static HRESULT WINAPI PersistMoniker_Load(IPersistMoniker *iface, BOOL fFullyAvailable,
 288         IMoniker *pimkName, LPBC pibc, DWORD grfMode)
 289 {
 290     HTMLDocument *This = PERSISTMON_THIS(iface);
 291     IBindCtx *pbind;
 292     BindStatusCallback *callback;
 293     IStream *str;
 294     LPOLESTR url;
 295     HRESULT hres;
 296     nsresult nsres;
 297
 298     FIXME("(%p)->(%x %p %p %08lx)\n", This, fFullyAvailable, pimkName, pibc, grfMode);
 299
 300     if(pibc) {
 301         IUnknown *unk = NULL;
 302
 303         static WCHAR wszClientSiteParam[] = {'{','d','4','d','b','6','8','5','0','-',
 304             '5','3','8','5','-','1','1','d','0','-','8','9','e','9','-','0','0','a',
 305             '0','c','9','0','a','9','0','a','c','}',0};
 306
 307         /* FIXME:
 308          * Use params:
 309          * "__PrecreatedObject"
 310          * "BIND_CONTEXT_PARAM"
 311          * "__HTMLLOADOPTIONS"
 312          * "__DWNBINDINFO"
 313          * "URL Context"
 314          * "CBinding Context"
 315          * "_ITransData_Object_"
 316          * "_EnumFORMATETC_"
 317          */
 318
 319         IBindCtx_GetObjectParam(pibc, wszClientSiteParam, &unk);
 320         if(unk) {
 321             IOleClientSite *client = NULL;
 322
 323             hres = IUnknown_QueryInterface(unk, &IID_IOleClientSite, (void**)&client);
 324             if(SUCCEEDED(hres)) {
 325                 TRACE("Got client site %p\n", client);
 326                 IOleObject_SetClientSite(OLEOBJ(This), client);
 327                 IOleClientSite_Release(client);
 328             }
 329
 330             IUnknown_Release(unk);
 331         }
 332     }
 333
 334     hres = IMoniker_GetDisplayName(pimkName, pibc, NULL, &url);
 335     if(FAILED(hres)) {
 336         WARN("GetDiaplayName failed: %08lx\n", hres);
 337         return hres;
 338     }
 339
 340     TRACE("got url: %s\n", debugstr_w(url));
 341
 342     if(This->nscontainer && !This->nscontainer->stream) {
 343         /*
 344          * This is a workaround for older Gecko that doesn't support nsIWebBrowserStream.
 345          * It uses Gecko's LoadURI instead of IMoniker's BindToStorage. Should we improve
 346          * it (to do so we'd have to use not frozen interfaces)?
 347          */
 348         nsres = nsIWebNavigation_LoadURI(This->nscontainer->navigation, url,
 349                 LOAD_FLAGS_NONE, NULL, NULL, NULL);
 350         if(NS_SUCCEEDED(nsres)) {
 351             CoTaskMemFree(url);
 352             return S_OK;
 353         }else {
 354             WARN("LoadURI failed: %08lx\n", nsres);
 355         }
 356     }
 357
 358     /* FIXME: Use grfMode */
 359
 360     if(fFullyAvailable)
 361         FIXME("not supported fFullyAvailable\n");
 362
 363     if(This->status_callback && This->status_callback->binding)
 364         IBinding_Abort(This->status_callback->binding);
 365
 366     callback = This->status_callback = BindStatusCallback_Create(This, url);
 367
 368     if(pibc) {
 369         pbind = pibc;
 370         RegisterBindStatusCallback(pbind, STATUSCLB(callback), NULL, 0);
 371     }else {
 372         CreateAsyncBindCtx(0, STATUSCLB(callback), NULL, &pbind);
 373     }
 374
 375     hres = IMoniker_BindToStorage(pimkName, pbind, NULL, &IID_IStream, (void**)&str);
 376
 377     if(!pibc)
 378         IBindCtx_Release(pbind);
 379     if(str)
 380         IStream_Release(str);
 381     if(FAILED(hres)) {
 382         WARN("BindToStorage failed: %08lx\n", hres);
 383         return hres;
 384     }
 385
 386     return S_OK;
 387 }
 388
 389 static HRESULT WINAPI PersistMoniker_Save(IPersistMoniker *iface, IMoniker *pimkName,
 390         LPBC pbc, BOOL fRemember)
 391 {
 392     HTMLDocument *This = PERSISTMON_THIS(iface);
 393     FIXME("(%p)->(%p %p %x)\n", This, pimkName, pbc, fRemember);
 394     return E_NOTIMPL;
 395 }
 396
 397 static HRESULT WINAPI PersistMoniker_SaveCompleted(IPersistMoniker *iface, IMoniker *pimkName, LPBC pibc)
 398 {
 399     HTMLDocument *This = PERSISTMON_THIS(iface);
 400     FIXME("(%p)->(%p %p)\n", This, pimkName, pibc);
 401     return E_NOTIMPL;
 402 }
 403
 404 static HRESULT WINAPI PersistMoniker_GetCurMoniker(IPersistMoniker *iface, IMoniker **ppimkName)
 405 {
 406     HTMLDocument *This = PERSISTMON_THIS(iface);
 407     FIXME("(%p)->(%p)\n", This, ppimkName);
 408     return E_NOTIMPL;
 409 }
 410
 411 static const IPersistMonikerVtbl PersistMonikerVtbl = {
 412     PersistMoniker_QueryInterface,
 413     PersistMoniker_AddRef,
 414     PersistMoniker_Release,
 415     PersistMoniker_GetClassID,
 416     PersistMoniker_IsDirty,
 417     PersistMoniker_Load,
 418     PersistMoniker_Save,
 419     PersistMoniker_SaveCompleted,
 420     PersistMoniker_GetCurMoniker
 421 };
 422
 423 /**********************************************************
 424  * IMonikerProp implementation
 425  */
 426
 427 #define MONPROP_THIS(iface) DEFINE_THIS(HTMLDocument, MonikerProp, iface)
 428
 429 static HRESULT WINAPI MonikerProp_QueryInterface(IMonikerProp *iface, REFIID riid, void **ppvObject)
 430 {
 431     HTMLDocument *This = MONPROP_THIS(iface);
 432     return IHTMLDocument2_QueryInterface(HTMLDOC(This), riid, ppvObject);
 433 }
 434
 435 static ULONG WINAPI MonikerProp_AddRef(IMonikerProp *iface)
 436 {
 437     HTMLDocument *This = MONPROP_THIS(iface);
 438     return IHTMLDocument2_AddRef(HTMLDOC(This));
 439 }
 440
 441 static ULONG WINAPI MonikerProp_Release(IMonikerProp *iface)
 442 {
 443     HTMLDocument *This = MONPROP_THIS(iface);
 444     return IHTMLDocument_Release(HTMLDOC(This));
 445 }
 446
 447 static HRESULT WINAPI MonikerProp_PutProperty(IMonikerProp *iface, MONIKERPROPERTY mkp, LPCWSTR val)
 448 {
 449     HTMLDocument *This = MONPROP_THIS(iface);
 450     FIXME("(%p)->(%d %s)\n", This, mkp, debugstr_w(val));
 451     return E_NOTIMPL;
 452 }
 453
 454 static const IMonikerPropVtbl MonikerPropVtbl = {
 455     MonikerProp_QueryInterface,
 456     MonikerProp_AddRef,
 457     MonikerProp_Release,
 458     MonikerProp_PutProperty
 459 };
 460
 461 /**********************************************************
 462  * IPersistFile implementation
 463  */
 464
 465 #define PERSISTFILE_THIS(iface) DEFINE_THIS(HTMLDocument, PersistFile, iface)
 466
 467 static HRESULT WINAPI PersistFile_QueryInterface(IPersistFile *iface, REFIID riid, void **ppvObject)
 468 {
 469     HTMLDocument *This = PERSISTFILE_THIS(iface);
 470     return IHTMLDocument2_QueryInterface(HTMLDOC(This), riid, ppvObject);
 471 }
 472
 473 static ULONG WINAPI PersistFile_AddRef(IPersistFile *iface)
 474 {
 475     HTMLDocument *This = PERSISTFILE_THIS(iface);
 476     return IHTMLDocument2_AddRef(HTMLDOC(This));
 477 }
 478
 479 static ULONG WINAPI PersistFile_Release(IPersistFile *iface)
 480 {
 481     HTMLDocument *This = PERSISTFILE_THIS(iface);
 482     return IHTMLDocument2_Release(HTMLDOC(This));
 483 }
 484
 485 static HRESULT WINAPI PersistFile_GetClassID(IPersistFile *iface, CLSID *pClassID)
 486 {
 487     HTMLDocument *This = PERSISTFILE_THIS(iface);
 488
 489     TRACE("(%p)->(%p)\n", This, pClassID);
 490
 491     if(!pClassID)
 492         return E_INVALIDARG;
 493
 494     memcpy(pClassID, &CLSID_HTMLDocument, sizeof(CLSID));
 495     return S_OK;
 496 }
 497
 498 static HRESULT WINAPI PersistFile_IsDirty(IPersistFile *iface)
 499 {
 500     HTMLDocument *This = PERSISTFILE_THIS(iface);
 501     FIXME("(%p)\n", This);
 502     return E_NOTIMPL;
 503 }
 504
 505 static HRESULT WINAPI PersistFile_Load(IPersistFile *iface, LPCOLESTR pszFileName, DWORD dwMode)
 506 {
 507     HTMLDocument *This = PERSISTFILE_THIS(iface);
 508     FIXME("(%p)->(%s %08lx)\n", This, debugstr_w(pszFileName), dwMode);
 509     return E_NOTIMPL;
 510 }
 511
 512 static HRESULT WINAPI PersistFile_Save(IPersistFile *iface, LPCOLESTR pszFileName, BOOL fRemember)
 513 {
 514     HTMLDocument *This = PERSISTFILE_THIS(iface);
 515     FIXME("(%p)->(%s %x)\n", This, debugstr_w(pszFileName), fRemember);
 516     return E_NOTIMPL;
 517 }
 518
 519 static HRESULT WINAPI PersistFile_SaveCompleted(IPersistFile *iface, LPCOLESTR pszFileName)
 520 {
 521     HTMLDocument *This = PERSISTFILE_THIS(iface);
 522     FIXME("(%p)->(%s)\n", This, debugstr_w(pszFileName));
 523     return E_NOTIMPL;
 524 }
 525
 526 static HRESULT WINAPI PersistFile_GetCurFile(IPersistFile *iface, LPOLESTR *pszFileName)
 527 {
 528     HTMLDocument *This = PERSISTFILE_THIS(iface);
 529     FIXME("(%p)->(%p)\n", This, pszFileName);
 530     return E_NOTIMPL;
 531 }
 532
 533 static const IPersistFileVtbl PersistFileVtbl = {
 534     PersistFile_QueryInterface,
 535     PersistFile_AddRef,
 536     PersistFile_Release,
 537     PersistFile_GetClassID,
 538     PersistFile_IsDirty,
 539     PersistFile_Load,
 540     PersistFile_Save,
 541     PersistFile_SaveCompleted,
 542     PersistFile_GetCurFile
 543 };
 544
 545 void HTMLDocument_Persist_Init(HTMLDocument *This)
 546 {
 547     This->lpPersistMonikerVtbl = &PersistMonikerVtbl;
 548     This->lpPersistFileVtbl = &PersistFileVtbl;
 549     This->lpMonikerPropVtbl = &MonikerPropVtbl;
 550
 551     This->status_callback = NULL;
 552 }