dlls/msxml3/node.c

   1 /*
   2  *    Node 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 #include "config.h"
  22
  23 #define COBJMACROS
  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
  34 #include "msxml_private.h"
  35
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  39
  40 #ifdef HAVE_LIBXML2
  41
  42 static inline xmlnode *impl_from_InternalUnknown( IUnknown *iface )
  43 {
  44     return (xmlnode *)((char*)iface - FIELD_OFFSET(xmlnode, lpInternalUnkVtbl));
  45 }
  46
  47 xmlNodePtr xmlNodePtr_from_domnode( IXMLDOMNode *iface, xmlElementType type )
  48 {
  49     xmlnode *This;
  50
  51     if ( !iface )
  52         return NULL;
  53     This = impl_from_IXMLDOMNode( iface );
  54     if ( !This->node )
  55         return NULL;
  56     if ( type && This->node->type != type )
  57         return NULL;
  58     return This->node;
  59 }
  60
  61 void attach_xmlnode( IXMLDOMNode *node, xmlNodePtr xml )
  62 {
  63     xmlnode *This = impl_from_IXMLDOMNode( node );
  64
  65     if(This->node)
  66         xmldoc_release(This->node->doc);
  67
  68     This->node = xml;
  69     if(This->node)
  70         xmldoc_add_ref(This->node->doc);
  71
  72     return;
  73 }
  74
  75 static HRESULT WINAPI xmlnode_QueryInterface(
  76     IXMLDOMNode *iface,
  77     REFIID riid,
  78     void** ppvObject )
  79 {
  80     xmlnode *This = impl_from_IXMLDOMNode( iface );
  81     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
  82
  83     return IUnknown_QueryInterface(This->pUnkOuter, riid, ppvObject);
  84 }
  85
  86 static ULONG WINAPI xmlnode_AddRef(
  87     IXMLDOMNode *iface )
  88 {
  89     xmlnode *This = impl_from_IXMLDOMNode( iface );
  90     return IUnknown_AddRef(This->pUnkOuter);
  91 }
  92
  93 static ULONG WINAPI xmlnode_Release(
  94     IXMLDOMNode *iface )
  95 {
  96     xmlnode *This = impl_from_IXMLDOMNode( iface );
  97     return IUnknown_Release(This->pUnkOuter);
  98 }
  99
 100 static HRESULT WINAPI xmlnode_GetTypeInfoCount(
 101     IXMLDOMNode *iface,
 102     UINT* pctinfo )
 103 {
 104     FIXME("\n");
 105     return E_NOTIMPL;
 106 }
 107
 108 static HRESULT WINAPI xmlnode_GetTypeInfo(
 109     IXMLDOMNode *iface,
 110     UINT iTInfo,
 111     LCID lcid,
 112     ITypeInfo** ppTInfo )
 113 {
 114     FIXME("\n");
 115     return E_NOTIMPL;
 116 }
 117
 118 static HRESULT WINAPI xmlnode_GetIDsOfNames(
 119     IXMLDOMNode *iface,
 120     REFIID riid,
 121     LPOLESTR* rgszNames,
 122     UINT cNames,
 123     LCID lcid,
 124     DISPID* rgDispId )
 125 {
 126     FIXME("\n");
 127     return E_NOTIMPL;
 128 }
 129
 130 static HRESULT WINAPI xmlnode_Invoke(
 131     IXMLDOMNode *iface,
 132     DISPID dispIdMember,
 133     REFIID riid,
 134     LCID lcid,
 135     WORD wFlags,
 136     DISPPARAMS* pDispParams,
 137     VARIANT* pVarResult,
 138     EXCEPINFO* pExcepInfo,
 139     UINT* puArgErr )
 140 {
 141     FIXME("\n");
 142     return E_NOTIMPL;
 143 }
 144
 145 static HRESULT WINAPI xmlnode_get_nodeName(
 146     IXMLDOMNode *iface,
 147     BSTR* name)
 148 {
 149     xmlnode *This = impl_from_IXMLDOMNode( iface );
 150     const xmlChar *str;
 151
 152     TRACE("%p\n", This );
 153
 154     if (!name)
 155         return E_INVALIDARG;
 156
 157     if ( !This->node )
 158         return E_FAIL;
 159
 160     switch( This->node->type )
 161     {
 162     case XML_CDATA_SECTION_NODE:
 163         str = (const xmlChar*) "#cdata-section";
 164         break;
 165     case XML_COMMENT_NODE:
 166         str = (const xmlChar*) "#comment";
 167         break;
 168     case XML_DOCUMENT_FRAG_NODE:
 169         str = (const xmlChar*) "#document-fragment";
 170         break;
 171     case XML_TEXT_NODE:
 172          str = (const xmlChar*) "#text";
 173          break;
 174     case XML_DOCUMENT_NODE:
 175          str = (const xmlChar*) "#document";
 176             break;
 177         case XML_ATTRIBUTE_NODE:
 178         case XML_ELEMENT_NODE:
 179         str = This->node->name;
 180             break;
 181     default:
 182         FIXME("nodeName not mapped correctly (%d)\n", This->node->type);
 183         str = This->node->name;
 184         break;
 185     }
 186
 187     *name = bstr_from_xmlChar( str );
 188     if (!*name)
 189         return S_FALSE;
 190
 191     return S_OK;
 192 }
 193
 194 BSTR bstr_from_xmlChar( const xmlChar *buf )
 195 {
 196     DWORD len;
 197     LPWSTR str;
 198     BSTR bstr;
 199
 200     if ( !buf )
 201         return NULL;
 202
 203     len = MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) buf, -1, NULL, 0 );
 204     str = (LPWSTR) HeapAlloc( GetProcessHeap(), 0, len * sizeof (WCHAR) );
 205     if ( !str )
 206         return NULL;
 207     MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) buf, -1, str, len );
 208     bstr = SysAllocString( str );
 209     HeapFree( GetProcessHeap(), 0, str );
 210     return bstr;
 211 }
 212
 213 static HRESULT WINAPI xmlnode_get_nodeValue(
 214     IXMLDOMNode *iface,
 215     VARIANT* value)
 216 {
 217     xmlnode *This = impl_from_IXMLDOMNode( iface );
 218     HRESULT r = S_FALSE;
 219
 220     TRACE("%p %p\n", This, value);
 221
 222     if(!value)
 223         return E_INVALIDARG;
 224
 225     V_BSTR(value) = NULL;
 226     V_VT(value) = VT_NULL;
 227
 228     switch ( This->node->type )
 229     {
 230     case XML_ATTRIBUTE_NODE:
 231       {
 232         xmlChar *content = xmlNodeGetContent(This->node);
 233         V_VT(value) = VT_BSTR;
 234         V_BSTR(value) = bstr_from_xmlChar( content );
 235         xmlFree(content);
 236         r = S_OK;
 237         break;
 238       }
 239     case XML_TEXT_NODE:
 240         V_VT(value) = VT_BSTR;
 241         V_BSTR(value) = bstr_from_xmlChar( This->node->content );
 242         r = S_OK;
 243         break;
 244     case XML_ELEMENT_NODE:
 245     case XML_DOCUMENT_NODE:
 246         /* these seem to return NULL */
 247         break;
 248     case XML_PI_NODE:
 249     default:
 250         FIXME("node %p type %d\n", This, This->node->type);
 251     }
 252
 253     TRACE("%p returned %s\n", This, debugstr_w( V_BSTR(value) ) );
 254
 255     return r;
 256 }
 257
 258 static HRESULT WINAPI xmlnode_put_nodeValue(
 259     IXMLDOMNode *iface,
 260     VARIANT value)
 261 {
 262     FIXME("\n");
 263     return E_NOTIMPL;
 264 }
 265
 266 static HRESULT WINAPI xmlnode_get_nodeType(
 267     IXMLDOMNode *iface,
 268     DOMNodeType* type)
 269 {
 270     xmlnode *This = impl_from_IXMLDOMNode( iface );
 271
 272     TRACE("%p %p\n", This, type);
 273
 274     assert( NODE_ELEMENT == XML_ELEMENT_NODE );
 275     assert( NODE_NOTATION == XML_NOTATION_NODE );
 276
 277     *type = This->node->type;
 278
 279     return S_OK;
 280 }
 281
 282 static HRESULT get_node(
 283     xmlnode *This,
 284     const char *name,
 285     xmlNodePtr node,
 286     IXMLDOMNode **out )
 287 {
 288     TRACE("%p->%s %p\n", This, name, node );
 289
 290     if ( !out )
 291         return E_INVALIDARG;
 292     *out = create_node( node );
 293     if (!*out)
 294         return S_FALSE;
 295     return S_OK;
 296 }
 297
 298 static HRESULT WINAPI xmlnode_get_parentNode(
 299     IXMLDOMNode *iface,
 300     IXMLDOMNode** parent)
 301 {
 302     xmlnode *This = impl_from_IXMLDOMNode( iface );
 303     return get_node( This, "parent", This->node->parent, parent );
 304 }
 305
 306 static HRESULT WINAPI xmlnode_get_childNodes(
 307     IXMLDOMNode *iface,
 308     IXMLDOMNodeList** childList)
 309 {
 310     xmlnode *This = impl_from_IXMLDOMNode( iface );
 311
 312     TRACE("%p %p\n", This, childList );
 313
 314     if ( !childList )
 315         return E_INVALIDARG;
 316
 317     *childList = create_children_nodelist(This->node);
 318     if (*childList == NULL)
 319         return E_OUTOFMEMORY;
 320
 321     return S_OK;
 322 }
 323
 324 static HRESULT WINAPI xmlnode_get_firstChild(
 325     IXMLDOMNode *iface,
 326     IXMLDOMNode** firstChild)
 327 {
 328     xmlnode *This = impl_from_IXMLDOMNode( iface );
 329     return get_node( This, "firstChild", This->node->children, firstChild );
 330 }
 331
 332 static HRESULT WINAPI xmlnode_get_lastChild(
 333     IXMLDOMNode *iface,
 334     IXMLDOMNode** lastChild)
 335 {
 336     xmlnode *This = impl_from_IXMLDOMNode( iface );
 337
 338     TRACE("%p\n", This );
 339
 340     if (!lastChild)
 341         return E_INVALIDARG;
 342
 343     switch( This->node->type )
 344     {
 345     /* CDATASection, Comment, PI and Text Nodes do not support lastChild */
 346     case XML_TEXT_NODE:
 347     case XML_CDATA_SECTION_NODE:
 348     case XML_PI_NODE:
 349     case XML_COMMENT_NODE:
 350         *lastChild = NULL;
 351         return S_FALSE;
 352     default:
 353         return get_node( This, "lastChild", This->node->last, lastChild );
 354     }
 355 }
 356
 357 static HRESULT WINAPI xmlnode_get_previousSibling(
 358     IXMLDOMNode *iface,
 359     IXMLDOMNode** previousSibling)
 360 {
 361     xmlnode *This = impl_from_IXMLDOMNode( iface );
 362
 363     TRACE("%p\n", This );
 364
 365     if (!previousSibling)
 366         return E_INVALIDARG;
 367
 368     switch( This->node->type )
 369     {
 370     /* Attribute, Document and Document Fragment Nodes do not support previousSibling */
 371     case XML_DOCUMENT_NODE:
 372     case XML_DOCUMENT_FRAG_NODE:
 373     case XML_ATTRIBUTE_NODE:
 374         *previousSibling = NULL;
 375         return S_FALSE;
 376     default:
 377         return get_node( This, "previous", This->node->prev, previousSibling );
 378     }
 379 }
 380
 381 static HRESULT WINAPI xmlnode_get_nextSibling(
 382     IXMLDOMNode *iface,
 383     IXMLDOMNode** nextSibling)
 384 {
 385     xmlnode *This = impl_from_IXMLDOMNode( iface );
 386
 387     TRACE("%p\n", This );
 388
 389     if (!nextSibling)
 390         return E_INVALIDARG;
 391
 392     switch( This->node->type )
 393     {
 394     /* Attribute, Document and Document Fragment Nodes do not support nextSibling */
 395     case XML_DOCUMENT_NODE:
 396     case XML_DOCUMENT_FRAG_NODE:
 397     case XML_ATTRIBUTE_NODE:
 398         *nextSibling = NULL;
 399         return S_FALSE;
 400     default:
 401         return get_node( This, "next", This->node->next, nextSibling );
 402     }
 403 }
 404
 405 static HRESULT WINAPI xmlnode_get_attributes(
 406     IXMLDOMNode *iface,
 407     IXMLDOMNamedNodeMap** attributeMap)
 408 {
 409     xmlnode *This = impl_from_IXMLDOMNode( iface );
 410     TRACE("%p\n", This);
 411
 412     if (!attributeMap)
 413         return E_INVALIDARG;
 414
 415     switch( This->node->type )
 416     {
 417     /* Attribute, CDataSection, Comment, Documents, Documents Fragments,
 418        Entity and Text Nodes does not support get_attributes */
 419     case XML_ATTRIBUTE_NODE:
 420     case XML_CDATA_SECTION_NODE:
 421     case XML_COMMENT_NODE:
 422     case XML_DOCUMENT_NODE:
 423     case XML_DOCUMENT_FRAG_NODE:
 424     case XML_ENTITY_NODE:
 425     case XML_TEXT_NODE:
 426         *attributeMap = NULL;
 427         return S_FALSE;
 428     default:
 429         *attributeMap = create_nodemap( iface );
 430         return S_OK;
 431     }
 432 }
 433
 434 static HRESULT WINAPI xmlnode_insertBefore(
 435     IXMLDOMNode *iface,
 436     IXMLDOMNode* newChild,
 437     VARIANT refChild,
 438     IXMLDOMNode** outNewChild)
 439 {
 440     xmlnode *This = impl_from_IXMLDOMNode( iface );
 441     xmlNodePtr before_node, new_child_node;
 442     IXMLDOMNode *before = NULL, *new;
 443     HRESULT hr;
 444
 445     TRACE("(%p)->(%p,var,%p)\n",This,newChild,outNewChild);
 446
 447     if (!newChild)
 448         return E_INVALIDARG;
 449
 450     switch(V_VT(&refChild))
 451     {
 452     case VT_EMPTY:
 453     case VT_NULL:
 454         break;
 455
 456     case VT_UNKNOWN:
 457         hr = IUnknown_QueryInterface(V_UNKNOWN(&refChild), &IID_IXMLDOMNode, (LPVOID)&before);
 458         if(FAILED(hr)) return hr;
 459         break;
 460
 461     case VT_DISPATCH:
 462         hr = IDispatch_QueryInterface(V_DISPATCH(&refChild), &IID_IXMLDOMNode, (LPVOID)&before);
 463         if(FAILED(hr)) return hr;
 464         break;
 465
 466     default:
 467         FIXME("refChild var type %x\n", V_VT(&refChild));
 468         return E_FAIL;
 469     }
 470
 471     IXMLDOMNode_QueryInterface(newChild, &IID_IXMLDOMNode, (LPVOID)&new);
 472     new_child_node = impl_from_IXMLDOMNode(new)->node;
 473     TRACE("new_child_node %p This->node %p\n", new_child_node, This->node);
 474
 475     if(before)
 476     {
 477         before_node = impl_from_IXMLDOMNode(before)->node;
 478         xmlAddPrevSibling(before_node, new_child_node);
 479         IXMLDOMNode_Release(before);
 480     }
 481     else
 482     {
 483         xmlAddChild(This->node, new_child_node);
 484     }
 485
 486     IXMLDOMNode_Release(new);
 487     IXMLDOMNode_AddRef(newChild);
 488     if(outNewChild)
 489         *outNewChild = newChild;
 490
 491     TRACE("ret S_OK\n");
 492     return S_OK;
 493 }
 494
 495 static HRESULT WINAPI xmlnode_replaceChild(
 496     IXMLDOMNode *iface,
 497     IXMLDOMNode* newChild,
 498     IXMLDOMNode* oldChild,
 499     IXMLDOMNode** outOldChild)
 500 {
 501     FIXME("\n");
 502     return E_NOTIMPL;
 503 }
 504
 505 static HRESULT WINAPI xmlnode_removeChild(
 506     IXMLDOMNode *iface,
 507     IXMLDOMNode* childNode,
 508     IXMLDOMNode** oldChild)
 509 {
 510     xmlnode *This = impl_from_IXMLDOMNode( iface );
 511     xmlNode *ancestor, *child_node_ptr;
 512     HRESULT hr;
 513     IXMLDOMNode *child;
 514
 515     TRACE("%p->(%p, %p)\n", This, childNode, oldChild);
 516
 517     *oldChild = NULL;
 518
 519     if(!childNode) return E_INVALIDARG;
 520
 521     hr = IXMLDOMNode_QueryInterface(childNode, &IID_IXMLDOMNode, (LPVOID)&child);
 522     if(FAILED(hr))
 523         return hr;
 524
 525     child_node_ptr = ancestor = impl_from_IXMLDOMNode(child)->node;
 526     while(ancestor->parent)
 527     {
 528         if(ancestor->parent == This->node)
 529             break;
 530         ancestor = ancestor->parent;
 531     }
 532     if(!ancestor->parent)
 533     {
 534         WARN("childNode %p is not a child of %p\n", childNode, iface);
 535         IXMLDOMNode_Release(child);
 536         return E_INVALIDARG;
 537     }
 538
 539     xmlUnlinkNode(child_node_ptr);
 540
 541     IXMLDOMNode_Release(child);
 542     IXMLDOMNode_AddRef(childNode);
 543     *oldChild = childNode;
 544     return S_OK;
 545 }
 546
 547 static HRESULT WINAPI xmlnode_appendChild(
 548     IXMLDOMNode *iface,
 549     IXMLDOMNode* newChild,
 550     IXMLDOMNode** outNewChild)
 551 {
 552     xmlnode *This = impl_from_IXMLDOMNode( iface );
 553     IXMLDOMNode *pAttr = NULL;
 554     VARIANT var;
 555
 556     TRACE("(%p)->(%p,%p)\n", This, newChild, outNewChild);
 557
 558     /* Cannot Append an Attribute node. */
 559     IUnknown_QueryInterface(newChild, &IID_IXMLDOMNode, (LPVOID*)&pAttr);
 560     if(pAttr)
 561     {
 562         xmlnode *ThisNew = impl_from_IXMLDOMNode( pAttr );
 563
 564         if(ThisNew->node->type == XML_ATTRIBUTE_NODE)
 565         {
 566             if(outNewChild) *outNewChild = NULL;
 567
 568             IUnknown_Release(pAttr);
 569
 570             return E_FAIL;
 571         }
 572
 573         IUnknown_Release(pAttr);
 574     }
 575
 576     VariantInit(&var);
 577     return IXMLDOMNode_insertBefore(iface, newChild, var, outNewChild);
 578 }
 579
 580 static HRESULT WINAPI xmlnode_hasChildNodes(
 581     IXMLDOMNode *iface,
 582     VARIANT_BOOL* hasChild)
 583 {
 584     xmlnode *This = impl_from_IXMLDOMNode( iface );
 585
 586     TRACE("%p\n", This);
 587
 588     if (!hasChild)
 589         return E_INVALIDARG;
 590     if (!This->node->children)
 591     {
 592         *hasChild = VARIANT_FALSE;
 593         return S_FALSE;
 594     }
 595
 596     *hasChild = VARIANT_TRUE;
 597     return S_OK;
 598 }
 599
 600 static HRESULT WINAPI xmlnode_get_ownerDocument(
 601     IXMLDOMNode *iface,
 602     IXMLDOMDocument** DOMDocument)
 603 {
 604     FIXME("\n");
 605     return E_NOTIMPL;
 606 }
 607
 608 static HRESULT WINAPI xmlnode_cloneNode(
 609     IXMLDOMNode *iface,
 610     VARIANT_BOOL deep,
 611     IXMLDOMNode** cloneRoot)
 612 {
 613     xmlnode *This = impl_from_IXMLDOMNode( iface );
 614     xmlNodePtr pClone = NULL;
 615     IXMLDOMNode *pNode = NULL;
 616
 617     TRACE("%p (%d)\n", This, deep);
 618
 619     if(!cloneRoot)
 620         return E_INVALIDARG;
 621
 622     pClone = xmlCopyNode(This->node, deep ? 1 : 2);
 623     if(pClone)
 624     {
 625         pClone->doc = This->node->doc;
 626
 627         pNode = create_node(pClone);
 628         if(!pNode)
 629         {
 630             ERR("Copy failed\n");
 631             return E_FAIL;
 632         }
 633
 634         *cloneRoot = pNode;
 635     }
 636     else
 637     {
 638         ERR("Copy failed\n");
 639         return E_FAIL;
 640     }
 641
 642     return S_OK;
 643 }
 644
 645 static HRESULT WINAPI xmlnode_get_nodeTypeString(
 646     IXMLDOMNode *iface,
 647     BSTR* xmlnodeType)
 648 {
 649     xmlnode *This = impl_from_IXMLDOMNode( iface );
 650     const xmlChar *str;
 651
 652     TRACE("%p\n", This );
 653
 654     if (!xmlnodeType)
 655         return E_INVALIDARG;
 656
 657     if ( !This->node )
 658         return E_FAIL;
 659
 660     switch( This->node->type )
 661     {
 662     case XML_ATTRIBUTE_NODE:
 663         str = (const xmlChar*) "attribute";
 664         break;
 665     case XML_CDATA_SECTION_NODE:
 666         str = (const xmlChar*) "cdatasection";
 667         break;
 668     case XML_COMMENT_NODE:
 669         str = (const xmlChar*) "comment";
 670         break;
 671     case XML_DOCUMENT_NODE:
 672         str = (const xmlChar*) "document";
 673         break;
 674     case XML_DOCUMENT_FRAG_NODE:
 675         str = (const xmlChar*) "documentfragment";
 676         break;
 677     case XML_ELEMENT_NODE:
 678         str = (const xmlChar*) "element";
 679         break;
 680     case XML_ENTITY_NODE:
 681         str = (const xmlChar*) "entity";
 682         break;
 683     case XML_ENTITY_REF_NODE:
 684         str = (const xmlChar*) "entityreference";
 685         break;
 686     case XML_NOTATION_NODE:
 687         str = (const xmlChar*) "notation";
 688         break;
 689     case XML_PI_NODE:
 690         str = (const xmlChar*) "processinginstruction";
 691         break;
 692     case XML_TEXT_NODE:
 693         str = (const xmlChar*) "text";
 694         break;
 695     default:
 696         FIXME("nodeName not mapped correctly (%d)\n", This->node->type);
 697         str = This->node->name;
 698         break;
 699     }
 700
 701     *xmlnodeType = bstr_from_xmlChar( str );
 702     if (!*xmlnodeType)
 703         return S_FALSE;
 704
 705     return S_OK;
 706 }
 707
 708 static HRESULT WINAPI xmlnode_get_text(
 709     IXMLDOMNode *iface,
 710     BSTR* text)
 711 {
 712     xmlnode *This = impl_from_IXMLDOMNode( iface );
 713     BSTR str = NULL;
 714
 715     TRACE("%p\n", This);
 716
 717     if ( !text )
 718         return E_INVALIDARG;
 719
 720     switch(This->node->type)
 721     {
 722     case XML_ELEMENT_NODE:
 723     case XML_ATTRIBUTE_NODE:
 724     {
 725         xmlNodePtr child = This->node->children;
 726         if ( child && child->type == XML_TEXT_NODE )
 727             str = bstr_from_xmlChar( child->content );
 728         break;
 729     }
 730
 731     case XML_TEXT_NODE:
 732     case XML_CDATA_SECTION_NODE:
 733     case XML_PI_NODE:
 734     case XML_COMMENT_NODE:
 735         str = bstr_from_xmlChar( This->node->content );
 736         break;
 737
 738     default:
 739         FIXME("Unhandled node type %d\n", This->node->type);
 740     }
 741
 742     /* Always return a string. */
 743     if (!str) str = SysAllocStringLen( NULL, 0 );
 744
 745     TRACE("%p %s\n", This, debugstr_w(str) );
 746     *text = str;
 747
 748     return S_OK;
 749 }
 750
 751 static HRESULT WINAPI xmlnode_put_text(
 752     IXMLDOMNode *iface,
 753     BSTR text)
 754 {
 755     xmlnode *This = impl_from_IXMLDOMNode( iface );
 756     xmlChar *str = NULL;
 757
 758     TRACE("%p\n", This);
 759
 760     switch(This->node->type)
 761     {
 762     case XML_DOCUMENT_NODE:
 763         return E_FAIL;
 764     default:
 765         break;
 766     }
 767
 768     str = xmlChar_from_wchar((WCHAR*)text);
 769
 770     /* Escape the string. */
 771     str = xmlEncodeEntitiesReentrant(This->node->doc, str);
 772     str = xmlEncodeSpecialChars(This->node->doc, str);
 773
 774     xmlNodeSetContent(This->node, str);
 775     xmlFree(str);
 776
 777     return S_OK;
 778 }
 779
 780 static HRESULT WINAPI xmlnode_get_specified(
 781     IXMLDOMNode *iface,
 782     VARIANT_BOOL* isSpecified)
 783 {
 784     FIXME("\n");
 785     return E_NOTIMPL;
 786 }
 787
 788 static HRESULT WINAPI xmlnode_get_definition(
 789     IXMLDOMNode *iface,
 790     IXMLDOMNode** definitionNode)
 791 {
 792     FIXME("\n");
 793     return E_NOTIMPL;
 794 }
 795
 796 static HRESULT WINAPI xmlnode_get_nodeTypedValue(
 797     IXMLDOMNode *iface,
 798     VARIANT* typedValue)
 799 {
 800     FIXME("ignoring data type\n");
 801     return xmlnode_get_nodeValue(iface, typedValue);
 802 }
 803
 804 static HRESULT WINAPI xmlnode_put_nodeTypedValue(
 805     IXMLDOMNode *iface,
 806     VARIANT typedValue)
 807 {
 808     FIXME("\n");
 809     return E_NOTIMPL;
 810 }
 811
 812 static HRESULT WINAPI xmlnode_get_dataType(
 813     IXMLDOMNode *iface,
 814     VARIANT* dataTypeName)
 815 {
 816     xmlnode *This = impl_from_IXMLDOMNode( iface );
 817     xmlChar *pVal;
 818
 819     TRACE("iface %p\n", iface);
 820
 821     if(!dataTypeName)
 822         return E_INVALIDARG;
 823
 824     /* CDATA Section, Comment, Document, Document Fragment,
 825         Entity, Notation, PI, and Text Node are non-typed. */
 826     V_BSTR(dataTypeName) = NULL;
 827     V_VT(dataTypeName) = VT_NULL;
 828
 829     switch ( This->node->type )
 830     {
 831     case XML_ATTRIBUTE_NODE:
 832         FIXME("NODE_ATTRIBUTE_NODE should return a valid value.\n");
 833         break;
 834     case XML_ELEMENT_NODE:
 835         pVal = xmlGetNsProp(This->node, (xmlChar*)"dt",
 836                             (xmlChar*)"urn:schemas-microsoft-com:datatypes");
 837         if (pVal)
 838         {
 839             V_VT(dataTypeName) = VT_BSTR;
 840             V_BSTR(dataTypeName) = bstr_from_xmlChar( pVal );
 841             xmlFree(pVal);
 842         }
 843         break;
 844     case XML_ENTITY_REF_NODE:
 845         FIXME("XML_ENTITY_REF_NODE should return a valid value.\n");
 846         break;
 847     default:
 848         TRACE("Type %d returning NULL\n", This->node->type);
 849     }
 850
 851     /* non-typed nodes return S_FALSE */
 852     if(V_VT(dataTypeName) == VT_NULL)
 853     {
 854         return S_FALSE;
 855     }
 856
 857     return S_OK;
 858 }
 859
 860 static HRESULT WINAPI xmlnode_put_dataType(
 861     IXMLDOMNode *iface,
 862     BSTR dataTypeName)
 863 {
 864     FIXME("\n");
 865     return E_NOTIMPL;
 866 }
 867
 868 static HRESULT WINAPI xmlnode_get_xml(
 869     IXMLDOMNode *iface,
 870     BSTR* xmlString)
 871 {
 872     xmlnode *This = impl_from_IXMLDOMNode( iface );
 873     xmlBufferPtr pXmlBuf;
 874     int nSize;
 875
 876     TRACE("iface %p\n", iface);
 877
 878     if(!xmlString)
 879         return E_INVALIDARG;
 880
 881     *xmlString = NULL;
 882
 883     pXmlBuf = xmlBufferCreate();
 884     if(pXmlBuf)
 885     {
 886         nSize = xmlNodeDump(pXmlBuf, This->node->doc, This->node, 0, 0);
 887         if(nSize > 0)
 888         {
 889             const xmlChar *pContent;
 890
 891             /* Attribute Nodes return a space infront of their name */
 892             pContent = xmlBufferContent(pXmlBuf);
 893             if( ((char*)pContent)[0] == ' ')
 894                 *xmlString = bstr_from_xmlChar(pContent+1);
 895             else
 896                 *xmlString = bstr_from_xmlChar(pContent);
 897
 898
 899             xmlBufferFree(pXmlBuf);
 900         }
 901     }
 902
 903     /* Always returns a string. */
 904     if(*xmlString == NULL)  *xmlString = SysAllocStringLen( NULL, 0 );
 905
 906     return S_OK;
 907 }
 908
 909 static HRESULT WINAPI xmlnode_transformNode(
 910     IXMLDOMNode *iface,
 911     IXMLDOMNode* styleSheet,
 912     BSTR* xmlString)
 913 {
 914     FIXME("\n");
 915     return E_NOTIMPL;
 916 }
 917
 918 static HRESULT WINAPI xmlnode_selectNodes(
 919     IXMLDOMNode *iface,
 920     BSTR queryString,
 921     IXMLDOMNodeList** resultList)
 922 {
 923     xmlnode *This = impl_from_IXMLDOMNode( iface );
 924
 925     TRACE("%p %s %p\n", This, debugstr_w(queryString), resultList );
 926
 927     return queryresult_create( This->node, queryString, resultList );
 928 }
 929
 930 static HRESULT WINAPI xmlnode_selectSingleNode(
 931     IXMLDOMNode *iface,
 932     BSTR queryString,
 933     IXMLDOMNode** resultNode)
 934 {
 935     xmlnode *This = impl_from_IXMLDOMNode( iface );
 936     IXMLDOMNodeList *list;
 937     HRESULT r;
 938
 939     TRACE("%p %s %p\n", This, debugstr_w(queryString), resultNode );
 940
 941     *resultNode = NULL;
 942     r = IXMLDOMNode_selectNodes(iface, queryString, &list);
 943     if(r == S_OK)
 944     {
 945         r = IXMLDOMNodeList_nextNode(list, resultNode);
 946         IXMLDOMNodeList_Release(list);
 947     }
 948     return r;
 949 }
 950
 951 static HRESULT WINAPI xmlnode_get_parsed(
 952     IXMLDOMNode *iface,
 953     VARIANT_BOOL* isParsed)
 954 {
 955     FIXME("\n");
 956     return E_NOTIMPL;
 957 }
 958
 959 static HRESULT WINAPI xmlnode_get_namespaceURI(
 960     IXMLDOMNode *iface,
 961     BSTR* namespaceURI)
 962 {
 963     FIXME("\n");
 964     return E_NOTIMPL;
 965 }
 966
 967 static HRESULT WINAPI xmlnode_get_prefix(
 968     IXMLDOMNode *iface,
 969     BSTR* prefixString)
 970 {
 971     FIXME("\n");
 972     return E_NOTIMPL;
 973 }
 974
 975 static HRESULT WINAPI xmlnode_get_baseName(
 976     IXMLDOMNode *iface,
 977     BSTR* nameString)
 978 {
 979     xmlnode *This = impl_from_IXMLDOMNode( iface );
 980     BSTR str = NULL;
 981     HRESULT r = S_FALSE;
 982
 983     TRACE("%p %p\n", This, nameString );
 984
 985     if ( !nameString )
 986         return E_INVALIDARG;
 987
 988     switch ( This->node->type )
 989     {
 990     case XML_ELEMENT_NODE:
 991     case XML_ATTRIBUTE_NODE:
 992         str = bstr_from_xmlChar( This->node->name );
 993         r = S_OK;
 994         break;
 995     case XML_TEXT_NODE:
 996         break;
 997     default:
 998         ERR("Unhandled type %d\n", This->node->type );
 999         break;
1000     }
1001
1002     TRACE("returning %08x str = %s\n", r, debugstr_w( str ) );
1003
1004     *nameString = str;
1005     return r;
1006 }
1007
1008 static HRESULT WINAPI xmlnode_transformNodeToObject(
1009     IXMLDOMNode *iface,
1010     IXMLDOMNode* stylesheet,
1011     VARIANT outputObject)
1012 {
1013     FIXME("\n");
1014     return E_NOTIMPL;
1015 }
1016
1017 static const struct IXMLDOMNodeVtbl xmlnode_vtbl =
1018 {
1019     xmlnode_QueryInterface,
1020     xmlnode_AddRef,
1021     xmlnode_Release,
1022     xmlnode_GetTypeInfoCount,
1023     xmlnode_GetTypeInfo,
1024     xmlnode_GetIDsOfNames,
1025     xmlnode_Invoke,
1026     xmlnode_get_nodeName,
1027     xmlnode_get_nodeValue,
1028     xmlnode_put_nodeValue,
1029     xmlnode_get_nodeType,
1030     xmlnode_get_parentNode,
1031     xmlnode_get_childNodes,
1032     xmlnode_get_firstChild,
1033     xmlnode_get_lastChild,
1034     xmlnode_get_previousSibling,
1035     xmlnode_get_nextSibling,
1036     xmlnode_get_attributes,
1037     xmlnode_insertBefore,
1038     xmlnode_replaceChild,
1039     xmlnode_removeChild,
1040     xmlnode_appendChild,
1041     xmlnode_hasChildNodes,
1042     xmlnode_get_ownerDocument,
1043     xmlnode_cloneNode,
1044     xmlnode_get_nodeTypeString,
1045     xmlnode_get_text,
1046     xmlnode_put_text,
1047     xmlnode_get_specified,
1048     xmlnode_get_definition,
1049     xmlnode_get_nodeTypedValue,
1050     xmlnode_put_nodeTypedValue,
1051     xmlnode_get_dataType,
1052     xmlnode_put_dataType,
1053     xmlnode_get_xml,
1054     xmlnode_transformNode,
1055     xmlnode_selectNodes,
1056     xmlnode_selectSingleNode,
1057     xmlnode_get_parsed,
1058     xmlnode_get_namespaceURI,
1059     xmlnode_get_prefix,
1060     xmlnode_get_baseName,
1061     xmlnode_transformNodeToObject,
1062 };
1063
1064 static HRESULT WINAPI Internal_QueryInterface(
1065     IUnknown *iface,
1066     REFIID riid,
1067     void** ppvObject )
1068 {
1069     xmlnode *This = impl_from_InternalUnknown( iface );
1070
1071     TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
1072
1073
1074     if ( IsEqualGUID( riid, &IID_IUnknown ))
1075         *ppvObject = iface;
1076     else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
1077               IsEqualGUID( riid, &IID_IXMLDOMNode ) )
1078         *ppvObject = &This->lpVtbl;
1079     else
1080     {
1081         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1082         *ppvObject = NULL;
1083         return E_NOINTERFACE;
1084     }
1085
1086     IUnknown_AddRef( (IUnknown*)*ppvObject );
1087
1088     return S_OK;
1089 }
1090
1091 static ULONG WINAPI Internal_AddRef(
1092                  IUnknown *iface )
1093 {
1094     xmlnode *This = impl_from_InternalUnknown( iface );
1095     return InterlockedIncrement( &This->ref );
1096 }
1097
1098 static ULONG WINAPI Internal_Release(
1099     IUnknown *iface )
1100 {
1101     xmlnode *This = impl_from_InternalUnknown( iface );
1102     ULONG ref;
1103
1104     ref = InterlockedDecrement( &This->ref );
1105     if ( ref == 0 )
1106     {
1107         if( This->node )
1108             xmldoc_release( This->node->doc );
1109         HeapFree( GetProcessHeap(), 0, This );
1110     }
1111
1112     return ref;
1113 }
1114
1115 static const struct IUnknownVtbl internal_unk_vtbl =
1116 {
1117     Internal_QueryInterface,
1118     Internal_AddRef,
1119     Internal_Release
1120 };
1121
1122 IUnknown *create_basic_node( xmlNodePtr node, IUnknown *pUnkOuter )
1123 {
1124     xmlnode *This;
1125
1126     This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
1127     if ( !This )
1128         return NULL;
1129
1130     if(node)
1131         xmldoc_add_ref( node->doc );
1132
1133     This->lpVtbl = &xmlnode_vtbl;
1134     This->lpInternalUnkVtbl = &internal_unk_vtbl;
1135
1136     if(pUnkOuter)
1137         This->pUnkOuter = pUnkOuter; /* Don't take a ref on outer Unknown */
1138     else
1139         This->pUnkOuter = (IUnknown *)&This->lpInternalUnkVtbl;
1140
1141     This->ref = 1;
1142     This->node = node;
1143
1144     return (IUnknown*)&This->lpInternalUnkVtbl;
1145 }
1146
1147 IXMLDOMNode *create_node( xmlNodePtr node )
1148 {
1149     IUnknown *pUnk;
1150     IXMLDOMNode *ret;
1151     HRESULT hr;
1152
1153     if ( !node )
1154         return NULL;
1155
1156     TRACE("type %d\n", node->type);
1157     switch(node->type)
1158     {
1159     case XML_ELEMENT_NODE:
1160         pUnk = create_element( node, NULL );
1161         break;
1162     case XML_ATTRIBUTE_NODE:
1163         pUnk = create_attribute( node );
1164         break;
1165     case XML_TEXT_NODE:
1166         pUnk = create_text( node );
1167         break;
1168     case XML_COMMENT_NODE:
1169         pUnk = create_comment( node );
1170         break;
1171     case XML_DOCUMENT_NODE:
1172         ERR("shouldn't be here!\n");
1173         return NULL;
1174     default:
1175         FIXME("only creating basic node for type %d\n", node->type);
1176         pUnk = create_basic_node( node, NULL );
1177     }
1178
1179     hr = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMNode, (LPVOID*)&ret);
1180     IUnknown_Release(pUnk);
1181     if(FAILED(hr)) return NULL;
1182     return ret;
1183 }
1184 #endif