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     hres = IMoniker_GetDisplayName(pimkName, pibc, NULL, &url);
 301     if(FAILED(hres)) {
 302         WARN("GetDiaplayName failed: %08lx\n", hres);
 303         return hres;
 304     }
 305
 306     TRACE("got url: %s\n", debugstr_w(url));
 307
 308     if(This->nscontainer && !This->nscontainer->stream) {
 309         /*
 310          * This is a workaround for older Gecko that doesn't support nsIWebBrowserStream.
 311          * It uses Gecko's LoadURI instead of IMoniker's BindToStorage. Should we improve
 312          * it (to do so we'd have to use not frozen interfaces)?
 313          */
 314         nsres = nsIWebNavigation_LoadURI(This->nscontainer->navigation, url,
 315                 LOAD_FLAGS_NONE, NULL, NULL, NULL);
 316         if(NS_SUCCEEDED(nsres)) {
 317             CoTaskMemFree(url);
 318             return S_OK;
 319         }else {
 320             WARN("LoadURI failed: %08lx\n", nsres);
 321         }
 322     }
 323
 324     /* FIXME: Use grfMode */
 325
 326     if(fFullyAvailable)
 327         FIXME("not supported fFullyAvailable\n");
 328     if(pibc)
 329         FIXME("not supported pibc\n");
 330
 331     if(This->status_callback && This->status_callback->binding)
 332         IBinding_Abort(This->status_callback->binding);
 333
 334     callback = This->status_callback = BindStatusCallback_Create(This, url);
 335
 336     CreateAsyncBindCtx(0, STATUSCLB(callback), NULL, &pbind);
 337
 338     hres = IMoniker_BindToStorage(pimkName, pbind, NULL, &IID_IStream, (void**)&str);
 339     IBindCtx_Release(pbind);
 340     if(str)
 341         IStream_Release(str);
 342     if(FAILED(hres)) {
 343         WARN("BindToStorage failed: %08lx\n", hres);
 344         return hres;
 345     }
 346
 347     return S_OK;
 348 }
 349
 350 static HRESULT WINAPI PersistMoniker_Save(IPersistMoniker *iface, IMoniker *pimkName,
 351         LPBC pbc, BOOL fRemember)
 352 {
 353     HTMLDocument *This = PERSISTMON_THIS(iface);
 354     FIXME("(%p)->(%p %p %x)\n", This, pimkName, pbc, fRemember);
 355     return E_NOTIMPL;
 356 }
 357
 358 static HRESULT WINAPI PersistMoniker_SaveCompleted(IPersistMoniker *iface, IMoniker *pimkName, LPBC pibc)
 359 {
 360     HTMLDocument *This = PERSISTMON_THIS(iface);
 361     FIXME("(%p)->(%p %p)\n", This, pimkName, pibc);
 362     return E_NOTIMPL;
 363 }
 364
 365 static HRESULT WINAPI PersistMoniker_GetCurMoniker(IPersistMoniker *iface, IMoniker **ppimkName)
 366 {
 367     HTMLDocument *This = PERSISTMON_THIS(iface);
 368     FIXME("(%p)->(%p)\n", This, ppimkName);
 369     return E_NOTIMPL;
 370 }
 371
 372 static const IPersistMonikerVtbl PersistMonikerVtbl = {
 373     PersistMoniker_QueryInterface,
 374     PersistMoniker_AddRef,
 375     PersistMoniker_Release,
 376     PersistMoniker_GetClassID,
 377     PersistMoniker_IsDirty,
 378     PersistMoniker_Load,
 379     PersistMoniker_Save,
 380     PersistMoniker_SaveCompleted,
 381     PersistMoniker_GetCurMoniker
 382 };
 383
 384 /**********************************************************
 385  * IMonikerProp implementation
 386  */
 387
 388 #define MONPROP_THIS(iface) DEFINE_THIS(HTMLDocument, MonikerProp, iface)
 389
 390 static HRESULT WINAPI MonikerProp_QueryInterface(IMonikerProp *iface, REFIID riid, void **ppvObject)
 391 {
 392     HTMLDocument *This = MONPROP_THIS(iface);
 393     return IHTMLDocument2_QueryInterface(HTMLDOC(This), riid, ppvObject);
 394 }
 395
 396 static ULONG WINAPI MonikerProp_AddRef(IMonikerProp *iface)
 397 {
 398     HTMLDocument *This = MONPROP_THIS(iface);
 399     return IHTMLDocument2_AddRef(HTMLDOC(This));
 400 }
 401
 402 static ULONG WINAPI MonikerProp_Release(IMonikerProp *iface)
 403 {
 404     HTMLDocument *This = MONPROP_THIS(iface);
 405     return IHTMLDocument_Release(HTMLDOC(This));
 406 }
 407
 408 static HRESULT WINAPI MonikerProp_PutProperty(IMonikerProp *iface, MONIKERPROPERTY mkp, LPCWSTR val)
 409 {
 410     HTMLDocument *This = MONPROP_THIS(iface);
 411     FIXME("(%p)->(%d %s)\n", This, mkp, debugstr_w(val));
 412     return E_NOTIMPL;
 413 }
 414
 415 static const IMonikerPropVtbl MonikerPropVtbl = {
 416     MonikerProp_QueryInterface,
 417     MonikerProp_AddRef,
 418     MonikerProp_Release,
 419     MonikerProp_PutProperty
 420 };
 421
 422 /**********************************************************
 423  * IPersistFile implementation
 424  */
 425
 426 #define PERSISTFILE_THIS(iface) DEFINE_THIS(HTMLDocument, PersistFile, iface)
 427
 428 static HRESULT WINAPI PersistFile_QueryInterface(IPersistFile *iface, REFIID riid, void **ppvObject)
 429 {
 430     HTMLDocument *This = PERSISTFILE_THIS(iface);
 431     return IHTMLDocument2_QueryInterface(HTMLDOC(This), riid, ppvObject);
 432 }
 433
 434 static ULONG WINAPI PersistFile_AddRef(IPersistFile *iface)
 435 {
 436     HTMLDocument *This = PERSISTFILE_THIS(iface);
 437     return IHTMLDocument2_AddRef(HTMLDOC(This));
 438 }
 439
 440 static ULONG WINAPI PersistFile_Release(IPersistFile *iface)
 441 {
 442     HTMLDocument *This = PERSISTFILE_THIS(iface);
 443     return IHTMLDocument2_Release(HTMLDOC(This));
 444 }
 445
 446 static HRESULT WINAPI PersistFile_GetClassID(IPersistFile *iface, CLSID *pClassID)
 447 {
 448     HTMLDocument *This = PERSISTFILE_THIS(iface);
 449
 450     TRACE("(%p)->(%p)\n", This, pClassID);
 451
 452     if(!pClassID)
 453         return E_INVALIDARG;
 454
 455     memcpy(pClassID, &CLSID_HTMLDocument, sizeof(CLSID));
 456     return S_OK;
 457 }
 458
 459 static HRESULT WINAPI PersistFile_IsDirty(IPersistFile *iface)
 460 {
 461     HTMLDocument *This = PERSISTFILE_THIS(iface);
 462     FIXME("(%p)\n", This);
 463     return E_NOTIMPL;
 464 }
 465
 466 static HRESULT WINAPI PersistFile_Load(IPersistFile *iface, LPCOLESTR pszFileName, DWORD dwMode)
 467 {
 468     HTMLDocument *This = PERSISTFILE_THIS(iface);
 469     FIXME("(%p)->(%s %08lx)\n", This, debugstr_w(pszFileName), dwMode);
 470     return E_NOTIMPL;
 471 }
 472
 473 static HRESULT WINAPI PersistFile_Save(IPersistFile *iface, LPCOLESTR pszFileName, BOOL fRemember)
 474 {
 475     HTMLDocument *This = PERSISTFILE_THIS(iface);
 476     FIXME("(%p)->(%s %x)\n", This, debugstr_w(pszFileName), fRemember);
 477     return E_NOTIMPL;
 478 }
 479
 480 static HRESULT WINAPI PersistFile_SaveCompleted(IPersistFile *iface, LPCOLESTR pszFileName)
 481 {
 482     HTMLDocument *This = PERSISTFILE_THIS(iface);
 483     FIXME("(%p)->(%s)\n", This, debugstr_w(pszFileName));
 484     return E_NOTIMPL;
 485 }
 486
 487 static HRESULT WINAPI PersistFile_GetCurFile(IPersistFile *iface, LPOLESTR *pszFileName)
 488 {
 489     HTMLDocument *This = PERSISTFILE_THIS(iface);
 490     FIXME("(%p)->(%p)\n", This, pszFileName);
 491     return E_NOTIMPL;
 492 }
 493
 494 static const IPersistFileVtbl PersistFileVtbl = {
 495     PersistFile_QueryInterface,
 496     PersistFile_AddRef,
 497     PersistFile_Release,
 498     PersistFile_GetClassID,
 499     PersistFile_IsDirty,
 500     PersistFile_Load,
 501     PersistFile_Save,
 502     PersistFile_SaveCompleted,
 503     PersistFile_GetCurFile
 504 };
 505
 506 void HTMLDocument_Persist_Init(HTMLDocument *This)
 507 {
 508     This->lpPersistMonikerVtbl = &PersistMonikerVtbl;
 509     This->lpPersistFileVtbl = &PersistFileVtbl;
 510     This->lpMonikerPropVtbl = &MonikerPropVtbl;
 511
 512     This->status_callback = NULL;
 513 }