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