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