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