dlls/msxml3/domdoc.c

   1 /*
   2  *    DOM Document implementation
   3  *
   4  * Copyright 2005 Mike McCormack
   5  *
   6  * iface 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  * iface 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "winnls.h"
  30 #include "ole2.h"
  31 #include "ocidl.h"
  32 #include "msxml.h"
  33 #include "xmldom.h"
  34
  35 #include "wine/debug.h"
  36
  37 #include "msxml_private.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  40
  41 #ifdef HAVE_LIBXML2
  42
  43 typedef struct _domdoc
  44 {
  45     const struct IXMLDOMDocumentVtbl *lpVtbl;
  46     LONG ref;
  47     VARIANT_BOOL async;
  48     IXMLDOMNode *node;
  49 } domdoc;
  50
  51 static inline domdoc *impl_from_IXMLDOMDocument( IXMLDOMDocument *iface )
  52 {
  53     return (domdoc *)((char*)iface - FIELD_OFFSET(domdoc, lpVtbl));
  54 }
  55
  56 static inline xmlDocPtr get_doc( domdoc *This )
  57 {
  58     return (xmlDocPtr) xmlNodePtr_from_domnode( This->node, XML_DOCUMENT_NODE );
  59 }
  60
  61 static HRESULT WINAPI domdoc_QueryInterface( IXMLDOMDocument *iface, REFIID riid, void** ppvObject )
  62 {
  63     domdoc *This = impl_from_IXMLDOMDocument( iface );
  64
  65     TRACE("%p %p %p\n", This, debugstr_guid( riid ), ppvObject );
  66
  67     if ( IsEqualGUID( riid, &IID_IXMLDOMDocument ) ||
  68          IsEqualGUID( riid, &IID_IXMLDOMNode ) ||
  69          IsEqualGUID( riid, &IID_IDispatch ) ||
  70          IsEqualGUID( riid, &IID_IUnknown ) )
  71     {
  72         *ppvObject = iface;
  73     }
  74     else
  75         return E_NOINTERFACE;
  76
  77     IXMLDOMDocument_AddRef( iface );
  78
  79     return S_OK;
  80 }
  81
  82
  83 static ULONG WINAPI domdoc_AddRef(
  84      IXMLDOMDocument *iface )
  85 {
  86     domdoc *This = impl_from_IXMLDOMDocument( iface );
  87     TRACE("%p\n", This );
  88     return InterlockedIncrement( &This->ref );
  89 }
  90
  91
  92 static ULONG WINAPI domdoc_Release(
  93      IXMLDOMDocument *iface )
  94 {
  95     domdoc *This = impl_from_IXMLDOMDocument( iface );
  96     LONG ref;
  97
  98     TRACE("%p\n", This );
  99
 100     ref = InterlockedDecrement( &This->ref );
 101     if ( ref == 0 )
 102     {
 103         if ( This->node )
 104             IXMLDOMElement_Release( This->node );
 105         HeapFree( GetProcessHeap(), 0, This );
 106     }
 107
 108     return ref;
 109 }
 110
 111 static HRESULT WINAPI domdoc_GetTypeInfoCount( IXMLDOMDocument *iface, UINT* pctinfo )
 112 {
 113     FIXME("\n");
 114     return E_NOTIMPL;
 115 }
 116
 117 static HRESULT WINAPI domdoc_GetTypeInfo(
 118     IXMLDOMDocument *iface,
 119     UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo )
 120 {
 121     FIXME("\n");
 122     return E_NOTIMPL;
 123 }
 124
 125 static HRESULT WINAPI domdoc_GetIDsOfNames(
 126     IXMLDOMDocument *iface,
 127     REFIID riid,
 128     LPOLESTR* rgszNames,
 129     UINT cNames,
 130     LCID lcid,
 131     DISPID* rgDispId)
 132 {
 133     FIXME("\n");
 134     return E_NOTIMPL;
 135 }
 136
 137
 138 static HRESULT WINAPI domdoc_Invoke(
 139     IXMLDOMDocument *iface,
 140     DISPID dispIdMember,
 141     REFIID riid,
 142     LCID lcid,
 143     WORD wFlags,
 144     DISPPARAMS* pDispParams,
 145     VARIANT* pVarResult,
 146     EXCEPINFO* pExcepInfo,
 147     UINT* puArgErr)
 148 {
 149     FIXME("\n");
 150     return E_NOTIMPL;
 151 }
 152
 153
 154 static HRESULT WINAPI domdoc_get_nodeName(
 155     IXMLDOMDocument *iface,
 156     BSTR* name )
 157 {
 158     domdoc *This = impl_from_IXMLDOMDocument( iface );
 159     return IXMLDOMNode_get_nodeName( This->node, name );
 160 }
 161
 162
 163 static HRESULT WINAPI domdoc_get_nodeValue(
 164     IXMLDOMDocument *iface,
 165     VARIANT* value )
 166 {
 167     domdoc *This = impl_from_IXMLDOMDocument( iface );
 168     return IXMLDOMNode_get_nodeValue( This->node, value );
 169 }
 170
 171
 172 static HRESULT WINAPI domdoc_put_nodeValue(
 173     IXMLDOMDocument *iface,
 174     VARIANT value)
 175 {
 176     domdoc *This = impl_from_IXMLDOMDocument( iface );
 177     return IXMLDOMNode_put_nodeValue( This->node, value );
 178 }
 179
 180
 181 static HRESULT WINAPI domdoc_get_nodeType(
 182     IXMLDOMDocument *iface,
 183     DOMNodeType* type )
 184 {
 185     domdoc *This = impl_from_IXMLDOMDocument( iface );
 186     return IXMLDOMNode_get_nodeType( This->node, type );
 187 }
 188
 189
 190 static HRESULT WINAPI domdoc_get_parentNode(
 191     IXMLDOMDocument *iface,
 192     IXMLDOMNode** parent )
 193 {
 194     domdoc *This = impl_from_IXMLDOMDocument( iface );
 195     return IXMLDOMNode_get_parentNode( This->node, parent );
 196 }
 197
 198
 199 static HRESULT WINAPI domdoc_get_childNodes(
 200     IXMLDOMDocument *iface,
 201     IXMLDOMNodeList** childList )
 202 {
 203     domdoc *This = impl_from_IXMLDOMDocument( iface );
 204     return IXMLDOMNode_get_childNodes( This->node, childList );
 205 }
 206
 207
 208 static HRESULT WINAPI domdoc_get_firstChild(
 209     IXMLDOMDocument *iface,
 210     IXMLDOMNode** firstChild )
 211 {
 212     domdoc *This = impl_from_IXMLDOMDocument( iface );
 213     return IXMLDOMNode_get_firstChild( This->node, firstChild );
 214 }
 215
 216
 217 static HRESULT WINAPI domdoc_get_lastChild(
 218     IXMLDOMDocument *iface,
 219     IXMLDOMNode** lastChild )
 220 {
 221     domdoc *This = impl_from_IXMLDOMDocument( iface );
 222     return IXMLDOMNode_get_lastChild( This->node, lastChild );
 223 }
 224
 225
 226 static HRESULT WINAPI domdoc_get_previousSibling(
 227     IXMLDOMDocument *iface,
 228     IXMLDOMNode** previousSibling )
 229 {
 230     domdoc *This = impl_from_IXMLDOMDocument( iface );
 231     return IXMLDOMNode_get_previousSibling( This->node, previousSibling );
 232 }
 233
 234
 235 static HRESULT WINAPI domdoc_get_nextSibling(
 236     IXMLDOMDocument *iface,
 237     IXMLDOMNode** nextSibling )
 238 {
 239     domdoc *This = impl_from_IXMLDOMDocument( iface );
 240     return IXMLDOMNode_get_nextSibling( This->node, nextSibling );
 241 }
 242
 243
 244 static HRESULT WINAPI domdoc_get_attributes(
 245     IXMLDOMDocument *iface,
 246     IXMLDOMNamedNodeMap** attributeMap )
 247 {
 248     domdoc *This = impl_from_IXMLDOMDocument( iface );
 249     return IXMLDOMNode_get_attributes( This->node, attributeMap );
 250 }
 251
 252
 253 static HRESULT WINAPI domdoc_insertBefore(
 254     IXMLDOMDocument *iface,
 255     IXMLDOMNode* newChild,
 256     VARIANT refChild,
 257     IXMLDOMNode** outNewChild )
 258 {
 259     domdoc *This = impl_from_IXMLDOMDocument( iface );
 260     return IXMLDOMNode_insertBefore( This->node, newChild, refChild, outNewChild );
 261 }
 262
 263
 264 static HRESULT WINAPI domdoc_replaceChild(
 265     IXMLDOMDocument *iface,
 266     IXMLDOMNode* newChild,
 267     IXMLDOMNode* oldChild,
 268     IXMLDOMNode** outOldChild)
 269 {
 270     domdoc *This = impl_from_IXMLDOMDocument( iface );
 271     return IXMLDOMNode_replaceChild( This->node, newChild, oldChild, outOldChild );
 272 }
 273
 274
 275 static HRESULT WINAPI domdoc_removeChild(
 276     IXMLDOMDocument *iface,
 277     IXMLDOMNode* childNode,
 278     IXMLDOMNode** oldChild)
 279 {
 280     domdoc *This = impl_from_IXMLDOMDocument( iface );
 281     return IXMLDOMNode_removeChild( This->node, childNode, oldChild );
 282 }
 283
 284
 285 static HRESULT WINAPI domdoc_appendChild(
 286     IXMLDOMDocument *iface,
 287     IXMLDOMNode* newChild,
 288     IXMLDOMNode** outNewChild)
 289 {
 290     domdoc *This = impl_from_IXMLDOMDocument( iface );
 291     return IXMLDOMNode_appendChild( This->node, newChild, outNewChild );
 292 }
 293
 294
 295 static HRESULT WINAPI domdoc_hasChildNodes(
 296     IXMLDOMDocument *iface,
 297     VARIANT_BOOL* hasChild)
 298 {
 299     domdoc *This = impl_from_IXMLDOMDocument( iface );
 300     return IXMLDOMNode_hasChildNodes( This->node, hasChild );
 301 }
 302
 303
 304 static HRESULT WINAPI domdoc_get_ownerDocument(
 305     IXMLDOMDocument *iface,
 306     IXMLDOMDocument** DOMDocument)
 307 {
 308     domdoc *This = impl_from_IXMLDOMDocument( iface );
 309     return IXMLDOMNode_get_ownerDocument( This->node, DOMDocument );
 310 }
 311
 312
 313 static HRESULT WINAPI domdoc_cloneNode(
 314     IXMLDOMDocument *iface,
 315     VARIANT_BOOL deep,
 316     IXMLDOMNode** cloneRoot)
 317 {
 318     domdoc *This = impl_from_IXMLDOMDocument( iface );
 319     return IXMLDOMNode_cloneNode( This->node, deep, cloneRoot );
 320 }
 321
 322
 323 static HRESULT WINAPI domdoc_get_nodeTypeString(
 324     IXMLDOMDocument *iface,
 325     BSTR* nodeType )
 326 {
 327     domdoc *This = impl_from_IXMLDOMDocument( iface );
 328     return IXMLDOMNode_get_nodeTypeString( This->node, nodeType );
 329 }
 330
 331
 332 static HRESULT WINAPI domdoc_get_text(
 333     IXMLDOMDocument *iface,
 334     BSTR* text )
 335 {
 336     domdoc *This = impl_from_IXMLDOMDocument( iface );
 337     return IXMLDOMNode_get_text( This->node, text );
 338 }
 339
 340
 341 static HRESULT WINAPI domdoc_put_text(
 342     IXMLDOMDocument *iface,
 343     BSTR text )
 344 {
 345     domdoc *This = impl_from_IXMLDOMDocument( iface );
 346     return IXMLDOMNode_put_text( This->node, text );
 347 }
 348
 349
 350 static HRESULT WINAPI domdoc_get_specified(
 351     IXMLDOMDocument *iface,
 352     VARIANT_BOOL* isSpecified )
 353 {
 354     domdoc *This = impl_from_IXMLDOMDocument( iface );
 355     return IXMLDOMNode_get_specified( This->node, isSpecified );
 356 }
 357
 358
 359 static HRESULT WINAPI domdoc_get_definition(
 360     IXMLDOMDocument *iface,
 361     IXMLDOMNode** definitionNode )
 362 {
 363     domdoc *This = impl_from_IXMLDOMDocument( iface );
 364     return IXMLDOMNode_get_definition( This->node, definitionNode );
 365 }
 366
 367
 368 static HRESULT WINAPI domdoc_get_nodeTypedValue(
 369     IXMLDOMDocument *iface,
 370     VARIANT* typedValue )
 371 {
 372     domdoc *This = impl_from_IXMLDOMDocument( iface );
 373     return IXMLDOMNode_get_nodeTypedValue( This->node, typedValue );
 374 }
 375
 376 static HRESULT WINAPI domdoc_put_nodeTypedValue(
 377     IXMLDOMDocument *iface,
 378     VARIANT typedValue )
 379 {
 380     domdoc *This = impl_from_IXMLDOMDocument( iface );
 381     return IXMLDOMNode_put_nodeTypedValue( This->node, typedValue );
 382 }
 383
 384
 385 static HRESULT WINAPI domdoc_get_dataType(
 386     IXMLDOMDocument *iface,
 387     VARIANT* dataTypeName )
 388 {
 389     domdoc *This = impl_from_IXMLDOMDocument( iface );
 390     return IXMLDOMNode_get_dataType( This->node, dataTypeName );
 391 }
 392
 393
 394 static HRESULT WINAPI domdoc_put_dataType(
 395     IXMLDOMDocument *iface,
 396     BSTR dataTypeName )
 397 {
 398     domdoc *This = impl_from_IXMLDOMDocument( iface );
 399     return IXMLDOMNode_put_dataType( This->node, dataTypeName );
 400 }
 401
 402
 403 static HRESULT WINAPI domdoc_get_xml(
 404     IXMLDOMDocument *iface,
 405     BSTR* xmlString )
 406 {
 407     domdoc *This = impl_from_IXMLDOMDocument( iface );
 408     return IXMLDOMNode_get_xml( This->node, xmlString );
 409 }
 410
 411
 412 static HRESULT WINAPI domdoc_transformNode(
 413     IXMLDOMDocument *iface,
 414     IXMLDOMNode* styleSheet,
 415     BSTR* xmlString )
 416 {
 417     domdoc *This = impl_from_IXMLDOMDocument( iface );
 418     return IXMLDOMNode_transformNode( This->node, styleSheet, xmlString );
 419 }
 420
 421
 422 static HRESULT WINAPI domdoc_selectNodes(
 423     IXMLDOMDocument *iface,
 424     BSTR queryString,
 425     IXMLDOMNodeList** resultList )
 426 {
 427     domdoc *This = impl_from_IXMLDOMDocument( iface );
 428     return IXMLDOMNode_selectNodes( This->node, queryString, resultList );
 429 }
 430
 431
 432 static HRESULT WINAPI domdoc_selectSingleNode(
 433     IXMLDOMDocument *iface,
 434     BSTR queryString,
 435     IXMLDOMNode** resultNode )
 436 {
 437     domdoc *This = impl_from_IXMLDOMDocument( iface );
 438     return IXMLDOMNode_selectSingleNode( This->node, queryString, resultNode );
 439 }
 440
 441
 442 static HRESULT WINAPI domdoc_get_parsed(
 443     IXMLDOMDocument *iface,
 444     VARIANT_BOOL* isParsed )
 445 {
 446     domdoc *This = impl_from_IXMLDOMDocument( iface );
 447     return IXMLDOMNode_get_parsed( This->node, isParsed );
 448 }
 449
 450
 451 static HRESULT WINAPI domdoc_get_namespaceURI(
 452     IXMLDOMDocument *iface,
 453     BSTR* namespaceURI )
 454 {
 455     domdoc *This = impl_from_IXMLDOMDocument( iface );
 456     return IXMLDOMNode_get_namespaceURI( This->node, namespaceURI );
 457 }
 458
 459
 460 static HRESULT WINAPI domdoc_get_prefix(
 461     IXMLDOMDocument *iface,
 462     BSTR* prefixString )
 463 {
 464     domdoc *This = impl_from_IXMLDOMDocument( iface );
 465     return IXMLDOMNode_get_prefix( This->node, prefixString );
 466 }
 467
 468
 469 static HRESULT WINAPI domdoc_get_baseName(
 470     IXMLDOMDocument *iface,
 471     BSTR* nameString )
 472 {
 473     domdoc *This = impl_from_IXMLDOMDocument( iface );
 474     return IXMLDOMNode_get_baseName( This->node, nameString );
 475 }
 476
 477
 478 static HRESULT WINAPI domdoc_transformNodeToObject(
 479     IXMLDOMDocument *iface,
 480     IXMLDOMNode* stylesheet,
 481     VARIANT outputObject)
 482 {
 483     domdoc *This = impl_from_IXMLDOMDocument( iface );
 484     return IXMLDOMNode_transformNodeToObject( This->node, stylesheet, outputObject );
 485 }
 486
 487
 488 static HRESULT WINAPI domdoc_get_doctype(
 489     IXMLDOMDocument *iface,
 490     IXMLDOMDocument** documentType )
 491 {
 492     FIXME("\n");
 493     return E_NOTIMPL;
 494 }
 495
 496
 497 static HRESULT WINAPI domdoc_get_implementation(
 498     IXMLDOMDocument *iface,
 499     IXMLDOMImplementation** impl )
 500 {
 501     FIXME("\n");
 502     return E_NOTIMPL;
 503 }
 504
 505 static HRESULT WINAPI domdoc_get_documentElement(
 506     IXMLDOMDocument *iface,
 507     IXMLDOMElement** DOMElement )
 508 {
 509     domdoc *This = impl_from_IXMLDOMDocument( iface );
 510     xmlDocPtr xmldoc = NULL;
 511     xmlNodePtr root = NULL;
 512
 513     TRACE("%p\n", This);
 514
 515     *DOMElement = NULL;
 516
 517     if ( !This->node )
 518         return S_FALSE;
 519
 520     xmldoc = get_doc( This );
 521     if ( !xmldoc )
 522         return S_FALSE;
 523
 524     root = xmlDocGetRootElement( xmldoc );
 525     if ( !root )
 526         return S_FALSE;
 527
 528     *DOMElement = create_element( root );
 529
 530     return S_OK;
 531 }
 532
 533
 534 static HRESULT WINAPI domdoc_documentElement(
 535     IXMLDOMDocument *iface,
 536     IXMLDOMElement* DOMElement )
 537 {
 538     FIXME("\n");
 539     return E_NOTIMPL;
 540 }
 541
 542
 543 static HRESULT WINAPI domdoc_createElement(
 544     IXMLDOMDocument *iface,
 545     BSTR tagname,
 546     IXMLDOMElement** element )
 547 {
 548     FIXME("\n");
 549     return E_NOTIMPL;
 550 }
 551
 552
 553 static HRESULT WINAPI domdoc_createDocumentFragment(
 554     IXMLDOMDocument *iface,
 555     IXMLDOMDocumentFragment** docFrag )
 556 {
 557     FIXME("\n");
 558     return E_NOTIMPL;
 559 }
 560
 561
 562 static HRESULT WINAPI domdoc_createTextNode(
 563     IXMLDOMDocument *iface,
 564     BSTR data,
 565     IXMLDOMText** text )
 566 {
 567     FIXME("\n");
 568     return E_NOTIMPL;
 569 }
 570
 571
 572 static HRESULT WINAPI domdoc_createComment(
 573     IXMLDOMDocument *iface,
 574     BSTR data,
 575     IXMLDOMComment** comment )
 576 {
 577     FIXME("\n");
 578     return E_NOTIMPL;
 579 }
 580
 581
 582 static HRESULT WINAPI domdoc_createCDATASection(
 583     IXMLDOMDocument *iface,
 584     BSTR data,
 585     IXMLDOMCDATASection** cdata )
 586 {
 587     FIXME("\n");
 588     return E_NOTIMPL;
 589 }
 590
 591
 592 static HRESULT WINAPI domdoc_createProcessingInstruction(
 593     IXMLDOMDocument *iface,
 594     BSTR target,
 595     BSTR data,
 596     IXMLDOMProcessingInstruction** pi )
 597 {
 598     FIXME("\n");
 599     return E_NOTIMPL;
 600 }
 601
 602
 603 static HRESULT WINAPI domdoc_createAttribute(
 604     IXMLDOMDocument *iface,
 605     BSTR name,
 606     IXMLDOMAttribute** attribute )
 607 {
 608     FIXME("\n");
 609     return E_NOTIMPL;
 610 }
 611
 612
 613 static HRESULT WINAPI domdoc_createEntityReference(
 614     IXMLDOMDocument *iface,
 615     BSTR name,
 616     IXMLDOMEntityReference** entityRef )
 617 {
 618     FIXME("\n");
 619     return E_NOTIMPL;
 620 }
 621
 622
 623 static HRESULT WINAPI domdoc_getElementsByTagName(
 624     IXMLDOMDocument *iface,
 625     BSTR tagName,
 626     IXMLDOMNodeList** resultList )
 627 {
 628     FIXME("\n");
 629     return E_NOTIMPL;
 630 }
 631
 632
 633 static HRESULT WINAPI domdoc_createNode(
 634     IXMLDOMDocument *iface,
 635     VARIANT Type,
 636     BSTR name,
 637     BSTR namespaceURI,
 638     IXMLDOMNode** node )
 639 {
 640     FIXME("\n");
 641     return E_NOTIMPL;
 642 }
 643
 644
 645 static HRESULT WINAPI domdoc_nodeFromID(
 646     IXMLDOMDocument *iface,
 647     BSTR idString,
 648     IXMLDOMNode** node )
 649 {
 650     FIXME("\n");
 651     return E_NOTIMPL;
 652 }
 653
 654 static xmlDocPtr doparse( char *ptr, int len )
 655 {
 656 #ifdef HAVE_XMLREADMEMORY
 657     /*
 658      * use xmlReadMemory if possible so we can suppress
 659      * writing errors to stderr
 660      */
 661     return xmlReadMemory( ptr, len, NULL, NULL,
 662                           XML_PARSE_NOERROR | XML_PARSE_NOWARNING );
 663 #else
 664     return xmlParseMemory( ptr, len );
 665 #endif
 666 }
 667
 668 static xmlDocPtr doread( LPWSTR filename )
 669 {
 670     HANDLE handle, mapping;
 671     DWORD len;
 672     xmlDocPtr xmldoc = NULL;
 673     char *ptr;
 674
 675     TRACE("%s\n", debugstr_w( filename ));
 676
 677     handle = CreateFileW( filename, GENERIC_READ, FILE_SHARE_READ,
 678                          NULL, OPEN_EXISTING, 0, NULL );
 679     if( handle == INVALID_HANDLE_VALUE )
 680         return xmldoc;
 681
 682     len = GetFileSize( handle, NULL );
 683     if( len != INVALID_FILE_SIZE || GetLastError() == NO_ERROR )
 684     {
 685         mapping = CreateFileMappingW( handle, NULL, PAGE_READONLY, 0, 0, NULL );
 686         if ( mapping )
 687         {
 688             ptr = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, len );
 689             if ( ptr )
 690             {
 691                 xmldoc = doparse( ptr, len );
 692                 UnmapViewOfFile( ptr );
 693             }
 694             CloseHandle( mapping );
 695         }
 696     }
 697     CloseHandle( handle );
 698
 699     return xmldoc;
 700 }
 701
 702
 703 static HRESULT WINAPI domdoc_load(
 704     IXMLDOMDocument *iface,
 705     VARIANT xmlSource,
 706     VARIANT_BOOL* isSuccessful )
 707 {
 708     domdoc *This = impl_from_IXMLDOMDocument( iface );
 709     LPWSTR filename = NULL;
 710     xmlDocPtr xmldoc;
 711
 712     TRACE("type %d\n", V_VT(&xmlSource) );
 713
 714     if ( This->node )
 715     {
 716         IXMLDOMNode_Release( This->node );
 717         This->node = NULL;
 718     }
 719
 720     switch( V_VT(&xmlSource) )
 721     {
 722     case VT_BSTR:
 723         filename = V_BSTR(&xmlSource);
 724     }
 725
 726     if ( !filename )
 727         return S_FALSE;
 728
 729     xmldoc = doread( filename );
 730     if ( !xmldoc ) {
 731         *isSuccessful = VARIANT_FALSE;
 732         return S_FALSE;
 733     }
 734
 735     This->node = create_node( (xmlNodePtr) xmldoc );
 736     if ( !This->node )
 737     {
 738         *isSuccessful = VARIANT_FALSE;
 739         return S_FALSE;
 740     }
 741
 742     *isSuccessful = VARIANT_TRUE;
 743     return S_OK;
 744 }
 745
 746
 747 static HRESULT WINAPI domdoc_get_readyState(
 748     IXMLDOMDocument *iface,
 749     long* value )
 750 {
 751     FIXME("\n");
 752     return E_NOTIMPL;
 753 }
 754
 755
 756 static HRESULT WINAPI domdoc_get_parseError(
 757     IXMLDOMDocument *iface,
 758     IXMLDOMParseError** errorObj )
 759 {
 760     FIXME("\n");
 761     return E_NOTIMPL;
 762 }
 763
 764
 765 static HRESULT WINAPI domdoc_get_url(
 766     IXMLDOMDocument *iface,
 767     BSTR* urlString )
 768 {
 769     FIXME("\n");
 770     return E_NOTIMPL;
 771 }
 772
 773
 774 static HRESULT WINAPI domdoc_get_async(
 775     IXMLDOMDocument *iface,
 776     VARIANT_BOOL* isAsync )
 777 {
 778     domdoc *This = impl_from_IXMLDOMDocument( iface );
 779
 780     TRACE("%p <- %d\n", isAsync, This->async);
 781     *isAsync = This->async;
 782     return S_OK;
 783 }
 784
 785
 786 static HRESULT WINAPI domdoc_put_async(
 787     IXMLDOMDocument *iface,
 788     VARIANT_BOOL isAsync )
 789 {
 790     domdoc *This = impl_from_IXMLDOMDocument( iface );
 791
 792     TRACE("%d\n", isAsync);
 793     This->async = isAsync;
 794     return S_OK;
 795 }
 796
 797
 798 static HRESULT WINAPI domdoc_abort(
 799     IXMLDOMDocument *iface )
 800 {
 801     FIXME("\n");
 802     return E_NOTIMPL;
 803 }
 804
 805
 806 BOOL bstr_to_utf8( BSTR bstr, char **pstr, int *plen )
 807 {
 808     UINT len, blen = SysStringLen( bstr );
 809     LPSTR str;
 810
 811     len = WideCharToMultiByte( CP_UTF8, 0, bstr, blen, NULL, 0, NULL, NULL );
 812     str = HeapAlloc( GetProcessHeap(), 0, len );
 813     if ( !str )
 814         return FALSE;
 815     WideCharToMultiByte( CP_UTF8, 0, bstr, blen, str, len, NULL, NULL );
 816     *plen = len;
 817     *pstr = str;
 818     return TRUE;
 819 }
 820
 821 static HRESULT WINAPI domdoc_loadXML(
 822     IXMLDOMDocument *iface,
 823     BSTR bstrXML,
 824     VARIANT_BOOL* isSuccessful )
 825 {
 826     domdoc *This = impl_from_IXMLDOMDocument( iface );
 827     xmlDocPtr xmldoc;
 828     char *str;
 829     int len;
 830
 831     TRACE("%p %s %p\n", This, debugstr_w( bstrXML ), isSuccessful );
 832
 833     if ( This->node )
 834     {
 835         IXMLDOMNode_Release( This->node );
 836         This->node = NULL;
 837     }
 838
 839     if ( !isSuccessful )
 840         return S_FALSE;
 841
 842     *isSuccessful = VARIANT_FALSE;
 843
 844     if ( !bstrXML )
 845         return S_FALSE;
 846
 847     if ( !bstr_to_utf8( bstrXML, &str, &len ) )
 848         return S_FALSE;
 849
 850     xmldoc = doparse( str, len );
 851     HeapFree( GetProcessHeap(), 0, str );
 852
 853     This->node = create_node( (xmlNodePtr) xmldoc );
 854     if( !This->node )
 855         return S_FALSE;
 856
 857     *isSuccessful = VARIANT_TRUE;
 858     return S_OK;
 859 }
 860
 861
 862 static HRESULT WINAPI domdoc_save(
 863     IXMLDOMDocument *iface,
 864     VARIANT destination )
 865 {
 866     FIXME("\n");
 867     return E_NOTIMPL;
 868 }
 869
 870 static HRESULT WINAPI domdoc_get_validateOnParse(
 871     IXMLDOMDocument *iface,
 872     VARIANT_BOOL* isValidating )
 873 {
 874     FIXME("\n");
 875     return E_NOTIMPL;
 876 }
 877
 878
 879 static HRESULT WINAPI domdoc_put_validateOnParse(
 880     IXMLDOMDocument *iface,
 881     VARIANT_BOOL isValidating )
 882 {
 883     FIXME("\n");
 884     return E_NOTIMPL;
 885 }
 886
 887
 888 static HRESULT WINAPI domdoc_get_resolveExternals(
 889     IXMLDOMDocument *iface,
 890     VARIANT_BOOL* isResolving )
 891 {
 892     FIXME("\n");
 893     return E_NOTIMPL;
 894 }
 895
 896
 897 static HRESULT WINAPI domdoc_put_resolveExternals(
 898     IXMLDOMDocument *iface,
 899     VARIANT_BOOL isValidating )
 900 {
 901     FIXME("\n");
 902     return E_NOTIMPL;
 903 }
 904
 905
 906 static HRESULT WINAPI domdoc_get_preserveWhiteSpace(
 907     IXMLDOMDocument *iface,
 908     VARIANT_BOOL* isPreserving )
 909 {
 910     FIXME("\n");
 911     return E_NOTIMPL;
 912 }
 913
 914
 915 static HRESULT WINAPI domdoc_put_preserveWhiteSpace(
 916     IXMLDOMDocument *iface,
 917     VARIANT_BOOL isPreserving )
 918 {
 919     FIXME("\n");
 920     return E_NOTIMPL;
 921 }
 922
 923
 924 static HRESULT WINAPI domdoc_put_onReadyStateChange(
 925     IXMLDOMDocument *iface,
 926     VARIANT readyStateChangeSink )
 927 {
 928     FIXME("\n");
 929     return E_NOTIMPL;
 930 }
 931
 932
 933 static HRESULT WINAPI domdoc_put_onDataAvailable(
 934     IXMLDOMDocument *iface,
 935     VARIANT onDataAvailableSink )
 936 {
 937     FIXME("\n");
 938     return E_NOTIMPL;
 939 }
 940
 941 static HRESULT WINAPI domdoc_put_onTransformNode(
 942     IXMLDOMDocument *iface,
 943     VARIANT onTransformNodeSink )
 944 {
 945     FIXME("\n");
 946     return E_NOTIMPL;
 947 }
 948
 949 const struct IXMLDOMDocumentVtbl domdoc_vtbl =
 950 {
 951     domdoc_QueryInterface,
 952     domdoc_AddRef,
 953     domdoc_Release,
 954     domdoc_GetTypeInfoCount,
 955     domdoc_GetTypeInfo,
 956     domdoc_GetIDsOfNames,
 957     domdoc_Invoke,
 958     domdoc_get_nodeName,
 959     domdoc_get_nodeValue,
 960     domdoc_put_nodeValue,
 961     domdoc_get_nodeType,
 962     domdoc_get_parentNode,
 963     domdoc_get_childNodes,
 964     domdoc_get_firstChild,
 965     domdoc_get_lastChild,
 966     domdoc_get_previousSibling,
 967     domdoc_get_nextSibling,
 968     domdoc_get_attributes,
 969     domdoc_insertBefore,
 970     domdoc_replaceChild,
 971     domdoc_removeChild,
 972     domdoc_appendChild,
 973     domdoc_hasChildNodes,
 974     domdoc_get_ownerDocument,
 975     domdoc_cloneNode,
 976     domdoc_get_nodeTypeString,
 977     domdoc_get_text,
 978     domdoc_put_text,
 979     domdoc_get_specified,
 980     domdoc_get_definition,
 981     domdoc_get_nodeTypedValue,
 982     domdoc_put_nodeTypedValue,
 983     domdoc_get_dataType,
 984     domdoc_put_dataType,
 985     domdoc_get_xml,
 986     domdoc_transformNode,
 987     domdoc_selectNodes,
 988     domdoc_selectSingleNode,
 989     domdoc_get_parsed,
 990     domdoc_get_namespaceURI,
 991     domdoc_get_prefix,
 992     domdoc_get_baseName,
 993     domdoc_transformNodeToObject,
 994     domdoc_get_doctype,
 995     domdoc_get_implementation,
 996     domdoc_get_documentElement,
 997     domdoc_documentElement,
 998     domdoc_createElement,
 999     domdoc_createDocumentFragment,
1000     domdoc_createTextNode,
1001     domdoc_createComment,
1002     domdoc_createCDATASection,
1003     domdoc_createProcessingInstruction,
1004     domdoc_createAttribute,
1005     domdoc_createEntityReference,
1006     domdoc_getElementsByTagName,
1007     domdoc_createNode,
1008     domdoc_nodeFromID,
1009     domdoc_load,
1010     domdoc_get_readyState,
1011     domdoc_get_parseError,
1012     domdoc_get_url,
1013     domdoc_get_async,
1014     domdoc_put_async,
1015     domdoc_abort,
1016     domdoc_loadXML,
1017     domdoc_save,
1018     domdoc_get_validateOnParse,
1019     domdoc_put_validateOnParse,
1020     domdoc_get_resolveExternals,
1021     domdoc_put_resolveExternals,
1022     domdoc_get_preserveWhiteSpace,
1023     domdoc_put_preserveWhiteSpace,
1024     domdoc_put_onReadyStateChange,
1025     domdoc_put_onDataAvailable,
1026     domdoc_put_onTransformNode,
1027 };
1028
1029 HRESULT DOMDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj)
1030 {
1031     domdoc *doc;
1032
1033     doc = HeapAlloc( GetProcessHeap(), 0, sizeof (*doc) );
1034     if( !doc )
1035         return E_OUTOFMEMORY;
1036
1037     doc->lpVtbl = &domdoc_vtbl;
1038     doc->ref = 1;
1039     doc->async = 0;
1040     doc->node = NULL;
1041
1042     *ppObj = &doc->lpVtbl;
1043
1044     return S_OK;
1045 }
1046
1047 #else
1048
1049 HRESULT DOMDocument_create(IUnknown *pUnkOuter, LPVOID *ppObj)
1050 {
1051     MESSAGE("This program tried to use a DOMDocument object, but\n"
1052             "libxml2 support was not present at compile time.\n");
1053     return E_NOTIMPL;
1054 }
1055
1056 #endif