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