git.oblomov.eu Git - wine/blob - 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
  38 #include "wine/debug.h"
  39
  40 #include "msxml_private.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  43
  44 #ifdef HAVE_LIBXML2
  45
  46 typedef struct {
  47     const struct IBindStatusCallbackVtbl *lpVtbl;
  48 } bsc;
  49
  50 static HRESULT WINAPI bsc_QueryInterface(
  51     IBindStatusCallback *iface,
  52     REFIID riid,
  53     LPVOID *ppobj )
  54 {
  55     if (IsEqualGUID(riid, &IID_IUnknown) ||
  56         IsEqualGUID(riid, &IID_IBindStatusCallback))
  57     {
  58         IBindStatusCallback_AddRef( iface );
  59         *ppobj = iface;
  60         return S_OK;
  61     }
  62
  63     FIXME("interface %s not implemented\n", debugstr_guid(riid));
  64     return E_NOINTERFACE;
  65 }
  66
  67 static ULONG WINAPI bsc_AddRef(
  68     IBindStatusCallback *iface )
  69 {
  70     return 2;
  71 }
  72
  73 static ULONG WINAPI bsc_Release(
  74     IBindStatusCallback *iface )
  75 {
  76     return 1;
  77 }
  78
  79 static HRESULT WINAPI bsc_OnStartBinding(
  80         IBindStatusCallback* iface,
  81         DWORD dwReserved,
  82         IBinding* pib)
  83 {
  84     return S_OK;
  85 }
  86
  87 static HRESULT WINAPI bsc_GetPriority(
  88         IBindStatusCallback* iface,
  89         LONG* pnPriority)
  90 {
  91     return S_OK;
  92 }
  93
  94 static HRESULT WINAPI bsc_OnLowResource(
  95         IBindStatusCallback* iface,
  96         DWORD reserved)
  97 {
  98     return S_OK;
  99 }
 100
 101 static HRESULT WINAPI bsc_OnProgress(
 102         IBindStatusCallback* iface,
 103         ULONG ulProgress,
 104         ULONG ulProgressMax,
 105         ULONG ulStatusCode,
 106         LPCWSTR szStatusText)
 107 {
 108     return S_OK;
 109 }
 110
 111 static HRESULT WINAPI bsc_OnStopBinding(
 112         IBindStatusCallback* iface,
 113         HRESULT hresult,
 114         LPCWSTR szError)
 115 {
 116     return S_OK;
 117 }
 118
 119 static HRESULT WINAPI bsc_GetBindInfo(
 120         IBindStatusCallback* iface,
 121         DWORD* grfBINDF,
 122         BINDINFO* pbindinfo)
 123 {
 124     *grfBINDF = BINDF_RESYNCHRONIZE;
 125
 126     return S_OK;
 127 }
 128
 129 static HRESULT WINAPI bsc_OnDataAvailable(
 130         IBindStatusCallback* iface,
 131         DWORD grfBSCF,
 132         DWORD dwSize,
 133         FORMATETC* pformatetc,
 134         STGMEDIUM* pstgmed)
 135 {
 136     return S_OK;
 137 }
 138
 139 static HRESULT WINAPI bsc_OnObjectAvailable(
 140         IBindStatusCallback* iface,
 141         REFIID riid,
 142         IUnknown* punk)
 143 {
 144     return S_OK;
 145 }
 146
 147 static const struct IBindStatusCallbackVtbl bsc_vtbl =
 148 {
 149     bsc_QueryInterface,
 150     bsc_AddRef,
 151     bsc_Release,
 152     bsc_OnStartBinding,
 153     bsc_GetPriority,
 154     bsc_OnLowResource,
 155     bsc_OnProgress,
 156     bsc_OnStopBinding,
 157     bsc_GetBindInfo,
 158     bsc_OnDataAvailable,
 159     bsc_OnObjectAvailable
 160 };
 161
 162 static bsc domdoc_bsc = { &bsc_vtbl };
 163
 164 typedef struct _domdoc
 165 {
 166     const struct IXMLDOMDocument2Vtbl *lpVtbl;
 167     LONG ref;
 168     VARIANT_BOOL async;
 169     VARIANT_BOOL validating;
 170     VARIANT_BOOL resolving;
 171     VARIANT_BOOL preserving;
 172     IUnknown *node_unk;
 173     IXMLDOMNode *node;
 174     IXMLDOMSchemaCollection *schema;
 175     HRESULT error;
 176 } domdoc;
 177
 178 LONG xmldoc_add_ref(xmlDocPtr doc)
 179 {
 180     LONG ref = InterlockedIncrement((LONG*)&doc->_private);
 181     TRACE("%d\n", ref);
 182     return ref;
 183 }
 184
 185 LONG xmldoc_release(xmlDocPtr doc)
 186 {
 187     LONG ref = InterlockedDecrement((LONG*)&doc->_private);
 188     TRACE("%d\n", ref);
 189     if(ref == 0)
 190     {
 191         TRACE("freeing docptr %p\n", doc);
 192         xmlFreeDoc(doc);
 193     }
 194
 195     return ref;
 196 }
 197
 198 static inline domdoc *impl_from_IXMLDOMDocument2( IXMLDOMDocument2 *iface )
 199 {
 200     return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpVtbl));
 201 }
 202
 203 static inline xmlDocPtr get_doc( domdoc *This )
 204 {
 205     return (xmlDocPtr) xmlNodePtr_from_domnode( This->node, XML_DOCUMENT_NODE );
 206 }
 207
 208 static HRESULT WINAPI domdoc_QueryInterface( IXMLDOMDocument2 *iface, REFIID riid, void** ppvObject )
 209 {
 210     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 211
 212     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
 213
 214     if ( IsEqualGUID( riid, &IID_IUnknown ) ||
 215          IsEqualGUID( riid, &IID_IXMLDOMDocument ) ||
 216          IsEqualGUID( riid, &IID_IXMLDOMDocument2 ) )
 217     {
 218         *ppvObject = iface;
 219     }
 220     else if ( IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
 221               IsEqualGUID( riid, &IID_IDispatch ) )
 222     {
 223         return IUnknown_QueryInterface(This->node_unk, riid, ppvObject);
 224     }
 225     else
 226     {
 227         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 228         return E_NOINTERFACE;
 229     }
 230
 231     IXMLDOMDocument_AddRef( iface );
 232
 233     return S_OK;
 234 }
 235
 236
 237 static ULONG WINAPI domdoc_AddRef(
 238      IXMLDOMDocument2 *iface )
 239 {
 240     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 241     TRACE("%p\n", This );
 242     return InterlockedIncrement( &This->ref );
 243 }
 244
 245
 246 static ULONG WINAPI domdoc_Release(
 247      IXMLDOMDocument2 *iface )
 248 {
 249     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 250     LONG ref;
 251
 252     TRACE("%p\n", This );
 253
 254     ref = InterlockedDecrement( &This->ref );
 255     if ( ref == 0 )
 256     {
 257         IUnknown_Release( This->node_unk );
 258         if(This->schema) IXMLDOMSchemaCollection_Release( This->schema );
 259         HeapFree( GetProcessHeap(), 0, This );
 260     }
 261
 262     return ref;
 263 }
 264
 265 static HRESULT WINAPI domdoc_GetTypeInfoCount( IXMLDOMDocument2 *iface, UINT* pctinfo )
 266 {
 267     FIXME("\n");
 268     return E_NOTIMPL;
 269 }
 270
 271 static HRESULT WINAPI domdoc_GetTypeInfo(
 272     IXMLDOMDocument2 *iface,
 273     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
 274 {
 275     FIXME("\n");
 276     return E_NOTIMPL;
 277 }
 278
 279 static HRESULT WINAPI domdoc_GetIDsOfNames(
 280     IXMLDOMDocument2 *iface,
 281     REFIID riid,
 282     LPOLESTR* rgszNames,
 283     UINT cNames,
 284     LCID lcid,
 285     DISPID* rgDispId)
 286 {
 287     FIXME("\n");
 288     return E_NOTIMPL;
 289 }
 290
 291
 292 static HRESULT WINAPI domdoc_Invoke(
 293     IXMLDOMDocument2 *iface,
 294     DISPID dispIdMember,
 295     REFIID riid,
 296     LCID lcid,
 297     WORD wFlags,
 298     DISPPARAMS* pDispParams,
 299     VARIANT* pVarResult,
 300     EXCEPINFO* pExcepInfo,
 301     UINT* puArgErr)
 302 {
 303     FIXME("\n");
 304     return E_NOTIMPL;
 305 }
 306
 307
 308 static HRESULT WINAPI domdoc_get_nodeName(
 309     IXMLDOMDocument2 *iface,
 310     BSTR* name )
 311 {
 312     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 313     return IXMLDOMNode_get_nodeName( This->node, name );
 314 }
 315
 316
 317 static HRESULT WINAPI domdoc_get_nodeValue(
 318     IXMLDOMDocument2 *iface,
 319     VARIANT* value )
 320 {
 321     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 322     return IXMLDOMNode_get_nodeValue( This->node, value );
 323 }
 324
 325
 326 static HRESULT WINAPI domdoc_put_nodeValue(
 327     IXMLDOMDocument2 *iface,
 328     VARIANT value)
 329 {
 330     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 331     return IXMLDOMNode_put_nodeValue( This->node, value );
 332 }
 333
 334
 335 static HRESULT WINAPI domdoc_get_nodeType(
 336     IXMLDOMDocument2 *iface,
 337     DOMNodeType* type )
 338 {
 339     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 340     return IXMLDOMNode_get_nodeType( This->node, type );
 341 }
 342
 343
 344 static HRESULT WINAPI domdoc_get_parentNode(
 345     IXMLDOMDocument2 *iface,
 346     IXMLDOMNode** parent )
 347 {
 348     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 349     return IXMLDOMNode_get_parentNode( This->node, parent );
 350 }
 351
 352
 353 static HRESULT WINAPI domdoc_get_childNodes(
 354     IXMLDOMDocument2 *iface,
 355     IXMLDOMNodeList** childList )
 356 {
 357     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 358     return IXMLDOMNode_get_childNodes( This->node, childList );
 359 }
 360
 361
 362 static HRESULT WINAPI domdoc_get_firstChild(
 363     IXMLDOMDocument2 *iface,
 364     IXMLDOMNode** firstChild )
 365 {
 366     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 367     return IXMLDOMNode_get_firstChild( This->node, firstChild );
 368 }
 369
 370
 371 static HRESULT WINAPI domdoc_get_lastChild(
 372     IXMLDOMDocument2 *iface,
 373     IXMLDOMNode** lastChild )
 374 {
 375     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 376     return IXMLDOMNode_get_lastChild( This->node, lastChild );
 377 }
 378
 379
 380 static HRESULT WINAPI domdoc_get_previousSibling(
 381     IXMLDOMDocument2 *iface,
 382     IXMLDOMNode** previousSibling )
 383 {
 384     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 385     return IXMLDOMNode_get_previousSibling( This->node, previousSibling );
 386 }
 387
 388
 389 static HRESULT WINAPI domdoc_get_nextSibling(
 390     IXMLDOMDocument2 *iface,
 391     IXMLDOMNode** nextSibling )
 392 {
 393     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 394     return IXMLDOMNode_get_nextSibling( This->node, nextSibling );
 395 }
 396
 397
 398 static HRESULT WINAPI domdoc_get_attributes(
 399     IXMLDOMDocument2 *iface,
 400     IXMLDOMNamedNodeMap** attributeMap )
 401 {
 402     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 403     return IXMLDOMNode_get_attributes( This->node, attributeMap );
 404 }
 405
 406
 407 static HRESULT WINAPI domdoc_insertBefore(
 408     IXMLDOMDocument2 *iface,
 409     IXMLDOMNode* newChild,
 410     VARIANT refChild,
 411     IXMLDOMNode** outNewChild )
 412 {
 413     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 414     return IXMLDOMNode_insertBefore( This->node, newChild, refChild, outNewChild );
 415 }
 416
 417
 418 static HRESULT WINAPI domdoc_replaceChild(
 419     IXMLDOMDocument2 *iface,
 420     IXMLDOMNode* newChild,
 421     IXMLDOMNode* oldChild,
 422     IXMLDOMNode** outOldChild)
 423 {
 424     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 425     return IXMLDOMNode_replaceChild( This->node, newChild, oldChild, outOldChild );
 426 }
 427
 428
 429 static HRESULT WINAPI domdoc_removeChild(
 430     IXMLDOMDocument2 *iface,
 431     IXMLDOMNode* childNode,
 432     IXMLDOMNode** oldChild)
 433 {
 434     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 435     return IXMLDOMNode_removeChild( This->node, childNode, oldChild );
 436 }
 437
 438
 439 static HRESULT WINAPI domdoc_appendChild(
 440     IXMLDOMDocument2 *iface,
 441     IXMLDOMNode* newChild,
 442     IXMLDOMNode** outNewChild)
 443 {
 444     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 445     return IXMLDOMNode_appendChild( This->node, newChild, outNewChild );
 446 }
 447
 448
 449 static HRESULT WINAPI domdoc_hasChildNodes(
 450     IXMLDOMDocument2 *iface,
 451     VARIANT_BOOL* hasChild)
 452 {
 453     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 454     return IXMLDOMNode_hasChildNodes( This->node, hasChild );
 455 }
 456
 457
 458 static HRESULT WINAPI domdoc_get_ownerDocument(
 459     IXMLDOMDocument2 *iface,
 460     IXMLDOMDocument** DOMDocument)
 461 {
 462     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 463     return IXMLDOMNode_get_ownerDocument( This->node, DOMDocument );
 464 }
 465
 466
 467 static HRESULT WINAPI domdoc_cloneNode(
 468     IXMLDOMDocument2 *iface,
 469     VARIANT_BOOL deep,
 470     IXMLDOMNode** cloneRoot)
 471 {
 472     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 473     return IXMLDOMNode_cloneNode( This->node, deep, cloneRoot );
 474 }
 475
 476
 477 static HRESULT WINAPI domdoc_get_nodeTypeString(
 478     IXMLDOMDocument2 *iface,
 479     BSTR* nodeType )
 480 {
 481     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 482     return IXMLDOMNode_get_nodeTypeString( This->node, nodeType );
 483 }
 484
 485
 486 static HRESULT WINAPI domdoc_get_text(
 487     IXMLDOMDocument2 *iface,
 488     BSTR* text )
 489 {
 490     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 491     return IXMLDOMNode_get_text( This->node, text );
 492 }
 493
 494
 495 static HRESULT WINAPI domdoc_put_text(
 496     IXMLDOMDocument2 *iface,
 497     BSTR text )
 498 {
 499     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 500     return IXMLDOMNode_put_text( This->node, text );
 501 }
 502
 503
 504 static HRESULT WINAPI domdoc_get_specified(
 505     IXMLDOMDocument2 *iface,
 506     VARIANT_BOOL* isSpecified )
 507 {
 508     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 509     return IXMLDOMNode_get_specified( This->node, isSpecified );
 510 }
 511
 512
 513 static HRESULT WINAPI domdoc_get_definition(
 514     IXMLDOMDocument2 *iface,
 515     IXMLDOMNode** definitionNode )
 516 {
 517     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 518     return IXMLDOMNode_get_definition( This->node, definitionNode );
 519 }
 520
 521
 522 static HRESULT WINAPI domdoc_get_nodeTypedValue(
 523     IXMLDOMDocument2 *iface,
 524     VARIANT* typedValue )
 525 {
 526     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 527     return IXMLDOMNode_get_nodeTypedValue( This->node, typedValue );
 528 }
 529
 530 static HRESULT WINAPI domdoc_put_nodeTypedValue(
 531     IXMLDOMDocument2 *iface,
 532     VARIANT typedValue )
 533 {
 534     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 535     return IXMLDOMNode_put_nodeTypedValue( This->node, typedValue );
 536 }
 537
 538
 539 static HRESULT WINAPI domdoc_get_dataType(
 540     IXMLDOMDocument2 *iface,
 541     VARIANT* dataTypeName )
 542 {
 543     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 544     return IXMLDOMNode_get_dataType( This->node, dataTypeName );
 545 }
 546
 547
 548 static HRESULT WINAPI domdoc_put_dataType(
 549     IXMLDOMDocument2 *iface,
 550     BSTR dataTypeName )
 551 {
 552     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 553     return IXMLDOMNode_put_dataType( This->node, dataTypeName );
 554 }
 555
 556
 557 static HRESULT WINAPI domdoc_get_xml(
 558     IXMLDOMDocument2 *iface,
 559     BSTR* xmlString )
 560 {
 561     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 562     return IXMLDOMNode_get_xml( This->node, xmlString );
 563 }
 564
 565
 566 static HRESULT WINAPI domdoc_transformNode(
 567     IXMLDOMDocument2 *iface,
 568     IXMLDOMNode* styleSheet,
 569     BSTR* xmlString )
 570 {
 571     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 572     return IXMLDOMNode_transformNode( This->node, styleSheet, xmlString );
 573 }
 574
 575
 576 static HRESULT WINAPI domdoc_selectNodes(
 577     IXMLDOMDocument2 *iface,
 578     BSTR queryString,
 579     IXMLDOMNodeList** resultList )
 580 {
 581     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 582     return IXMLDOMNode_selectNodes( This->node, queryString, resultList );
 583 }
 584
 585
 586 static HRESULT WINAPI domdoc_selectSingleNode(
 587     IXMLDOMDocument2 *iface,
 588     BSTR queryString,
 589     IXMLDOMNode** resultNode )
 590 {
 591     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 592     return IXMLDOMNode_selectSingleNode( This->node, queryString, resultNode );
 593 }
 594
 595
 596 static HRESULT WINAPI domdoc_get_parsed(
 597     IXMLDOMDocument2 *iface,
 598     VARIANT_BOOL* isParsed )
 599 {
 600     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 601     return IXMLDOMNode_get_parsed( This->node, isParsed );
 602 }
 603
 604
 605 static HRESULT WINAPI domdoc_get_namespaceURI(
 606     IXMLDOMDocument2 *iface,
 607     BSTR* namespaceURI )
 608 {
 609     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 610     return IXMLDOMNode_get_namespaceURI( This->node, namespaceURI );
 611 }
 612
 613
 614 static HRESULT WINAPI domdoc_get_prefix(
 615     IXMLDOMDocument2 *iface,
 616     BSTR* prefixString )
 617 {
 618     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 619     return IXMLDOMNode_get_prefix( This->node, prefixString );
 620 }
 621
 622
 623 static HRESULT WINAPI domdoc_get_baseName(
 624     IXMLDOMDocument2 *iface,
 625     BSTR* nameString )
 626 {
 627     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 628     return IXMLDOMNode_get_baseName( This->node, nameString );
 629 }
 630
 631
 632 static HRESULT WINAPI domdoc_transformNodeToObject(
 633     IXMLDOMDocument2 *iface,
 634     IXMLDOMNode* stylesheet,
 635     VARIANT outputObject)
 636 {
 637     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 638     return IXMLDOMNode_transformNodeToObject( This->node, stylesheet, outputObject );
 639 }
 640
 641
 642 static HRESULT WINAPI domdoc_get_doctype(
 643     IXMLDOMDocument2 *iface,
 644     IXMLDOMDocumentType** documentType )
 645 {
 646     FIXME("\n");
 647     return E_NOTIMPL;
 648 }
 649
 650
 651 static HRESULT WINAPI domdoc_get_implementation(
 652     IXMLDOMDocument2 *iface,
 653     IXMLDOMImplementation** impl )
 654 {
 655     FIXME("\n");
 656     return E_NOTIMPL;
 657 }
 658
 659 static HRESULT WINAPI domdoc_get_documentElement(
 660     IXMLDOMDocument2 *iface,
 661     IXMLDOMElement** DOMElement )
 662 {
 663     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 664     xmlDocPtr xmldoc = NULL;
 665     xmlNodePtr root = NULL;
 666     IXMLDOMNode *element_node;
 667     HRESULT hr;
 668
 669     TRACE("%p\n", This);
 670
 671     *DOMElement = NULL;
 672
 673     xmldoc = get_doc( This );
 674
 675     root = xmlDocGetRootElement( xmldoc );
 676     if ( !root )
 677         return S_FALSE;
 678
 679     element_node = create_node( root );
 680     if(!element_node) return S_FALSE;
 681
 682     hr = IXMLDOMNode_QueryInterface(element_node, &IID_IXMLDOMElement, (LPVOID*)DOMElement);
 683     IXMLDOMNode_Release(element_node);
 684
 685     return hr;
 686 }
 687
 688
 689 static HRESULT WINAPI domdoc_documentElement(
 690     IXMLDOMDocument2 *iface,
 691     IXMLDOMElement* DOMElement )
 692 {
 693     FIXME("\n");
 694     return E_NOTIMPL;
 695 }
 696
 697
 698 static HRESULT WINAPI domdoc_createElement(
 699     IXMLDOMDocument2 *iface,
 700     BSTR tagname,
 701     IXMLDOMElement** element )
 702 {
 703     xmlNodePtr xmlnode;
 704     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 705     xmlChar *xml_name;
 706     IUnknown *elem_unk;
 707     HRESULT hr;
 708
 709     TRACE("%p->(%s,%p)\n", iface, debugstr_w(tagname), element);
 710
 711     xml_name = xmlChar_from_wchar((WCHAR*)tagname);
 712     xmlnode = xmlNewDocNode(get_doc(This), NULL, xml_name, NULL);
 713
 714     TRACE("created xmlptr %p\n", xmlnode);
 715     elem_unk = create_element(xmlnode, NULL);
 716     HeapFree(GetProcessHeap(), 0, xml_name);
 717
 718     hr = IUnknown_QueryInterface(elem_unk, &IID_IXMLDOMElement, (void **)element);
 719     IUnknown_Release(elem_unk);
 720     TRACE("returning %p\n", *element);
 721     return hr;
 722 }
 723
 724
 725 static HRESULT WINAPI domdoc_createDocumentFragment(
 726     IXMLDOMDocument2 *iface,
 727     IXMLDOMDocumentFragment** docFrag )
 728 {
 729     FIXME("\n");
 730     return E_NOTIMPL;
 731 }
 732
 733
 734 static HRESULT WINAPI domdoc_createTextNode(
 735     IXMLDOMDocument2 *iface,
 736     BSTR data,
 737     IXMLDOMText** text )
 738 {
 739     FIXME("\n");
 740     return E_NOTIMPL;
 741 }
 742
 743
 744 static HRESULT WINAPI domdoc_createComment(
 745     IXMLDOMDocument2 *iface,
 746     BSTR data,
 747     IXMLDOMComment** comment )
 748 {
 749     FIXME("\n");
 750     return E_NOTIMPL;
 751 }
 752
 753
 754 static HRESULT WINAPI domdoc_createCDATASection(
 755     IXMLDOMDocument2 *iface,
 756     BSTR data,
 757     IXMLDOMCDATASection** cdata )
 758 {
 759     FIXME("\n");
 760     return E_NOTIMPL;
 761 }
 762
 763
 764 static HRESULT WINAPI domdoc_createProcessingInstruction(
 765     IXMLDOMDocument2 *iface,
 766     BSTR target,
 767     BSTR data,
 768     IXMLDOMProcessingInstruction** pi )
 769 {
 770 #ifdef HAVE_XMLNEWDOCPI
 771     xmlNodePtr xmlnode;
 772     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 773     xmlChar *xml_target, *xml_content;
 774
 775     TRACE("%p->(%s %s %p)\n", iface, debugstr_w(target), debugstr_w(data), pi);
 776
 777     xml_target = xmlChar_from_wchar((WCHAR*)target);
 778     xml_content = xmlChar_from_wchar((WCHAR*)data);
 779
 780     xmlnode = xmlNewDocPI(get_doc(This), xml_target, xml_content);
 781     TRACE("created xmlptr %p\n", xmlnode);
 782     *pi = (IXMLDOMProcessingInstruction*)create_pi(xmlnode);
 783
 784     HeapFree(GetProcessHeap(), 0, xml_content);
 785     HeapFree(GetProcessHeap(), 0, xml_target);
 786
 787     return S_OK;
 788 #else
 789     FIXME("Libxml 2.6.15 or greater required.\n");
 790     return E_NOTIMPL;
 791 #endif
 792 }
 793
 794
 795 static HRESULT WINAPI domdoc_createAttribute(
 796     IXMLDOMDocument2 *iface,
 797     BSTR name,
 798     IXMLDOMAttribute** attribute )
 799 {
 800     FIXME("\n");
 801     return E_NOTIMPL;
 802 }
 803
 804
 805 static HRESULT WINAPI domdoc_createEntityReference(
 806     IXMLDOMDocument2 *iface,
 807     BSTR name,
 808     IXMLDOMEntityReference** entityRef )
 809 {
 810     FIXME("\n");
 811     return E_NOTIMPL;
 812 }
 813
 814
 815 static HRESULT WINAPI domdoc_getElementsByTagName(
 816     IXMLDOMDocument2 *iface,
 817     BSTR tagName,
 818     IXMLDOMNodeList** resultList )
 819 {
 820     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 821     xmlChar *name;
 822     TRACE("(%p)->(%s, %p)\n", This, debugstr_w(tagName), resultList);
 823
 824     name = xmlChar_from_wchar((WCHAR*)tagName);
 825     *resultList = create_filtered_nodelist((xmlNodePtr)get_doc(This), name, TRUE);
 826     HeapFree(GetProcessHeap(), 0, name);
 827
 828     if(!*resultList) return S_FALSE;
 829     return S_OK;
 830 }
 831
 832 static DOMNodeType get_node_type(VARIANT Type)
 833 {
 834     if(V_VT(&Type) == VT_I4)
 835         return V_I4(&Type);
 836
 837     FIXME("Unsupported variant type %x\n", V_VT(&Type));
 838     return 0;
 839 }
 840
 841 static HRESULT WINAPI domdoc_createNode(
 842     IXMLDOMDocument2 *iface,
 843     VARIANT Type,
 844     BSTR name,
 845     BSTR namespaceURI,
 846     IXMLDOMNode** node )
 847 {
 848     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 849     DOMNodeType node_type;
 850     xmlNodePtr xmlnode = NULL;
 851     xmlChar *xml_name;
 852
 853     TRACE("(%p)->(type,%s,%s,%p)\n", This, debugstr_w(name), debugstr_w(namespaceURI), node);
 854
 855     node_type = get_node_type(Type);
 856     TRACE("node_type %d\n", node_type);
 857
 858     xml_name = xmlChar_from_wchar((WCHAR*)name);
 859
 860     switch(node_type)
 861     {
 862     case NODE_ELEMENT:
 863         xmlnode = xmlNewDocNode(get_doc(This), NULL, xml_name, NULL);
 864         *node = create_node(xmlnode);
 865         TRACE("created %p\n", xmlnode);
 866         break;
 867
 868     default:
 869         FIXME("unhandled node type %d\n", node_type);
 870         break;
 871     }
 872
 873     HeapFree(GetProcessHeap(), 0, xml_name);
 874
 875     if(xmlnode && *node)
 876         return S_OK;
 877
 878     return E_FAIL;
 879 }
 880
 881 static HRESULT WINAPI domdoc_nodeFromID(
 882     IXMLDOMDocument2 *iface,
 883     BSTR idString,
 884     IXMLDOMNode** node )
 885 {
 886     FIXME("\n");
 887     return E_NOTIMPL;
 888 }
 889
 890 static xmlDocPtr doparse( char *ptr, int len )
 891 {
 892 #ifdef HAVE_XMLREADMEMORY
 893     /*
 894      * use xmlReadMemory if possible so we can suppress
 895      * writing errors to stderr
 896      */
 897     return xmlReadMemory( ptr, len, NULL, NULL,
 898                           XML_PARSE_NOERROR | XML_PARSE_NOWARNING | XML_PARSE_NOBLANKS );
 899 #else
 900     return xmlParseMemory( ptr, len );
 901 #endif
 902 }
 903
 904 static xmlDocPtr doread( LPWSTR filename )
 905 {
 906     xmlDocPtr xmldoc = NULL;
 907     HRESULT hr;
 908     IBindCtx *pbc;
 909     IStream *stream, *memstream;
 910     WCHAR url[INTERNET_MAX_URL_LENGTH];
 911     BYTE buf[4096];
 912     DWORD read, written;
 913
 914     TRACE("%s\n", debugstr_w( filename ));
 915
 916     if(!PathIsURLW(filename))
 917     {
 918         WCHAR fullpath[MAX_PATH];
 919         DWORD needed = sizeof(url)/sizeof(WCHAR);
 920
 921         if(!PathSearchAndQualifyW(filename, fullpath, sizeof(fullpath)/sizeof(WCHAR)))
 922         {
 923             WARN("can't find path\n");
 924             return NULL;
 925         }
 926
 927         if(FAILED(UrlCreateFromPathW(fullpath, url, &needed, 0)))
 928         {
 929             ERR("can't create url from path\n");
 930             return NULL;
 931         }
 932         filename = url;
 933     }
 934
 935     hr = CreateBindCtx(0, &pbc);
 936     if(SUCCEEDED(hr))
 937     {
 938         hr = RegisterBindStatusCallback(pbc, (IBindStatusCallback*)&domdoc_bsc.lpVtbl, NULL, 0);
 939         if(SUCCEEDED(hr))
 940         {
 941             IMoniker *moniker;
 942             hr = CreateURLMoniker(NULL, filename, &moniker);
 943             if(SUCCEEDED(hr))
 944             {
 945                 hr = IMoniker_BindToStorage(moniker, pbc, NULL, &IID_IStream, (LPVOID*)&stream);
 946                 IMoniker_Release(moniker);
 947             }
 948         }
 949         IBindCtx_Release(pbc);
 950     }
 951     if(FAILED(hr))
 952         return NULL;
 953
 954     hr = CreateStreamOnHGlobal(NULL, TRUE, &memstream);
 955     if(FAILED(hr))
 956     {
 957         IStream_Release(stream);
 958         return NULL;
 959     }
 960
 961     do
 962     {
 963         IStream_Read(stream, buf, sizeof(buf), &read);
 964         hr = IStream_Write(memstream, buf, read, &written);
 965     } while(SUCCEEDED(hr) && written != 0 && read != 0);
 966
 967     if(SUCCEEDED(hr))
 968     {
 969         HGLOBAL hglobal;
 970         hr = GetHGlobalFromStream(memstream, &hglobal);
 971         if(SUCCEEDED(hr))
 972         {
 973             DWORD len = GlobalSize(hglobal);
 974             char *ptr = GlobalLock(hglobal);
 975             if(len != 0)
 976                 xmldoc = doparse( ptr, len );
 977             GlobalUnlock(hglobal);
 978         }
 979     }
 980     IStream_Release(memstream);
 981     IStream_Release(stream);
 982     return xmldoc;
 983 }
 984
 985 static HRESULT WINAPI domdoc_load(
 986     IXMLDOMDocument2 *iface,
 987     VARIANT xmlSource,
 988     VARIANT_BOOL* isSuccessful )
 989 {
 990     domdoc *This = impl_from_IXMLDOMDocument2( iface );
 991     LPWSTR filename = NULL;
 992     xmlDocPtr xmldoc = NULL;
 993     HRESULT hr = S_FALSE;
 994
 995     TRACE("type %d\n", V_VT(&xmlSource) );
 996
 997     *isSuccessful = VARIANT_FALSE;
 998
 999     assert( This->node );
1000
1001     attach_xmlnode(This->node, NULL);
1002
1003     switch( V_VT(&xmlSource) )
1004     {
1005     case VT_BSTR:
1006         filename = V_BSTR(&xmlSource);
1007     }
1008
1009     if ( filename )
1010     {
1011         xmldoc = doread( filename );
1012
1013         if ( !xmldoc )
1014             This->error = E_FAIL;
1015         else
1016         {
1017             hr = This->error = S_OK;
1018             *isSuccessful = VARIANT_TRUE;
1019         }
1020     }
1021
1022     if(!xmldoc)
1023         xmldoc = xmlNewDoc(NULL);
1024
1025     xmldoc->_private = 0;
1026     attach_xmlnode(This->node, (xmlNodePtr) xmldoc);
1027
1028     return hr;
1029 }
1030
1031
1032 static HRESULT WINAPI domdoc_get_readyState(
1033     IXMLDOMDocument2 *iface,
1034     long* value )
1035 {
1036     FIXME("\n");
1037     return E_NOTIMPL;
1038 }
1039
1040
1041 static HRESULT WINAPI domdoc_get_parseError(
1042     IXMLDOMDocument2 *iface,
1043     IXMLDOMParseError** errorObj )
1044 {
1045     BSTR error_string = NULL;
1046     static const WCHAR err[] = {'e','r','r','o','r',0};
1047     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1048
1049     FIXME("(%p)->(%p): creating a dummy parseError\n", iface, errorObj);
1050
1051     if(This->error)
1052         error_string = SysAllocString(err);
1053
1054     *errorObj = create_parseError(This->error, NULL, error_string, NULL, 0, 0, 0);
1055     if(!*errorObj) return E_OUTOFMEMORY;
1056     return S_OK;
1057 }
1058
1059
1060 static HRESULT WINAPI domdoc_get_url(
1061     IXMLDOMDocument2 *iface,
1062     BSTR* urlString )
1063 {
1064     FIXME("\n");
1065     return E_NOTIMPL;
1066 }
1067
1068
1069 static HRESULT WINAPI domdoc_get_async(
1070     IXMLDOMDocument2 *iface,
1071     VARIANT_BOOL* isAsync )
1072 {
1073     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1074
1075     TRACE("%p <- %d\n", isAsync, This->async);
1076     *isAsync = This->async;
1077     return S_OK;
1078 }
1079
1080
1081 static HRESULT WINAPI domdoc_put_async(
1082     IXMLDOMDocument2 *iface,
1083     VARIANT_BOOL isAsync )
1084 {
1085     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1086
1087     TRACE("%d\n", isAsync);
1088     This->async = isAsync;
1089     return S_OK;
1090 }
1091
1092
1093 static HRESULT WINAPI domdoc_abort(
1094     IXMLDOMDocument2 *iface )
1095 {
1096     FIXME("\n");
1097     return E_NOTIMPL;
1098 }
1099
1100
1101 static BOOL bstr_to_utf8( BSTR bstr, char **pstr, int *plen )
1102 {
1103     UINT len, blen = SysStringLen( bstr );
1104     LPSTR str;
1105
1106     len = WideCharToMultiByte( CP_UTF8, 0, bstr, blen, NULL, 0, NULL, NULL );
1107     str = HeapAlloc( GetProcessHeap(), 0, len );
1108     if ( !str )
1109         return FALSE;
1110     WideCharToMultiByte( CP_UTF8, 0, bstr, blen, str, len, NULL, NULL );
1111     *plen = len;
1112     *pstr = str;
1113     return TRUE;
1114 }
1115
1116 static HRESULT WINAPI domdoc_loadXML(
1117     IXMLDOMDocument2 *iface,
1118     BSTR bstrXML,
1119     VARIANT_BOOL* isSuccessful )
1120 {
1121     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1122     xmlDocPtr xmldoc = NULL;
1123     char *str;
1124     int len;
1125     HRESULT hr = S_FALSE;
1126
1127     TRACE("%p %s %p\n", This, debugstr_w( bstrXML ), isSuccessful );
1128
1129     assert ( This->node );
1130
1131     attach_xmlnode( This->node, NULL );
1132
1133     if ( isSuccessful )
1134     {
1135         *isSuccessful = VARIANT_FALSE;
1136
1137         if ( bstrXML  && bstr_to_utf8( bstrXML, &str, &len ) )
1138         {
1139             xmldoc = doparse( str, len );
1140             HeapFree( GetProcessHeap(), 0, str );
1141             if ( !xmldoc )
1142                 This->error = E_FAIL;
1143             else
1144             {
1145                 hr = This->error = S_OK;
1146                 *isSuccessful = VARIANT_TRUE;
1147             }
1148         }
1149     }
1150     if(!xmldoc)
1151         xmldoc = xmlNewDoc(NULL);
1152
1153     xmldoc->_private = 0;
1154     attach_xmlnode( This->node, (xmlNodePtr) xmldoc );
1155
1156     return hr;
1157 }
1158
1159
1160 static HRESULT WINAPI domdoc_save(
1161     IXMLDOMDocument2 *iface,
1162     VARIANT destination )
1163 {
1164     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1165     HANDLE handle;
1166     xmlChar *mem;
1167     int size;
1168     HRESULT ret = S_OK;
1169     DWORD written;
1170
1171     TRACE("(%p)->(var(vt %x, %s))\n", This, V_VT(&destination),
1172           V_VT(&destination) == VT_BSTR ? debugstr_w(V_BSTR(&destination)) : NULL);
1173
1174     if(V_VT(&destination) != VT_BSTR)
1175     {
1176         FIXME("Unhandled vt %x\n", V_VT(&destination));
1177         return S_FALSE;
1178     }
1179
1180     handle = CreateFileW( V_BSTR(&destination), GENERIC_WRITE, 0,
1181                           NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
1182     if( handle == INVALID_HANDLE_VALUE )
1183     {
1184         WARN("failed to create file\n");
1185         return S_FALSE;
1186     }
1187
1188     xmlDocDumpMemory(get_doc(This), &mem, &size);
1189     if(!WriteFile(handle, mem, (DWORD)size, &written, NULL) || written != (DWORD)size)
1190     {
1191         WARN("write error\n");
1192         ret = S_FALSE;
1193     }
1194
1195     xmlFree(mem);
1196     CloseHandle(handle);
1197     return ret;
1198 }
1199
1200 static HRESULT WINAPI domdoc_get_validateOnParse(
1201     IXMLDOMDocument2 *iface,
1202     VARIANT_BOOL* isValidating )
1203 {
1204     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1205
1206     TRACE("%p <- %d\n", isValidating, This->validating);
1207     *isValidating = This->validating;
1208     return S_OK;
1209 }
1210
1211
1212 static HRESULT WINAPI domdoc_put_validateOnParse(
1213     IXMLDOMDocument2 *iface,
1214     VARIANT_BOOL isValidating )
1215 {
1216     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1217
1218     TRACE("%d\n", isValidating);
1219     This->validating = isValidating;
1220     return S_OK;
1221 }
1222
1223
1224 static HRESULT WINAPI domdoc_get_resolveExternals(
1225     IXMLDOMDocument2 *iface,
1226     VARIANT_BOOL* isResolving )
1227 {
1228     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1229
1230     TRACE("%p <- %d\n", isResolving, This->resolving);
1231     *isResolving = This->resolving;
1232     return S_OK;
1233 }
1234
1235
1236 static HRESULT WINAPI domdoc_put_resolveExternals(
1237     IXMLDOMDocument2 *iface,
1238     VARIANT_BOOL isResolving )
1239 {
1240     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1241
1242     TRACE("%d\n", isResolving);
1243     This->resolving = isResolving;
1244     return S_OK;
1245 }
1246
1247
1248 static HRESULT WINAPI domdoc_get_preserveWhiteSpace(
1249     IXMLDOMDocument2 *iface,
1250     VARIANT_BOOL* isPreserving )
1251 {
1252     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1253
1254     TRACE("%p <- %d\n", isPreserving, This->preserving);
1255     *isPreserving = This->preserving;
1256     return S_OK;
1257 }
1258
1259
1260 static HRESULT WINAPI domdoc_put_preserveWhiteSpace(
1261     IXMLDOMDocument2 *iface,
1262     VARIANT_BOOL isPreserving )
1263 {
1264     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1265
1266     TRACE("%d\n", isPreserving);
1267     This->preserving = isPreserving;
1268     return S_OK;
1269 }
1270
1271
1272 static HRESULT WINAPI domdoc_put_onReadyStateChange(
1273     IXMLDOMDocument2 *iface,
1274     VARIANT readyStateChangeSink )
1275 {
1276     FIXME("\n");
1277     return E_NOTIMPL;
1278 }
1279
1280
1281 static HRESULT WINAPI domdoc_put_onDataAvailable(
1282     IXMLDOMDocument2 *iface,
1283     VARIANT onDataAvailableSink )
1284 {
1285     FIXME("\n");
1286     return E_NOTIMPL;
1287 }
1288
1289 static HRESULT WINAPI domdoc_put_onTransformNode(
1290     IXMLDOMDocument2 *iface,
1291     VARIANT onTransformNodeSink )
1292 {
1293     FIXME("\n");
1294     return E_NOTIMPL;
1295 }
1296
1297 static HRESULT WINAPI domdoc_get_namespaces(
1298     IXMLDOMDocument2* iface,
1299     IXMLDOMSchemaCollection** schemaCollection )
1300 {
1301     FIXME("\n");
1302     return E_NOTIMPL;
1303 }
1304
1305 static HRESULT WINAPI domdoc_get_schemas(
1306     IXMLDOMDocument2* iface,
1307     VARIANT* var1 )
1308 {
1309     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1310     HRESULT hr = S_FALSE;
1311     IXMLDOMSchemaCollection *cur_schema = This->schema;
1312
1313     TRACE("(%p)->(%p)\n", This, var1);
1314
1315     VariantInit(var1); /* Test shows we don't call VariantClear here */
1316     V_VT(var1) = VT_NULL;
1317
1318     if(cur_schema)
1319     {
1320         hr = IXMLDOMSchemaCollection_QueryInterface(cur_schema, &IID_IDispatch, (void**)&V_DISPATCH(var1));
1321         if(SUCCEEDED(hr))
1322             V_VT(var1) = VT_DISPATCH;
1323     }
1324     return hr;
1325 }
1326
1327 static HRESULT WINAPI domdoc_putref_schemas(
1328     IXMLDOMDocument2* iface,
1329     VARIANT var1)
1330 {
1331     domdoc *This = impl_from_IXMLDOMDocument2( iface );
1332     HRESULT hr = E_FAIL;
1333     IXMLDOMSchemaCollection *new_schema = NULL;
1334
1335     FIXME("(%p): semi-stub\n", This);
1336     switch(V_VT(&var1))
1337     {
1338     case VT_UNKNOWN:
1339         hr = IUnknown_QueryInterface(V_UNKNOWN(&var1), &IID_IXMLDOMSchemaCollection, (void**)&new_schema);
1340         break;
1341
1342     case VT_DISPATCH:
1343         hr = IDispatch_QueryInterface(V_DISPATCH(&var1), &IID_IXMLDOMSchemaCollection, (void**)&new_schema);
1344         break;
1345
1346     case VT_NULL:
1347     case VT_EMPTY:
1348         hr = S_OK;
1349         break;
1350
1351     default:
1352         WARN("Can't get schema from vt %x\n", V_VT(&var1));
1353     }
1354
1355     if(SUCCEEDED(hr))
1356     {
1357         IXMLDOMSchemaCollection *old_schema = InterlockedExchangePointer((void**)&This->schema, new_schema);
1358         if(old_schema) IXMLDOMSchemaCollection_Release(old_schema);
1359     }
1360
1361     return hr;
1362 }
1363
1364 static HRESULT WINAPI domdoc_validate(
1365     IXMLDOMDocument2* iface,
1366     IXMLDOMParseError** err)
1367 {
1368     FIXME("\n");
1369     return E_NOTIMPL;
1370 }
1371
1372 static HRESULT WINAPI domdoc_setProperty(
1373     IXMLDOMDocument2* iface,
1374     BSTR p,
1375     VARIANT var)
1376 {
1377     FIXME("\n");
1378     return E_NOTIMPL;
1379 }
1380
1381 static HRESULT WINAPI domdoc_getProperty(
1382     IXMLDOMDocument2* iface,
1383     BSTR p,
1384     VARIANT* var)
1385 {
1386     FIXME("\n");
1387     return E_NOTIMPL;
1388 }
1389
1390 static const struct IXMLDOMDocument2Vtbl domdoc_vtbl =
1391 {
1392     domdoc_QueryInterface,
1393     domdoc_AddRef,
1394     domdoc_Release,
1395     domdoc_GetTypeInfoCount,
1396     domdoc_GetTypeInfo,
1397     domdoc_GetIDsOfNames,
1398     domdoc_Invoke,
1399     domdoc_get_nodeName,
1400     domdoc_get_nodeValue,
1401     domdoc_put_nodeValue,
1402     domdoc_get_nodeType,
1403     domdoc_get_parentNode,
1404     domdoc_get_childNodes,
1405     domdoc_get_firstChild,
1406     domdoc_get_lastChild,
1407     domdoc_get_previousSibling,
1408     domdoc_get_nextSibling,
1409     domdoc_get_attributes,
1410     domdoc_insertBefore,
1411     domdoc_replaceChild,
1412     domdoc_removeChild,
1413     domdoc_appendChild,
1414     domdoc_hasChildNodes,
1415     domdoc_get_ownerDocument,
1416     domdoc_cloneNode,
1417     domdoc_get_nodeTypeString,
1418     domdoc_get_text,
1419     domdoc_put_text,
1420     domdoc_get_specified,
1421     domdoc_get_definition,
1422     domdoc_get_nodeTypedValue,
1423     domdoc_put_nodeTypedValue,
1424     domdoc_get_dataType,
1425     domdoc_put_dataType,
1426     domdoc_get_xml,
1427     domdoc_transformNode,
1428     domdoc_selectNodes,
1429     domdoc_selectSingleNode,
1430     domdoc_get_parsed,
1431     domdoc_get_namespaceURI,
1432     domdoc_get_prefix,
1433     domdoc_get_baseName,
1434     domdoc_transformNodeToObject,
1435     domdoc_get_doctype,
1436     domdoc_get_implementation,
1437     domdoc_get_documentElement,
1438     domdoc_documentElement,
1439     domdoc_createElement,
1440     domdoc_createDocumentFragment,
1441     domdoc_createTextNode,
1442     domdoc_createComment,
1443     domdoc_createCDATASection,
1444     domdoc_createProcessingInstruction,
1445     domdoc_createAttribute,
1446     domdoc_createEntityReference,
1447     domdoc_getElementsByTagName,
1448     domdoc_createNode,
1449     domdoc_nodeFromID,
1450     domdoc_load,
1451     domdoc_get_readyState,
1452     domdoc_get_parseError,
1453     domdoc_get_url,
1454     domdoc_get_async,
1455     domdoc_put_async,
1456     domdoc_abort,
1457     domdoc_loadXML,
1458     domdoc_save,
1459     domdoc_get_validateOnParse,
1460     domdoc_put_validateOnParse,
1461     domdoc_get_resolveExternals,
1462     domdoc_put_resolveExternals,
1463     domdoc_get_preserveWhiteSpace,
1464     domdoc_put_preserveWhiteSpace,
1465     domdoc_put_onReadyStateChange,
1466     domdoc_put_onDataAvailable,
1467     domdoc_put_onTransformNode,
1468     domdoc_get_namespaces,
1469     domdoc_get_schemas,
1470     domdoc_putref_schemas,
1471     domdoc_validate,
1472     domdoc_setProperty,
1473     domdoc_getProperty
1474 };
1475
1476 HRESULT DOMDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj)
1477 {
1478     domdoc *doc;
1479     HRESULT hr;
1480     xmlDocPtr xmldoc;
1481
1482     TRACE("(%p,%p)\n", pUnkOuter, ppObj);
1483
1484     doc = HeapAlloc( GetProcessHeap(), 0, sizeof (*doc) );
1485     if( !doc )
1486         return E_OUTOFMEMORY;
1487
1488     doc->lpVtbl = &domdoc_vtbl;
1489     doc->ref = 1;
1490     doc->async = 0;
1491     doc->validating = 0;
1492     doc->resolving = 0;
1493     doc->preserving = 0;
1494     doc->error = S_OK;
1495     doc->schema = NULL;
1496
1497     xmldoc = xmlNewDoc(NULL);
1498     if(!xmldoc)
1499     {
1500         HeapFree(GetProcessHeap(), 0, doc);
1501         return E_OUTOFMEMORY;
1502     }
1503
1504     xmldoc->_private = 0;
1505
1506     doc->node_unk = create_basic_node( (xmlNodePtr)xmldoc, (IUnknown*)&doc->lpVtbl );
1507     if(!doc->node_unk)
1508     {
1509         xmlFreeDoc(xmldoc);
1510         HeapFree(GetProcessHeap(), 0, doc);
1511         return E_FAIL;
1512     }
1513
1514     hr = IUnknown_QueryInterface(doc->node_unk, &IID_IXMLDOMNode, (LPVOID*)&doc->node);
1515     if(FAILED(hr))
1516     {
1517         IUnknown_Release(doc->node_unk);
1518         HeapFree( GetProcessHeap(), 0, doc );
1519         return E_FAIL;
1520     }
1521     /* The ref on doc->node is actually looped back into this object, so release it */
1522     IXMLDOMNode_Release(doc->node);
1523
1524     *ppObj = &doc->lpVtbl;
1525
1526     TRACE("returning iface %p\n", *ppObj);
1527     return S_OK;
1528 }
1529
1530 #else
1531
1532 HRESULT DOMDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj)
1533 {
1534     MESSAGE("This program tried to use a DOMDocument object, but\n"
1535             "libxml2 support was not present at compile time.\n");
1536     return E_NOTIMPL;
1537 }
1538
1539 #endif