dlls/msxml3/xmlview.c

   1 /*
   2  * Copyright 2012 Piotr Caban for CodeWeavers
   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
  21 #define COBJMACROS
  22 #define NONAMELESSUNION
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "ole2.h"
  27 #include "msxml6.h"
  28 #include "mshtml.h"
  29 #include "mshtmhst.h"
  30 #include "perhist.h"
  31 #include "docobj.h"
  32
  33 #include "wine/debug.h"
  34
  35 #include "msxml_dispex.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  38
  39 typedef struct
  40 {
  41     IPersistMoniker IPersistMoniker_iface;
  42     IPersistHistory IPersistHistory_iface;
  43     IOleCommandTarget IOleCommandTarget_iface;
  44     IOleObject IOleObject_iface;
  45
  46     LONG ref;
  47
  48     IUnknown *html_doc;
  49     IMoniker *mon;
  50 } XMLView;
  51
  52 typedef struct
  53 {
  54     IMoniker IMoniker_iface;
  55     LONG ref;
  56     IMoniker *mon;
  57
  58     IStream *stream;
  59 } Moniker;
  60
  61 typedef struct
  62 {
  63     IBindStatusCallback IBindStatusCallback_iface;
  64     LONG ref;
  65     IBindStatusCallback *bsc;
  66
  67     IMoniker *mon;
  68     IStream *stream;
  69 } BindStatusCallback;
  70
  71 typedef struct
  72 {
  73     IBinding IBinding_iface;
  74     LONG ref;
  75     IBinding *binding;
  76 } Binding;
  77
  78 static inline Binding* impl_from_IBinding(IBinding *iface)
  79 {
  80     return CONTAINING_RECORD(iface, Binding, IBinding_iface);
  81 }
  82
  83 static HRESULT WINAPI XMLView_Binding_QueryInterface(
  84         IBinding *iface, REFIID riid, void **ppvObject)
  85 {
  86     Binding *This = impl_from_IBinding(iface);
  87
  88     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
  89
  90     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IBinding)) {
  91         *ppvObject = iface;
  92         IBinding_AddRef(iface);
  93         return S_OK;
  94     }
  95
  96     *ppvObject = NULL;
  97     return E_NOINTERFACE;
  98 }
  99
 100 static ULONG WINAPI XMLView_Binding_AddRef(IBinding *iface)
 101 {
 102     Binding *This = impl_from_IBinding(iface);
 103     ULONG ref = InterlockedIncrement(&This->ref);
 104
 105     TRACE("%p, refcount %lu.\n", iface, ref);
 106
 107     return ref;
 108 }
 109
 110 static ULONG WINAPI XMLView_Binding_Release(IBinding *iface)
 111 {
 112     Binding *This = impl_from_IBinding(iface);
 113     ULONG ref = InterlockedDecrement(&This->ref);
 114
 115     TRACE("%p, refcount %lu.\n", iface, ref);
 116
 117     if(!ref) {
 118         IBinding_Release(This->binding);
 119         heap_free(This);
 120     }
 121     return ref;
 122 }
 123
 124 static HRESULT WINAPI XMLView_Binding_Abort(IBinding *iface)
 125 {
 126     Binding *This = impl_from_IBinding(iface);
 127     TRACE("(%p)\n", This);
 128
 129     return IBinding_Abort(This->binding);
 130 }
 131
 132 static HRESULT WINAPI XMLView_Binding_Suspend(IBinding *iface)
 133 {
 134     Binding *This = impl_from_IBinding(iface);
 135     FIXME("(%p)\n", This);
 136     return E_NOTIMPL;
 137 }
 138
 139 static HRESULT WINAPI XMLView_Binding_Resume(IBinding *iface)
 140 {
 141     Binding *This = impl_from_IBinding(iface);
 142     FIXME("(%p)\n", This);
 143     return E_NOTIMPL;
 144 }
 145
 146 static HRESULT WINAPI XMLView_Binding_SetPriority(
 147         IBinding *iface, LONG nPriority)
 148 {
 149     Binding *This = impl_from_IBinding(iface);
 150     TRACE("%p, %ld.\n", iface, nPriority);
 151
 152     return IBinding_SetPriority(This->binding, nPriority);
 153 }
 154
 155 static HRESULT WINAPI XMLView_Binding_GetPriority(
 156         IBinding *iface, LONG *pnPriority)
 157 {
 158     Binding *This = impl_from_IBinding(iface);
 159     TRACE("(%p)->(%p)\n", This, pnPriority);
 160
 161     return IBinding_GetPriority(This->binding, pnPriority);
 162 }
 163
 164 static HRESULT WINAPI XMLView_Binding_GetBindResult(IBinding *iface,
 165         CLSID *pclsidProtocol, DWORD *pdwResult, LPOLESTR *pszResult,
 166         DWORD *pdwReserved)
 167 {
 168     Binding *This = impl_from_IBinding(iface);
 169     FIXME("(%p)->(%s %p %p %p)\n", This, debugstr_guid(pclsidProtocol),
 170             pdwResult, pszResult, pdwReserved);
 171     return E_NOTIMPL;
 172 }
 173
 174 static IBindingVtbl XMLView_BindingVtbl = {
 175     XMLView_Binding_QueryInterface,
 176     XMLView_Binding_AddRef,
 177     XMLView_Binding_Release,
 178     XMLView_Binding_Abort,
 179     XMLView_Binding_Suspend,
 180     XMLView_Binding_Resume,
 181     XMLView_Binding_SetPriority,
 182     XMLView_Binding_GetPriority,
 183     XMLView_Binding_GetBindResult
 184 };
 185
 186 static inline HRESULT XMLView_Binding_Create(IBinding *binding, IBinding **ret)
 187 {
 188     Binding *bind;
 189
 190     bind = heap_alloc_zero(sizeof(Binding));
 191     if(!bind)
 192         return E_OUTOFMEMORY;
 193
 194     bind->IBinding_iface.lpVtbl = &XMLView_BindingVtbl;
 195     bind->ref = 1;
 196
 197     bind->binding = binding;
 198     IBinding_AddRef(binding);
 199
 200     *ret = &bind->IBinding_iface;
 201     return S_OK;
 202 }
 203
 204 static inline BindStatusCallback* impl_from_IBindStatusCallback(
 205         IBindStatusCallback *iface)
 206 {
 207     return CONTAINING_RECORD(iface, BindStatusCallback,
 208             IBindStatusCallback_iface);
 209 }
 210
 211 static HRESULT WINAPI XMLView_BindStatusCallback_QueryInterface(
 212         IBindStatusCallback *iface, REFIID riid, void **ppvObject)
 213 {
 214     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 215
 216     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
 217
 218     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IBindStatusCallback)) {
 219         *ppvObject = iface;
 220         IBindStatusCallback_AddRef(iface);
 221         return S_OK;
 222     }
 223
 224     *ppvObject = NULL;
 225     return E_NOINTERFACE;
 226 }
 227
 228 static ULONG WINAPI XMLView_BindStatusCallback_AddRef(
 229         IBindStatusCallback *iface)
 230 {
 231     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 232     ULONG ref = InterlockedIncrement(&This->ref);
 233
 234     TRACE("%p, refcount %lu.\n", iface, ref);
 235
 236     return ref;
 237 }
 238
 239 static ULONG WINAPI XMLView_BindStatusCallback_Release(
 240         IBindStatusCallback *iface)
 241 {
 242     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 243     ULONG ref = InterlockedDecrement(&This->ref);
 244
 245     TRACE("%p, refcount %lu.\n", iface, ref);
 246
 247     if(!ref) {
 248         if(This->stream)
 249             IStream_Release(This->stream);
 250         IBindStatusCallback_Release(This->bsc);
 251         IMoniker_Release(This->mon);
 252         heap_free(This);
 253     }
 254     return ref;
 255 }
 256
 257 static HRESULT WINAPI XMLView_BindStatusCallback_OnStartBinding(
 258         IBindStatusCallback *iface, DWORD dwReserved, IBinding *pib)
 259 {
 260     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 261     IBinding *binding;
 262     HRESULT hres;
 263
 264     TRACE("%p, %lx, %p.\n", iface, dwReserved, pib);
 265
 266     hres = XMLView_Binding_Create(pib, &binding);
 267     if(FAILED(hres)) {
 268         IBinding_Abort(pib);
 269         return hres;
 270     }
 271
 272     hres = IBindStatusCallback_OnStartBinding(This->bsc, dwReserved, binding);
 273     if(FAILED(hres)) {
 274         IBinding_Abort(binding);
 275         return hres;
 276     }
 277
 278     IBinding_Release(binding);
 279     return hres;
 280 }
 281
 282 static HRESULT WINAPI XMLView_BindStatusCallback_GetPriority(
 283         IBindStatusCallback *iface, LONG *pnPriority)
 284 {
 285     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 286     FIXME("(%p)->(%p)\n", This, pnPriority);
 287     return E_NOTIMPL;
 288 }
 289
 290 static HRESULT WINAPI XMLView_BindStatusCallback_OnLowResource(
 291         IBindStatusCallback *iface, DWORD reserved)
 292 {
 293     FIXME("%p, %lx.\n", iface, reserved);
 294     return E_NOTIMPL;
 295 }
 296
 297 static HRESULT WINAPI XMLView_BindStatusCallback_OnProgress(
 298         IBindStatusCallback *iface, ULONG ulProgress, ULONG ulProgressMax,
 299         ULONG ulStatusCode, LPCWSTR szStatusText)
 300 {
 301     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 302     TRACE("%p, %lu, %lu, %lu, %s.\n", iface, ulProgress, ulProgressMax,
 303             ulStatusCode, debugstr_w(szStatusText));
 304
 305     switch(ulStatusCode) {
 306     case BINDSTATUS_BEGINDOWNLOADDATA:
 307         return IBindStatusCallback_OnProgress(This->bsc, ulProgress,
 308                 ulProgressMax, ulStatusCode, szStatusText);
 309     case BINDSTATUS_MIMETYPEAVAILABLE:
 310         return S_OK;
 311     default:
 312         FIXME("ulStatusCode: %lu\n", ulStatusCode);
 313         return E_NOTIMPL;
 314     }
 315 }
 316
 317 static HRESULT WINAPI XMLView_BindStatusCallback_OnStopBinding(
 318         IBindStatusCallback *iface, HRESULT hresult, LPCWSTR szError)
 319 {
 320     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 321     TRACE("%p, %#lx, %s.\n", iface, hresult, debugstr_w(szError));
 322     return IBindStatusCallback_OnStopBinding(This->bsc, hresult, szError);
 323 }
 324
 325 static HRESULT WINAPI XMLView_BindStatusCallback_GetBindInfo(
 326         IBindStatusCallback *iface, DWORD *grfBINDF, BINDINFO *pbindinfo)
 327 {
 328     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 329     TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
 330     return IBindStatusCallback_GetBindInfo(This->bsc, grfBINDF, pbindinfo);
 331 }
 332
 333 static inline HRESULT report_data(BindStatusCallback *This)
 334 {
 335     FORMATETC formatetc = {0, NULL, 1, -1, TYMED_ISTREAM};
 336     STGMEDIUM stgmedium;
 337     LARGE_INTEGER off;
 338     ULARGE_INTEGER size;
 339     HRESULT hres;
 340
 341     off.QuadPart = 0;
 342     hres = IStream_Seek(This->stream, off, STREAM_SEEK_CUR, &size);
 343     if(FAILED(hres))
 344         return hres;
 345
 346     hres = IStream_Seek(This->stream, off, STREAM_SEEK_SET, NULL);
 347     if(FAILED(hres))
 348         return hres;
 349
 350     stgmedium.tymed = TYMED_ISTREAM;
 351     stgmedium.u.pstm = This->stream;
 352     stgmedium.pUnkForRelease = NULL;
 353
 354     hres = IBindStatusCallback_OnDataAvailable(This->bsc,
 355             BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION,
 356             size.u.LowPart, &formatetc, &stgmedium);
 357
 358     IStream_Release(This->stream);
 359     This->stream = NULL;
 360     return hres;
 361 }
 362
 363 static inline HRESULT display_error_page(BindStatusCallback *This)
 364 {
 365     FIXME("Error page not implemented yet.\n");
 366     return report_data(This);
 367 }
 368
 369 static inline HRESULT handle_xml_load(BindStatusCallback *This)
 370 {
 371     static const WCHAR selectW[] = {'p','r','o','c','e','s','s','i','n','g','-',
 372         'i','n','s','t','r','u','c','t','i','o','n','(','\'','x','m','l',
 373         '-','s','t','y','l','e','s','h','e','e','t','\'',')',0};
 374     static const WCHAR hrefW[] = {'h','r','e','f','=',0};
 375
 376     IXMLDOMDocument3 *xml = NULL, *xsl = NULL;
 377     IXMLDOMNode *stylesheet;
 378     IBindCtx *pbc;
 379     IMoniker *mon;
 380     LPOLESTR xsl_url;
 381     LARGE_INTEGER off;
 382     VARIANT_BOOL succ;
 383     VARIANT var;
 384     WCHAR *href = NULL, *p;
 385     BSTR bstr;
 386     HRESULT hres;
 387
 388     off.QuadPart = 0;
 389     hres = IStream_Seek(This->stream, off, STREAM_SEEK_SET, NULL);
 390     if(FAILED(hres))
 391         return display_error_page(This);
 392
 393     hres = dom_document_create(MSXML_DEFAULT, (void **)&xml);
 394     if(FAILED(hres))
 395         return display_error_page(This);
 396
 397     V_VT(&var) = VT_UNKNOWN;
 398     V_UNKNOWN(&var) = (IUnknown*)This->stream;
 399     hres = IXMLDOMDocument3_load(xml, var, &succ);
 400     if(FAILED(hres) || !succ) {
 401         IXMLDOMDocument3_Release(xml);
 402         return display_error_page(This);
 403     }
 404     V_VT(&var) = VT_EMPTY;
 405
 406     bstr = SysAllocString(selectW);
 407     hres = IXMLDOMDocument3_selectSingleNode(xml, bstr, &stylesheet);
 408     SysFreeString(bstr);
 409     if(hres != S_OK) {
 410         IXMLDOMDocument3_Release(xml);
 411         return display_error_page(This);
 412     }
 413
 414     hres = IXMLDOMNode_get_nodeValue(stylesheet, &var);
 415     IXMLDOMNode_Release(stylesheet);
 416     if(SUCCEEDED(hres) && V_VT(&var)!=VT_BSTR) {
 417         FIXME("Variant type %d not supported\n", V_VT(&var));
 418         VariantClear(&var);
 419         hres = E_FAIL;
 420     }
 421     if(FAILED(hres)) {
 422         IXMLDOMDocument3_Release(xml);
 423         return display_error_page(This);
 424     }
 425
 426     /* TODO: fix parsing processing instruction value */
 427     if((p = wcsstr(V_BSTR(&var), hrefW))) {
 428         p += ARRAY_SIZE(hrefW) - 1;
 429         if(*p!='\'' && *p!='\"') p = NULL;
 430         else {
 431             href = p+1;
 432             p = wcschr(href, *p);
 433         }
 434     }
 435     if(p) {
 436         *p = 0;
 437     } else {
 438         VariantClear(&var);
 439         IXMLDOMDocument3_Release(xml);
 440         return display_error_page(This);
 441     }
 442
 443     hres = CreateURLMonikerEx(This->mon, href, &mon, 0);
 444     VariantClear(&var);
 445     if(FAILED(hres)) {
 446         IXMLDOMDocument3_Release(xml);
 447         return display_error_page(This);
 448     }
 449
 450     hres = CreateBindCtx(0, &pbc);
 451     if(SUCCEEDED(hres)) {
 452         hres = IMoniker_GetDisplayName(mon, pbc, NULL, &xsl_url);
 453         IMoniker_Release(mon);
 454         IBindCtx_Release(pbc);
 455     }
 456     if(FAILED(hres)) {
 457         IXMLDOMDocument3_Release(xml);
 458         return display_error_page(This);
 459     }
 460
 461     V_VT(&var) = VT_BSTR;
 462     V_BSTR(&var) = SysAllocString(xsl_url);
 463     CoTaskMemFree(xsl_url);
 464     if(!V_BSTR(&var)) {
 465         IXMLDOMDocument3_Release(xml);
 466         return display_error_page(This);
 467     }
 468
 469     hres = dom_document_create(MSXML_DEFAULT, (void **)&xsl);
 470     if(FAILED(hres)) {
 471         VariantClear(&var);
 472         IXMLDOMDocument3_Release(xml);
 473         return display_error_page(This);
 474     }
 475
 476     /* TODO: do the binding asynchronously */
 477     hres = IXMLDOMDocument3_load(xsl, var, &succ);
 478     VariantClear(&var);
 479     if(FAILED(hres) || !succ) {
 480         IXMLDOMDocument3_Release(xsl);
 481         IXMLDOMDocument3_Release(xml);
 482         return display_error_page(This);
 483     }
 484
 485     hres = IXMLDOMDocument3_transformNode(xml, (IXMLDOMNode*)xsl, &bstr);
 486     IXMLDOMDocument3_Release(xsl);
 487     IXMLDOMDocument3_Release(xml);
 488     if(FAILED(hres))
 489         return display_error_page(This);
 490
 491     hres = IStream_Seek(This->stream, off, STREAM_SEEK_SET, NULL);
 492     if(FAILED(hres)) {
 493         SysFreeString(bstr);
 494         return display_error_page(This);
 495     }
 496
 497     hres = IStream_Write(This->stream, (BYTE*)bstr,
 498             SysStringLen(bstr)*sizeof(WCHAR), NULL);
 499     SysFreeString(bstr);
 500     if(FAILED(hres))
 501         return display_error_page(This);
 502
 503     return report_data(This);
 504 }
 505
 506 static HRESULT WINAPI XMLView_BindStatusCallback_OnDataAvailable(
 507         IBindStatusCallback *iface, DWORD grfBSCF, DWORD dwSize,
 508         FORMATETC *pformatetc, STGMEDIUM *pstgmed)
 509 {
 510     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 511     char buf[1024];
 512     DWORD size;
 513     HRESULT hres;
 514
 515     TRACE("%p, %lx, %ld, %p, %p.\n", iface, grfBSCF, dwSize, pformatetc, pstgmed);
 516
 517     if(!This->stream)
 518         return E_FAIL;
 519
 520     do {
 521         hres = IStream_Read(pstgmed->u.pstm, buf, sizeof(buf), &size);
 522         IStream_Write(This->stream, buf, size, &size);
 523     } while(hres==S_OK && size);
 524
 525     if(FAILED(hres) && hres!=E_PENDING)
 526         return hres;
 527     if(hres != S_FALSE)
 528         return S_OK;
 529
 530     return handle_xml_load(This);
 531 }
 532
 533 static HRESULT WINAPI XMLView_BindStatusCallback_OnObjectAvailable(
 534         IBindStatusCallback *iface, REFIID riid, IUnknown *punk)
 535 {
 536     BindStatusCallback *This = impl_from_IBindStatusCallback(iface);
 537     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), punk);
 538     return E_NOTIMPL;
 539 }
 540
 541 static IBindStatusCallbackVtbl XMLView_BindStatusCallbackVtbl = {
 542     XMLView_BindStatusCallback_QueryInterface,
 543     XMLView_BindStatusCallback_AddRef,
 544     XMLView_BindStatusCallback_Release,
 545     XMLView_BindStatusCallback_OnStartBinding,
 546     XMLView_BindStatusCallback_GetPriority,
 547     XMLView_BindStatusCallback_OnLowResource,
 548     XMLView_BindStatusCallback_OnProgress,
 549     XMLView_BindStatusCallback_OnStopBinding,
 550     XMLView_BindStatusCallback_GetBindInfo,
 551     XMLView_BindStatusCallback_OnDataAvailable,
 552     XMLView_BindStatusCallback_OnObjectAvailable
 553 };
 554
 555 static inline HRESULT XMLView_BindStatusCallback_Create(IBindStatusCallback *bsc_html,
 556         IMoniker *mon, IStream *stream, IBindStatusCallback **ret)
 557 {
 558     BindStatusCallback *bsc;
 559
 560     bsc = heap_alloc_zero(sizeof(BindStatusCallback));
 561     if(!bsc)
 562         return E_OUTOFMEMORY;
 563
 564     bsc->IBindStatusCallback_iface.lpVtbl = &XMLView_BindStatusCallbackVtbl;
 565     bsc->ref = 1;
 566
 567     bsc->bsc = bsc_html;
 568     IBindStatusCallback_AddRef(bsc_html);
 569     bsc->stream = stream;
 570     IStream_AddRef(bsc->stream);
 571     bsc->mon = mon;
 572     IMoniker_AddRef(mon);
 573
 574     *ret = &bsc->IBindStatusCallback_iface;
 575     return S_OK;
 576 }
 577
 578 static inline Moniker* impl_from_IMoniker(IMoniker *iface)
 579 {
 580     return CONTAINING_RECORD(iface, Moniker, IMoniker_iface);
 581 }
 582
 583 static HRESULT WINAPI XMLView_Moniker_QueryInterface(
 584         IMoniker *iface, REFIID riid, void **ppvObject)
 585 {
 586     Moniker *This = impl_from_IMoniker(iface);
 587
 588     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
 589
 590     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IPersist)
 591             || IsEqualGUID(riid, &IID_IPersistStream) || IsEqualGUID(riid, &IID_IMoniker)) {
 592         *ppvObject = iface;
 593         IMoniker_AddRef(iface);
 594         return S_OK;
 595     }
 596
 597     *ppvObject = NULL;
 598     return E_NOINTERFACE;
 599 }
 600
 601 static ULONG WINAPI XMLView_Moniker_AddRef(IMoniker *iface)
 602 {
 603     Moniker *This = impl_from_IMoniker(iface);
 604     LONG ref = InterlockedIncrement(&This->ref);
 605
 606     TRACE("%p, refcount %lu.\n", iface, ref);
 607
 608     return ref;
 609 }
 610
 611 static ULONG WINAPI XMLView_Moniker_Release(IMoniker *iface)
 612 {
 613     Moniker *This = impl_from_IMoniker(iface);
 614     ULONG ref = InterlockedDecrement(&This->ref);
 615
 616     TRACE("%p, refcount %lu.\n", iface, ref);
 617
 618     if(!ref) {
 619         IMoniker_Release(This->mon);
 620         heap_free(This);
 621     }
 622     return ref;
 623 }
 624
 625 static HRESULT WINAPI XMLView_Moniker_GetClassID(IMoniker *iface, CLSID *pClassID)
 626 {
 627     Moniker *This = impl_from_IMoniker(iface);
 628     FIXME("(%p)->(%p)\n", This, pClassID);
 629     return E_NOTIMPL;
 630 }
 631
 632 static HRESULT WINAPI XMLView_Moniker_IsDirty(IMoniker *iface)
 633 {
 634     Moniker *This = impl_from_IMoniker(iface);
 635     FIXME("(%p)\n", This);
 636     return E_NOTIMPL;
 637 }
 638
 639 static HRESULT WINAPI XMLView_Moniker_Load(IMoniker *iface, IStream *pStm)
 640 {
 641     Moniker *This = impl_from_IMoniker(iface);
 642     FIXME("(%p)->(%p)\n", This, pStm);
 643     return E_NOTIMPL;
 644 }
 645
 646 static HRESULT WINAPI XMLView_Moniker_Save(IMoniker *iface,
 647         IStream *pStm, BOOL fClearDirty)
 648 {
 649     Moniker *This = impl_from_IMoniker(iface);
 650     FIXME("(%p)->(%p %x)\n", This, pStm, fClearDirty);
 651     return E_NOTIMPL;
 652 }
 653
 654 static HRESULT WINAPI XMLView_Moniker_GetSizeMax(
 655         IMoniker *iface, ULARGE_INTEGER *pcbSize)
 656 {
 657     Moniker *This = impl_from_IMoniker(iface);
 658     FIXME("(%p)->(%p)\n", This, pcbSize);
 659     return E_NOTIMPL;
 660 }
 661
 662 static HRESULT WINAPI XMLView_Moniker_BindToObject(IMoniker *iface, IBindCtx *pbc,
 663         IMoniker *pmkToLeft, REFIID riidResult, void **ppvResult)
 664 {
 665     Moniker *This = impl_from_IMoniker(iface);
 666     FIXME("(%p)->(%p %p %s %p)\n", This, pbc, pmkToLeft,
 667             debugstr_guid(riidResult), ppvResult);
 668     return E_NOTIMPL;
 669 }
 670
 671 static HRESULT WINAPI XMLView_Moniker_BindToStorage(IMoniker *iface, IBindCtx *pbc,
 672         IMoniker *pmkToLeft, REFIID riid, void **ppvObj)
 673 {
 674     Moniker *This = impl_from_IMoniker(iface);
 675
 676     TRACE("(%p)->(%p %p %s %p)\n", This, pbc, pmkToLeft, debugstr_guid(riid), ppvObj);
 677
 678     if(IsEqualGUID(riid, &IID_IStream)) {
 679         if(!This->stream)
 680             return E_FAIL;
 681
 682         *ppvObj = This->stream;
 683         This->stream = NULL;
 684         return S_ASYNCHRONOUS;
 685     }
 686
 687     return E_NOTIMPL;
 688 }
 689
 690 static HRESULT WINAPI XMLView_Moniker_Reduce(IMoniker *iface, IBindCtx *pbc,
 691         DWORD dwReduceHowFar, IMoniker **ppmkToLeft, IMoniker **ppmkReduced)
 692 {
 693     FIXME("%p, %p, %ld, %p, %p.\n", iface, pbc, dwReduceHowFar, ppmkToLeft, ppmkReduced);
 694     return E_NOTIMPL;
 695 }
 696
 697 static HRESULT WINAPI XMLView_Moniker_ComposeWith(IMoniker *iface, IMoniker *pmkRight,
 698         BOOL fOnlyIfNotGeneric, IMoniker **ppmkComposite)
 699 {
 700     Moniker *This = impl_from_IMoniker(iface);
 701     FIXME("(%p)->(%p %x %p)\n", This, pmkRight, fOnlyIfNotGeneric, ppmkComposite);
 702     return E_NOTIMPL;
 703 }
 704
 705 static HRESULT WINAPI XMLView_Moniker_Enum(IMoniker *iface,
 706         BOOL fForward, IEnumMoniker **ppenumMoniker)
 707 {
 708     Moniker *This = impl_from_IMoniker(iface);
 709     FIXME("(%p)->(%x %p)\n", This, fForward, ppenumMoniker);
 710     return E_NOTIMPL;
 711 }
 712
 713 static HRESULT WINAPI XMLView_Moniker_IsEqual(IMoniker *iface,
 714         IMoniker *pmkOtherMoniker)
 715 {
 716     Moniker *This = impl_from_IMoniker(iface);
 717     FIXME("(%p)->(%p)\n", This, pmkOtherMoniker);
 718     return E_NOTIMPL;
 719 }
 720
 721 static HRESULT WINAPI XMLView_Moniker_Hash(IMoniker *iface, DWORD *pdwHash)
 722 {
 723     Moniker *This = impl_from_IMoniker(iface);
 724     FIXME("(%p)->(%p)\n", This, pdwHash);
 725     return E_NOTIMPL;
 726 }
 727
 728 static HRESULT WINAPI XMLView_Moniker_IsRunning(IMoniker *iface, IBindCtx *pbc,
 729         IMoniker *pmkToLeft, IMoniker *pmkNewlyRunning)
 730 {
 731     Moniker *This = impl_from_IMoniker(iface);
 732     FIXME("(%p)->(%p %p %p)\n", This, pbc, pmkToLeft, pmkNewlyRunning);
 733     return E_NOTIMPL;
 734 }
 735
 736 static HRESULT WINAPI XMLView_Moniker_GetTimeOfLastChange(IMoniker *iface,
 737         IBindCtx *pbc, IMoniker *pmkToLeft, FILETIME *pFileTime)
 738 {
 739     Moniker *This = impl_from_IMoniker(iface);
 740     FIXME("(%p)->(%p %p %p)\n", This, pbc, pmkToLeft, pFileTime);
 741     return E_NOTIMPL;
 742 }
 743
 744 static HRESULT WINAPI XMLView_Moniker_Inverse(IMoniker *iface, IMoniker **ppmk)
 745 {
 746     Moniker *This = impl_from_IMoniker(iface);
 747     FIXME("(%p)->(%p)\n", This, ppmk);
 748     return E_NOTIMPL;
 749 }
 750
 751 static HRESULT WINAPI XMLView_Moniker_CommonPrefixWith(IMoniker *iface,
 752         IMoniker *pmkOther, IMoniker **ppmkPrefix)
 753 {
 754     Moniker *This = impl_from_IMoniker(iface);
 755     FIXME("(%p)->(%p %p)\n", This, pmkOther, ppmkPrefix);
 756     return E_NOTIMPL;
 757 }
 758
 759 static HRESULT WINAPI XMLView_Moniker_RelativePathTo(IMoniker *iface,
 760         IMoniker *pmkOther, IMoniker **ppmkRelPath)
 761 {
 762     Moniker *This = impl_from_IMoniker(iface);
 763     FIXME("(%p)->(%p %p)\n", This, pmkOther, ppmkRelPath);
 764     return E_NOTIMPL;
 765 }
 766
 767 static HRESULT WINAPI XMLView_Moniker_GetDisplayName(IMoniker *iface,
 768         IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR *ppszDisplayName)
 769 {
 770     Moniker *This = impl_from_IMoniker(iface);
 771     TRACE("(%p)->(%p %p %p)\n", This, pbc, pmkToLeft, ppszDisplayName);
 772     return IMoniker_GetDisplayName(This->mon, pbc, pmkToLeft, ppszDisplayName);
 773 }
 774
 775 static HRESULT WINAPI XMLView_Moniker_ParseDisplayName(IMoniker *iface,
 776         IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR pszDisplayName,
 777         ULONG *pchEaten, IMoniker **ppmkOut)
 778 {
 779     Moniker *This = impl_from_IMoniker(iface);
 780     FIXME("(%p)->(%p %p %s %p %p)\n", This, pbc, pmkToLeft,
 781             debugstr_w(pszDisplayName), pchEaten, ppmkOut);
 782     return E_NOTIMPL;
 783 }
 784
 785 static HRESULT WINAPI XMLView_Moniker_IsSystemMoniker(
 786         IMoniker *iface, DWORD *pdwMksys)
 787 {
 788     Moniker *This = impl_from_IMoniker(iface);
 789     FIXME("(%p)->(%p)\n", This, pdwMksys);
 790     return E_NOTIMPL;
 791 }
 792
 793 static IMonikerVtbl XMLView_MonikerVtbl = {
 794     XMLView_Moniker_QueryInterface,
 795     XMLView_Moniker_AddRef,
 796     XMLView_Moniker_Release,
 797     XMLView_Moniker_GetClassID,
 798     XMLView_Moniker_IsDirty,
 799     XMLView_Moniker_Load,
 800     XMLView_Moniker_Save,
 801     XMLView_Moniker_GetSizeMax,
 802     XMLView_Moniker_BindToObject,
 803     XMLView_Moniker_BindToStorage,
 804     XMLView_Moniker_Reduce,
 805     XMLView_Moniker_ComposeWith,
 806     XMLView_Moniker_Enum,
 807     XMLView_Moniker_IsEqual,
 808     XMLView_Moniker_Hash,
 809     XMLView_Moniker_IsRunning,
 810     XMLView_Moniker_GetTimeOfLastChange,
 811     XMLView_Moniker_Inverse,
 812     XMLView_Moniker_CommonPrefixWith,
 813     XMLView_Moniker_RelativePathTo,
 814     XMLView_Moniker_GetDisplayName,
 815     XMLView_Moniker_ParseDisplayName,
 816     XMLView_Moniker_IsSystemMoniker
 817 };
 818
 819 static inline HRESULT XMLView_Moniker_Create(IMoniker *mon,
 820         IStream *stream, IMoniker **ret)
 821 {
 822     Moniker *wrap;
 823
 824     wrap = heap_alloc_zero(sizeof(Moniker));
 825     if(!wrap)
 826         return E_OUTOFMEMORY;
 827
 828     wrap->IMoniker_iface.lpVtbl = &XMLView_MonikerVtbl;
 829     wrap->ref = 1;
 830
 831     wrap->mon = mon;
 832     IMoniker_AddRef(mon);
 833     wrap->stream = stream;
 834     IStream_AddRef(stream);
 835
 836     *ret = &wrap->IMoniker_iface;
 837     return S_OK;
 838 }
 839
 840 static inline XMLView* impl_from_IPersistMoniker(IPersistMoniker *iface)
 841 {
 842     return CONTAINING_RECORD(iface, XMLView, IPersistMoniker_iface);
 843 }
 844
 845 static HRESULT WINAPI XMLView_PersistMoniker_QueryInterface(
 846         IPersistMoniker *iface, REFIID riid, void **ppvObject)
 847 {
 848     XMLView *This = impl_from_IPersistMoniker(iface);
 849
 850     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
 851
 852     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IPersistMoniker))
 853         *ppvObject = &This->IPersistMoniker_iface;
 854     else if(IsEqualGUID(riid, &IID_IPersistHistory) ||
 855             IsEqualGUID(riid, &IID_IPersist))
 856         *ppvObject = &This->IPersistHistory_iface;
 857     else if(IsEqualGUID(riid, &IID_IOleCommandTarget))
 858         *ppvObject = &This->IOleCommandTarget_iface;
 859     else if(IsEqualGUID(riid, &IID_IOleObject))
 860         *ppvObject = &This->IOleObject_iface;
 861     else
 862         return IUnknown_QueryInterface(This->html_doc, riid, ppvObject);
 863
 864     IPersistMoniker_AddRef(&This->IPersistMoniker_iface);
 865     return S_OK;
 866 }
 867
 868 static ULONG WINAPI XMLView_PersistMoniker_AddRef(IPersistMoniker *iface)
 869 {
 870     XMLView *This = impl_from_IPersistMoniker(iface);
 871     ULONG ref = InterlockedIncrement(&This->ref);
 872
 873     TRACE("%p, refcount %lu.\n", iface, ref);
 874
 875     return ref;
 876 }
 877
 878 static ULONG WINAPI XMLView_PersistMoniker_Release(IPersistMoniker *iface)
 879 {
 880     XMLView *This = impl_from_IPersistMoniker(iface);
 881     ULONG ref = InterlockedDecrement(&This->ref);
 882
 883     TRACE("%p, refcount %lu.\n", iface, ref);
 884
 885     if(!ref) {
 886         if(This->mon)
 887             IMoniker_Release(This->mon);
 888         IUnknown_Release(This->html_doc);
 889         heap_free(This);
 890     }
 891     return ref;
 892 }
 893
 894 static HRESULT WINAPI XMLView_PersistMoniker_GetClassID(
 895         IPersistMoniker *iface, CLSID *pClassID)
 896 {
 897     XMLView *This = impl_from_IPersistMoniker(iface);
 898     FIXME("(%p)->(%p)\n", This, pClassID);
 899     return E_NOTIMPL;
 900 }
 901
 902 static HRESULT WINAPI XMLView_PersistMoniker_IsDirty(IPersistMoniker *iface)
 903 {
 904     XMLView *This = impl_from_IPersistMoniker(iface);
 905     FIXME("(%p)\n", This);
 906     return E_NOTIMPL;
 907 }
 908
 909 static HRESULT WINAPI XMLView_PersistMoniker_Load(IPersistMoniker *iface,
 910         BOOL fFullyAvailable, IMoniker *pimkName, LPBC pibc, DWORD grfMode)
 911 {
 912     static const WCHAR XSLParametersW[] = {'X','S','L','P','a','r','a','m','e','t','e','r','s',0};
 913     static const WCHAR XMLBufferStreamW[] = {'X','M','L','B','u','f','f','e','r','S','t','r','e','a','m',0};
 914     static const WCHAR DWNBINDINFOW[] = {'_','_','D','W','N','B','I','N','D','I','N','F','O',0};
 915     static const WCHAR HTMLLOADOPTIONSW[] = {'_','_','H','T','M','L','L','O','A','D','O','P','T','I','O','N','S',0};
 916     static const WCHAR BSCBHolderW[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
 917
 918     XMLView *This = impl_from_IPersistMoniker(iface);
 919     IPersistMoniker *html_persist_mon;
 920     IBindStatusCallback *bsc, *bsc_html;
 921     IBindCtx *bindctx;
 922     IStream *stream;
 923     IMoniker *mon;
 924     IUnknown *unk;
 925     HRESULT hres;
 926
 927     TRACE("%p, %x, %p, %p, %lx.\n", iface, fFullyAvailable, pimkName, pibc, grfMode);
 928
 929     hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)XSLParametersW, &unk);
 930     if(SUCCEEDED(hres)) {
 931         FIXME("ignoring XSLParameters\n");
 932         IUnknown_Release(unk);
 933     }
 934     hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)XMLBufferStreamW, &unk);
 935     if(SUCCEEDED(hres)) {
 936         FIXME("ignoring XMLBufferStream\n");
 937         IUnknown_Release(unk);
 938     }
 939
 940     hres = CreateBindCtx(0, &bindctx);
 941     if(FAILED(hres))
 942         return hres;
 943
 944     hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)DWNBINDINFOW, &unk);
 945     if(SUCCEEDED(hres)) {
 946         IBindCtx_RegisterObjectParam(bindctx, (LPOLESTR)DWNBINDINFOW, unk);
 947         IUnknown_Release(unk);
 948     }
 949     hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)HTMLLOADOPTIONSW, &unk);
 950     if(SUCCEEDED(hres)) {
 951         IBindCtx_RegisterObjectParam(bindctx, (LPOLESTR)HTMLLOADOPTIONSW, unk);
 952         IUnknown_Release(unk);
 953     }
 954     hres = IBindCtx_GetObjectParam(pibc, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM, &unk);
 955     if(SUCCEEDED(hres)) {
 956         IBindCtx_RegisterObjectParam(bindctx, (LPOLESTR)SZ_HTML_CLIENTSITE_OBJECTPARAM, unk);
 957         IUnknown_Release(unk);
 958     }
 959
 960     hres = CreateStreamOnHGlobal(NULL, TRUE, &stream);
 961     if(FAILED(hres)) {
 962         IBindCtx_Release(bindctx);
 963         return hres;
 964     }
 965
 966     if(This->mon)
 967         IMoniker_Release(This->mon);
 968     This->mon = pimkName;
 969     IMoniker_AddRef(This->mon);
 970
 971     hres = XMLView_Moniker_Create(This->mon, stream, &mon);
 972     if(FAILED(hres)) {
 973         IStream_Release(stream);
 974         IBindCtx_Release(bindctx);
 975         return hres;
 976     }
 977
 978     hres = IUnknown_QueryInterface(This->html_doc,
 979             &IID_IPersistMoniker, (void**)&html_persist_mon);
 980     if(FAILED(hres)) {
 981         IMoniker_Release(mon);
 982         IStream_Release(stream);
 983         IBindCtx_Release(bindctx);
 984         return hres;
 985     }
 986
 987     hres = IPersistMoniker_Load(html_persist_mon, FALSE, mon, bindctx, 0);
 988     IPersistMoniker_Release(html_persist_mon);
 989     IMoniker_Release(mon);
 990     if(FAILED(hres)) {
 991         IStream_Release(stream);
 992         IBindCtx_Release(bindctx);
 993         return hres;
 994     }
 995
 996     hres = IBindCtx_GetObjectParam(bindctx, (LPOLESTR)BSCBHolderW, &unk);
 997     IBindCtx_Release(bindctx);
 998     if(FAILED(hres)) {
 999         IStream_Release(stream);
1000         return hres;
1001     }
1002     hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&bsc_html);
1003     IUnknown_Release(unk);
1004     if(FAILED(hres)) {
1005         IStream_Release(stream);
1006         return hres;
1007     }
1008
1009     hres = XMLView_BindStatusCallback_Create(bsc_html, This->mon, stream, &bsc);
1010     IStream_Release(stream);
1011     if(FAILED(hres)) {
1012         IBindStatusCallback_OnStopBinding(bsc_html, hres, NULL);
1013         IBindStatusCallback_Release(bsc_html);
1014         return hres;
1015     }
1016
1017     hres = RegisterBindStatusCallback(pibc, bsc, NULL, 0);
1018     IBindStatusCallback_Release(bsc);
1019     if(FAILED(hres)) {
1020         IBindStatusCallback_OnStopBinding(bsc_html, hres, NULL);
1021         IBindStatusCallback_Release(bsc_html);
1022         return hres;
1023     }
1024
1025     hres = IMoniker_BindToStorage(pimkName, pibc, NULL,
1026             &IID_IStream, (void**)&stream);
1027     if(FAILED(hres)) {
1028         IBindStatusCallback_OnStopBinding(bsc_html, hres, NULL);
1029         IBindStatusCallback_Release(bsc_html);
1030         return hres;
1031     }
1032
1033     if(stream)
1034         IStream_Release(stream);
1035     IBindStatusCallback_Release(bsc_html);
1036     return S_OK;
1037 }
1038
1039 static HRESULT WINAPI XMLView_PersistMoniker_Save(IPersistMoniker *iface,
1040         IMoniker *pimkName, LPBC pbc, BOOL fRemember)
1041 {
1042     XMLView *This = impl_from_IPersistMoniker(iface);
1043     FIXME("(%p)->(%p %p %x)\n", This, pimkName, pbc, fRemember);
1044     return E_NOTIMPL;
1045 }
1046
1047 static HRESULT WINAPI XMLView_PersistMoniker_SaveCompleted(
1048         IPersistMoniker *iface, IMoniker *pimkName, LPBC pibc)
1049 {
1050     XMLView *This = impl_from_IPersistMoniker(iface);
1051     FIXME("(%p)->(%p %p)\n", This, pimkName, pibc);
1052     return E_NOTIMPL;
1053 }
1054
1055 static HRESULT WINAPI XMLView_PersistMoniker_GetCurMoniker(
1056         IPersistMoniker *iface, IMoniker **ppimkName)
1057 {
1058     XMLView *This = impl_from_IPersistMoniker(iface);
1059     FIXME("(%p)->(%p)\n", This, ppimkName);
1060     return E_NOTIMPL;
1061 }
1062
1063 static IPersistMonikerVtbl XMLView_PersistMonikerVtbl = {
1064     XMLView_PersistMoniker_QueryInterface,
1065     XMLView_PersistMoniker_AddRef,
1066     XMLView_PersistMoniker_Release,
1067     XMLView_PersistMoniker_GetClassID,
1068     XMLView_PersistMoniker_IsDirty,
1069     XMLView_PersistMoniker_Load,
1070     XMLView_PersistMoniker_Save,
1071     XMLView_PersistMoniker_SaveCompleted,
1072     XMLView_PersistMoniker_GetCurMoniker
1073 };
1074
1075 static inline XMLView* impl_from_IPersistHistory(IPersistHistory *iface)
1076 {
1077     return CONTAINING_RECORD(iface, XMLView, IPersistHistory_iface);
1078 }
1079
1080 static HRESULT WINAPI XMLView_PersistHistory_QueryInterface(
1081         IPersistHistory *iface, REFIID riid, void **ppvObject)
1082 {
1083     XMLView *This = impl_from_IPersistHistory(iface);
1084     return IPersistMoniker_QueryInterface(&This->IPersistMoniker_iface, riid, ppvObject);
1085 }
1086
1087 static ULONG WINAPI XMLView_PersistHistory_AddRef(IPersistHistory *iface)
1088 {
1089     XMLView *This = impl_from_IPersistHistory(iface);
1090     return IPersistMoniker_AddRef(&This->IPersistMoniker_iface);
1091 }
1092
1093 static ULONG WINAPI XMLView_PersistHistory_Release(IPersistHistory *iface)
1094 {
1095     XMLView *This = impl_from_IPersistHistory(iface);
1096     return IPersistMoniker_Release(&This->IPersistMoniker_iface);
1097 }
1098
1099 static HRESULT WINAPI XMLView_PersistHistory_GetClassID(
1100         IPersistHistory *iface, CLSID *pClassID)
1101 {
1102     XMLView *This = impl_from_IPersistHistory(iface);
1103     FIXME("(%p)->(%p)\n", This, pClassID);
1104     return E_NOTIMPL;
1105 }
1106
1107 static HRESULT WINAPI XMLView_PersistHistory_LoadHistory(
1108         IPersistHistory *iface, IStream *pStream, IBindCtx *pbc)
1109 {
1110     XMLView *This = impl_from_IPersistHistory(iface);
1111     FIXME("(%p)->(%p %p)\n", This, pStream, pbc);
1112     return E_NOTIMPL;
1113 }
1114
1115 static HRESULT WINAPI XMLView_PersistHistory_SaveHistory(
1116         IPersistHistory *iface, IStream *pStream)
1117 {
1118     XMLView *This = impl_from_IPersistHistory(iface);
1119     FIXME("(%p)->(%p)\n", This, pStream);
1120     return E_NOTIMPL;
1121 }
1122
1123 static HRESULT WINAPI XMLView_PersistHistory_SetPositionCookie(
1124         IPersistHistory *iface, DWORD dwPositioncookie)
1125 {
1126     FIXME("%p, %ld.\n", iface, dwPositioncookie);
1127     return E_NOTIMPL;
1128 }
1129
1130 static HRESULT WINAPI XMLView_PersistHistory_GetPositionCookie(
1131         IPersistHistory *iface, DWORD *pdwPositioncookie)
1132 {
1133     XMLView *This = impl_from_IPersistHistory(iface);
1134     FIXME("(%p)->(%p)\n", This, pdwPositioncookie);
1135     return E_NOTIMPL;
1136 }
1137
1138 static IPersistHistoryVtbl XMLView_PersistHistoryVtbl = {
1139     XMLView_PersistHistory_QueryInterface,
1140     XMLView_PersistHistory_AddRef,
1141     XMLView_PersistHistory_Release,
1142     XMLView_PersistHistory_GetClassID,
1143     XMLView_PersistHistory_LoadHistory,
1144     XMLView_PersistHistory_SaveHistory,
1145     XMLView_PersistHistory_SetPositionCookie,
1146     XMLView_PersistHistory_GetPositionCookie
1147 };
1148
1149 static inline XMLView* impl_from_IOleCommandTarget(IOleCommandTarget *iface)
1150 {
1151     return CONTAINING_RECORD(iface, XMLView, IOleCommandTarget_iface);
1152 }
1153
1154 static HRESULT WINAPI XMLView_OleCommandTarget_QueryInterface(
1155         IOleCommandTarget *iface, REFIID riid, void **ppvObject)
1156 {
1157     XMLView *This = impl_from_IOleCommandTarget(iface);
1158     return IPersistMoniker_QueryInterface(&This->IPersistMoniker_iface, riid, ppvObject);
1159 }
1160
1161 static ULONG WINAPI XMLView_OleCommandTarget_AddRef(IOleCommandTarget *iface)
1162 {
1163     XMLView *This = impl_from_IOleCommandTarget(iface);
1164     return IPersistMoniker_AddRef(&This->IPersistMoniker_iface);
1165 }
1166
1167 static ULONG WINAPI XMLView_OleCommandTarget_Release(IOleCommandTarget *iface)
1168 {
1169     XMLView *This = impl_from_IOleCommandTarget(iface);
1170     return IPersistMoniker_Release(&This->IPersistMoniker_iface);
1171 }
1172
1173 static HRESULT WINAPI XMLView_OleCommandTarget_QueryStatus(IOleCommandTarget *iface,
1174         const GUID *pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT *pCmdText)
1175 {
1176     FIXME("%p, %p, %lu, %p, %p.\n", iface, pguidCmdGroup, cCmds, prgCmds, pCmdText);
1177     return E_NOTIMPL;
1178 }
1179
1180 static HRESULT WINAPI XMLView_OleCommandTarget_Exec(IOleCommandTarget *iface,
1181         const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdexecopt,
1182         VARIANT *pvaIn, VARIANT *pvaOut)
1183 {
1184     FIXME("%p, %p, %ld, %lx, %p, %p.\n", iface, pguidCmdGroup,
1185             nCmdID, nCmdexecopt, pvaIn, pvaOut);
1186     return E_NOTIMPL;
1187 }
1188
1189 static IOleCommandTargetVtbl XMLView_OleCommandTargetVtbl = {
1190     XMLView_OleCommandTarget_QueryInterface,
1191     XMLView_OleCommandTarget_AddRef,
1192     XMLView_OleCommandTarget_Release,
1193     XMLView_OleCommandTarget_QueryStatus,
1194     XMLView_OleCommandTarget_Exec
1195 };
1196
1197 static inline XMLView* impl_from_IOleObject(IOleObject *iface)
1198 {
1199     return CONTAINING_RECORD(iface, XMLView, IOleObject_iface);
1200 }
1201
1202 static HRESULT WINAPI XMLView_OleObject_QueryInterface(
1203         IOleObject *iface, REFIID riid, void **ppvObject)
1204 {
1205     XMLView *This = impl_from_IOleObject(iface);
1206     return IPersistMoniker_QueryInterface(&This->IPersistMoniker_iface, riid, ppvObject);
1207 }
1208
1209 static ULONG WINAPI XMLView_OleObject_AddRef(IOleObject *iface)
1210 {
1211     XMLView *This = impl_from_IOleObject(iface);
1212     return IPersistMoniker_AddRef(&This->IPersistMoniker_iface);
1213 }
1214
1215 static ULONG WINAPI XMLView_OleObject_Release(IOleObject *iface)
1216 {
1217     XMLView *This = impl_from_IOleObject(iface);
1218     return IPersistMoniker_Release(&This->IPersistMoniker_iface);
1219 }
1220
1221 static HRESULT WINAPI XMLView_OleObject_SetClientSite(
1222         IOleObject *iface, IOleClientSite *pClientSite)
1223 {
1224     XMLView *This = impl_from_IOleObject(iface);
1225     FIXME("(%p)->(%p)\n", This, pClientSite);
1226     return E_NOTIMPL;
1227 }
1228
1229 static HRESULT WINAPI XMLView_OleObject_GetClientSite(
1230         IOleObject *iface, IOleClientSite **ppClientSite)
1231 {
1232     XMLView *This = impl_from_IOleObject(iface);
1233     FIXME("(%p)->(%p)\n", This, ppClientSite);
1234     return E_NOTIMPL;
1235 }
1236
1237 static HRESULT WINAPI XMLView_OleObject_SetHostNames(IOleObject *iface,
1238         LPCOLESTR szContainerApp, LPCOLESTR szContainerObj)
1239 {
1240     XMLView *This = impl_from_IOleObject(iface);
1241     FIXME("(%p)->(%s %s)\n", This, debugstr_w(szContainerApp), debugstr_w(szContainerObj));
1242     return E_NOTIMPL;
1243 }
1244
1245 static HRESULT WINAPI XMLView_OleObject_Close(IOleObject *iface, DWORD dwSaveOption)
1246 {
1247     FIXME("%p, %lx.\n", iface, dwSaveOption);
1248     return E_NOTIMPL;
1249 }
1250
1251 static HRESULT WINAPI XMLView_OleObject_SetMoniker(IOleObject *iface,
1252         DWORD dwWhichMoniker, IMoniker *pmk)
1253 {
1254     FIXME("%p, %lx, %p.\n", iface, dwWhichMoniker, pmk);
1255     return E_NOTIMPL;
1256 }
1257
1258 static HRESULT WINAPI XMLView_OleObject_GetMoniker(IOleObject *iface,
1259         DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk)
1260 {
1261     FIXME("%p, %lx, %lx, %p.\n", iface, dwAssign, dwWhichMoniker, ppmk);
1262     return E_NOTIMPL;
1263 }
1264
1265 static HRESULT WINAPI XMLView_OleObject_InitFromData(IOleObject *iface,
1266         IDataObject *pDataObject, BOOL fCreation, DWORD dwReserved)
1267 {
1268     FIXME("%p, %p, %x, %lx.\n", iface, pDataObject, fCreation, dwReserved);
1269     return E_NOTIMPL;
1270 }
1271
1272 static HRESULT WINAPI XMLView_OleObject_GetClipboardData(IOleObject *iface,
1273         DWORD dwReserved, IDataObject **ppDataObject)
1274 {
1275     FIXME("%p, %lx, %p.\n", iface, dwReserved, ppDataObject);
1276     return E_NOTIMPL;
1277 }
1278
1279 static HRESULT WINAPI XMLView_OleObject_DoVerb(IOleObject *iface,
1280         LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite,
1281         LONG lindex, HWND hwndParent, LPCRECT lprcPosRect)
1282 {
1283     FIXME("%p, %ld, %p, %p, %ld, %p, %p.\n", iface, iVerb, lpmsg,
1284             pActiveSite, lindex, hwndParent, lprcPosRect);
1285     return E_NOTIMPL;
1286 }
1287
1288 static HRESULT WINAPI XMLView_OleObject_EnumVerbs(
1289         IOleObject *iface, IEnumOLEVERB **ppEnumOleVerb)
1290 {
1291     XMLView *This = impl_from_IOleObject(iface);
1292     FIXME("(%p)->{%p)\n", This, ppEnumOleVerb);
1293     return E_NOTIMPL;
1294 }
1295
1296 static HRESULT WINAPI XMLView_OleObject_Update(IOleObject *iface)
1297 {
1298     XMLView *This = impl_from_IOleObject(iface);
1299     FIXME("(%p)\n", This);
1300     return E_NOTIMPL;
1301 }
1302
1303 static HRESULT WINAPI XMLView_OleObject_IsUpToDate(IOleObject *iface)
1304 {
1305     XMLView *This = impl_from_IOleObject(iface);
1306     FIXME("(%p)\n", This);
1307     return E_NOTIMPL;
1308 }
1309
1310 static HRESULT WINAPI XMLView_OleObject_GetUserClassID(IOleObject *iface, CLSID *pClsid)
1311 {
1312     XMLView *This = impl_from_IOleObject(iface);
1313     FIXME("(%p)->(%p)\n", This, pClsid);
1314     return E_NOTIMPL;
1315 }
1316
1317 static HRESULT WINAPI XMLView_OleObject_GetUserType(IOleObject *iface,
1318         DWORD dwFormOfType, LPOLESTR *pszUserType)
1319 {
1320     FIXME("%p, %lx, %p.\n", iface, dwFormOfType, pszUserType);
1321     return E_NOTIMPL;
1322 }
1323
1324 static HRESULT WINAPI XMLView_OleObject_SetExtent(IOleObject *iface,
1325         DWORD dwDrawAspect, SIZEL *psizel)
1326 {
1327     FIXME("%p, %lx, %p.\n", iface, dwDrawAspect, psizel);
1328     return E_NOTIMPL;
1329 }
1330
1331 static HRESULT WINAPI XMLView_OleObject_GetExtent(IOleObject *iface,
1332         DWORD dwDrawAspect, SIZEL *psizel)
1333 {
1334     FIXME("%p, %lx, %p.\n", iface, dwDrawAspect, psizel);
1335     return E_NOTIMPL;
1336 }
1337
1338 static HRESULT WINAPI XMLView_OleObject_Advise(IOleObject *iface,
1339         IAdviseSink *pAdvSink, DWORD *pdwConnection)
1340 {
1341     XMLView *This = impl_from_IOleObject(iface);
1342     FIXME("(%p)->(%p %p)\n", This, pAdvSink, pdwConnection);
1343     return E_NOTIMPL;
1344 }
1345
1346 static HRESULT WINAPI XMLView_OleObject_Unadvise(
1347         IOleObject *iface, DWORD dwConnection)
1348 {
1349     FIXME("%p, %ld.\n", iface, dwConnection);
1350     return E_NOTIMPL;
1351 }
1352
1353 static HRESULT WINAPI XMLView_OleObject_EnumAdvise(
1354         IOleObject *iface, IEnumSTATDATA **ppenumAdvise)
1355 {
1356     XMLView *This = impl_from_IOleObject(iface);
1357     FIXME("(%p)->(%p)\n", This, ppenumAdvise);
1358     return E_NOTIMPL;
1359 }
1360
1361 static HRESULT WINAPI XMLView_OleObject_GetMiscStatus(
1362         IOleObject *iface, DWORD dwAspect, DWORD *pdwStatus)
1363 {
1364     FIXME("%p, %ld, %p.\n", iface, dwAspect, pdwStatus);
1365     return E_NOTIMPL;
1366 }
1367
1368 static HRESULT WINAPI XMLView_OleObject_SetColorScheme(
1369         IOleObject *iface, LOGPALETTE *pLogpal)
1370 {
1371     XMLView *This = impl_from_IOleObject(iface);
1372     FIXME("(%p)->(%p)\n", This, pLogpal);
1373     return E_NOTIMPL;
1374 }
1375
1376 static IOleObjectVtbl XMLView_OleObjectVtbl = {
1377     XMLView_OleObject_QueryInterface,
1378     XMLView_OleObject_AddRef,
1379     XMLView_OleObject_Release,
1380     XMLView_OleObject_SetClientSite,
1381     XMLView_OleObject_GetClientSite,
1382     XMLView_OleObject_SetHostNames,
1383     XMLView_OleObject_Close,
1384     XMLView_OleObject_SetMoniker,
1385     XMLView_OleObject_GetMoniker,
1386     XMLView_OleObject_InitFromData,
1387     XMLView_OleObject_GetClipboardData,
1388     XMLView_OleObject_DoVerb,
1389     XMLView_OleObject_EnumVerbs,
1390     XMLView_OleObject_Update,
1391     XMLView_OleObject_IsUpToDate,
1392     XMLView_OleObject_GetUserClassID,
1393     XMLView_OleObject_GetUserType,
1394     XMLView_OleObject_SetExtent,
1395     XMLView_OleObject_GetExtent,
1396     XMLView_OleObject_Advise,
1397     XMLView_OleObject_Unadvise,
1398     XMLView_OleObject_EnumAdvise,
1399     XMLView_OleObject_GetMiscStatus,
1400     XMLView_OleObject_SetColorScheme
1401 };
1402
1403 HRESULT XMLView_create(void **ppObj)
1404 {
1405     XMLView *This;
1406     HRESULT hres;
1407
1408     TRACE("(%p)\n", ppObj);
1409
1410     This = heap_alloc_zero(sizeof(*This));
1411     if(!This)
1412         return E_OUTOFMEMORY;
1413
1414     This->IPersistMoniker_iface.lpVtbl = &XMLView_PersistMonikerVtbl;
1415     This->IPersistHistory_iface.lpVtbl = &XMLView_PersistHistoryVtbl;
1416     This->IOleCommandTarget_iface.lpVtbl = &XMLView_OleCommandTargetVtbl;
1417     This->IOleObject_iface.lpVtbl = &XMLView_OleObjectVtbl;
1418     This->ref = 1;
1419
1420     hres = CoCreateInstance(&CLSID_HTMLDocument, (IUnknown*)&This->IPersistMoniker_iface,
1421             CLSCTX_INPROC_SERVER, &IID_IUnknown, (void**)&This->html_doc);
1422     if(FAILED(hres)) {
1423         heap_free(This);
1424         return hres;
1425     }
1426
1427     *ppObj = &This->IPersistMoniker_iface;
1428     return S_OK;
1429 }