dlls/msxml3/domdoc.c

   1 /*
   2  *    DOM Document implementation
   3  *
   4  * Copyright 2005 Mike McCormack
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #include <assert.h>
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "winnls.h"
  31 #include "ole2.h"
  32 #include "msxml2.h"
  33 #include "wininet.h"
  34 #include "urlmon.h"
  35 #include "winreg.h"
  36 #include "shlwapi.h"
  37 #include "ocidl.h"
  38 #include "objsafe.h"
  39
  40 #include "wine/debug.h"
  41
  42 #include "msxml_private.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  45
  46 #ifdef HAVE_LIBXML2
  47
  48 static const WCHAR SZ_PROPERTY_SELECTION_LANGUAGE[] = {'S','e','l','e','c','t','i','o','n','L','a','n','g','u','a','g','e',0};
  49 static const WCHAR SZ_VALUE_XPATH[] = {'X','P','a','t','h',0};
  50 static const WCHAR SZ_VALUE_XSLPATTERN[] = {'X','S','L','P','a','t','t','e','r','n',0};
  51
  52 typedef struct {
  53     const struct IBindStatusCallbackVtbl *lpVtbl;
  54 } bsc;
  55
  56 static HRESULT WINAPI bsc_QueryInterface(
  57     IBindStatusCallback *iface,
  58     REFIID riid,
  59     LPVOID *ppobj )
  60 {
  61     if (IsEqualGUID(riid, &IID_IUnknown) ||
  62         IsEqualGUID(riid, &IID_IBindStatusCallback))
  63     {
  64         IBindStatusCallback_AddRef( iface );
  65         *ppobj = iface;
  66         return S_OK;
  67     }
  68
  69     FIXME("interface %s not implemented\n", debugstr_guid(riid));
  70     return E_NOINTERFACE;
  71 }
  72
  73 static ULONG WINAPI bsc_AddRef(
  74     IBindStatusCallback *iface )
  75 {
  76     return 2;
  77 }
  78
  79 static ULONG WINAPI bsc_Release(
  80     IBindStatusCallback *iface )
  81 {
  82     return 1;
  83 }
  84
  85 static HRESULT WINAPI bsc_OnStartBinding(
  86         IBindStatusCallback* iface,
  87         DWORD dwReserved,
  88         IBinding* pib)
  89 {
  90     return S_OK;
  91 }
  92
  93 static HRESULT WINAPI bsc_GetPriority(
  94         IBindStatusCallback* iface,
  95         LONG* pnPriority)
  96 {
  97     return S_OK;
  98 }
  99
 100 static HRESULT WINAPI bsc_OnLowResource(
 101         IBindStatusCallback* iface,
 102         DWORD reserved)
 103 {
 104     return S_OK;
 105 }
 106
 107 static HRESULT WINAPI bsc_OnProgress(
 108         IBindStatusCallback* iface,
 109         ULONG ulProgress,
 110         ULONG ulProgressMax,
 111         ULONG ulStatusCode,
 112         LPCWSTR szStatusText)
 113 {
 114     return S_OK;
 115 }
 116
 117 static HRESULT WINAPI bsc_OnStopBinding(
 118         IBindStatusCallback* iface,
 119         HRESULT hresult,
 120         LPCWSTR szError)
 121 {
 122     return S_OK;
 123 }
 124
 125 static HRESULT WINAPI bsc_GetBindInfo(
 126         IBindStatusCallback* iface,
 127         DWORD* grfBINDF,
 128         BINDINFO* pbindinfo)
 129 {
 130     *grfBINDF = BINDF_RESYNCHRONIZE;
 131
 132     return S_OK;
 133 }
 134
 135 static HRESULT WINAPI bsc_OnDataAvailable(
 136         IBindStatusCallback* iface,
 137         DWORD grfBSCF,
 138         DWORD dwSize,
 139         FORMATETC* pformatetc,
 140         STGMEDIUM* pstgmed)
 141 {
 142     return S_OK;
 143 }
 144
 145 static HRESULT WINAPI bsc_OnObjectAvailable(
 146         IBindStatusCallback* iface,
 147         REFIID riid,
 148         IUnknown* punk)
 149 {
 150     return S_OK;
 151 }
 152
 153 static const struct IBindStatusCallbackVtbl bsc_vtbl =
 154 {
 155     bsc_QueryInterface,
 156     bsc_AddRef,
 157     bsc_Release,
 158     bsc_OnStartBinding,
 159     bsc_GetPriority,
 160     bsc_OnLowResource,
 161     bsc_OnProgress,
 162     bsc_OnStopBinding,
 163     bsc_GetBindInfo,
 164     bsc_OnDataAvailable,
 165     bsc_OnObjectAvailable
 166 };
 167
 168 static bsc domdoc_bsc = { &bsc_vtbl };
 169
 170 typedef struct _domdoc
 171 {
 172     const struct IXMLDOMDocument2Vtbl *lpVtbl;
 173     const struct IPersistStreamVtbl   *lpvtblIPersistStream;
 174     const struct IObjectWithSiteVtbl  *lpvtblIObjectWithSite;
 175     const struct IObjectSafetyVtbl    *lpvtblIObjectSafety;
 176     LONG ref;
 177     VARIANT_BOOL async;
 178     VARIANT_BOOL validating;
 179     VARIANT_BOOL resolving;
 180     VARIANT_BOOL preserving;
 181     BOOL bUseXPath;
 182     IUnknown *node_unk;
 183     IXMLDOMNode *node;
 184     IXMLDOMSchemaCollection *schema;
 185     HRESULT error;
 186
 187      /* IPersistStream */
 188      IStream *stream;
 189
 190      /* IObjectWithSite*/
 191      IUnknown *site;
 192
 193      /* IObjectSafety */
 194      DWORD safeopt;
 195
 196 } domdoc;
 197
 198 LONG xmldoc_add_ref(xmlDocPtr doc)
 199 {
 200     LONG ref = InterlockedIncrement((LONG*)&doc->_private);
 201     TRACE("%d\n", ref);
 202     return ref;
 203 }
 204
 205 LONG xmldoc_release(xmlDocPtr doc)
 206 {
 207     LONG ref = InterlockedDecrement((LONG*)&doc->_private);
 208     TRACE("%d\n", ref);
 209     if(ref == 0)
 210     {
 211         TRACE("freeing docptr %p\n", doc);
 212         xmlFreeDoc(doc);
 213     }
 214
 215     return ref;
 216 }
 217
 218 static inline domdoc *impl_from_IXMLDOMDocument2( IXMLDOMDocument2 *iface )
 219 {
 220     return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpVtbl));
 221 }
 222
 223 static inline xmlDocPtr get_doc( domdoc *This )
 224 {
 225     return (xmlDocPtr) xmlNodePtr_from_domnode( This->node, XML_DOCUMENT_NODE );
 226 }
 227
 228 static inline domdoc *impl_from_IPersistStream(IPersistStream *iface)
 229 {
 230     return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpvtblIPersistStream));
 231 }
 232
 233 static inline domdoc *impl_from_IObjectWithSite(IObjectWithSite *iface)
 234 {
 235     return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpvtblIObjectWithSite));
 236 }
 237
 238 static inline domdoc *impl_from_IObjectSafety(IObjectSafety *iface)
 239 {
 240     return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpvtblIObjectSafety));
 241 }
 242
 243
 244 /************************************************************************
 245  * xmldoc implementation of IPersistStream.
 246  */
 247 static HRESULT WINAPI xmldoc_IPersistStream_QueryInterface(
 248     IPersistStream *iface, REFIID riid, LPVOID *ppvObj)
 249 {
 250     domdoc *this = impl_from_IPersistStream(iface);
 251     return IXMLDocument_QueryInterface((IXMLDocument *)this, riid, ppvObj);
 252 }
 253
 254 static ULONG WINAPI xmldoc_IPersistStream_AddRef(
 255     IPersistStream *iface)
 256 {
 257     domdoc *this = impl_from_IPersistStream(iface);
 258     return IXMLDocument_AddRef((IXMLDocument *)this);
 259 }
 260
 261 static ULONG WINAPI xmldoc_IPersistStream_Release(
 262     IPersistStream *iface)
 263 {
 264     domdoc *this = impl_from_IPersistStream(iface);
 265     return IXMLDocument_Release((IXMLDocument *)this);
 266 }
 267
 268 static HRESULT WINAPI xmldoc_IPersistStream_GetClassID(
 269     IPersistStream *iface, CLSID *classid)
 270 {
 271     TRACE("(%p,%p): stub!\n", iface, classid);
 272
 273     if(!classid)
 274         return E_POINTER;
 275
 276     *classid = CLSID_DOMDocument2;
 277
 278     return S_OK;
 279 }
 280
 281 static HRESULT WINAPI xmldoc_IPersistStream_IsDirty(
 282     IPersistStream *iface)
 283 {
 284     domdoc *This = impl_from_IPersistStream(iface);
 285
 286     FIXME("(%p->%p): stub!\n", iface, This);
 287
 288     return S_FALSE;
 289 }
 290
 291 static HRESULT WINAPI xmldoc_IPersistStream_Load(
 292     IPersistStream *iface, LPSTREAM pStm)
 293 {
 294     domdoc *This = impl_from_IPersistStream(iface);
 295     HRESULT hr;
 296     HGLOBAL hglobal;
 297     DWORD read, written, len;
 298     BYTE buf[4096];
 299     char *ptr;
 300     xmlDocPtr xmldoc = NULL;
 301
 302     TRACE("(%p, %p)\n", iface, pStm);
 303
 304     if (!pStm)
 305         return E_INVALIDARG;
 306
 307     hr = CreateStreamOnHGlobal(NULL, TRUE, &This->stream);
 308     if (FAILED(hr))
 309         return hr;
 310
 311     do
 312     {
 313         IStream_Read(pStm, buf, sizeof(buf), &read);
 314         hr = IStream_Write(This->stream, buf, read, &written);
 315     } while(SUCCEEDED(hr) && written != 0 && read != 0);
 316
 317     if (FAILED(hr))
 318     {
 319         ERR("Failed to copy stream\n");
 320         return hr;
 321     }
 322
 323     hr = GetHGlobalFromStream(This->stream, &hglobal);
 324     if (FAILED(hr))
 325         return hr;
 326
 327     len = GlobalSize(hglobal);
 328     ptr = GlobalLock(hglobal);
 329     if (len != 0)
 330         xmldoc = parse_xml(ptr, len);
 331     GlobalUnlock(hglobal);
 332
 333     if (!xmldoc)
 334     {
 335         ERR("Failed to parse xml\n");
 336         return E_FAIL;
 337     }
 338
 339     attach_xmlnode( This->node, (xmlNodePtr)xmldoc );
 340
 341     return S_OK;
 342 }
 343
 344 static HRESULT WINAPI xmldoc_IPersistStream_Save(
 345     IPersistStream *iface, LPSTREAM pStm, BOOL fClearDirty)
 346 {
 347     FIXME("(%p, %p, %d): stub!\n", iface, pStm, fClearDirty);
 348     return E_NOTIMPL;
 349 }
 350
 351 static HRESULT WINAPI xmldoc_IPersistStream_GetSizeMax(
 352     IPersistStream *iface, ULARGE_INTEGER *pcbSize)
 353 {
 354     TRACE("(%p, %p): stub!\n", iface, pcbSize);
 355     return E_NOTIMPL;
 356 }
 357
 358 static const IPersistStreamVtbl xmldoc_IPersistStream_VTable =
 359 {
 360     xmldoc_IPersistStream_QueryInterface,
 361     xmldoc_IPersistStream_AddRef,
 362     xmldoc_IPersistStream_Release,
 363     xmldoc_IPersistStream_GetClassID,
 364     xmldoc_IPersistStream_IsDirty,
 365     xmldoc_IPersistStream_Load,
 366     xmldoc_IPersistStream_Save,
 367     xmldoc_IPersistStream_GetSizeMax,
 368 };
 369
 370 static HRESULT WINAPI domdoc_QueryInterface( IXMLDOMDocument2 *iface, REFIID riid, void** ppvObject )
 371 {
 372     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 373
 374     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
 375
 376     *ppvObject = NULL;
 377
 378     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
 379          IsEqualGUID( riid, &IID_IDispatch ) ||
 380          IsEqualGUID( riid, &IID_IXMLDOMDocument ) ||
 381          IsEqualGUID( riid, &IID_IXMLDOMDocument2 ) )
 382     {
 383         *ppvObject = iface;
 384     }
 385     else if ( IsEqualGUID( riid, &IID_IXMLDOMNode ) )
 386     {
 387         return IUnknown_QueryInterface(This->node_unk, riid, ppvObject);
 388     }
 389     else if (IsEqualGUID(&IID_IPersistStream, riid))
 390     {
 391         *ppvObject = (IPersistStream*)&(This->lpvtblIPersistStream);
 392     }
 393     else if (IsEqualGUID(&IID_IObjectWithSite, riid))
 394     {
 395         *ppvObject = (IObjectWithSite*)&(This->lpvtblIObjectWithSite);
 396     }
 397     else if(IsEqualGUID(&IID_IRunnableObject, riid))
 398     {
 399         TRACE("IID_IRunnableObject not supported returning NULL\n");
 400         return E_NOINTERFACE;
 401     }
 402     else
 403     {
 404         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 405         return E_NOINTERFACE;
 406     }
 407
 408     IXMLDOMDocument_AddRef( iface );
 409
 410     return S_OK;
 411 }
 412
 413
 414 static ULONG WINAPI domdoc_AddRef(
 415      IXMLDOMDocument2 *iface )
 416 {
 417     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 418     TRACE("%p\n", This );
 419     return InterlockedIncrement( &This->ref );
 420 }
 421
 422
 423 static ULONG WINAPI domdoc_Release(
 424      IXMLDOMDocument2 *iface )
 425 {
 426     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 427     LONG ref;
 428
 429     TRACE("%p\n", This );
 430
 431     ref = InterlockedDecrement( &This->ref );
 432     if ( ref == 0 )
 433     {
 434         if (This->site)
 435             IUnknown_Release( This->site );
 436         IUnknown_Release( This->node_unk );
 437         if(This->schema) IXMLDOMSchemaCollection_Release( This->schema );
 438         if (This->stream) IStream_Release(This->stream);
 439         HeapFree( GetProcessHeap(), 0, This );
 440     }
 441
 442     return ref;
 443 }
 444
 445 static HRESULT WINAPI domdoc_GetTypeInfoCount( IXMLDOMDocument2 *iface, UINT* pctinfo )
 446 {
 447     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 448
 449     TRACE("(%p)->(%p)\n", This, pctinfo);
 450
 451     *pctinfo = 1;
 452
 453     return S_OK;
 454 }
 455
 456 static HRESULT WINAPI domdoc_GetTypeInfo(
 457     IXMLDOMDocument2 *iface,
 458     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
 459 {
 460     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 461     HRESULT hr;
 462
 463     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 464
 465     hr = get_typeinfo(IXMLDOMDocument2_tid, ppTInfo);
 466
 467     return hr;
 468 }
 469
 470 static HRESULT WINAPI domdoc_GetIDsOfNames(
 471     IXMLDOMDocument2 *iface,
 472     REFIID riid,
 473     LPOLESTR* rgszNames,
 474     UINT cNames,
 475     LCID lcid,
 476     DISPID* rgDispId)
 477 {
 478     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 479     ITypeInfo *typeinfo;
 480     HRESULT hr;
 481
 482     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 483           lcid, rgDispId);
 484
 485     if(!rgszNames || cNames == 0 || !rgDispId)
 486         return E_INVALIDARG;
 487
 488     hr = get_typeinfo(IXMLDOMDocument2_tid, &typeinfo);
 489     if(SUCCEEDED(hr))
 490     {
 491         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
 492         ITypeInfo_Release(typeinfo);
 493     }
 494
 495     return hr;
 496 }
 497
 498
 499 static HRESULT WINAPI domdoc_Invoke(
 500     IXMLDOMDocument2 *iface,
 501     DISPID dispIdMember,
 502     REFIID riid,
 503     LCID lcid,
 504     WORD wFlags,
 505     DISPPARAMS* pDispParams,
 506     VARIANT* pVarResult,
 507     EXCEPINFO* pExcepInfo,
 508     UINT* puArgErr)
 509 {
 510     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 511     ITypeInfo *typeinfo;
 512     HRESULT hr;
 513
 514     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 515           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 516
 517     hr = get_typeinfo(IXMLDOMDocument2_tid, &typeinfo);
 518     if(SUCCEEDED(hr))
 519     {
 520         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
 521                 pVarResult, pExcepInfo, puArgErr);
 522         ITypeInfo_Release(typeinfo);
 523     }
 524
 525     return hr;
 526 }
 527
 528
 529 static HRESULT WINAPI domdoc_get_nodeName(
 530     IXMLDOMDocument2 *iface,
 531     BSTR* name )
 532 {
 533     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 534     return IXMLDOMNode_get_nodeName( This->node, name );
 535 }
 536
 537
 538 static HRESULT WINAPI domdoc_get_nodeValue(
 539     IXMLDOMDocument2 *iface,
 540     VARIANT* value )
 541 {
 542     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 543     return IXMLDOMNode_get_nodeValue( This->node, value );
 544 }
 545
 546
 547 static HRESULT WINAPI domdoc_put_nodeValue(
 548     IXMLDOMDocument2 *iface,
 549     VARIANT value)
 550 {
 551     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 552     return IXMLDOMNode_put_nodeValue( This->node, value );
 553 }
 554
 555
 556 static HRESULT WINAPI domdoc_get_nodeType(
 557     IXMLDOMDocument2 *iface,
 558     DOMNodeType* type )
 559 {
 560     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 561     return IXMLDOMNode_get_nodeType( This->node, type );
 562 }
 563
 564
 565 static HRESULT WINAPI domdoc_get_parentNode(
 566     IXMLDOMDocument2 *iface,
 567     IXMLDOMNode** parent )
 568 {
 569     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 570     return IXMLDOMNode_get_parentNode( This->node, parent );
 571 }
 572
 573
 574 static HRESULT WINAPI domdoc_get_childNodes(
 575     IXMLDOMDocument2 *iface,
 576     IXMLDOMNodeList** childList )
 577 {
 578     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 579     return IXMLDOMNode_get_childNodes( This->node, childList );
 580 }
 581
 582
 583 static HRESULT WINAPI domdoc_get_firstChild(
 584     IXMLDOMDocument2 *iface,
 585     IXMLDOMNode** firstChild )
 586 {
 587     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 588     return IXMLDOMNode_get_firstChild( This->node, firstChild );
 589 }
 590
 591
 592 static HRESULT WINAPI domdoc_get_lastChild(
 593     IXMLDOMDocument2 *iface,
 594     IXMLDOMNode** lastChild )
 595 {
 596     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 597     return IXMLDOMNode_get_lastChild( This->node, lastChild );
 598 }
 599
 600
 601 static HRESULT WINAPI domdoc_get_previousSibling(
 602     IXMLDOMDocument2 *iface,
 603     IXMLDOMNode** previousSibling )
 604 {
 605     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 606     return IXMLDOMNode_get_previousSibling( This->node, previousSibling );
 607 }
 608
 609
 610 static HRESULT WINAPI domdoc_get_nextSibling(
 611     IXMLDOMDocument2 *iface,
 612     IXMLDOMNode** nextSibling )
 613 {
 614     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 615     return IXMLDOMNode_get_nextSibling( This->node, nextSibling );
 616 }
 617
 618
 619 static HRESULT WINAPI domdoc_get_attributes(
 620     IXMLDOMDocument2 *iface,
 621     IXMLDOMNamedNodeMap** attributeMap )
 622 {
 623     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 624     return IXMLDOMNode_get_attributes( This->node, attributeMap );
 625 }
 626
 627
 628 static HRESULT WINAPI domdoc_insertBefore(
 629     IXMLDOMDocument2 *iface,
 630     IXMLDOMNode* newChild,
 631     VARIANT refChild,
 632     IXMLDOMNode** outNewChild )
 633 {
 634     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 635     return IXMLDOMNode_insertBefore( This->node, newChild, refChild, outNewChild );
 636 }
 637
 638
 639 static HRESULT WINAPI domdoc_replaceChild(
 640     IXMLDOMDocument2 *iface,
 641     IXMLDOMNode* newChild,
 642     IXMLDOMNode* oldChild,
 643     IXMLDOMNode** outOldChild)
 644 {
 645     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 646     return IXMLDOMNode_replaceChild( This->node, newChild, oldChild, outOldChild );
 647 }
 648
 649
 650 static HRESULT WINAPI domdoc_removeChild(
 651     IXMLDOMDocument2 *iface,
 652     IXMLDOMNode* childNode,
 653     IXMLDOMNode** oldChild)
 654 {
 655     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 656     return IXMLDOMNode_removeChild( This->node, childNode, oldChild );
 657 }
 658
 659
 660 static HRESULT WINAPI domdoc_appendChild(
 661     IXMLDOMDocument2 *iface,
 662     IXMLDOMNode* newChild,
 663     IXMLDOMNode** outNewChild)
 664 {
 665     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 666     return IXMLDOMNode_appendChild( This->node, newChild, outNewChild );
 667 }
 668
 669
 670 static HRESULT WINAPI domdoc_hasChildNodes(
 671     IXMLDOMDocument2 *iface,
 672     VARIANT_BOOL* hasChild)
 673 {
 674     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 675     return IXMLDOMNode_hasChildNodes( This->node, hasChild );
 676 }
 677
 678
 679 static HRESULT WINAPI domdoc_get_ownerDocument(
 680     IXMLDOMDocument2 *iface,
 681     IXMLDOMDocument** DOMDocument)
 682 {
 683     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 684     return IXMLDOMNode_get_ownerDocument( This->node, DOMDocument );
 685 }
 686
 687
 688 static HRESULT WINAPI domdoc_cloneNode(
 689     IXMLDOMDocument2 *iface,
 690     VARIANT_BOOL deep,
 691     IXMLDOMNode** cloneRoot)
 692 {
 693     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 694     return IXMLDOMNode_cloneNode( This->node, deep, cloneRoot );
 695 }
 696
 697
 698 static HRESULT WINAPI domdoc_get_nodeTypeString(
 699     IXMLDOMDocument2 *iface,
 700     BSTR* nodeType )
 701 {
 702     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 703     return IXMLDOMNode_get_nodeTypeString( This->node, nodeType );
 704 }
 705
 706
 707 static HRESULT WINAPI domdoc_get_text(
 708     IXMLDOMDocument2 *iface,
 709     BSTR* text )
 710 {
 711     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 712     return IXMLDOMNode_get_text( This->node, text );
 713 }
 714
 715
 716 static HRESULT WINAPI domdoc_put_text(
 717     IXMLDOMDocument2 *iface,
 718     BSTR text )
 719 {
 720     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 721     return IXMLDOMNode_put_text( This->node, text );
 722 }
 723
 724
 725 static HRESULT WINAPI domdoc_get_specified(
 726     IXMLDOMDocument2 *iface,
 727     VARIANT_BOOL* isSpecified )
 728 {
 729     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 730     return IXMLDOMNode_get_specified( This->node, isSpecified );
 731 }
 732
 733
 734 static HRESULT WINAPI domdoc_get_definition(
 735     IXMLDOMDocument2 *iface,
 736     IXMLDOMNode** definitionNode )
 737 {
 738     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 739     return IXMLDOMNode_get_definition( This->node, definitionNode );
 740 }
 741
 742
 743 static HRESULT WINAPI domdoc_get_nodeTypedValue(
 744     IXMLDOMDocument2 *iface,
 745     VARIANT* typedValue )
 746 {
 747     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 748     return IXMLDOMNode_get_nodeTypedValue( This->node, typedValue );
 749 }
 750
 751 static HRESULT WINAPI domdoc_put_nodeTypedValue(
 752     IXMLDOMDocument2 *iface,
 753     VARIANT typedValue )
 754 {
 755     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 756     return IXMLDOMNode_put_nodeTypedValue( This->node, typedValue );
 757 }
 758
 759
 760 static HRESULT WINAPI domdoc_get_dataType(
 761     IXMLDOMDocument2 *iface,
 762     VARIANT* dataTypeName )
 763 {
 764     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 765     return IXMLDOMNode_get_dataType( This->node, dataTypeName );
 766 }
 767
 768
 769 static HRESULT WINAPI domdoc_put_dataType(
 770     IXMLDOMDocument2 *iface,
 771     BSTR dataTypeName )
 772 {
 773     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 774     return IXMLDOMNode_put_dataType( This->node, dataTypeName );
 775 }
 776
 777
 778 static HRESULT WINAPI domdoc_get_xml(
 779     IXMLDOMDocument2 *iface,
 780     BSTR* xmlString )
 781 {
 782     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 783     return IXMLDOMNode_get_xml( This->node, xmlString );
 784 }
 785
 786
 787 static HRESULT WINAPI domdoc_transformNode(
 788     IXMLDOMDocument2 *iface,
 789     IXMLDOMNode* styleSheet,
 790     BSTR* xmlString )
 791 {
 792     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 793     return IXMLDOMNode_transformNode( This->node, styleSheet, xmlString );
 794 }
 795
 796
 797 static HRESULT WINAPI domdoc_selectNodes(
 798     IXMLDOMDocument2 *iface,
 799     BSTR queryString,
 800     IXMLDOMNodeList** resultList )
 801 {
 802     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 803     return IXMLDOMNode_selectNodes( This->node, queryString, resultList );
 804 }
 805
 806
 807 static HRESULT WINAPI domdoc_selectSingleNode(
 808     IXMLDOMDocument2 *iface,
 809     BSTR queryString,
 810     IXMLDOMNode** resultNode )
 811 {
 812     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 813     return IXMLDOMNode_selectSingleNode( This->node, queryString, resultNode );
 814 }
 815
 816
 817 static HRESULT WINAPI domdoc_get_parsed(
 818     IXMLDOMDocument2 *iface,
 819     VARIANT_BOOL* isParsed )
 820 {
 821     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 822     return IXMLDOMNode_get_parsed( This->node, isParsed );
 823 }
 824
 825
 826 static HRESULT WINAPI domdoc_get_namespaceURI(
 827     IXMLDOMDocument2 *iface,
 828     BSTR* namespaceURI )
 829 {
 830     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 831     return IXMLDOMNode_get_namespaceURI( This->node, namespaceURI );
 832 }
 833
 834
 835 static HRESULT WINAPI domdoc_get_prefix(
 836     IXMLDOMDocument2 *iface,
 837     BSTR* prefixString )
 838 {
 839     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 840     return IXMLDOMNode_get_prefix( This->node, prefixString );
 841 }
 842
 843
 844 static HRESULT WINAPI domdoc_get_baseName(
 845     IXMLDOMDocument2 *iface,
 846     BSTR* nameString )
 847 {
 848     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 849     return IXMLDOMNode_get_baseName( This->node, nameString );
 850 }
 851
 852
 853 static HRESULT WINAPI domdoc_transformNodeToObject(
 854     IXMLDOMDocument2 *iface,
 855     IXMLDOMNode* stylesheet,
 856     VARIANT outputObject)
 857 {
 858     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 859     return IXMLDOMNode_transformNodeToObject( This->node, stylesheet, outputObject );
 860 }
 861
 862
 863 static HRESULT WINAPI domdoc_get_doctype(
 864     IXMLDOMDocument2 *iface,
 865     IXMLDOMDocumentType** documentType )
 866 {
 867     FIXME("\n");
 868     return E_NOTIMPL;
 869 }
 870
 871
 872 static HRESULT WINAPI domdoc_get_implementation(
 873     IXMLDOMDocument2 *iface,
 874     IXMLDOMImplementation** impl )
 875 {
 876     if(!impl)
 877         return E_INVALIDARG;
 878
 879     *impl = (IXMLDOMImplementation*)create_doc_Implementation();
 880
 881     return S_OK;
 882 }
 883
 884 static HRESULT WINAPI domdoc_get_documentElement(
 885     IXMLDOMDocument2 *iface,
 886     IXMLDOMElement** DOMElement )
 887 {
 888     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 889     xmlDocPtr xmldoc = NULL;
 890     xmlNodePtr root = NULL;
 891     IXMLDOMNode *element_node;
 892     HRESULT hr;
 893
 894     TRACE("%p %p\n", This, This->node);
 895
 896     if(!DOMElement)
 897         return E_INVALIDARG;
 898
 899     *DOMElement = NULL;
 900
 901     xmldoc = get_doc( This );
 902
 903     root = xmlDocGetRootElement( xmldoc );
 904     if ( !root )
 905         return S_FALSE;
 906
 907     element_node = create_node( root );
 908     if(!element_node) return S_FALSE;
 909
 910     hr = IXMLDOMNode_QueryInterface(element_node, &IID_IXMLDOMElement, (LPVOID*)DOMElement);
 911     IXMLDOMNode_Release(element_node);
 912
 913     return hr;
 914 }
 915
 916
 917 static HRESULT WINAPI domdoc_put_documentElement(
 918     IXMLDOMDocument2 *iface,
 919     IXMLDOMElement* DOMElement )
 920 {
 921     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 922     IXMLDOMNode *elementNode;
 923     xmlnode *xmlNode;
 924     HRESULT hr;
 925
 926     TRACE("(%p)->(%p)\n", This, DOMElement);
 927
 928     hr = IXMLDOMElement_QueryInterface( DOMElement, &IID_IXMLDOMNode, (void**)&elementNode );
 929     if(FAILED(hr))
 930         return hr;
 931
 932     xmlNode = impl_from_IXMLDOMNode( elementNode );
 933     xmlDocSetRootElement( get_doc(This), xmlNode->node);
 934     IXMLDOMNode_Release( elementNode );
 935
 936     return S_OK;
 937 }
 938
 939
 940 static HRESULT WINAPI domdoc_createElement(
 941     IXMLDOMDocument2 *iface,
 942     BSTR tagname,
 943     IXMLDOMElement** element )
 944 {
 945     xmlNodePtr xmlnode;
 946     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 947     xmlChar *xml_name;
 948     IUnknown *elem_unk;
 949     HRESULT hr;
 950
 951     TRACE("%p->(%s,%p)\n", iface, debugstr_w(tagname), element);
 952
 953     xml_name = xmlChar_from_wchar((WCHAR*)tagname);
 954     xmlnode = xmlNewDocNode(get_doc(This), NULL, xml_name, NULL);
 955
 956     TRACE("created xmlptr %p\n", xmlnode);
 957     elem_unk = create_element(xmlnode, NULL);
 958     HeapFree(GetProcessHeap(), 0, xml_name);
 959
 960     hr = IUnknown_QueryInterface(elem_unk, &IID_IXMLDOMElement, (void **)element);
 961     IUnknown_Release(elem_unk);
 962     TRACE("returning %p\n", *element);
 963     return hr;
 964 }
 965
 966
 967 static HRESULT WINAPI domdoc_createDocumentFragment(
 968     IXMLDOMDocument2 *iface,
 969     IXMLDOMDocumentFragment** docFrag )
 970 {
 971     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 972     xmlNodePtr xmlnode;
 973
 974     TRACE("%p\n", iface);
 975
 976     if(!docFrag)
 977         return E_INVALIDARG;
 978
 979     *docFrag = NULL;
 980
 981     xmlnode = xmlNewDocFragment(get_doc( This ) );
 982
 983     if(!xmlnode)
 984         return E_FAIL;
 985
 986     xmlnode->doc = get_doc( This );
 987
 988     *docFrag = (IXMLDOMDocumentFragment*)create_doc_fragment(xmlnode);
 989
 990     return S_OK;
 991 }
 992
 993
 994 static HRESULT WINAPI domdoc_createTextNode(
 995     IXMLDOMDocument2 *iface,
 996     BSTR data,
 997     IXMLDOMText** text )
 998 {
 999     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1000     xmlNodePtr xmlnode;
1001     xmlChar *xml_content;
1002
1003     TRACE("%p->(%s %p)\n", iface, debugstr_w(data), text);
1004
1005     if(!text)
1006         return E_INVALIDARG;
1007
1008     *text = NULL;
1009
1010     xml_content = xmlChar_from_wchar((WCHAR*)data);
1011     xmlnode = xmlNewText(xml_content);
1012     HeapFree(GetProcessHeap(), 0, xml_content);
1013
1014     if(!xmlnode)
1015         return E_FAIL;
1016
1017     xmlnode->doc = get_doc( This );
1018
1019     *text = (IXMLDOMText*)create_text(xmlnode);
1020
1021     return S_OK;
1022 }
1023
1024
1025 static HRESULT WINAPI domdoc_createComment(
1026     IXMLDOMDocument2 *iface,
1027     BSTR data,
1028     IXMLDOMComment** comment )
1029 {
1030     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1031     xmlNodePtr xmlnode;
1032     xmlChar *xml_content;
1033
1034     TRACE("%p->(%s %p)\n", iface, debugstr_w(data), comment);
1035
1036     if(!comment)
1037         return E_INVALIDARG;
1038
1039     *comment = NULL;
1040
1041     xml_content = xmlChar_from_wchar((WCHAR*)data);
1042     xmlnode = xmlNewComment(xml_content);
1043     HeapFree(GetProcessHeap(), 0, xml_content);
1044
1045     if(!xmlnode)
1046         return E_FAIL;
1047
1048     xmlnode->doc = get_doc( This );
1049
1050     *comment = (IXMLDOMComment*)create_comment(xmlnode);
1051
1052     return S_OK;
1053 }
1054
1055
1056 static HRESULT WINAPI domdoc_createCDATASection(
1057     IXMLDOMDocument2 *iface,
1058     BSTR data,
1059     IXMLDOMCDATASection** cdata )
1060 {
1061     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1062     xmlNodePtr xmlnode;
1063     xmlChar *xml_content;
1064
1065     TRACE("%p->(%s %p)\n", iface, debugstr_w(data), cdata);
1066
1067     if(!cdata)
1068         return E_INVALIDARG;
1069
1070     *cdata = NULL;
1071
1072     xml_content = xmlChar_from_wchar((WCHAR*)data);
1073     xmlnode = xmlNewCDataBlock(get_doc( This ), xml_content, strlen( (char*)xml_content) );
1074     HeapFree(GetProcessHeap(), 0, xml_content);
1075
1076     if(!xmlnode)
1077         return E_FAIL;
1078
1079     xmlnode->doc = get_doc( This );
1080
1081     *cdata = (IXMLDOMCDATASection*)create_cdata(xmlnode);
1082
1083     return S_OK;
1084 }
1085
1086
1087 static HRESULT WINAPI domdoc_createProcessingInstruction(
1088     IXMLDOMDocument2 *iface,
1089     BSTR target,
1090     BSTR data,
1091     IXMLDOMProcessingInstruction** pi )
1092 {
1093 #ifdef HAVE_XMLNEWDOCPI
1094     xmlNodePtr xmlnode;
1095     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1096     xmlChar *xml_target, *xml_content;
1097
1098     TRACE("%p->(%s %s %p)\n", iface, debugstr_w(target), debugstr_w(data), pi);
1099
1100     if(!pi)
1101         return E_INVALIDARG;
1102
1103     if(!target || lstrlenW(target) == 0)
1104         return E_FAIL;
1105
1106     xml_target = xmlChar_from_wchar((WCHAR*)target);
1107     xml_content = xmlChar_from_wchar((WCHAR*)data);
1108
1109     xmlnode = xmlNewDocPI(get_doc(This), xml_target, xml_content);
1110     TRACE("created xmlptr %p\n", xmlnode);
1111     *pi = (IXMLDOMProcessingInstruction*)create_pi(xmlnode);
1112
1113     HeapFree(GetProcessHeap(), 0, xml_content);
1114     HeapFree(GetProcessHeap(), 0, xml_target);
1115
1116     return S_OK;
1117 #else
1118     FIXME("Libxml 2.6.15 or greater required.\n");
1119     return E_NOTIMPL;
1120 #endif
1121 }
1122
1123
1124 static HRESULT WINAPI domdoc_createAttribute(
1125     IXMLDOMDocument2 *iface,
1126     BSTR name,
1127     IXMLDOMAttribute** attribute )
1128 {
1129     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1130     xmlNodePtr xmlnode;
1131     xmlChar *xml_name;
1132
1133     TRACE("%p->(%s %p)\n", iface, debugstr_w(name), attribute);
1134
1135     if(!attribute)
1136         return E_INVALIDARG;
1137
1138     *attribute = NULL;
1139
1140     xml_name = xmlChar_from_wchar((WCHAR*)name);
1141     xmlnode = (xmlNode *)xmlNewProp(NULL, xml_name, NULL);
1142     HeapFree(GetProcessHeap(), 0, xml_name);
1143
1144     if(!xmlnode)
1145         return E_FAIL;
1146
1147     xmlnode->doc = get_doc( This );
1148
1149     *attribute = (IXMLDOMAttribute*)create_attribute(xmlnode);
1150
1151     return S_OK;
1152 }
1153
1154
1155 static HRESULT WINAPI domdoc_createEntityReference(
1156     IXMLDOMDocument2 *iface,
1157     BSTR name,
1158     IXMLDOMEntityReference** entityRef )
1159 {
1160     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1161     xmlNodePtr xmlnode;
1162     xmlChar *xml_name;
1163
1164     TRACE("%p\n", iface);
1165
1166     if(!entityRef)
1167         return E_INVALIDARG;
1168
1169     *entityRef = NULL;
1170
1171     xml_name = xmlChar_from_wchar((WCHAR*)name);
1172     xmlnode = xmlNewReference(get_doc( This ), xml_name );
1173     HeapFree(GetProcessHeap(), 0, xml_name);
1174
1175     if(!xmlnode)
1176         return E_FAIL;
1177
1178     xmlnode->doc = get_doc( This );
1179
1180     *entityRef = (IXMLDOMEntityReference*)create_doc_entity_ref(xmlnode);
1181
1182     return S_OK;
1183 }
1184
1185
1186 static HRESULT WINAPI domdoc_getElementsByTagName(
1187     IXMLDOMDocument2 *iface,
1188     BSTR tagName,
1189     IXMLDOMNodeList** resultList )
1190 {
1191     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1192     LPWSTR szPattern;
1193     HRESULT hr;
1194     TRACE("(%p)->(%s, %p)\n", This, debugstr_w(tagName), resultList);
1195
1196     szPattern = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*(2+lstrlenW(tagName)+1));
1197     szPattern[0] = szPattern[1] = '/';
1198     lstrcpyW(szPattern + 2, tagName);
1199
1200     hr = queryresult_create((xmlNodePtr)get_doc(This), szPattern, resultList);
1201     HeapFree(GetProcessHeap(), 0, szPattern);
1202
1203     return hr;
1204 }
1205
1206 static DOMNodeType get_node_type(VARIANT Type)
1207 {
1208     if(V_VT(&Type) == VT_I4)
1209         return V_I4(&Type);
1210
1211     FIXME("Unsupported variant type %x\n", V_VT(&Type));
1212     return 0;
1213 }
1214
1215 static HRESULT WINAPI domdoc_createNode(
1216     IXMLDOMDocument2 *iface,
1217     VARIANT Type,
1218     BSTR name,
1219     BSTR namespaceURI,
1220     IXMLDOMNode** node )
1221 {
1222     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1223     DOMNodeType node_type;
1224     xmlNodePtr xmlnode = NULL;
1225     xmlChar *xml_name;
1226
1227     TRACE("(%p)->(type,%s,%s,%p)\n", This, debugstr_w(name), debugstr_w(namespaceURI), node);
1228
1229     node_type = get_node_type(Type);
1230     TRACE("node_type %d\n", node_type);
1231
1232     xml_name = xmlChar_from_wchar((WCHAR*)name);
1233
1234     switch(node_type)
1235     {
1236     case NODE_ELEMENT:
1237         xmlnode = xmlNewDocNode(get_doc(This), NULL, xml_name, NULL);
1238         *node = create_node(xmlnode);
1239         TRACE("created %p\n", xmlnode);
1240         break;
1241     case NODE_ATTRIBUTE:
1242         xmlnode = (xmlNode *)xmlNewProp(NULL, xml_name, NULL);
1243         if(xmlnode)
1244         {
1245             xmlnode->doc = get_doc( This );
1246
1247             *node = (IXMLDOMNode*)create_attribute(xmlnode);
1248         }
1249
1250         TRACE("created %p\n", xmlnode);
1251         break;
1252
1253     default:
1254         FIXME("unhandled node type %d\n", node_type);
1255         break;
1256     }
1257
1258     HeapFree(GetProcessHeap(), 0, xml_name);
1259
1260     if(xmlnode && *node)
1261         return S_OK;
1262
1263     return E_FAIL;
1264 }
1265
1266 static HRESULT WINAPI domdoc_nodeFromID(
1267     IXMLDOMDocument2 *iface,
1268     BSTR idString,
1269     IXMLDOMNode** node )
1270 {
1271     FIXME("\n");
1272     return E_NOTIMPL;
1273 }
1274
1275 static xmlDocPtr doparse( char *ptr, int len )
1276 {
1277 #ifdef HAVE_XMLREADMEMORY
1278     /*
1279      * use xmlReadMemory if possible so we can suppress
1280      * writing errors to stderr
1281      */
1282     return xmlReadMemory( ptr, len, NULL, NULL,
1283                           XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NOBLANKS );
1284 #else
1285     return xmlParseMemory( ptr, len );
1286 #endif
1287 }
1288
1289 static xmlDocPtr doread( LPWSTR filename )
1290 {
1291     xmlDocPtr xmldoc = NULL;
1292     HRESULT hr;
1293     IBindCtx *pbc;
1294     IStream *stream, *memstream;
1295     WCHAR url[INTERNET_MAX_URL_LENGTH];
1296     BYTE buf[4096];
1297     DWORD read, written;
1298
1299     TRACE("%s\n", debugstr_w( filename ));
1300
1301     if(!PathIsURLW(filename))
1302     {
1303         WCHAR fullpath[MAX_PATH];
1304         DWORD needed = sizeof(url)/sizeof(WCHAR);
1305
1306         if(!PathSearchAndQualifyW(filename, fullpath, sizeof(fullpath)/sizeof(WCHAR)))
1307         {
1308             WARN("can't find path\n");
1309             return NULL;
1310         }
1311
1312         if(FAILED(UrlCreateFromPathW(fullpath, url, &needed, 0)))
1313         {
1314             ERR("can't create url from path\n");
1315             return NULL;
1316         }
1317         filename = url;
1318     }
1319
1320     hr = CreateBindCtx(0, &pbc);
1321     if(SUCCEEDED(hr))
1322     {
1323         hr = RegisterBindStatusCallback(pbc, (IBindStatusCallback*)&domdoc_bsc.lpVtbl, NULL, 0);
1324         if(SUCCEEDED(hr))
1325         {
1326             IMoniker *moniker;
1327             hr = CreateURLMoniker(NULL, filename, &moniker);
1328             if(SUCCEEDED(hr))
1329             {
1330                 hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (LPVOID*)&stream);
1331                 IMoniker_Release(moniker);
1332             }
1333         }
1334         IBindCtx_Release(pbc);
1335     }
1336     if(FAILED(hr))
1337         return NULL;
1338
1339     hr = CreateStreamOnHGlobal(NULL, TRUE, &memstream);
1340     if(FAILED(hr))
1341     {
1342         IStream_Release(stream);
1343         return NULL;
1344     }
1345
1346     do
1347     {
1348         IStream_Read(stream, buf, sizeof(buf), &read);
1349         hr = IStream_Write(memstream, buf, read, &written);
1350     } while(SUCCEEDED(hr) && written != 0 && read != 0);
1351
1352     if(SUCCEEDED(hr))
1353     {
1354         HGLOBAL hglobal;
1355         hr = GetHGlobalFromStream(memstream, &hglobal);
1356         if(SUCCEEDED(hr))
1357         {
1358             DWORD len = GlobalSize(hglobal);
1359             char *ptr = GlobalLock(hglobal);
1360             if(len != 0)
1361                 xmldoc = doparse( ptr, len );
1362             GlobalUnlock(hglobal);
1363         }
1364     }
1365     IStream_Release(memstream);
1366     IStream_Release(stream);
1367     return xmldoc;
1368 }
1369
1370 static HRESULT WINAPI domdoc_load(
1371     IXMLDOMDocument2 *iface,
1372     VARIANT xmlSource,
1373     VARIANT_BOOL* isSuccessful )
1374 {
1375     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1376     LPWSTR filename = NULL;
1377     xmlDocPtr xmldoc = NULL;
1378     HRESULT hr = S_FALSE;
1379     IXMLDOMDocument2 *pNewDoc = NULL;
1380     IStream *pStream = NULL;
1381
1382     TRACE("type %d\n", V_VT(&xmlSource) );
1383
1384     *isSuccessful = VARIANT_FALSE;
1385
1386     assert( This->node );
1387
1388     attach_xmlnode(This->node, NULL);
1389
1390     switch( V_VT(&xmlSource) )
1391     {
1392     case VT_BSTR:
1393         filename = V_BSTR(&xmlSource);
1394         break;
1395     case VT_UNKNOWN:
1396         hr = IUnknown_QueryInterface(V_UNKNOWN(&xmlSource), &IID_IXMLDOMDocument2, (void**)&pNewDoc);
1397         if(hr == S_OK)
1398         {
1399             if(pNewDoc)
1400             {
1401                 domdoc *newDoc = impl_from_IXMLDOMDocument2( pNewDoc );
1402                 xmldoc = xmlCopyDoc(get_doc(newDoc), 1);
1403                 attach_xmlnode(This->node, (xmlNodePtr) xmldoc);
1404
1405                 *isSuccessful = VARIANT_TRUE;
1406
1407                 return S_OK;
1408             }
1409         }
1410         hr = IUnknown_QueryInterface(V_UNKNOWN(&xmlSource), &IID_IStream, (void**)&pStream);
1411         if(hr == S_OK)
1412         {
1413             IPersistStream *pDocStream;
1414             hr = IUnknown_QueryInterface(iface, &IID_IPersistStream, (void**)&pDocStream);
1415             if(hr == S_OK)
1416             {
1417                 hr = xmldoc_IPersistStream_Load(pDocStream, pStream);
1418                 IStream_Release(pStream);
1419                 if(hr == S_OK)
1420                 {
1421                     *isSuccessful = VARIANT_TRUE;
1422
1423                     TRACE("Using ID_IStream to load Document\n");
1424                     return S_OK;
1425                 }
1426                 else
1427                 {
1428                     ERR("xmldoc_IPersistStream_Load failed (%d)\n", hr);
1429                 }
1430             }
1431             else
1432             {
1433                 ERR("QueryInterface IID_IPersistStream failed (%d)\n", hr);
1434             }
1435         }
1436         else
1437         {
1438             /* ISequentialStream */
1439             FIXME("Unknown type not supported (%d) (%p)(%p)\n", hr, pNewDoc, V_UNKNOWN(&xmlSource)->lpVtbl);
1440         }
1441         break;
1442      default:
1443             FIXME("VT type not supported (%d)\n", V_VT(&xmlSource));
1444      }
1445
1446     TRACE("filename (%s)\n", debugstr_w(filename));
1447
1448     if ( filename )
1449     {
1450         xmldoc = doread( filename );
1451
1452         if ( !xmldoc )
1453             This->error = E_FAIL;
1454         else
1455         {
1456             hr = This->error = S_OK;
1457             *isSuccessful = VARIANT_TRUE;
1458         }
1459     }
1460
1461     if(!xmldoc)
1462         xmldoc = xmlNewDoc(NULL);
1463
1464     xmldoc->_private = 0;
1465     attach_xmlnode(This->node, (xmlNodePtr) xmldoc);
1466
1467     TRACE("ret (%d)\n", hr);
1468
1469     return hr;
1470 }
1471
1472
1473 static HRESULT WINAPI domdoc_get_readyState(
1474     IXMLDOMDocument2 *iface,
1475     long* value )
1476 {
1477     FIXME("\n");
1478     return E_NOTIMPL;
1479 }
1480
1481
1482 static HRESULT WINAPI domdoc_get_parseError(
1483     IXMLDOMDocument2 *iface,
1484     IXMLDOMParseError** errorObj )
1485 {
1486     BSTR error_string = NULL;
1487     static const WCHAR err[] = {'e','r','r','o','r',0};
1488     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1489
1490     FIXME("(%p)->(%p): creating a dummy parseError\n", iface, errorObj);
1491
1492     if(This->error)
1493         error_string = SysAllocString(err);
1494
1495     *errorObj = create_parseError(This->error, NULL, error_string, NULL, 0, 0, 0);
1496     if(!*errorObj) return E_OUTOFMEMORY;
1497     return S_OK;
1498 }
1499
1500
1501 static HRESULT WINAPI domdoc_get_url(
1502     IXMLDOMDocument2 *iface,
1503     BSTR* urlString )
1504 {
1505     FIXME("\n");
1506     return E_NOTIMPL;
1507 }
1508
1509
1510 static HRESULT WINAPI domdoc_get_async(
1511     IXMLDOMDocument2 *iface,
1512     VARIANT_BOOL* isAsync )
1513 {
1514     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1515
1516     TRACE("%p <- %d\n", isAsync, This->async);
1517     *isAsync = This->async;
1518     return S_OK;
1519 }
1520
1521
1522 static HRESULT WINAPI domdoc_put_async(
1523     IXMLDOMDocument2 *iface,
1524     VARIANT_BOOL isAsync )
1525 {
1526     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1527
1528     TRACE("%d\n", isAsync);
1529     This->async = isAsync;
1530     return S_OK;
1531 }
1532
1533
1534 static HRESULT WINAPI domdoc_abort(
1535     IXMLDOMDocument2 *iface )
1536 {
1537     FIXME("\n");
1538     return E_NOTIMPL;
1539 }
1540
1541
1542 static BOOL bstr_to_utf8( BSTR bstr, char **pstr, int *plen )
1543 {
1544     UINT len, blen = SysStringLen( bstr );
1545     LPSTR str;
1546
1547     len = WideCharToMultiByte( CP_UTF8, 0, bstr, blen, NULL, 0, NULL, NULL );
1548     str = HeapAlloc( GetProcessHeap(), 0, len );
1549     if ( !str )
1550         return FALSE;
1551     WideCharToMultiByte( CP_UTF8, 0, bstr, blen, str, len, NULL, NULL );
1552     *plen = len;
1553     *pstr = str;
1554     return TRUE;
1555 }
1556
1557 static HRESULT WINAPI domdoc_loadXML(
1558     IXMLDOMDocument2 *iface,
1559     BSTR bstrXML,
1560     VARIANT_BOOL* isSuccessful )
1561 {
1562     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1563     xmlDocPtr xmldoc = NULL;
1564     char *str;
1565     int len;
1566     HRESULT hr = S_FALSE;
1567
1568     TRACE("%p %s %p\n", This, debugstr_w( bstrXML ), isSuccessful );
1569
1570     assert ( This->node );
1571
1572     attach_xmlnode( This->node, NULL );
1573
1574     if ( isSuccessful )
1575     {
1576         *isSuccessful = VARIANT_FALSE;
1577
1578         if ( bstrXML  && bstr_to_utf8( bstrXML, &str, &len ) )
1579         {
1580             xmldoc = doparse( str, len );
1581             HeapFree( GetProcessHeap(), 0, str );
1582             if ( !xmldoc )
1583                 This->error = E_FAIL;
1584             else
1585             {
1586                 hr = This->error = S_OK;
1587                 *isSuccessful = VARIANT_TRUE;
1588             }
1589         }
1590     }
1591     if(!xmldoc)
1592         xmldoc = xmlNewDoc(NULL);
1593
1594     xmldoc->_private = 0;
1595     attach_xmlnode( This->node, (xmlNodePtr) xmldoc );
1596
1597     return hr;
1598 }
1599
1600
1601 static HRESULT WINAPI domdoc_save(
1602     IXMLDOMDocument2 *iface,
1603     VARIANT destination )
1604 {
1605     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1606     HANDLE handle;
1607     xmlChar *mem;
1608     int size;
1609     HRESULT ret = S_OK;
1610     DWORD written;
1611
1612     TRACE("(%p)->(var(vt %x, %s))\n", This, V_VT(&destination),
1613           V_VT(&destination) == VT_BSTR ? debugstr_w(V_BSTR(&destination)) : NULL);
1614
1615     if(V_VT(&destination) != VT_BSTR && V_VT(&destination) != VT_UNKNOWN)
1616     {
1617         FIXME("Unhandled vt %d\n", V_VT(&destination));
1618         return S_FALSE;
1619     }
1620
1621     if(V_VT(&destination) == VT_UNKNOWN)
1622     {
1623         IUnknown *pUnk = V_UNKNOWN(&destination);
1624         IXMLDOMDocument *pDocument;
1625
1626         ret = IXMLDOMDocument_QueryInterface(pUnk, &IID_IXMLDOMDocument2, (void**)&pDocument);
1627         if(ret == S_OK)
1628         {
1629             BSTR bXML;
1630             VARIANT_BOOL bSuccessful;
1631
1632             ret = IXMLDOMDocument_get_xml(iface, &bXML);
1633             if(ret == S_OK)
1634             {
1635                 ret = IXMLDOMDocument_loadXML(pDocument, bXML, &bSuccessful);
1636
1637                 SysFreeString(bXML);
1638             }
1639
1640             IXMLDOMDocument_Release(pDocument);
1641         }
1642
1643         return ret;
1644     }
1645
1646     handle = CreateFileW( V_BSTR(&destination), GENERIC_WRITE, 0,
1647                           NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
1648     if( handle == INVALID_HANDLE_VALUE )
1649     {
1650         WARN("failed to create file\n");
1651         return S_FALSE;
1652     }
1653
1654     xmlDocDumpMemory(get_doc(This), &mem, &size);
1655     if(!WriteFile(handle, mem, (DWORD)size, &written, NULL) || written != (DWORD)size)
1656     {
1657         WARN("write error\n");
1658         ret = S_FALSE;
1659     }
1660
1661     xmlFree(mem);
1662     CloseHandle(handle);
1663     return ret;
1664 }
1665
1666 static HRESULT WINAPI domdoc_get_validateOnParse(
1667     IXMLDOMDocument2 *iface,
1668     VARIANT_BOOL* isValidating )
1669 {
1670     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1671
1672     TRACE("%p <- %d\n", isValidating, This->validating);
1673     *isValidating = This->validating;
1674     return S_OK;
1675 }
1676
1677
1678 static HRESULT WINAPI domdoc_put_validateOnParse(
1679     IXMLDOMDocument2 *iface,
1680     VARIANT_BOOL isValidating )
1681 {
1682     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1683
1684     TRACE("%d\n", isValidating);
1685     This->validating = isValidating;
1686     return S_OK;
1687 }
1688
1689
1690 static HRESULT WINAPI domdoc_get_resolveExternals(
1691     IXMLDOMDocument2 *iface,
1692     VARIANT_BOOL* isResolving )
1693 {
1694     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1695
1696     TRACE("%p <- %d\n", isResolving, This->resolving);
1697     *isResolving = This->resolving;
1698     return S_OK;
1699 }
1700
1701
1702 static HRESULT WINAPI domdoc_put_resolveExternals(
1703     IXMLDOMDocument2 *iface,
1704     VARIANT_BOOL isResolving )
1705 {
1706     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1707
1708     TRACE("%d\n", isResolving);
1709     This->resolving = isResolving;
1710     return S_OK;
1711 }
1712
1713
1714 static HRESULT WINAPI domdoc_get_preserveWhiteSpace(
1715     IXMLDOMDocument2 *iface,
1716     VARIANT_BOOL* isPreserving )
1717 {
1718     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1719
1720     TRACE("%p <- %d\n", isPreserving, This->preserving);
1721     *isPreserving = This->preserving;
1722     return S_OK;
1723 }
1724
1725
1726 static HRESULT WINAPI domdoc_put_preserveWhiteSpace(
1727     IXMLDOMDocument2 *iface,
1728     VARIANT_BOOL isPreserving )
1729 {
1730     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1731
1732     TRACE("%d\n", isPreserving);
1733     This->preserving = isPreserving;
1734     return S_OK;
1735 }
1736
1737
1738 static HRESULT WINAPI domdoc_put_onReadyStateChange(
1739     IXMLDOMDocument2 *iface,
1740     VARIANT readyStateChangeSink )
1741 {
1742     FIXME("\n");
1743     return E_NOTIMPL;
1744 }
1745
1746
1747 static HRESULT WINAPI domdoc_put_onDataAvailable(
1748     IXMLDOMDocument2 *iface,
1749     VARIANT onDataAvailableSink )
1750 {
1751     FIXME("\n");
1752     return E_NOTIMPL;
1753 }
1754
1755 static HRESULT WINAPI domdoc_put_onTransformNode(
1756     IXMLDOMDocument2 *iface,
1757     VARIANT onTransformNodeSink )
1758 {
1759     FIXME("\n");
1760     return E_NOTIMPL;
1761 }
1762
1763 static HRESULT WINAPI domdoc_get_namespaces(
1764     IXMLDOMDocument2* iface,
1765     IXMLDOMSchemaCollection** schemaCollection )
1766 {
1767     FIXME("\n");
1768     return E_NOTIMPL;
1769 }
1770
1771 static HRESULT WINAPI domdoc_get_schemas(
1772     IXMLDOMDocument2* iface,
1773     VARIANT* var1 )
1774 {
1775     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1776     HRESULT hr = S_FALSE;
1777     IXMLDOMSchemaCollection *cur_schema = This->schema;
1778
1779     TRACE("(%p)->(%p)\n", This, var1);
1780
1781     VariantInit(var1); /* Test shows we don't call VariantClear here */
1782     V_VT(var1) = VT_NULL;
1783
1784     if(cur_schema)
1785     {
1786         hr = IXMLDOMSchemaCollection_QueryInterface(cur_schema, &IID_IDispatch, (void**)&V_DISPATCH(var1));
1787         if(SUCCEEDED(hr))
1788             V_VT(var1) = VT_DISPATCH;
1789     }
1790     return hr;
1791 }
1792
1793 static HRESULT WINAPI domdoc_putref_schemas(
1794     IXMLDOMDocument2* iface,
1795     VARIANT var1)
1796 {
1797     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1798     HRESULT hr = E_FAIL;
1799     IXMLDOMSchemaCollection *new_schema = NULL;
1800
1801     FIXME("(%p): semi-stub\n", This);
1802     switch(V_VT(&var1))
1803     {
1804     case VT_UNKNOWN:
1805         hr = IUnknown_QueryInterface(V_UNKNOWN(&var1), &IID_IXMLDOMSchemaCollection, (void**)&new_schema);
1806         break;
1807
1808     case VT_DISPATCH:
1809         hr = IDispatch_QueryInterface(V_DISPATCH(&var1), &IID_IXMLDOMSchemaCollection, (void**)&new_schema);
1810         break;
1811
1812     case VT_NULL:
1813     case VT_EMPTY:
1814         hr = S_OK;
1815         break;
1816
1817     default:
1818         WARN("Can't get schema from vt %x\n", V_VT(&var1));
1819     }
1820
1821     if(SUCCEEDED(hr))
1822     {
1823         IXMLDOMSchemaCollection *old_schema = InterlockedExchangePointer((void**)&This->schema, new_schema);
1824         if(old_schema) IXMLDOMSchemaCollection_Release(old_schema);
1825     }
1826
1827     return hr;
1828 }
1829
1830 static HRESULT WINAPI domdoc_validate(
1831     IXMLDOMDocument2* iface,
1832     IXMLDOMParseError** err)
1833 {
1834     FIXME("\n");
1835     return E_NOTIMPL;
1836 }
1837
1838 static HRESULT WINAPI domdoc_setProperty(
1839     IXMLDOMDocument2* iface,
1840     BSTR p,
1841     VARIANT var)
1842 {
1843     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1844
1845     if (lstrcmpiW(p, SZ_PROPERTY_SELECTION_LANGUAGE) == 0)
1846     {
1847         VARIANT varStr;
1848         HRESULT hr;
1849         BSTR bstr;
1850
1851         V_VT(&varStr) = VT_EMPTY;
1852         if (V_VT(&var) != VT_BSTR)
1853         {
1854             if (FAILED(hr = VariantChangeType(&varStr, &var, 0, VT_BSTR)))
1855                 return hr;
1856             bstr = V_BSTR(&varStr);
1857         }
1858         else
1859             bstr = V_BSTR(&var);
1860
1861         hr = S_OK;
1862         if (lstrcmpiW(bstr, SZ_VALUE_XPATH) == 0)
1863             This->bUseXPath = TRUE;
1864         else if (lstrcmpiW(bstr, SZ_VALUE_XSLPATTERN) == 0)
1865             This->bUseXPath = FALSE;
1866         else
1867             hr = E_FAIL;
1868
1869         VariantClear(&varStr);
1870         return hr;
1871     }
1872
1873     FIXME("Unknown property %s\n", wine_dbgstr_w(p));
1874     return E_FAIL;
1875 }
1876
1877 static HRESULT WINAPI domdoc_getProperty(
1878     IXMLDOMDocument2* iface,
1879     BSTR p,
1880     VARIANT* var)
1881 {
1882     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1883
1884     if (var == NULL)
1885         return E_INVALIDARG;
1886     if (lstrcmpiW(p, SZ_PROPERTY_SELECTION_LANGUAGE) == 0)
1887     {
1888         V_VT(var) = VT_BSTR;
1889         if (This->bUseXPath)
1890             V_BSTR(var) = SysAllocString(SZ_VALUE_XPATH);
1891         else
1892             V_BSTR(var) = SysAllocString(SZ_VALUE_XSLPATTERN);
1893         return S_OK;
1894     }
1895
1896     FIXME("Unknown property %s\n", wine_dbgstr_w(p));
1897     return E_FAIL;
1898 }
1899
1900 static const struct IXMLDOMDocument2Vtbl domdoc_vtbl =
1901 {
1902     domdoc_QueryInterface,
1903     domdoc_AddRef,
1904     domdoc_Release,
1905     domdoc_GetTypeInfoCount,
1906     domdoc_GetTypeInfo,
1907     domdoc_GetIDsOfNames,
1908     domdoc_Invoke,
1909     domdoc_get_nodeName,
1910     domdoc_get_nodeValue,
1911     domdoc_put_nodeValue,
1912     domdoc_get_nodeType,
1913     domdoc_get_parentNode,
1914     domdoc_get_childNodes,
1915     domdoc_get_firstChild,
1916     domdoc_get_lastChild,
1917     domdoc_get_previousSibling,
1918     domdoc_get_nextSibling,
1919     domdoc_get_attributes,
1920     domdoc_insertBefore,
1921     domdoc_replaceChild,
1922     domdoc_removeChild,
1923     domdoc_appendChild,
1924     domdoc_hasChildNodes,
1925     domdoc_get_ownerDocument,
1926     domdoc_cloneNode,
1927     domdoc_get_nodeTypeString,
1928     domdoc_get_text,
1929     domdoc_put_text,
1930     domdoc_get_specified,
1931     domdoc_get_definition,
1932     domdoc_get_nodeTypedValue,
1933     domdoc_put_nodeTypedValue,
1934     domdoc_get_dataType,
1935     domdoc_put_dataType,
1936     domdoc_get_xml,
1937     domdoc_transformNode,
1938     domdoc_selectNodes,
1939     domdoc_selectSingleNode,
1940     domdoc_get_parsed,
1941     domdoc_get_namespaceURI,
1942     domdoc_get_prefix,
1943     domdoc_get_baseName,
1944     domdoc_transformNodeToObject,
1945     domdoc_get_doctype,
1946     domdoc_get_implementation,
1947     domdoc_get_documentElement,
1948     domdoc_put_documentElement,
1949     domdoc_createElement,
1950     domdoc_createDocumentFragment,
1951     domdoc_createTextNode,
1952     domdoc_createComment,
1953     domdoc_createCDATASection,
1954     domdoc_createProcessingInstruction,
1955     domdoc_createAttribute,
1956     domdoc_createEntityReference,
1957     domdoc_getElementsByTagName,
1958     domdoc_createNode,
1959     domdoc_nodeFromID,
1960     domdoc_load,
1961     domdoc_get_readyState,
1962     domdoc_get_parseError,
1963     domdoc_get_url,
1964     domdoc_get_async,
1965     domdoc_put_async,
1966     domdoc_abort,
1967     domdoc_loadXML,
1968     domdoc_save,
1969     domdoc_get_validateOnParse,
1970     domdoc_put_validateOnParse,
1971     domdoc_get_resolveExternals,
1972     domdoc_put_resolveExternals,
1973     domdoc_get_preserveWhiteSpace,
1974     domdoc_put_preserveWhiteSpace,
1975     domdoc_put_onReadyStateChange,
1976     domdoc_put_onDataAvailable,
1977     domdoc_put_onTransformNode,
1978     domdoc_get_namespaces,
1979     domdoc_get_schemas,
1980     domdoc_putref_schemas,
1981     domdoc_validate,
1982     domdoc_setProperty,
1983     domdoc_getProperty
1984 };
1985
1986 /* xmldoc implementation of IObjectWithSite */
1987 static HRESULT WINAPI
1988 xmldoc_ObjectWithSite_QueryInterface( IObjectWithSite* iface, REFIID riid, void** ppvObject )
1989 {
1990     domdoc *This = impl_from_IObjectWithSite(iface);
1991     return IXMLDocument_QueryInterface( (IXMLDocument *)This, riid, ppvObject );
1992 }
1993
1994 static ULONG WINAPI
1995 xmldoc_ObjectWithSite_AddRef( IObjectWithSite* iface )
1996 {
1997     domdoc *This = impl_from_IObjectWithSite(iface);
1998     return IXMLDocument_AddRef((IXMLDocument *)This);
1999 }
2000
2001 static ULONG WINAPI
2002 xmldoc_ObjectWithSite_Release( IObjectWithSite* iface )
2003 {
2004     domdoc *This = impl_from_IObjectWithSite(iface);
2005     return IXMLDocument_Release((IXMLDocument *)This);
2006 }
2007
2008 static HRESULT WINAPI
2009 xmldoc_GetSite( IObjectWithSite *iface, REFIID iid, void ** ppvSite )
2010 {
2011     domdoc *This = impl_from_IObjectWithSite(iface);
2012
2013     TRACE("%p %s %p\n", This, debugstr_guid( iid ), ppvSite );
2014
2015     if ( !This->site )
2016         return E_FAIL;
2017
2018     return IUnknown_QueryInterface( This->site, iid, ppvSite );
2019 }
2020
2021 static HRESULT WINAPI
2022 xmldoc_SetSite( IObjectWithSite *iface, IUnknown *punk )
2023 {
2024     domdoc *This = impl_from_IObjectWithSite(iface);
2025
2026     TRACE("%p %p\n", iface, punk);
2027
2028     if(!punk)
2029     {
2030         if(This->site)
2031         {
2032             IUnknown_Release( This->site );
2033             This->site = NULL;
2034         }
2035
2036         return S_OK;
2037     }
2038
2039     if ( punk )
2040         IUnknown_AddRef( punk );
2041
2042     if(This->site)
2043         IUnknown_Release( This->site );
2044
2045     This->site = punk;
2046
2047     return S_OK;
2048 }
2049
2050 static const IObjectWithSiteVtbl domdocObjectSite =
2051 {
2052     xmldoc_ObjectWithSite_QueryInterface,
2053     xmldoc_ObjectWithSite_AddRef,
2054     xmldoc_ObjectWithSite_Release,
2055     xmldoc_SetSite,
2056     xmldoc_GetSite,
2057 };
2058
2059 static HRESULT WINAPI xmldoc_Safety_QueryInterface(IObjectSafety *iface, REFIID riid, void **ppv)
2060 {
2061     domdoc *This = impl_from_IObjectSafety(iface);
2062     return IXMLDocument_QueryInterface( (IXMLDocument *)This, riid, ppv );
2063 }
2064
2065 static ULONG WINAPI xmldoc_Safety_AddRef(IObjectSafety *iface)
2066 {
2067     domdoc *This = impl_from_IObjectSafety(iface);
2068     return IXMLDocument_AddRef((IXMLDocument *)This);
2069 }
2070
2071 static ULONG WINAPI xmldoc_Safety_Release(IObjectSafety *iface)
2072 {
2073     domdoc *This = impl_from_IObjectSafety(iface);
2074     return IXMLDocument_Release((IXMLDocument *)This);
2075 }
2076
2077 #define SUPPORTED_OPTIONS (INTERFACESAFE_FOR_UNTRUSTED_CALLER|INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_SECURITY_MANAGER)
2078
2079 static HRESULT WINAPI xmldoc_Safety_GetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
2080         DWORD *pdwSupportedOptions, DWORD *pdwEnabledOptions)
2081 {
2082     domdoc *This = impl_from_IObjectSafety(iface);
2083
2084     TRACE("(%p)->(%s %p %p)\n", This, debugstr_guid(riid), pdwSupportedOptions, pdwEnabledOptions);
2085
2086     if(!pdwSupportedOptions || !pdwEnabledOptions)
2087         return E_POINTER;
2088
2089     *pdwSupportedOptions = SUPPORTED_OPTIONS;
2090     *pdwEnabledOptions = This->safeopt;
2091
2092     return S_OK;
2093 }
2094
2095 static HRESULT WINAPI xmldoc_Safety_SetInterfaceSafetyOptions(IObjectSafety *iface, REFIID riid,
2096         DWORD dwOptionSetMask, DWORD dwEnabledOptions)
2097 {
2098     domdoc *This = impl_from_IObjectSafety(iface);
2099
2100     TRACE("(%p)->(%s %x %x)\n", This, debugstr_guid(riid), dwOptionSetMask, dwEnabledOptions);
2101
2102     if(dwOptionSetMask & ~SUPPORTED_OPTIONS)
2103         return E_FAIL;
2104
2105     This->safeopt = dwEnabledOptions & dwEnabledOptions;
2106     return S_OK;
2107 }
2108
2109 static const IObjectSafetyVtbl domdocObjectSafetyVtbl = {
2110     xmldoc_Safety_QueryInterface,
2111     xmldoc_Safety_AddRef,
2112     xmldoc_Safety_Release,
2113     xmldoc_Safety_GetInterfaceSafetyOptions,
2114     xmldoc_Safety_SetInterfaceSafetyOptions
2115 };
2116
2117 HRESULT DOMDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2118 {
2119     domdoc *doc;
2120     HRESULT hr;
2121     xmlDocPtr xmldoc;
2122
2123     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
2124
2125     doc = HeapAlloc( GetProcessHeap(), 0, sizeof (*doc) );
2126     if( !doc )
2127         return E_OUTOFMEMORY;
2128
2129     doc->lpVtbl = &domdoc_vtbl;
2130     doc->lpvtblIPersistStream = &xmldoc_IPersistStream_VTable;
2131     doc->lpvtblIObjectWithSite = &domdocObjectSite;
2132     doc->lpvtblIObjectSafety = &domdocObjectSafetyVtbl;
2133     doc->ref = 1;
2134     doc->async = 0;
2135     doc->validating = 0;
2136     doc->resolving = 0;
2137     doc->preserving = 0;
2138     doc->bUseXPath = FALSE;
2139     doc->error = S_OK;
2140     doc->schema = NULL;
2141     doc->stream = NULL;
2142     doc->site = NULL;
2143     doc->safeopt = 0;
2144
2145     xmldoc = xmlNewDoc(NULL);
2146     if(!xmldoc)
2147     {
2148         HeapFree(GetProcessHeap(), 0, doc);
2149         return E_OUTOFMEMORY;
2150     }
2151
2152     xmldoc->_private = 0;
2153
2154     doc->node_unk = create_basic_node( (xmlNodePtr)xmldoc, (IUnknown*)&doc->lpVtbl );
2155     if(!doc->node_unk)
2156     {
2157         xmlFreeDoc(xmldoc);
2158         HeapFree(GetProcessHeap(), 0, doc);
2159         return E_FAIL;
2160     }
2161
2162     hr = IUnknown_QueryInterface(doc->node_unk, &IID_IXMLDOMNode, (LPVOID*)&doc->node);
2163     if(FAILED(hr))
2164     {
2165         IUnknown_Release(doc->node_unk);
2166         HeapFree( GetProcessHeap(), 0, doc );
2167         return E_FAIL;
2168     }
2169     /* The ref on doc->node is actually looped back into this object, so release it */
2170     IXMLDOMNode_Release(doc->node);
2171
2172     *ppObj = &doc->lpVtbl;
2173
2174     TRACE("returning iface %p\n", *ppObj);
2175     return S_OK;
2176 }
2177
2178 #else
2179
2180 HRESULT DOMDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj)
2181 {
2182     MESSAGE("This program tried to use a DOMDocument object, but\n"
2183             "libxml2 support was not present at compile time.\n");
2184     return E_NOTIMPL;
2185 }
2186
2187 #endif