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