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