dlls/msxml3/xmlview.c

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