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 "msxml6.h"
  33
  34 #include "msxml_private.h"
  35
  36 #ifdef HAVE_LIBXML2
  37 # include <libxml/HTMLtree.h>
  38 #endif
  39
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  43
  44 #ifdef HAVE_LIBXML2
  45
  46 static const WCHAR szBinBase64[]  = {'b','i','n','.','b','a','s','e','6','4',0};
  47 static const WCHAR szString[]     = {'s','t','r','i','n','g',0};
  48 static const WCHAR szNumber[]     = {'n','u','m','b','e','r',0};
  49 static const WCHAR szInt[]        = {'I','n','t',0};
  50 static const WCHAR szFixed[]      = {'F','i','x','e','d','.','1','4','.','4',0};
  51 static const WCHAR szBoolean[]    = {'B','o','o','l','e','a','n',0};
  52 static const WCHAR szDateTime[]   = {'d','a','t','e','T','i','m','e',0};
  53 static const WCHAR szDateTimeTZ[] = {'d','a','t','e','T','i','m','e','.','t','z',0};
  54 static const WCHAR szDate[]       = {'D','a','t','e',0};
  55 static const WCHAR szTime[]       = {'T','i','m','e',0};
  56 static const WCHAR szTimeTZ[]     = {'T','i','m','e','.','t','z',0};
  57 static const WCHAR szI1[]         = {'i','1',0};
  58 static const WCHAR szI2[]         = {'i','2',0};
  59 static const WCHAR szI4[]         = {'i','4',0};
  60 static const WCHAR szIU1[]        = {'u','i','1',0};
  61 static const WCHAR szIU2[]        = {'u','i','2',0};
  62 static const WCHAR szIU4[]        = {'u','i','4',0};
  63 static const WCHAR szR4[]         = {'r','4',0};
  64 static const WCHAR szR8[]         = {'r','8',0};
  65 static const WCHAR szFloat[]      = {'f','l','o','a','t',0};
  66 static const WCHAR szUUID[]       = {'u','u','i','d',0};
  67 static const WCHAR szBinHex[]     = {'b','i','n','.','h','e','x',0};
  68
  69 static const IID IID_xmlnode = {0x4f2f4ba2,0xb822,0x11df,{0x8b,0x8a,0x68,0x50,0xdf,0xd7,0x20,0x85}};
  70
  71 xmlNodePtr xmlNodePtr_from_domnode( IXMLDOMNode *iface, xmlElementType type )
  72 {
  73     xmlnode *This;
  74
  75     if ( !iface )
  76         return NULL;
  77     This = get_node_obj( iface );
  78     if ( !This || !This->node )
  79         return NULL;
  80     if ( type && This->node->type != type )
  81         return NULL;
  82     return This->node;
  83 }
  84
  85 BOOL node_query_interface(xmlnode *This, REFIID riid, void **ppv)
  86 {
  87     if(IsEqualGUID(&IID_xmlnode, riid)) {
  88         TRACE("(%p)->(IID_xmlnode %p)\n", This, ppv);
  89         *ppv = This;
  90         return TRUE;
  91     }
  92
  93     if(This->dispex.outer)
  94         return dispex_query_interface(&This->dispex, riid, ppv);
  95
  96     return FALSE;
  97 }
  98
  99 xmlnode *get_node_obj(IXMLDOMNode *node)
 100 {
 101     xmlnode *obj;
 102     HRESULT hres;
 103
 104     hres = IXMLDOMNode_QueryInterface(node, &IID_xmlnode, (void**)&obj);
 105     return SUCCEEDED(hres) ? obj : NULL;
 106 }
 107
 108 static inline xmlnode *impl_from_IXMLDOMNode( IXMLDOMNode *iface )
 109 {
 110     return (xmlnode *)((char*)iface - FIELD_OFFSET(xmlnode, lpVtbl));
 111 }
 112
 113 static HRESULT WINAPI xmlnode_QueryInterface(
 114     IXMLDOMNode *iface,
 115     REFIID riid,
 116     void** ppvObject )
 117 {
 118     ERR("Should not be called\n");
 119     return E_NOINTERFACE;
 120 }
 121
 122 static ULONG WINAPI xmlnode_AddRef(
 123     IXMLDOMNode *iface )
 124 {
 125     ERR("Should not be called\n");
 126     return 2;
 127 }
 128
 129 static ULONG WINAPI xmlnode_Release(
 130     IXMLDOMNode *iface )
 131 {
 132     ERR("Should not be called\n");
 133     return 1;
 134 }
 135
 136 static HRESULT WINAPI xmlnode_GetTypeInfoCount(
 137     IXMLDOMNode *iface,
 138     UINT* pctinfo )
 139 {
 140     ERR("Should not be called\n");
 141     return E_NOTIMPL;
 142 }
 143
 144 static HRESULT WINAPI xmlnode_GetTypeInfo(
 145     IXMLDOMNode *iface,
 146     UINT iTInfo,
 147     LCID lcid,
 148     ITypeInfo** ppTInfo )
 149 {
 150     ERR("Should not be called\n");
 151     return E_NOTIMPL;
 152 }
 153
 154 static HRESULT WINAPI xmlnode_GetIDsOfNames(
 155     IXMLDOMNode *iface,
 156     REFIID riid,
 157     LPOLESTR* rgszNames,
 158     UINT cNames,
 159     LCID lcid,
 160     DISPID* rgDispId )
 161 {
 162     ERR("Should not be called\n");
 163     return E_NOTIMPL;
 164 }
 165
 166 static HRESULT WINAPI xmlnode_Invoke(
 167     IXMLDOMNode *iface,
 168     DISPID dispIdMember,
 169     REFIID riid,
 170     LCID lcid,
 171     WORD wFlags,
 172     DISPPARAMS* pDispParams,
 173     VARIANT* pVarResult,
 174     EXCEPINFO* pExcepInfo,
 175     UINT* puArgErr )
 176 {
 177     ERR("Should not be called\n");
 178     return E_NOTIMPL;
 179 }
 180
 181 HRESULT node_get_nodeName(xmlnode *This, BSTR *name)
 182 {
 183     if (!name)
 184         return E_INVALIDARG;
 185
 186     *name = bstr_from_xmlChar(This->node->name);
 187     if (!*name)
 188         return S_FALSE;
 189
 190     return S_OK;
 191 }
 192
 193 static HRESULT WINAPI xmlnode_get_nodeName(
 194     IXMLDOMNode *iface,
 195     BSTR* name)
 196 {
 197     ERR("Should not be called\n");
 198     return E_NOTIMPL;
 199 }
 200
 201 HRESULT node_get_content(xmlnode *This, VARIANT *value)
 202 {
 203     xmlChar *content;
 204
 205     if(!value)
 206         return E_INVALIDARG;
 207
 208     content = xmlNodeGetContent(This->node);
 209     V_VT(value) = VT_BSTR;
 210     V_BSTR(value) = bstr_from_xmlChar( content );
 211     xmlFree(content);
 212
 213     TRACE("%p returned %s\n", This, debugstr_w(V_BSTR(value)));
 214     return S_OK;
 215 }
 216
 217 static HRESULT WINAPI xmlnode_get_nodeValue(
 218     IXMLDOMNode *iface,
 219     VARIANT* value)
 220 {
 221     ERR("Should not be called\n");
 222     return E_NOTIMPL;
 223 }
 224
 225 HRESULT node_put_value(xmlnode *This, VARIANT *value)
 226 {
 227     VARIANT string_value;
 228     xmlChar *str;
 229     HRESULT hr;
 230
 231     VariantInit(&string_value);
 232     hr = VariantChangeType(&string_value, value, 0, VT_BSTR);
 233     if(FAILED(hr)) {
 234         WARN("Couldn't convert to VT_BSTR\n");
 235         return hr;
 236     }
 237
 238     str = xmlChar_from_wchar(V_BSTR(&string_value));
 239     VariantClear(&string_value);
 240
 241     xmlNodeSetContent(This->node, str);
 242     heap_free(str);
 243     return S_OK;
 244 }
 245
 246 static HRESULT WINAPI xmlnode_put_nodeValue(
 247     IXMLDOMNode *iface,
 248     VARIANT value)
 249 {
 250     ERR("Should not be called\n");
 251     return E_NOTIMPL;
 252 }
 253
 254 static HRESULT WINAPI xmlnode_get_nodeType(
 255     IXMLDOMNode *iface,
 256     DOMNodeType* type)
 257 {
 258     ERR("Should not be called\n");
 259     return E_NOTIMPL;
 260 }
 261
 262 static HRESULT get_node(
 263     xmlnode *This,
 264     const char *name,
 265     xmlNodePtr node,
 266     IXMLDOMNode **out )
 267 {
 268     TRACE("(%p)->(%s %p %p)\n", This, name, node, out );
 269
 270     if ( !out )
 271         return E_INVALIDARG;
 272
 273     /* if we don't have a doc, use our parent. */
 274     if(node && !node->doc && node->parent)
 275         node->doc = node->parent->doc;
 276
 277     *out = create_node( node );
 278     if (!*out)
 279         return S_FALSE;
 280     return S_OK;
 281 }
 282
 283 HRESULT node_get_parent(xmlnode *This, IXMLDOMNode **parent)
 284 {
 285     return get_node( This, "parent", This->node->parent, parent );
 286 }
 287
 288 static HRESULT WINAPI xmlnode_get_parentNode(
 289     IXMLDOMNode *iface,
 290     IXMLDOMNode** parent)
 291 {
 292     ERR("Should not be called\n");
 293     return E_NOTIMPL;
 294 }
 295
 296 HRESULT node_get_child_nodes(xmlnode *This, IXMLDOMNodeList **ret)
 297 {
 298     if(!ret)
 299         return E_INVALIDARG;
 300
 301     *ret = create_children_nodelist(This->node);
 302     if(!*ret)
 303         return E_OUTOFMEMORY;
 304
 305     return S_OK;
 306 }
 307
 308 static HRESULT WINAPI xmlnode_get_childNodes(
 309     IXMLDOMNode *iface,
 310     IXMLDOMNodeList** childList)
 311 {
 312     ERR("Should not be called\n");
 313     return E_NOTIMPL;
 314 }
 315
 316 HRESULT node_get_first_child(xmlnode *This, IXMLDOMNode **ret)
 317 {
 318     return get_node(This, "firstChild", This->node->children, ret);
 319 }
 320
 321 static HRESULT WINAPI xmlnode_get_firstChild(
 322     IXMLDOMNode *iface,
 323     IXMLDOMNode** firstChild)
 324 {
 325     ERR("Should not be called\n");
 326     return E_NOTIMPL;
 327 }
 328
 329 HRESULT node_get_last_child(xmlnode *This, IXMLDOMNode **ret)
 330 {
 331     return get_node(This, "lastChild", This->node->last, ret);
 332 }
 333
 334 static HRESULT WINAPI xmlnode_get_lastChild(
 335     IXMLDOMNode *iface,
 336     IXMLDOMNode** lastChild)
 337 {
 338     ERR("Should not be called\n");
 339     return E_NOTIMPL;
 340 }
 341
 342 HRESULT node_get_previous_sibling(xmlnode *This, IXMLDOMNode **ret)
 343 {
 344     return get_node(This, "previous", This->node->prev, ret);
 345 }
 346
 347 static HRESULT WINAPI xmlnode_get_previousSibling(
 348     IXMLDOMNode *iface,
 349     IXMLDOMNode** previousSibling)
 350 {
 351     ERR("Should not be called\n");
 352     return E_NOTIMPL;
 353 }
 354
 355 HRESULT node_get_next_sibling(xmlnode *This, IXMLDOMNode **ret)
 356 {
 357     return get_node(This, "next", This->node->next, ret);
 358 }
 359
 360 static HRESULT WINAPI xmlnode_get_nextSibling(
 361     IXMLDOMNode *iface,
 362     IXMLDOMNode** nextSibling)
 363 {
 364     ERR("Should not be called\n");
 365     return E_NOTIMPL;
 366 }
 367
 368 static HRESULT WINAPI xmlnode_get_attributes(
 369     IXMLDOMNode *iface,
 370     IXMLDOMNamedNodeMap** attributeMap)
 371 {
 372     ERR("Should not be called\n");
 373     return E_NOTIMPL;
 374 }
 375
 376 HRESULT node_insert_before(xmlnode *This, IXMLDOMNode *new_child, const VARIANT *ref_child,
 377         IXMLDOMNode **ret)
 378 {
 379     xmlNodePtr before_node, new_child_node;
 380     IXMLDOMNode *before = NULL;
 381     xmlnode *node_obj;
 382     HRESULT hr;
 383
 384     if(!new_child)
 385         return E_INVALIDARG;
 386
 387     node_obj = get_node_obj(new_child);
 388     if(!node_obj) {
 389         FIXME("newChild is not our node implementation\n");
 390         return E_FAIL;
 391     }
 392
 393     switch(V_VT(ref_child))
 394     {
 395     case VT_EMPTY:
 396     case VT_NULL:
 397         break;
 398
 399     case VT_UNKNOWN:
 400     case VT_DISPATCH:
 401         hr = IUnknown_QueryInterface(V_UNKNOWN(ref_child), &IID_IXMLDOMNode, (LPVOID)&before);
 402         if(FAILED(hr)) return hr;
 403         break;
 404
 405     default:
 406         FIXME("refChild var type %x\n", V_VT(ref_child));
 407         return E_FAIL;
 408     }
 409
 410     new_child_node = node_obj->node;
 411     TRACE("new_child_node %p This->node %p\n", new_child_node, This->node);
 412
 413     if(!new_child_node->parent)
 414         if(xmldoc_remove_orphan(new_child_node->doc, new_child_node) != S_OK)
 415             WARN("%p is not an orphan of %p\n", new_child_node, new_child_node->doc);
 416
 417     if(before)
 418     {
 419         node_obj = get_node_obj(before);
 420         IXMLDOMNode_Release(before);
 421         if(!node_obj) {
 422             FIXME("before node is not our node implementation\n");
 423             return E_FAIL;
 424         }
 425
 426         before_node = node_obj->node;
 427         xmlAddPrevSibling(before_node, new_child_node);
 428     }
 429     else
 430     {
 431         xmlAddChild(This->node, new_child_node);
 432     }
 433
 434     if(ret) {
 435         IXMLDOMNode_AddRef(new_child);
 436         *ret = new_child;
 437     }
 438
 439     TRACE("ret S_OK\n");
 440     return S_OK;
 441 }
 442
 443 static HRESULT WINAPI xmlnode_insertBefore(
 444     IXMLDOMNode *iface,
 445     IXMLDOMNode* newChild,
 446     VARIANT refChild,
 447     IXMLDOMNode** outNewChild)
 448 {
 449     ERR("Should not be called\n");
 450     return E_NOTIMPL;
 451 }
 452
 453 static HRESULT WINAPI xmlnode_replaceChild(
 454     IXMLDOMNode *iface,
 455     IXMLDOMNode* newChild,
 456     IXMLDOMNode* oldChild,
 457     IXMLDOMNode** outOldChild)
 458 {
 459     xmlnode *This = impl_from_IXMLDOMNode( iface );
 460     xmlnode *old_child, *new_child;
 461     xmlDocPtr leaving_doc;
 462     xmlNode *my_ancestor;
 463
 464     TRACE("(%p)->(%p %p %p)\n", This, newChild, oldChild, outOldChild);
 465
 466     /* Do not believe any documentation telling that newChild == NULL
 467        means removal. It does certainly *not* apply to msxml3! */
 468     if(!newChild || !oldChild)
 469         return E_INVALIDARG;
 470
 471     if(outOldChild)
 472         *outOldChild = NULL;
 473
 474     old_child = get_node_obj(oldChild);
 475     if(!old_child) {
 476         FIXME("oldChild is not our node implementation\n");
 477         return E_FAIL;
 478     }
 479
 480     if(old_child->node->parent != This->node)
 481     {
 482         WARN("childNode %p is not a child of %p\n", oldChild, iface);
 483         return E_INVALIDARG;
 484     }
 485
 486     new_child = get_node_obj(newChild);
 487     if(!new_child) {
 488         FIXME("newChild is not our node implementation\n");
 489         return E_FAIL;
 490     }
 491
 492     my_ancestor = This->node;
 493     while(my_ancestor)
 494     {
 495         if(my_ancestor == new_child->node)
 496         {
 497             WARN("tried to create loop\n");
 498             return E_FAIL;
 499         }
 500         my_ancestor = my_ancestor->parent;
 501     }
 502
 503     if(!new_child->node->parent)
 504         if(xmldoc_remove_orphan(new_child->node->doc, new_child->node) != S_OK)
 505             WARN("%p is not an orphan of %p\n", new_child->node, new_child->node->doc);
 506
 507     leaving_doc = new_child->node->doc;
 508     xmldoc_add_ref(old_child->node->doc);
 509     xmlReplaceNode(old_child->node, new_child->node);
 510     xmldoc_release(leaving_doc);
 511
 512     xmldoc_add_orphan(old_child->node->doc, old_child->node);
 513
 514     if(outOldChild)
 515     {
 516         IXMLDOMNode_AddRef(oldChild);
 517         *outOldChild = oldChild;
 518     }
 519
 520     return S_OK;
 521 }
 522
 523 static HRESULT WINAPI xmlnode_removeChild(
 524     IXMLDOMNode *iface,
 525     IXMLDOMNode* childNode,
 526     IXMLDOMNode** oldChild)
 527 {
 528     xmlnode *This = impl_from_IXMLDOMNode( iface );
 529     xmlnode *child_node;
 530
 531     TRACE("(%p)->(%p %p)\n", This, childNode, oldChild);
 532
 533     if(!childNode) return E_INVALIDARG;
 534
 535     if(oldChild)
 536         *oldChild = NULL;
 537
 538     child_node = get_node_obj(childNode);
 539     if(!child_node) {
 540         FIXME("childNode is not our node implementation\n");
 541         return E_FAIL;
 542     }
 543
 544     if(child_node->node->parent != This->node)
 545     {
 546         WARN("childNode %p is not a child of %p\n", childNode, iface);
 547         return E_INVALIDARG;
 548     }
 549
 550     xmlUnlinkNode(child_node->node);
 551
 552     if(oldChild)
 553     {
 554         IXMLDOMNode_AddRef(childNode);
 555         *oldChild = childNode;
 556     }
 557
 558     return S_OK;
 559 }
 560
 561 static HRESULT WINAPI xmlnode_appendChild(
 562     IXMLDOMNode *iface,
 563     IXMLDOMNode* newChild,
 564     IXMLDOMNode** outNewChild)
 565 {
 566     xmlnode *This = impl_from_IXMLDOMNode( iface );
 567     DOMNodeType type;
 568     VARIANT var;
 569     HRESULT hr;
 570
 571     TRACE("(%p)->(%p %p)\n", This, newChild, outNewChild);
 572
 573     hr = IXMLDOMNode_get_nodeType(newChild, &type);
 574     if(FAILED(hr) || type == NODE_ATTRIBUTE) {
 575         if(outNewChild) *outNewChild = NULL;
 576         return E_FAIL;
 577     }
 578
 579     VariantInit(&var);
 580     return IXMLDOMNode_insertBefore(This->iface, newChild, var, outNewChild);
 581 }
 582
 583 static HRESULT WINAPI xmlnode_hasChildNodes(
 584     IXMLDOMNode *iface,
 585     VARIANT_BOOL* hasChild)
 586 {
 587     xmlnode *This = impl_from_IXMLDOMNode( iface );
 588
 589     TRACE("(%p)->(%p)\n", This, hasChild);
 590
 591     if (!hasChild)
 592         return E_INVALIDARG;
 593     if (!This->node->children)
 594     {
 595         *hasChild = VARIANT_FALSE;
 596         return S_FALSE;
 597     }
 598
 599     *hasChild = VARIANT_TRUE;
 600     return S_OK;
 601 }
 602
 603 static HRESULT WINAPI xmlnode_get_ownerDocument(
 604     IXMLDOMNode *iface,
 605     IXMLDOMDocument** DOMDocument)
 606 {
 607     xmlnode *This = impl_from_IXMLDOMNode( iface );
 608
 609     TRACE("(%p)->(%p)\n", This, DOMDocument);
 610
 611     return DOMDocument_create_from_xmldoc(This->node->doc, (IXMLDOMDocument3**)DOMDocument);
 612 }
 613
 614 static HRESULT WINAPI xmlnode_cloneNode(
 615     IXMLDOMNode *iface,
 616     VARIANT_BOOL deep,
 617     IXMLDOMNode** cloneRoot)
 618 {
 619     xmlnode *This = impl_from_IXMLDOMNode( iface );
 620     xmlNodePtr pClone = NULL;
 621     IXMLDOMNode *pNode = NULL;
 622
 623     TRACE("(%p)->(%d %p)\n", This, deep, cloneRoot);
 624
 625     if(!cloneRoot)
 626         return E_INVALIDARG;
 627
 628     pClone = xmlCopyNode(This->node, deep ? 1 : 2);
 629     if(pClone)
 630     {
 631         pClone->doc = This->node->doc;
 632         xmldoc_add_orphan(pClone->doc, pClone);
 633
 634         pNode = create_node(pClone);
 635         if(!pNode)
 636         {
 637             ERR("Copy failed\n");
 638             return E_FAIL;
 639         }
 640
 641         *cloneRoot = pNode;
 642     }
 643     else
 644     {
 645         ERR("Copy failed\n");
 646         return E_FAIL;
 647     }
 648
 649     return S_OK;
 650 }
 651
 652 static HRESULT WINAPI xmlnode_get_nodeTypeString(
 653     IXMLDOMNode *iface,
 654     BSTR* xmlnodeType)
 655 {
 656     xmlnode *This = impl_from_IXMLDOMNode( iface );
 657     const xmlChar *str;
 658
 659     TRACE("(%p)->(%p)\n", This, xmlnodeType );
 660
 661     if (!xmlnodeType)
 662         return E_INVALIDARG;
 663
 664     if ( !This->node )
 665         return E_FAIL;
 666
 667     switch( This->node->type )
 668     {
 669     case XML_ATTRIBUTE_NODE:
 670         str = (const xmlChar*) "attribute";
 671         break;
 672     case XML_CDATA_SECTION_NODE:
 673         str = (const xmlChar*) "cdatasection";
 674         break;
 675     case XML_COMMENT_NODE:
 676         str = (const xmlChar*) "comment";
 677         break;
 678     case XML_DOCUMENT_NODE:
 679         str = (const xmlChar*) "document";
 680         break;
 681     case XML_DOCUMENT_FRAG_NODE:
 682         str = (const xmlChar*) "documentfragment";
 683         break;
 684     case XML_ELEMENT_NODE:
 685         str = (const xmlChar*) "element";
 686         break;
 687     case XML_ENTITY_NODE:
 688         str = (const xmlChar*) "entity";
 689         break;
 690     case XML_ENTITY_REF_NODE:
 691         str = (const xmlChar*) "entityreference";
 692         break;
 693     case XML_NOTATION_NODE:
 694         str = (const xmlChar*) "notation";
 695         break;
 696     case XML_PI_NODE:
 697         str = (const xmlChar*) "processinginstruction";
 698         break;
 699     case XML_TEXT_NODE:
 700         str = (const xmlChar*) "text";
 701         break;
 702     default:
 703         FIXME("Unknown node type (%d)\n", This->node->type);
 704         str = This->node->name;
 705         break;
 706     }
 707
 708     *xmlnodeType = bstr_from_xmlChar( str );
 709     if (!*xmlnodeType)
 710         return S_FALSE;
 711
 712     return S_OK;
 713 }
 714
 715 static HRESULT WINAPI xmlnode_get_text(
 716     IXMLDOMNode *iface,
 717     BSTR* text)
 718 {
 719     xmlnode *This = impl_from_IXMLDOMNode( iface );
 720     BSTR str = NULL;
 721     xmlChar *pContent;
 722
 723     TRACE("(%p, type %d)->(%p)\n", This, This->node->type, text);
 724
 725     if ( !text )
 726         return E_INVALIDARG;
 727
 728     pContent = xmlNodeGetContent((xmlNodePtr)This->node);
 729     if(pContent)
 730     {
 731         str = bstr_from_xmlChar(pContent);
 732         xmlFree(pContent);
 733     }
 734
 735     /* Always return a string. */
 736     if (!str) str = SysAllocStringLen( NULL, 0 );
 737
 738     TRACE("%p %s\n", This, debugstr_w(str) );
 739     *text = str;
 740
 741     return S_OK;
 742 }
 743
 744 static HRESULT WINAPI xmlnode_put_text(
 745     IXMLDOMNode *iface,
 746     BSTR text)
 747 {
 748     xmlnode *This = impl_from_IXMLDOMNode( iface );
 749     xmlChar *str, *str2;
 750
 751     TRACE("(%p)->(%s)\n", This, debugstr_w(text));
 752
 753     switch(This->node->type)
 754     {
 755     case XML_DOCUMENT_NODE:
 756         return E_FAIL;
 757     default:
 758         break;
 759     }
 760
 761     str = xmlChar_from_wchar(text);
 762
 763     /* Escape the string. */
 764     str2 = xmlEncodeEntitiesReentrant(This->node->doc, str);
 765     heap_free(str);
 766
 767     xmlNodeSetContent(This->node, str2);
 768     xmlFree(str2);
 769
 770     return S_OK;
 771 }
 772
 773 static HRESULT WINAPI xmlnode_get_specified(
 774     IXMLDOMNode *iface,
 775     VARIANT_BOOL* isSpecified)
 776 {
 777     xmlnode *This = impl_from_IXMLDOMNode( iface );
 778     FIXME("(%p)->(%p) stub!\n", This, isSpecified);
 779     *isSpecified = VARIANT_TRUE;
 780     return S_OK;
 781 }
 782
 783 static HRESULT WINAPI xmlnode_get_definition(
 784     IXMLDOMNode *iface,
 785     IXMLDOMNode** definitionNode)
 786 {
 787     xmlnode *This = impl_from_IXMLDOMNode( iface );
 788     FIXME("(%p)->(%p)\n", This, definitionNode);
 789     return E_NOTIMPL;
 790 }
 791
 792 static inline BYTE hex_to_byte(xmlChar c)
 793 {
 794     if(c <= '9') return c-'0';
 795     if(c <= 'F') return c-'A'+10;
 796     return c-'a'+10;
 797 }
 798
 799 static inline BYTE base64_to_byte(xmlChar c)
 800 {
 801     if(c == '+') return 62;
 802     if(c == '/') return 63;
 803     if(c <= '9') return c-'0'+52;
 804     if(c <= 'Z') return c-'A';
 805     return c-'a'+26;
 806 }
 807
 808 static inline HRESULT VARIANT_from_xmlChar(xmlChar *str, VARIANT *v, BSTR type)
 809 {
 810     if(!type || !lstrcmpiW(type, szString) ||
 811             !lstrcmpiW(type, szNumber) || !lstrcmpiW(type, szUUID))
 812     {
 813         V_VT(v) = VT_BSTR;
 814         V_BSTR(v) = bstr_from_xmlChar(str);
 815
 816         if(!V_BSTR(v))
 817             return E_OUTOFMEMORY;
 818     }
 819     else if(!lstrcmpiW(type, szDateTime) || !lstrcmpiW(type, szDateTimeTZ) ||
 820             !lstrcmpiW(type, szDate) || !lstrcmpiW(type, szTime) ||
 821             !lstrcmpiW(type, szTimeTZ))
 822     {
 823         VARIANT src;
 824         WCHAR *p, *e;
 825         SYSTEMTIME st;
 826         DOUBLE date = 0.0;
 827
 828         st.wYear = 1899;
 829         st.wMonth = 12;
 830         st.wDay = 30;
 831         st.wDayOfWeek = st.wHour = st.wMinute = st.wSecond = st.wMilliseconds = 0;
 832
 833         V_VT(&src) = VT_BSTR;
 834         V_BSTR(&src) = bstr_from_xmlChar(str);
 835
 836         if(!V_BSTR(&src))
 837             return E_OUTOFMEMORY;
 838
 839         p = V_BSTR(&src);
 840         e = p + SysStringLen(V_BSTR(&src));
 841
 842         if(p+4<e && *(p+4)=='-') /* parse date (yyyy-mm-dd) */
 843         {
 844             st.wYear = atoiW(p);
 845             st.wMonth = atoiW(p+5);
 846             st.wDay = atoiW(p+8);
 847             p += 10;
 848
 849             if(*p == 'T') p++;
 850         }
 851
 852         if(p+2<e && *(p+2)==':') /* parse time (hh:mm:ss.?) */
 853         {
 854             st.wHour = atoiW(p);
 855             st.wMinute = atoiW(p+3);
 856             st.wSecond = atoiW(p+6);
 857             p += 8;
 858
 859             if(*p == '.')
 860             {
 861                 p++;
 862                 while(isdigitW(*p)) p++;
 863             }
 864         }
 865
 866         SystemTimeToVariantTime(&st, &date);
 867         V_VT(v) = VT_DATE;
 868         V_DATE(v) = date;
 869
 870         if(*p == '+') /* parse timezone offset (+hh:mm) */
 871             V_DATE(v) += (DOUBLE)atoiW(p+1)/24 + (DOUBLE)atoiW(p+4)/1440;
 872         else if(*p == '-') /* parse timezone offset (-hh:mm) */
 873             V_DATE(v) -= (DOUBLE)atoiW(p+1)/24 + (DOUBLE)atoiW(p+4)/1440;
 874
 875         VariantClear(&src);
 876     }
 877     else if(!lstrcmpiW(type, szBinHex))
 878     {
 879         SAFEARRAYBOUND sab;
 880         int i, len;
 881
 882         len = xmlStrlen(str)/2;
 883         sab.lLbound = 0;
 884         sab.cElements = len;
 885
 886         V_VT(v) = (VT_ARRAY|VT_UI1);
 887         V_ARRAY(v) = SafeArrayCreate(VT_UI1, 1, &sab);
 888
 889         if(!V_ARRAY(v))
 890             return E_OUTOFMEMORY;
 891
 892         for(i=0; i<len; i++)
 893             ((BYTE*)V_ARRAY(v)->pvData)[i] = (hex_to_byte(str[2*i])<<4)
 894                 + hex_to_byte(str[2*i+1]);
 895     }
 896     else if(!lstrcmpiW(type, szBinBase64))
 897     {
 898         SAFEARRAYBOUND sab;
 899         int i, len;
 900
 901         len  = xmlStrlen(str);
 902         if(str[len-2] == '=') i = 2;
 903         else if(str[len-1] == '=') i = 1;
 904         else i = 0;
 905
 906         sab.lLbound = 0;
 907         sab.cElements = len/4*3-i;
 908
 909         V_VT(v) = (VT_ARRAY|VT_UI1);
 910         V_ARRAY(v) = SafeArrayCreate(VT_UI1, 1, &sab);
 911
 912         if(!V_ARRAY(v))
 913             return E_OUTOFMEMORY;
 914
 915         for(i=0; i<len/4; i++)
 916         {
 917             ((BYTE*)V_ARRAY(v)->pvData)[3*i] = (base64_to_byte(str[4*i])<<2)
 918                 + (base64_to_byte(str[4*i+1])>>4);
 919             if(3*i+1 < sab.cElements)
 920                 ((BYTE*)V_ARRAY(v)->pvData)[3*i+1] = (base64_to_byte(str[4*i+1])<<4)
 921                     + (base64_to_byte(str[4*i+2])>>2);
 922             if(3*i+2 < sab.cElements)
 923                 ((BYTE*)V_ARRAY(v)->pvData)[3*i+2] = (base64_to_byte(str[4*i+2])<<6)
 924                     + base64_to_byte(str[4*i+3]);
 925         }
 926     }
 927     else
 928     {
 929         VARIANT src;
 930         HRESULT hres;
 931
 932         if(!lstrcmpiW(type, szInt) || !lstrcmpiW(type, szI4))
 933             V_VT(v) = VT_I4;
 934         else if(!lstrcmpiW(type, szFixed))
 935             V_VT(v) = VT_CY;
 936         else if(!lstrcmpiW(type, szBoolean))
 937             V_VT(v) = VT_BOOL;
 938         else if(!lstrcmpiW(type, szI1))
 939             V_VT(v) = VT_I1;
 940         else if(!lstrcmpiW(type, szI2))
 941             V_VT(v) = VT_I2;
 942         else if(!lstrcmpiW(type, szIU1))
 943             V_VT(v) = VT_UI1;
 944         else if(!lstrcmpiW(type, szIU2))
 945             V_VT(v) = VT_UI2;
 946         else if(!lstrcmpiW(type, szIU4))
 947             V_VT(v) = VT_UI4;
 948         else if(!lstrcmpiW(type, szR4))
 949             V_VT(v) = VT_R4;
 950         else if(!lstrcmpiW(type, szR8) || !lstrcmpiW(type, szFloat))
 951             V_VT(v) = VT_R8;
 952         else
 953         {
 954             FIXME("Type handling not yet implemented\n");
 955             V_VT(v) = VT_BSTR;
 956         }
 957
 958         V_VT(&src) = VT_BSTR;
 959         V_BSTR(&src) = bstr_from_xmlChar(str);
 960
 961         if(!V_BSTR(&src))
 962             return E_OUTOFMEMORY;
 963
 964         hres = VariantChangeTypeEx(v, &src, MAKELCID(MAKELANGID(
 965                         LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT),0, V_VT(v));
 966         VariantClear(&src);
 967         return hres;
 968     }
 969
 970     return S_OK;
 971 }
 972
 973 static HRESULT WINAPI xmlnode_get_nodeTypedValue(
 974     IXMLDOMNode *iface,
 975     VARIANT* typedValue)
 976 {
 977     xmlnode *This = impl_from_IXMLDOMNode( iface );
 978     VARIANT type;
 979     xmlChar *content;
 980     HRESULT hres = S_FALSE;
 981
 982     TRACE("(%p)->(%p)\n", This, typedValue);
 983
 984     if(!typedValue)
 985         return E_INVALIDARG;
 986
 987     V_VT(typedValue) = VT_NULL;
 988
 989     if(This->node->type == XML_ELEMENT_NODE ||
 990             This->node->type == XML_TEXT_NODE ||
 991             This->node->type == XML_ENTITY_REF_NODE)
 992         hres = IXMLDOMNode_get_dataType(This->iface, &type);
 993
 994     if(hres != S_OK && This->node->type != XML_ELEMENT_NODE)
 995         return IXMLDOMNode_get_nodeValue(This->iface, typedValue);
 996
 997     content = xmlNodeGetContent(This->node);
 998     hres = VARIANT_from_xmlChar(content, typedValue,
 999             hres==S_OK ? V_BSTR(&type) : NULL);
1000     xmlFree(content);
1001     VariantClear(&type);
1002
1003     return hres;
1004 }
1005
1006 static HRESULT WINAPI xmlnode_put_nodeTypedValue(
1007     IXMLDOMNode *iface,
1008     VARIANT typedValue)
1009 {
1010     xmlnode *This = impl_from_IXMLDOMNode( iface );
1011     FIXME("%p\n", This);
1012     return E_NOTIMPL;
1013 }
1014
1015 static HRESULT WINAPI xmlnode_get_dataType(
1016     IXMLDOMNode *iface,
1017     VARIANT* dataTypeName)
1018 {
1019     xmlnode *This = impl_from_IXMLDOMNode( iface );
1020     xmlChar *pVal;
1021
1022     TRACE("(%p)->(%p)\n", This, dataTypeName);
1023
1024     if(!dataTypeName)
1025         return E_INVALIDARG;
1026
1027     /* Attribute, CDATA Section, Comment, Document, Document Fragment,
1028         Entity, Notation, PI, and Text Node are non-typed. */
1029     V_BSTR(dataTypeName) = NULL;
1030     V_VT(dataTypeName) = VT_NULL;
1031
1032     switch ( This->node->type )
1033     {
1034     case XML_ELEMENT_NODE:
1035         pVal = xmlGetNsProp(This->node, (const xmlChar*)"dt",
1036                             (const xmlChar*)"urn:schemas-microsoft-com:datatypes");
1037         if (pVal)
1038         {
1039             V_VT(dataTypeName) = VT_BSTR;
1040             V_BSTR(dataTypeName) = bstr_from_xmlChar( pVal );
1041             xmlFree(pVal);
1042         }
1043         break;
1044     case XML_ENTITY_REF_NODE:
1045         FIXME("XML_ENTITY_REF_NODE should return a valid value.\n");
1046         break;
1047     default:
1048         TRACE("Type %d returning NULL\n", This->node->type);
1049     }
1050
1051     /* non-typed nodes return S_FALSE */
1052     if(V_VT(dataTypeName) == VT_NULL)
1053     {
1054         return S_FALSE;
1055     }
1056
1057     return S_OK;
1058 }
1059
1060 static HRESULT WINAPI xmlnode_put_dataType(
1061     IXMLDOMNode *iface,
1062     BSTR dataTypeName)
1063 {
1064     xmlnode *This = impl_from_IXMLDOMNode( iface );
1065     HRESULT hr = E_FAIL;
1066
1067     TRACE("(%p)->(%s)\n", This, debugstr_w(dataTypeName));
1068
1069     if(dataTypeName == NULL)
1070         return E_INVALIDARG;
1071
1072     /* An example of this is. The Text in the node needs to be a 0 or 1 for a boolean type.
1073        This applies to changing types (string->bool) or setting a new one
1074      */
1075     FIXME("Need to Validate the data before allowing a type to be set.\n");
1076
1077     /* Check all supported types. */
1078     if(lstrcmpiW(dataTypeName,szString) == 0  ||
1079        lstrcmpiW(dataTypeName,szNumber) == 0  ||
1080        lstrcmpiW(dataTypeName,szUUID) == 0    ||
1081        lstrcmpiW(dataTypeName,szInt) == 0     ||
1082        lstrcmpiW(dataTypeName,szI4) == 0      ||
1083        lstrcmpiW(dataTypeName,szFixed) == 0   ||
1084        lstrcmpiW(dataTypeName,szBoolean) == 0 ||
1085        lstrcmpiW(dataTypeName,szDateTime) == 0 ||
1086        lstrcmpiW(dataTypeName,szDateTimeTZ) == 0 ||
1087        lstrcmpiW(dataTypeName,szDate) == 0    ||
1088        lstrcmpiW(dataTypeName,szTime) == 0    ||
1089        lstrcmpiW(dataTypeName,szTimeTZ) == 0  ||
1090        lstrcmpiW(dataTypeName,szI1) == 0      ||
1091        lstrcmpiW(dataTypeName,szI2) == 0      ||
1092        lstrcmpiW(dataTypeName,szIU1) == 0     ||
1093        lstrcmpiW(dataTypeName,szIU2) == 0     ||
1094        lstrcmpiW(dataTypeName,szIU4) == 0     ||
1095        lstrcmpiW(dataTypeName,szR4) == 0      ||
1096        lstrcmpiW(dataTypeName,szR8) == 0      ||
1097        lstrcmpiW(dataTypeName,szFloat) == 0   ||
1098        lstrcmpiW(dataTypeName,szBinHex) == 0  ||
1099        lstrcmpiW(dataTypeName,szBinBase64) == 0)
1100     {
1101         xmlChar* str = xmlChar_from_wchar(dataTypeName);
1102         xmlAttrPtr attr;
1103
1104         if (!str) return E_OUTOFMEMORY;
1105
1106         attr = xmlHasNsProp(This->node, (const xmlChar*)"dt",
1107                             (const xmlChar*)"urn:schemas-microsoft-com:datatypes");
1108         if (attr)
1109         {
1110             attr = xmlSetNsProp(This->node, attr->ns, (const xmlChar*)"dt", str);
1111             hr = S_OK;
1112         }
1113         else
1114         {
1115             xmlNsPtr ns = xmlNewNs(This->node, (const xmlChar*)"urn:schemas-microsoft-com:datatypes", (const xmlChar*)"dt");
1116             if (ns)
1117             {
1118                 attr = xmlNewNsProp(This->node, ns, (const xmlChar*)"dt", str);
1119                 if (attr)
1120                 {
1121                     xmlAddChild(This->node, (xmlNodePtr)attr);
1122                     hr = S_OK;
1123                 }
1124                 else
1125                     ERR("Failed to create Attribute\n");
1126             }
1127             else
1128                 ERR("Failed to create Namespace\n");
1129         }
1130         heap_free( str );
1131     }
1132
1133     return hr;
1134 }
1135
1136 static BSTR EnsureCorrectEOL(BSTR sInput)
1137 {
1138     int nNum = 0;
1139     BSTR sNew;
1140     int nLen;
1141     int i;
1142
1143     nLen = lstrlenW(sInput);
1144     /* Count line endings */
1145     for(i=0; i < nLen; i++)
1146     {
1147         if(sInput[i] == '\n')
1148             nNum++;
1149     }
1150
1151     TRACE("len=%d, num=%d\n", nLen, nNum);
1152
1153     /* Add linefeed as needed */
1154     if(nNum > 0)
1155     {
1156         int nPlace = 0;
1157         sNew = SysAllocStringLen(NULL, nLen + nNum+1);
1158         for(i=0; i < nLen; i++)
1159         {
1160             if(sInput[i] == '\n')
1161             {
1162                 sNew[i+nPlace] = '\r';
1163                 nPlace++;
1164             }
1165             sNew[i+nPlace] = sInput[i];
1166         }
1167
1168         SysFreeString(sInput);
1169     }
1170     else
1171     {
1172         sNew = sInput;
1173     }
1174
1175     TRACE("len %d\n", lstrlenW(sNew));
1176
1177     return sNew;
1178 }
1179
1180 /* Removes encoding information and last character (nullbyte) */
1181 static BSTR EnsureNoEncoding(BSTR sInput)
1182 {
1183     static const WCHAR wszEncoding[] = {'e','n','c','o','d','i','n','g','='};
1184     BSTR sNew;
1185     WCHAR *pBeg, *pEnd;
1186
1187     pBeg = sInput;
1188     while(*pBeg != '\n' && memcmp(pBeg, wszEncoding, sizeof(wszEncoding)))
1189         pBeg++;
1190
1191     if(*pBeg == '\n')
1192     {
1193         SysReAllocStringLen(&sInput, sInput, SysStringLen(sInput)-1);
1194         return sInput;
1195     }
1196     pBeg--;
1197
1198     pEnd = pBeg + sizeof(wszEncoding)/sizeof(WCHAR) + 2;
1199     while(*pEnd != '\"') pEnd++;
1200     pEnd++;
1201
1202     sNew = SysAllocStringLen(NULL,
1203             pBeg-sInput + SysStringLen(sInput)-(pEnd-sInput)-1);
1204     memcpy(sNew, sInput, (pBeg-sInput)*sizeof(WCHAR));
1205     memcpy(&sNew[pBeg-sInput], pEnd, (SysStringLen(sInput)-(pEnd-sInput)-1)*sizeof(WCHAR));
1206
1207     SysFreeString(sInput);
1208     return sNew;
1209 }
1210
1211 /*
1212  * We are trying to replicate the same behaviour as msxml by converting
1213  * line endings to \r\n and using indents as \t. The problem is that msxml
1214  * only formats nodes that have a line ending. Using libxml we cannot
1215  * reproduce behaviour exactly.
1216  *
1217  */
1218 static HRESULT WINAPI xmlnode_get_xml(
1219     IXMLDOMNode *iface,
1220     BSTR* xmlString)
1221 {
1222     xmlnode *This = impl_from_IXMLDOMNode( iface );
1223     xmlBufferPtr pXmlBuf;
1224     xmlNodePtr xmldecl;
1225     int nSize;
1226
1227     TRACE("(%p %d)->(%p)\n", This, This->node->type, xmlString);
1228
1229     if(!xmlString)
1230         return E_INVALIDARG;
1231
1232     *xmlString = NULL;
1233
1234     xmldecl = xmldoc_unlink_xmldecl( This->node->doc );
1235
1236     pXmlBuf = xmlBufferCreate();
1237     if(pXmlBuf)
1238     {
1239         nSize = xmlNodeDump(pXmlBuf, This->node->doc, This->node, 0, 1);
1240         if(nSize > 0)
1241         {
1242             const xmlChar *pContent;
1243             BSTR bstrContent;
1244
1245             /* Attribute Nodes return a space in front of their name */
1246             pContent = xmlBufferContent(pXmlBuf);
1247             if( ((const char*)pContent)[0] == ' ')
1248                 bstrContent = bstr_from_xmlChar(pContent+1);
1249             else
1250                 bstrContent = bstr_from_xmlChar(pContent);
1251
1252             switch(This->node->type)
1253             {
1254                 case XML_ELEMENT_NODE:
1255                     *xmlString = EnsureCorrectEOL(bstrContent);
1256                     break;
1257                 case XML_DOCUMENT_NODE:
1258                     *xmlString = EnsureCorrectEOL(bstrContent);
1259                     *xmlString = EnsureNoEncoding(*xmlString);
1260                     break;
1261                 default:
1262                     *xmlString = bstrContent;
1263             }
1264         }
1265
1266         xmlBufferFree(pXmlBuf);
1267     }
1268
1269     xmldoc_link_xmldecl( This->node->doc, xmldecl );
1270
1271     /* Always returns a string. */
1272     if(*xmlString == NULL)  *xmlString = SysAllocStringLen( NULL, 0 );
1273
1274     return S_OK;
1275 }
1276
1277 static HRESULT WINAPI xmlnode_transformNode(
1278     IXMLDOMNode *iface,
1279     IXMLDOMNode* styleSheet,
1280     BSTR* xmlString)
1281 {
1282 #ifdef SONAME_LIBXSLT
1283     xmlnode *This = impl_from_IXMLDOMNode( iface );
1284     xmlnode *pStyleSheet = NULL;
1285     xsltStylesheetPtr xsltSS = NULL;
1286     xmlDocPtr result = NULL;
1287
1288     TRACE("(%p)->(%p %p)\n", This, styleSheet, xmlString);
1289
1290     if (!libxslt_handle)
1291         return E_NOTIMPL;
1292     if(!styleSheet || !xmlString)
1293         return E_INVALIDARG;
1294
1295     *xmlString = NULL;
1296
1297     pStyleSheet = get_node_obj(styleSheet);
1298     if(!pStyleSheet) {
1299         FIXME("styleSheet is not our xmlnode implementation\n");
1300         return E_FAIL;
1301     }
1302
1303     xsltSS = pxsltParseStylesheetDoc( pStyleSheet->node->doc);
1304     if(xsltSS)
1305     {
1306         result = pxsltApplyStylesheet(xsltSS, This->node->doc, NULL);
1307         if(result)
1308         {
1309             const xmlChar *pContent;
1310
1311             if(result->type == XML_HTML_DOCUMENT_NODE)
1312             {
1313                 xmlOutputBufferPtr      pOutput = xmlAllocOutputBuffer(NULL);
1314                 if(pOutput)
1315                 {
1316                     htmlDocContentDumpOutput(pOutput, result->doc, NULL);
1317                     pContent = xmlBufferContent(pOutput->buffer);
1318                     *xmlString = bstr_from_xmlChar(pContent);
1319                     xmlOutputBufferClose(pOutput);
1320                 }
1321             }
1322             else
1323             {
1324                 xmlBufferPtr pXmlBuf;
1325                 int nSize;
1326
1327                 pXmlBuf = xmlBufferCreate();
1328                 if(pXmlBuf)
1329                 {
1330                     nSize = xmlNodeDump(pXmlBuf, NULL, (xmlNodePtr)result, 0, 0);
1331                     if(nSize > 0)
1332                     {
1333                         pContent = xmlBufferContent(pXmlBuf);
1334                         *xmlString = bstr_from_xmlChar(pContent);
1335                     }
1336                     xmlBufferFree(pXmlBuf);
1337                 }
1338             }
1339             xmlFreeDoc(result);
1340         }
1341         /* libxslt "helpfully" frees the XML document the stylesheet was
1342            generated from, too */
1343         xsltSS->doc = NULL;
1344         pxsltFreeStylesheet(xsltSS);
1345     }
1346
1347     if(*xmlString == NULL)
1348         *xmlString = SysAllocStringLen(NULL, 0);
1349
1350     return S_OK;
1351 #else
1352     FIXME("libxslt headers were not found at compile time\n");
1353     return E_NOTIMPL;
1354 #endif
1355 }
1356
1357 static HRESULT WINAPI xmlnode_selectNodes(
1358     IXMLDOMNode *iface,
1359     BSTR queryString,
1360     IXMLDOMNodeList** resultList)
1361 {
1362     xmlnode *This = impl_from_IXMLDOMNode( iface );
1363
1364     TRACE("(%p)->(%s %p)\n", This, debugstr_w(queryString), resultList );
1365
1366     return queryresult_create( This->node, queryString, resultList );
1367 }
1368
1369 static HRESULT WINAPI xmlnode_selectSingleNode(
1370     IXMLDOMNode *iface,
1371     BSTR queryString,
1372     IXMLDOMNode** resultNode)
1373 {
1374     xmlnode *This = impl_from_IXMLDOMNode( iface );
1375     IXMLDOMNodeList *list;
1376     HRESULT r;
1377
1378     TRACE("(%p)->(%s %p)\n", This, debugstr_w(queryString), resultNode );
1379
1380     *resultNode = NULL;
1381     r = IXMLDOMNode_selectNodes(This->iface, queryString, &list);
1382     if(r == S_OK)
1383     {
1384         r = IXMLDOMNodeList_nextNode(list, resultNode);
1385         IXMLDOMNodeList_Release(list);
1386     }
1387     return r;
1388 }
1389
1390 static HRESULT WINAPI xmlnode_get_parsed(
1391     IXMLDOMNode *iface,
1392     VARIANT_BOOL* isParsed)
1393 {
1394     xmlnode *This = impl_from_IXMLDOMNode( iface );
1395     FIXME("(%p)->(%p) stub!\n", This, isParsed);
1396     *isParsed = VARIANT_TRUE;
1397     return S_OK;
1398 }
1399
1400 static HRESULT WINAPI xmlnode_get_namespaceURI(
1401     IXMLDOMNode *iface,
1402     BSTR* namespaceURI)
1403 {
1404     xmlnode *This = impl_from_IXMLDOMNode( iface );
1405     HRESULT hr = S_FALSE;
1406     xmlNsPtr *pNSList;
1407
1408     TRACE("(%p)->(%p)\n", This, namespaceURI );
1409
1410     if(!namespaceURI)
1411         return E_INVALIDARG;
1412
1413     *namespaceURI = NULL;
1414
1415     pNSList = xmlGetNsList(This->node->doc, This->node);
1416     if(pNSList)
1417     {
1418         *namespaceURI = bstr_from_xmlChar( pNSList[0]->href );
1419
1420         xmlFree( pNSList );
1421         hr = S_OK;
1422     }
1423
1424     return hr;
1425 }
1426
1427 static HRESULT WINAPI xmlnode_get_prefix(
1428     IXMLDOMNode *iface,
1429     BSTR* prefixString)
1430 {
1431     xmlnode *This = impl_from_IXMLDOMNode( iface );
1432     HRESULT hr = S_FALSE;
1433     xmlNsPtr *pNSList;
1434
1435     TRACE("(%p)->(%p)\n", This, prefixString );
1436
1437     if(!prefixString)
1438         return E_INVALIDARG;
1439
1440     *prefixString = NULL;
1441
1442     pNSList = xmlGetNsList(This->node->doc, This->node);
1443     if(pNSList)
1444     {
1445         *prefixString = bstr_from_xmlChar( pNSList[0]->prefix );
1446
1447         xmlFree(pNSList);
1448         hr = S_OK;
1449     }
1450
1451     return hr;
1452 }
1453
1454 static HRESULT WINAPI xmlnode_get_baseName(
1455     IXMLDOMNode *iface,
1456     BSTR* nameString)
1457 {
1458     xmlnode *This = impl_from_IXMLDOMNode( iface );
1459     BSTR str = NULL;
1460     HRESULT r = S_FALSE;
1461
1462     TRACE("(%p)->(%p)\n", This, nameString );
1463
1464     if ( !nameString )
1465         return E_INVALIDARG;
1466
1467     switch ( This->node->type )
1468     {
1469     case XML_ELEMENT_NODE:
1470     case XML_ATTRIBUTE_NODE:
1471     case XML_PI_NODE:
1472         str = bstr_from_xmlChar( This->node->name );
1473         r = S_OK;
1474         break;
1475     case XML_TEXT_NODE:
1476     case XML_COMMENT_NODE:
1477     case XML_DOCUMENT_NODE:
1478         break;
1479     default:
1480         ERR("Unhandled type %d\n", This->node->type );
1481         break;
1482     }
1483
1484     TRACE("returning %08x str = %s\n", r, debugstr_w( str ) );
1485
1486     *nameString = str;
1487     return r;
1488 }
1489
1490 static HRESULT WINAPI xmlnode_transformNodeToObject(
1491     IXMLDOMNode *iface,
1492     IXMLDOMNode* stylesheet,
1493     VARIANT outputObject)
1494 {
1495     xmlnode *This = impl_from_IXMLDOMNode( iface );
1496     FIXME("(%p)->(%p)\n", This, stylesheet);
1497     return E_NOTIMPL;
1498 }
1499
1500 static const struct IXMLDOMNodeVtbl xmlnode_vtbl =
1501 {
1502     xmlnode_QueryInterface,
1503     xmlnode_AddRef,
1504     xmlnode_Release,
1505     xmlnode_GetTypeInfoCount,
1506     xmlnode_GetTypeInfo,
1507     xmlnode_GetIDsOfNames,
1508     xmlnode_Invoke,
1509     xmlnode_get_nodeName,
1510     xmlnode_get_nodeValue,
1511     xmlnode_put_nodeValue,
1512     xmlnode_get_nodeType,
1513     xmlnode_get_parentNode,
1514     xmlnode_get_childNodes,
1515     xmlnode_get_firstChild,
1516     xmlnode_get_lastChild,
1517     xmlnode_get_previousSibling,
1518     xmlnode_get_nextSibling,
1519     xmlnode_get_attributes,
1520     xmlnode_insertBefore,
1521     xmlnode_replaceChild,
1522     xmlnode_removeChild,
1523     xmlnode_appendChild,
1524     xmlnode_hasChildNodes,
1525     xmlnode_get_ownerDocument,
1526     xmlnode_cloneNode,
1527     xmlnode_get_nodeTypeString,
1528     xmlnode_get_text,
1529     xmlnode_put_text,
1530     xmlnode_get_specified,
1531     xmlnode_get_definition,
1532     xmlnode_get_nodeTypedValue,
1533     xmlnode_put_nodeTypedValue,
1534     xmlnode_get_dataType,
1535     xmlnode_put_dataType,
1536     xmlnode_get_xml,
1537     xmlnode_transformNode,
1538     xmlnode_selectNodes,
1539     xmlnode_selectSingleNode,
1540     xmlnode_get_parsed,
1541     xmlnode_get_namespaceURI,
1542     xmlnode_get_prefix,
1543     xmlnode_get_baseName,
1544     xmlnode_transformNodeToObject,
1545 };
1546
1547 void destroy_xmlnode(xmlnode *This)
1548 {
1549     if(This->node)
1550         xmldoc_release(This->node->doc);
1551 }
1552
1553 void init_xmlnode(xmlnode *This, xmlNodePtr node, IXMLDOMNode *node_iface, dispex_static_data_t *dispex_data)
1554 {
1555     if(node)
1556         xmldoc_add_ref( node->doc );
1557
1558     This->lpVtbl = &xmlnode_vtbl;
1559     This->node = node;
1560     This->iface = node_iface;
1561
1562     if(dispex_data)
1563         init_dispex(&This->dispex, (IUnknown*)This->iface, dispex_data);
1564     else
1565         This->dispex.outer = NULL;
1566 }
1567
1568 typedef struct {
1569     xmlnode node;
1570     const IXMLDOMNodeVtbl *lpVtbl;
1571     LONG ref;
1572 } unknode;
1573
1574 static inline unknode *impl_from_unkIXMLDOMNode(IXMLDOMNode *iface)
1575 {
1576     return (unknode *)((char*)iface - FIELD_OFFSET(unknode, lpVtbl));
1577 }
1578
1579 static HRESULT WINAPI unknode_QueryInterface(
1580     IXMLDOMNode *iface,
1581     REFIID riid,
1582     void** ppvObject )
1583 {
1584     unknode *This = impl_from_unkIXMLDOMNode( iface );
1585
1586     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
1587
1588     if (IsEqualGUID(riid, &IID_IUnknown)) {
1589         *ppvObject = iface;
1590     }else if (IsEqualGUID( riid, &IID_IDispatch) ||
1591               IsEqualGUID( riid, &IID_IXMLDOMNode)) {
1592         *ppvObject = &This->lpVtbl;
1593     }else if(node_query_interface(&This->node, riid, ppvObject)) {
1594         return *ppvObject ? S_OK : E_NOINTERFACE;
1595     }else  {
1596         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1597         *ppvObject = NULL;
1598         return E_NOINTERFACE;
1599     }
1600
1601     IUnknown_AddRef((IUnknown*)*ppvObject);
1602     return S_OK;
1603 }
1604
1605 static ULONG WINAPI unknode_AddRef(
1606     IXMLDOMNode *iface )
1607 {
1608     unknode *This = impl_from_unkIXMLDOMNode( iface );
1609
1610     return InterlockedIncrement(&This->ref);
1611 }
1612
1613 static ULONG WINAPI unknode_Release(
1614     IXMLDOMNode *iface )
1615 {
1616     unknode *This = impl_from_unkIXMLDOMNode( iface );
1617     LONG ref;
1618
1619     ref = InterlockedDecrement( &This->ref );
1620     if(!ref) {
1621         destroy_xmlnode(&This->node);
1622         heap_free(This);
1623     }
1624
1625     return ref;
1626 }
1627
1628 static HRESULT WINAPI unknode_GetTypeInfoCount(
1629     IXMLDOMNode *iface,
1630     UINT* pctinfo )
1631 {
1632     unknode *This = impl_from_unkIXMLDOMNode( iface );
1633
1634     TRACE("(%p)->(%p)\n", This, pctinfo);
1635
1636     *pctinfo = 1;
1637
1638     return S_OK;
1639 }
1640
1641 static HRESULT WINAPI unknode_GetTypeInfo(
1642     IXMLDOMNode *iface,
1643     UINT iTInfo,
1644     LCID lcid,
1645     ITypeInfo** ppTInfo )
1646 {
1647     unknode *This = impl_from_unkIXMLDOMNode( iface );
1648     HRESULT hr;
1649
1650     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1651
1652     hr = get_typeinfo(IXMLDOMNode_tid, ppTInfo);
1653
1654     return hr;
1655 }
1656
1657 static HRESULT WINAPI unknode_GetIDsOfNames(
1658     IXMLDOMNode *iface,
1659     REFIID riid,
1660     LPOLESTR* rgszNames,
1661     UINT cNames,
1662     LCID lcid,
1663     DISPID* rgDispId )
1664 {
1665     unknode *This = impl_from_unkIXMLDOMNode( iface );
1666
1667     ITypeInfo *typeinfo;
1668     HRESULT hr;
1669
1670     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1671           lcid, rgDispId);
1672
1673     if(!rgszNames || cNames == 0 || !rgDispId)
1674         return E_INVALIDARG;
1675
1676     hr = get_typeinfo(IXMLDOMNode_tid, &typeinfo);
1677     if(SUCCEEDED(hr))
1678     {
1679         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1680         ITypeInfo_Release(typeinfo);
1681     }
1682
1683     return hr;
1684 }
1685
1686 static HRESULT WINAPI unknode_Invoke(
1687     IXMLDOMNode *iface,
1688     DISPID dispIdMember,
1689     REFIID riid,
1690     LCID lcid,
1691     WORD wFlags,
1692     DISPPARAMS* pDispParams,
1693     VARIANT* pVarResult,
1694     EXCEPINFO* pExcepInfo,
1695     UINT* puArgErr )
1696 {
1697     unknode *This = impl_from_unkIXMLDOMNode( iface );
1698     ITypeInfo *typeinfo;
1699     HRESULT hr;
1700
1701     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1702           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1703
1704     hr = get_typeinfo(IXMLDOMNode_tid, &typeinfo);
1705     if(SUCCEEDED(hr))
1706     {
1707         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
1708                 pVarResult, pExcepInfo, puArgErr);
1709         ITypeInfo_Release(typeinfo);
1710     }
1711
1712     return hr;
1713 }
1714
1715 static HRESULT WINAPI unknode_get_nodeName(
1716     IXMLDOMNode *iface,
1717     BSTR* p )
1718 {
1719     unknode *This = impl_from_unkIXMLDOMNode( iface );
1720
1721     FIXME("(%p)->(%p)\n", This, p);
1722
1723     return node_get_nodeName(&This->node, p);
1724 }
1725
1726 static HRESULT WINAPI unknode_get_nodeValue(
1727     IXMLDOMNode *iface,
1728     VARIANT* value)
1729 {
1730     unknode *This = impl_from_unkIXMLDOMNode( iface );
1731
1732     FIXME("(%p)->(%p)\n", This, value);
1733
1734     if(!value)
1735         return E_INVALIDARG;
1736
1737     V_VT(value) = VT_NULL;
1738     return S_FALSE;
1739 }
1740
1741 static HRESULT WINAPI unknode_put_nodeValue(
1742     IXMLDOMNode *iface,
1743     VARIANT value)
1744 {
1745     unknode *This = impl_from_unkIXMLDOMNode( iface );
1746     FIXME("(%p)->(v%d)\n", This, V_VT(&value));
1747     return E_FAIL;
1748 }
1749
1750 static HRESULT WINAPI unknode_get_nodeType(
1751     IXMLDOMNode *iface,
1752     DOMNodeType* domNodeType )
1753 {
1754     unknode *This = impl_from_unkIXMLDOMNode( iface );
1755
1756     FIXME("(%p)->(%p)\n", This, domNodeType);
1757
1758     *domNodeType = This->node.node->type;
1759     return S_OK;
1760 }
1761
1762 static HRESULT WINAPI unknode_get_parentNode(
1763     IXMLDOMNode *iface,
1764     IXMLDOMNode** parent )
1765 {
1766     unknode *This = impl_from_unkIXMLDOMNode( iface );
1767     FIXME("(%p)->(%p)\n", This, parent);
1768     if (!parent) return E_INVALIDARG;
1769     *parent = NULL;
1770     return S_FALSE;
1771 }
1772
1773 static HRESULT WINAPI unknode_get_childNodes(
1774     IXMLDOMNode *iface,
1775     IXMLDOMNodeList** outList)
1776 {
1777     unknode *This = impl_from_unkIXMLDOMNode( iface );
1778
1779     TRACE("(%p)->(%p)\n", This, outList);
1780
1781     return node_get_child_nodes(&This->node, outList);
1782 }
1783
1784 static HRESULT WINAPI unknode_get_firstChild(
1785     IXMLDOMNode *iface,
1786     IXMLDOMNode** domNode)
1787 {
1788     unknode *This = impl_from_unkIXMLDOMNode( iface );
1789
1790     TRACE("(%p)->(%p)\n", This, domNode);
1791
1792     return node_get_first_child(&This->node, domNode);
1793 }
1794
1795 static HRESULT WINAPI unknode_get_lastChild(
1796     IXMLDOMNode *iface,
1797     IXMLDOMNode** domNode)
1798 {
1799     unknode *This = impl_from_unkIXMLDOMNode( iface );
1800
1801     TRACE("(%p)->(%p)\n", This, domNode);
1802
1803     return node_get_last_child(&This->node, domNode);
1804 }
1805
1806 static HRESULT WINAPI unknode_get_previousSibling(
1807     IXMLDOMNode *iface,
1808     IXMLDOMNode** domNode)
1809 {
1810     unknode *This = impl_from_unkIXMLDOMNode( iface );
1811
1812     TRACE("(%p)->(%p)\n", This, domNode);
1813
1814     return node_get_previous_sibling(&This->node, domNode);
1815 }
1816
1817 static HRESULT WINAPI unknode_get_nextSibling(
1818     IXMLDOMNode *iface,
1819     IXMLDOMNode** domNode)
1820 {
1821     unknode *This = impl_from_unkIXMLDOMNode( iface );
1822
1823     TRACE("(%p)->(%p)\n", This, domNode);
1824
1825     return node_get_next_sibling(&This->node, domNode);
1826 }
1827
1828 static HRESULT WINAPI unknode_get_attributes(
1829     IXMLDOMNode *iface,
1830     IXMLDOMNamedNodeMap** attributeMap)
1831 {
1832     unknode *This = impl_from_unkIXMLDOMNode( iface );
1833
1834     FIXME("(%p)->(%p)\n", This, attributeMap);
1835
1836     return return_null_ptr((void**)attributeMap);
1837 }
1838
1839 static HRESULT WINAPI unknode_insertBefore(
1840     IXMLDOMNode *iface,
1841     IXMLDOMNode* newNode, VARIANT refChild,
1842     IXMLDOMNode** outOldNode)
1843 {
1844     unknode *This = impl_from_unkIXMLDOMNode( iface );
1845
1846     FIXME("(%p)->(%p x%d %p)\n", This, newNode, V_VT(&refChild), outOldNode);
1847
1848     return node_insert_before(&This->node, newNode, &refChild, outOldNode);
1849 }
1850
1851 static HRESULT WINAPI unknode_replaceChild(
1852     IXMLDOMNode *iface,
1853     IXMLDOMNode* newNode,
1854     IXMLDOMNode* oldNode,
1855     IXMLDOMNode** outOldNode)
1856 {
1857     unknode *This = impl_from_unkIXMLDOMNode( iface );
1858     return IXMLDOMNode_replaceChild( IXMLDOMNode_from_impl(&This->node), newNode, oldNode, outOldNode );
1859 }
1860
1861 static HRESULT WINAPI unknode_removeChild(
1862     IXMLDOMNode *iface,
1863     IXMLDOMNode* domNode, IXMLDOMNode** oldNode)
1864 {
1865     unknode *This = impl_from_unkIXMLDOMNode( iface );
1866     return IXMLDOMNode_removeChild( IXMLDOMNode_from_impl(&This->node), domNode, oldNode );
1867 }
1868
1869 static HRESULT WINAPI unknode_appendChild(
1870     IXMLDOMNode *iface,
1871     IXMLDOMNode* newNode, IXMLDOMNode** outNewNode)
1872 {
1873     unknode *This = impl_from_unkIXMLDOMNode( iface );
1874     return IXMLDOMNode_appendChild( IXMLDOMNode_from_impl(&This->node), newNode, outNewNode );
1875 }
1876
1877 static HRESULT WINAPI unknode_hasChildNodes(
1878     IXMLDOMNode *iface,
1879     VARIANT_BOOL* pbool)
1880 {
1881     unknode *This = impl_from_unkIXMLDOMNode( iface );
1882     return IXMLDOMNode_hasChildNodes( IXMLDOMNode_from_impl(&This->node), pbool );
1883 }
1884
1885 static HRESULT WINAPI unknode_get_ownerDocument(
1886     IXMLDOMNode *iface,
1887     IXMLDOMDocument** domDocument)
1888 {
1889     unknode *This = impl_from_unkIXMLDOMNode( iface );
1890     return IXMLDOMNode_get_ownerDocument( IXMLDOMNode_from_impl(&This->node), domDocument );
1891 }
1892
1893 static HRESULT WINAPI unknode_cloneNode(
1894     IXMLDOMNode *iface,
1895     VARIANT_BOOL pbool, IXMLDOMNode** outNode)
1896 {
1897     unknode *This = impl_from_unkIXMLDOMNode( iface );
1898     return IXMLDOMNode_cloneNode( IXMLDOMNode_from_impl(&This->node), pbool, outNode );
1899 }
1900
1901 static HRESULT WINAPI unknode_get_nodeTypeString(
1902     IXMLDOMNode *iface,
1903     BSTR* p)
1904 {
1905     unknode *This = impl_from_unkIXMLDOMNode( iface );
1906     return IXMLDOMNode_get_nodeTypeString( IXMLDOMNode_from_impl(&This->node), p );
1907 }
1908
1909 static HRESULT WINAPI unknode_get_text(
1910     IXMLDOMNode *iface,
1911     BSTR* p)
1912 {
1913     unknode *This = impl_from_unkIXMLDOMNode( iface );
1914     return IXMLDOMNode_get_text( IXMLDOMNode_from_impl(&This->node), p );
1915 }
1916
1917 static HRESULT WINAPI unknode_put_text(
1918     IXMLDOMNode *iface,
1919     BSTR p)
1920 {
1921     unknode *This = impl_from_unkIXMLDOMNode( iface );
1922     return IXMLDOMNode_put_text( IXMLDOMNode_from_impl(&This->node), p );
1923 }
1924
1925 static HRESULT WINAPI unknode_get_specified(
1926     IXMLDOMNode *iface,
1927     VARIANT_BOOL* pbool)
1928 {
1929     unknode *This = impl_from_unkIXMLDOMNode( iface );
1930     return IXMLDOMNode_get_specified( IXMLDOMNode_from_impl(&This->node), pbool );
1931 }
1932
1933 static HRESULT WINAPI unknode_get_definition(
1934     IXMLDOMNode *iface,
1935     IXMLDOMNode** domNode)
1936 {
1937     unknode *This = impl_from_unkIXMLDOMNode( iface );
1938     return IXMLDOMNode_get_definition( IXMLDOMNode_from_impl(&This->node), domNode );
1939 }
1940
1941 static HRESULT WINAPI unknode_get_nodeTypedValue(
1942     IXMLDOMNode *iface,
1943     VARIANT* var1)
1944 {
1945     unknode *This = impl_from_unkIXMLDOMNode( iface );
1946     return IXMLDOMNode_get_nodeTypedValue( IXMLDOMNode_from_impl(&This->node), var1 );
1947 }
1948
1949 static HRESULT WINAPI unknode_put_nodeTypedValue(
1950     IXMLDOMNode *iface,
1951     VARIANT var1)
1952 {
1953     unknode *This = impl_from_unkIXMLDOMNode( iface );
1954     return IXMLDOMNode_put_nodeTypedValue( IXMLDOMNode_from_impl(&This->node), var1 );
1955 }
1956
1957 static HRESULT WINAPI unknode_get_dataType(
1958     IXMLDOMNode *iface,
1959     VARIANT* var1)
1960 {
1961     unknode *This = impl_from_unkIXMLDOMNode( iface );
1962     return IXMLDOMNode_get_dataType( IXMLDOMNode_from_impl(&This->node), var1 );
1963 }
1964
1965 static HRESULT WINAPI unknode_put_dataType(
1966     IXMLDOMNode *iface,
1967     BSTR p)
1968 {
1969     unknode *This = impl_from_unkIXMLDOMNode( iface );
1970     return IXMLDOMNode_put_dataType( IXMLDOMNode_from_impl(&This->node), p );
1971 }
1972
1973 static HRESULT WINAPI unknode_get_xml(
1974     IXMLDOMNode *iface,
1975     BSTR* p)
1976 {
1977     unknode *This = impl_from_unkIXMLDOMNode( iface );
1978     return IXMLDOMNode_get_xml( IXMLDOMNode_from_impl(&This->node), p );
1979 }
1980
1981 static HRESULT WINAPI unknode_transformNode(
1982     IXMLDOMNode *iface,
1983     IXMLDOMNode* domNode, BSTR* p)
1984 {
1985     unknode *This = impl_from_unkIXMLDOMNode( iface );
1986     return IXMLDOMNode_transformNode( IXMLDOMNode_from_impl(&This->node), domNode, p );
1987 }
1988
1989 static HRESULT WINAPI unknode_selectNodes(
1990     IXMLDOMNode *iface,
1991     BSTR p, IXMLDOMNodeList** outList)
1992 {
1993     unknode *This = impl_from_unkIXMLDOMNode( iface );
1994     return IXMLDOMNode_selectNodes( IXMLDOMNode_from_impl(&This->node), p, outList );
1995 }
1996
1997 static HRESULT WINAPI unknode_selectSingleNode(
1998     IXMLDOMNode *iface,
1999     BSTR p, IXMLDOMNode** outNode)
2000 {
2001     unknode *This = impl_from_unkIXMLDOMNode( iface );
2002     return IXMLDOMNode_selectSingleNode( IXMLDOMNode_from_impl(&This->node), p, outNode );
2003 }
2004
2005 static HRESULT WINAPI unknode_get_parsed(
2006     IXMLDOMNode *iface,
2007     VARIANT_BOOL* pbool)
2008 {
2009     unknode *This = impl_from_unkIXMLDOMNode( iface );
2010     return IXMLDOMNode_get_parsed( IXMLDOMNode_from_impl(&This->node), pbool );
2011 }
2012
2013 static HRESULT WINAPI unknode_get_namespaceURI(
2014     IXMLDOMNode *iface,
2015     BSTR* p)
2016 {
2017     unknode *This = impl_from_unkIXMLDOMNode( iface );
2018     return IXMLDOMNode_get_namespaceURI( IXMLDOMNode_from_impl(&This->node), p );
2019 }
2020
2021 static HRESULT WINAPI unknode_get_prefix(
2022     IXMLDOMNode *iface,
2023     BSTR* p)
2024 {
2025     unknode *This = impl_from_unkIXMLDOMNode( iface );
2026     return IXMLDOMNode_get_prefix( IXMLDOMNode_from_impl(&This->node), p );
2027 }
2028
2029 static HRESULT WINAPI unknode_get_baseName(
2030     IXMLDOMNode *iface,
2031     BSTR* p)
2032 {
2033     unknode *This = impl_from_unkIXMLDOMNode( iface );
2034     return IXMLDOMNode_get_baseName( IXMLDOMNode_from_impl(&This->node), p );
2035 }
2036
2037 static HRESULT WINAPI unknode_transformNodeToObject(
2038     IXMLDOMNode *iface,
2039     IXMLDOMNode* domNode, VARIANT var1)
2040 {
2041     unknode *This = impl_from_unkIXMLDOMNode( iface );
2042     return IXMLDOMNode_transformNodeToObject( IXMLDOMNode_from_impl(&This->node), domNode, var1 );
2043 }
2044
2045 static const struct IXMLDOMNodeVtbl unknode_vtbl =
2046 {
2047     unknode_QueryInterface,
2048     unknode_AddRef,
2049     unknode_Release,
2050     unknode_GetTypeInfoCount,
2051     unknode_GetTypeInfo,
2052     unknode_GetIDsOfNames,
2053     unknode_Invoke,
2054     unknode_get_nodeName,
2055     unknode_get_nodeValue,
2056     unknode_put_nodeValue,
2057     unknode_get_nodeType,
2058     unknode_get_parentNode,
2059     unknode_get_childNodes,
2060     unknode_get_firstChild,
2061     unknode_get_lastChild,
2062     unknode_get_previousSibling,
2063     unknode_get_nextSibling,
2064     unknode_get_attributes,
2065     unknode_insertBefore,
2066     unknode_replaceChild,
2067     unknode_removeChild,
2068     unknode_appendChild,
2069     unknode_hasChildNodes,
2070     unknode_get_ownerDocument,
2071     unknode_cloneNode,
2072     unknode_get_nodeTypeString,
2073     unknode_get_text,
2074     unknode_put_text,
2075     unknode_get_specified,
2076     unknode_get_definition,
2077     unknode_get_nodeTypedValue,
2078     unknode_put_nodeTypedValue,
2079     unknode_get_dataType,
2080     unknode_put_dataType,
2081     unknode_get_xml,
2082     unknode_transformNode,
2083     unknode_selectNodes,
2084     unknode_selectSingleNode,
2085     unknode_get_parsed,
2086     unknode_get_namespaceURI,
2087     unknode_get_prefix,
2088     unknode_get_baseName,
2089     unknode_transformNodeToObject
2090 };
2091
2092 IXMLDOMNode *create_node( xmlNodePtr node )
2093 {
2094     IUnknown *pUnk;
2095     IXMLDOMNode *ret;
2096     HRESULT hr;
2097
2098     if ( !node )
2099         return NULL;
2100
2101     TRACE("type %d\n", node->type);
2102     switch(node->type)
2103     {
2104     case XML_ELEMENT_NODE:
2105         pUnk = create_element( node );
2106         break;
2107     case XML_ATTRIBUTE_NODE:
2108         pUnk = create_attribute( node );
2109         break;
2110     case XML_TEXT_NODE:
2111         pUnk = create_text( node );
2112         break;
2113     case XML_CDATA_SECTION_NODE:
2114         pUnk = create_cdata( node );
2115         break;
2116     case XML_ENTITY_REF_NODE:
2117         pUnk = create_doc_entity_ref( node );
2118         break;
2119     case XML_PI_NODE:
2120         pUnk = create_pi( node );
2121         break;
2122     case XML_COMMENT_NODE:
2123         pUnk = create_comment( node );
2124         break;
2125     case XML_DOCUMENT_NODE:
2126         pUnk = create_domdoc( node );
2127         break;
2128     case XML_DOCUMENT_FRAG_NODE:
2129         pUnk = create_doc_fragment( node );
2130         break;
2131     default: {
2132         unknode *new_node;
2133
2134         FIXME("only creating basic node for type %d\n", node->type);
2135
2136         new_node = heap_alloc(sizeof(unknode));
2137         if(!new_node)
2138             return NULL;
2139
2140         new_node->lpVtbl = &unknode_vtbl;
2141         new_node->ref = 1;
2142         init_xmlnode(&new_node->node, node, (IXMLDOMNode*)&new_node->lpVtbl, NULL);
2143         pUnk = (IUnknown*)&new_node->lpVtbl;
2144     }
2145     }
2146
2147     hr = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMNode, (LPVOID*)&ret);
2148     IUnknown_Release(pUnk);
2149     if(FAILED(hr)) return NULL;
2150     return ret;
2151 }
2152 #endif