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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #define COBJMACROS
  24
  25 #include <stdarg.h>
  26 #include <assert.h>
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "winnls.h"
  31 #include "ole2.h"
  32 #include "msxml2.h"
  33
  34 #include "msxml_private.h"
  35
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  39
  40 #ifdef HAVE_LIBXML2
  41
  42 typedef struct _xmlnode
  43 {
  44     const struct IXMLDOMNodeVtbl *lpVtbl;
  45     const struct IUnknownVtbl *lpInternalUnkVtbl;
  46     IUnknown *pUnkOuter;
  47     LONG ref;
  48     xmlNodePtr node;
  49 } xmlnode;
  50
  51 static inline xmlnode *impl_from_IXMLDOMNode( IXMLDOMNode *iface )
  52 {
  53     return (xmlnode *)((char*)iface - FIELD_OFFSET(xmlnode, lpVtbl));
  54 }
  55
  56 static inline xmlnode *impl_from_InternalUnknown( IUnknown *iface )
  57 {
  58     return (xmlnode *)((char*)iface - FIELD_OFFSET(xmlnode, lpInternalUnkVtbl));
  59 }
  60
  61 xmlNodePtr xmlNodePtr_from_domnode( IXMLDOMNode *iface, xmlElementType type )
  62 {
  63     xmlnode *This;
  64
  65     if ( !iface )
  66         return NULL;
  67     This = impl_from_IXMLDOMNode( iface );
  68     if ( !This->node )
  69         return NULL;
  70     if ( type && This->node->type != type )
  71         return NULL;
  72     return This->node;
  73 }
  74
  75 void attach_xmlnode( IXMLDOMNode *node, xmlNodePtr xml )
  76 {
  77     xmlnode *This = impl_from_IXMLDOMNode( node );
  78
  79     if(This->node)
  80         xmldoc_release(This->node->doc);
  81
  82     This->node = xml;
  83     if(This->node)
  84         xmldoc_add_ref(This->node->doc);
  85
  86     return;
  87 }
  88
  89 static HRESULT WINAPI xmlnode_QueryInterface(
  90     IXMLDOMNode *iface,
  91     REFIID riid,
  92     void** ppvObject )
  93 {
  94     xmlnode *This = impl_from_IXMLDOMNode( iface );
  95     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
  96
  97     return IUnknown_QueryInterface(This->pUnkOuter, riid, ppvObject);
  98 }
  99
 100 static ULONG WINAPI xmlnode_AddRef(
 101     IXMLDOMNode *iface )
 102 {
 103     xmlnode *This = impl_from_IXMLDOMNode( iface );
 104     return IUnknown_AddRef(This->pUnkOuter);
 105 }
 106
 107 static ULONG WINAPI xmlnode_Release(
 108     IXMLDOMNode *iface )
 109 {
 110     xmlnode *This = impl_from_IXMLDOMNode( iface );
 111     return IUnknown_Release(This->pUnkOuter);
 112 }
 113
 114 static HRESULT WINAPI xmlnode_GetTypeInfoCount(
 115     IXMLDOMNode *iface,
 116     UINT* pctinfo )
 117 {
 118     FIXME("\n");
 119     return E_NOTIMPL;
 120 }
 121
 122 static HRESULT WINAPI xmlnode_GetTypeInfo(
 123     IXMLDOMNode *iface,
 124     UINT iTInfo,
 125     LCID lcid,
 126     ITypeInfo** ppTInfo )
 127 {
 128     FIXME("\n");
 129     return E_NOTIMPL;
 130 }
 131
 132 static HRESULT WINAPI xmlnode_GetIDsOfNames(
 133     IXMLDOMNode *iface,
 134     REFIID riid,
 135     LPOLESTR* rgszNames,
 136     UINT cNames,
 137     LCID lcid,
 138     DISPID* rgDispId )
 139 {
 140     FIXME("\n");
 141     return E_NOTIMPL;
 142 }
 143
 144 static HRESULT WINAPI xmlnode_Invoke(
 145     IXMLDOMNode *iface,
 146     DISPID dispIdMember,
 147     REFIID riid,
 148     LCID lcid,
 149     WORD wFlags,
 150     DISPPARAMS* pDispParams,
 151     VARIANT* pVarResult,
 152     EXCEPINFO* pExcepInfo,
 153     UINT* puArgErr )
 154 {
 155     FIXME("\n");
 156     return E_NOTIMPL;
 157 }
 158
 159 static HRESULT WINAPI xmlnode_get_nodeName(
 160     IXMLDOMNode *iface,
 161     BSTR* name)
 162 {
 163     xmlnode *This = impl_from_IXMLDOMNode( iface );
 164     const xmlChar *str;
 165
 166     TRACE("%p\n", This );
 167
 168     if (!name)
 169         return E_INVALIDARG;
 170
 171     if ( !This->node )
 172         return E_FAIL;
 173
 174     switch( This->node->type )
 175     {
 176     case XML_TEXT_NODE:
 177         str = (const xmlChar*) "#text";
 178         break;
 179     case XML_DOCUMENT_NODE:
 180         str = (const xmlChar*) "#document";
 181         break;
 182     default:
 183         str = This->node->name;
 184         break;
 185     }
 186
 187     *name = bstr_from_xmlChar( str );
 188     if (!*name)
 189         return S_FALSE;
 190
 191     return S_OK;
 192 }
 193
 194 BSTR bstr_from_xmlChar( const xmlChar *buf )
 195 {
 196     DWORD len;
 197     LPWSTR str;
 198     BSTR bstr;
 199
 200     if ( !buf )
 201         return NULL;
 202
 203     len = MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) buf, -1, NULL, 0 );
 204     str = (LPWSTR) HeapAlloc( GetProcessHeap(), 0, len * sizeof (WCHAR) );
 205     if ( !str )
 206         return NULL;
 207     MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) buf, -1, str, len );
 208     bstr = SysAllocString( str );
 209     HeapFree( GetProcessHeap(), 0, str );
 210     return bstr;
 211 }
 212
 213 static HRESULT WINAPI xmlnode_get_nodeValue(
 214     IXMLDOMNode *iface,
 215     VARIANT* value)
 216 {
 217     xmlnode *This = impl_from_IXMLDOMNode( iface );
 218     HRESULT r = S_FALSE;
 219
 220     TRACE("%p %p\n", This, value);
 221
 222     V_BSTR(value) = NULL;
 223     V_VT(value) = VT_NULL;
 224
 225     switch ( This->node->type )
 226     {
 227     case XML_ATTRIBUTE_NODE:
 228       {
 229         xmlChar *content = xmlNodeGetContent(This->node);
 230         V_VT(value) = VT_BSTR;
 231         V_BSTR(value) = bstr_from_xmlChar( content );
 232         xmlFree(content);
 233         r = S_OK;
 234         break;
 235       }
 236     case XML_TEXT_NODE:
 237         V_VT(value) = VT_BSTR;
 238         V_BSTR(value) = bstr_from_xmlChar( This->node->content );
 239         r = S_OK;
 240         break;
 241     case XML_ELEMENT_NODE:
 242     case XML_DOCUMENT_NODE:
 243         /* these seem to return NULL */
 244         break;
 245     case XML_PI_NODE:
 246     default:
 247         FIXME("node %p type %d\n", This, This->node->type);
 248     }
 249
 250     TRACE("%p returned %s\n", This, debugstr_w( V_BSTR(value) ) );
 251
 252     return r;
 253 }
 254
 255 static HRESULT WINAPI xmlnode_put_nodeValue(
 256     IXMLDOMNode *iface,
 257     VARIANT value)
 258 {
 259     FIXME("\n");
 260     return E_NOTIMPL;
 261 }
 262
 263 static HRESULT WINAPI xmlnode_get_nodeType(
 264     IXMLDOMNode *iface,
 265     DOMNodeType* type)
 266 {
 267     xmlnode *This = impl_from_IXMLDOMNode( iface );
 268
 269     TRACE("%p %p\n", This, type);
 270
 271     assert( NODE_ELEMENT == XML_ELEMENT_NODE );
 272     assert( NODE_NOTATION == XML_NOTATION_NODE );
 273
 274     *type = This->node->type;
 275
 276     return S_OK;
 277 }
 278
 279 static HRESULT get_node(
 280     xmlnode *This,
 281     const char *name,
 282     xmlNodePtr node,
 283     IXMLDOMNode **out )
 284 {
 285     TRACE("%p->%s %p\n", This, name, node );
 286
 287     if ( !out )
 288         return E_INVALIDARG;
 289     *out = create_node( node );
 290     if (!*out)
 291         return S_FALSE;
 292     return S_OK;
 293 }
 294
 295 static HRESULT WINAPI xmlnode_get_parentNode(
 296     IXMLDOMNode *iface,
 297     IXMLDOMNode** parent)
 298 {
 299     xmlnode *This = impl_from_IXMLDOMNode( iface );
 300     return get_node( This, "parent", This->node->parent, parent );
 301 }
 302
 303 static HRESULT WINAPI xmlnode_get_childNodes(
 304     IXMLDOMNode *iface,
 305     IXMLDOMNodeList** childList)
 306 {
 307     xmlnode *This = impl_from_IXMLDOMNode( iface );
 308
 309     TRACE("%p %p\n", This, childList );
 310
 311     if ( !childList )
 312         return E_INVALIDARG;
 313
 314     switch(This->node->type)
 315     {
 316     case XML_ELEMENT_NODE:
 317         *childList = create_filtered_nodelist( This->node->children, (const xmlChar *)"*", FALSE );
 318         break;
 319
 320     case XML_ATTRIBUTE_NODE:
 321         *childList = create_filtered_nodelist( This->node->children, (const xmlChar *)"node()", FALSE );
 322         break;
 323
 324     default:
 325         FIXME("unhandled node type %d\n", This->node->type);
 326         break;
 327     }
 328
 329     if (!*childList)
 330         return S_FALSE;
 331     return S_OK;
 332 }
 333
 334 static HRESULT WINAPI xmlnode_get_firstChild(
 335     IXMLDOMNode *iface,
 336     IXMLDOMNode** firstChild)
 337 {
 338     xmlnode *This = impl_from_IXMLDOMNode( iface );
 339     return get_node( This, "firstChild", This->node->children, firstChild );
 340 }
 341
 342 static HRESULT WINAPI xmlnode_get_lastChild(
 343     IXMLDOMNode *iface,
 344     IXMLDOMNode** lastChild)
 345 {
 346     xmlnode *This = impl_from_IXMLDOMNode( iface );
 347     return get_node( This, "lastChild", This->node->last, lastChild );
 348 }
 349
 350 static HRESULT WINAPI xmlnode_get_previousSibling(
 351     IXMLDOMNode *iface,
 352     IXMLDOMNode** previousSibling)
 353 {
 354     xmlnode *This = impl_from_IXMLDOMNode( iface );
 355     return get_node( This, "previous", This->node->prev, previousSibling );
 356 }
 357
 358 static HRESULT WINAPI xmlnode_get_nextSibling(
 359     IXMLDOMNode *iface,
 360     IXMLDOMNode** nextSibling)
 361 {
 362     xmlnode *This = impl_from_IXMLDOMNode( iface );
 363     return get_node( This, "next", This->node->next, nextSibling );
 364 }
 365
 366 static HRESULT WINAPI xmlnode_get_attributes(
 367     IXMLDOMNode *iface,
 368     IXMLDOMNamedNodeMap** attributeMap)
 369 {
 370     xmlnode *This = impl_from_IXMLDOMNode( iface );
 371     TRACE("%p\n", This);
 372     *attributeMap = create_nodemap( iface );
 373     return S_OK;
 374 }
 375
 376 static HRESULT WINAPI xmlnode_insertBefore(
 377     IXMLDOMNode *iface,
 378     IXMLDOMNode* newChild,
 379     VARIANT refChild,
 380     IXMLDOMNode** outNewChild)
 381 {
 382     xmlnode *This = impl_from_IXMLDOMNode( iface );
 383     xmlNodePtr before_node, new_child_node;
 384     IXMLDOMNode *before = NULL, *new;
 385     HRESULT hr;
 386
 387     TRACE("(%p)->(%p,var,%p)\n",This,newChild,outNewChild);
 388
 389     switch(V_VT(&refChild))
 390     {
 391     case VT_EMPTY:
 392     case VT_NULL:
 393         break;
 394
 395     case VT_UNKNOWN:
 396         hr = IUnknown_QueryInterface(V_UNKNOWN(&refChild), &IID_IXMLDOMNode, (LPVOID)&before);
 397         if(FAILED(hr)) return hr;
 398         break;
 399
 400     case VT_DISPATCH:
 401         hr = IDispatch_QueryInterface(V_DISPATCH(&refChild), &IID_IXMLDOMNode, (LPVOID)&before);
 402         if(FAILED(hr)) return hr;
 403         break;
 404
 405     default:
 406         FIXME("refChild var type %x\n", V_VT(&refChild));
 407         return E_FAIL;
 408     }
 409
 410     IXMLDOMNode_QueryInterface(newChild, &IID_IXMLDOMNode, (LPVOID)&new);
 411     new_child_node = impl_from_IXMLDOMNode(new)->node;
 412     TRACE("new_child_node %p This->node %p\n", new_child_node, This->node);
 413
 414     if(before)
 415     {
 416         before_node = impl_from_IXMLDOMNode(before)->node;
 417         xmlAddPrevSibling(before_node, new_child_node);
 418         IXMLDOMNode_Release(before);
 419     }
 420     else
 421     {
 422         xmlAddChild(This->node, new_child_node);
 423     }
 424
 425     IXMLDOMNode_Release(new);
 426     IXMLDOMNode_AddRef(newChild);
 427     *outNewChild = newChild;
 428     TRACE("ret S_OK\n");
 429     return S_OK;
 430 }
 431
 432 static HRESULT WINAPI xmlnode_replaceChild(
 433     IXMLDOMNode *iface,
 434     IXMLDOMNode* newChild,
 435     IXMLDOMNode* oldChild,
 436     IXMLDOMNode** outOldChild)
 437 {
 438     FIXME("\n");
 439     return E_NOTIMPL;
 440 }
 441
 442 static HRESULT WINAPI xmlnode_removeChild(
 443     IXMLDOMNode *iface,
 444     IXMLDOMNode* childNode,
 445     IXMLDOMNode** oldChild)
 446 {
 447     FIXME("\n");
 448     return E_NOTIMPL;
 449 }
 450
 451 static HRESULT WINAPI xmlnode_appendChild(
 452     IXMLDOMNode *iface,
 453     IXMLDOMNode* newChild,
 454     IXMLDOMNode** outNewChild)
 455 {
 456     xmlnode *This = impl_from_IXMLDOMNode( iface );
 457     VARIANT var;
 458
 459     TRACE("(%p)->(%p,%p)\n", This, newChild, outNewChild);
 460     VariantInit(&var);
 461     return IXMLDOMNode_insertBefore(iface, newChild, var, outNewChild);
 462 }
 463
 464 static HRESULT WINAPI xmlnode_hasChildNodes(
 465     IXMLDOMNode *iface,
 466     VARIANT_BOOL* hasChild)
 467 {
 468     xmlnode *This = impl_from_IXMLDOMNode( iface );
 469
 470     TRACE("%p\n", This);
 471
 472     if (!hasChild)
 473         return E_INVALIDARG;
 474     if (!This->node->children)
 475     {
 476         *hasChild = VARIANT_FALSE;
 477         return S_FALSE;
 478     }
 479
 480     *hasChild = VARIANT_TRUE;
 481     return S_OK;
 482 }
 483
 484 static HRESULT WINAPI xmlnode_get_ownerDocument(
 485     IXMLDOMNode *iface,
 486     IXMLDOMDocument** DOMDocument)
 487 {
 488     FIXME("\n");
 489     return E_NOTIMPL;
 490 }
 491
 492 static HRESULT WINAPI xmlnode_cloneNode(
 493     IXMLDOMNode *iface,
 494     VARIANT_BOOL deep,
 495     IXMLDOMNode** cloneRoot)
 496 {
 497     FIXME("\n");
 498     return E_NOTIMPL;
 499 }
 500
 501 static HRESULT WINAPI xmlnode_get_nodeTypeString(
 502     IXMLDOMNode *iface,
 503     BSTR* xmlnodeType)
 504 {
 505     FIXME("\n");
 506     return E_NOTIMPL;
 507 }
 508
 509 static HRESULT WINAPI xmlnode_get_text(
 510     IXMLDOMNode *iface,
 511     BSTR* text)
 512 {
 513     xmlnode *This = impl_from_IXMLDOMNode( iface );
 514     xmlNodePtr child;
 515     BSTR str = NULL;
 516
 517     TRACE("%p\n", This);
 518
 519     if ( !text )
 520         return E_INVALIDARG;
 521
 522     child = This->node->children;
 523     if ( child && child->type == XML_TEXT_NODE )
 524         str = bstr_from_xmlChar( child->content );
 525
 526     TRACE("%p %s\n", This, debugstr_w(str) );
 527     *text = str;
 528
 529     return S_OK;
 530 }
 531
 532 static HRESULT WINAPI xmlnode_put_text(
 533     IXMLDOMNode *iface,
 534     BSTR text)
 535 {
 536     FIXME("\n");
 537     return E_NOTIMPL;
 538 }
 539
 540 static HRESULT WINAPI xmlnode_get_specified(
 541     IXMLDOMNode *iface,
 542     VARIANT_BOOL* isSpecified)
 543 {
 544     FIXME("\n");
 545     return E_NOTIMPL;
 546 }
 547
 548 static HRESULT WINAPI xmlnode_get_definition(
 549     IXMLDOMNode *iface,
 550     IXMLDOMNode** definitionNode)
 551 {
 552     FIXME("\n");
 553     return E_NOTIMPL;
 554 }
 555
 556 static HRESULT WINAPI xmlnode_get_nodeTypedValue(
 557     IXMLDOMNode *iface,
 558     VARIANT* typedValue)
 559 {
 560     FIXME("ignoring data type\n");
 561     return xmlnode_get_nodeValue(iface, typedValue);
 562 }
 563
 564 static HRESULT WINAPI xmlnode_put_nodeTypedValue(
 565     IXMLDOMNode *iface,
 566     VARIANT typedValue)
 567 {
 568     FIXME("\n");
 569     return E_NOTIMPL;
 570 }
 571
 572 static HRESULT WINAPI xmlnode_get_dataType(
 573     IXMLDOMNode *iface,
 574     VARIANT* dataTypeName)
 575 {
 576     FIXME("\n");
 577     return E_NOTIMPL;
 578 }
 579
 580 static HRESULT WINAPI xmlnode_put_dataType(
 581     IXMLDOMNode *iface,
 582     BSTR dataTypeName)
 583 {
 584     FIXME("\n");
 585     return E_NOTIMPL;
 586 }
 587
 588 static HRESULT WINAPI xmlnode_get_xml(
 589     IXMLDOMNode *iface,
 590     BSTR* xmlString)
 591 {
 592     FIXME("\n");
 593     return E_NOTIMPL;
 594 }
 595
 596 static HRESULT WINAPI xmlnode_transformNode(
 597     IXMLDOMNode *iface,
 598     IXMLDOMNode* styleSheet,
 599     BSTR* xmlString)
 600 {
 601     FIXME("\n");
 602     return E_NOTIMPL;
 603 }
 604
 605 static HRESULT WINAPI xmlnode_selectNodes(
 606     IXMLDOMNode *iface,
 607     BSTR queryString,
 608     IXMLDOMNodeList** resultList)
 609 {
 610     xmlnode *This = impl_from_IXMLDOMNode( iface );
 611     xmlChar *str = NULL;
 612     HRESULT r = E_FAIL;
 613
 614     TRACE("%p %s %p\n", This, debugstr_w(queryString), resultList );
 615
 616     str = xmlChar_from_wchar( queryString );
 617     if (!str)
 618         return r;
 619
 620     if( !This->node->children )
 621         return S_FALSE;
 622
 623     *resultList = create_filtered_nodelist( This->node->children, str, FALSE );
 624     HeapFree( GetProcessHeap(), 0, str );
 625     return S_OK;
 626 }
 627
 628 static HRESULT WINAPI xmlnode_selectSingleNode(
 629     IXMLDOMNode *iface,
 630     BSTR queryString,
 631     IXMLDOMNode** resultNode)
 632 {
 633     xmlnode *This = impl_from_IXMLDOMNode( iface );
 634     IXMLDOMNodeList *list;
 635     HRESULT r;
 636
 637     TRACE("%p %s %p\n", This, debugstr_w(queryString), resultNode );
 638
 639     r = IXMLDOMNode_selectNodes(iface, queryString, &list);
 640     if(r == S_OK)
 641     {
 642         r = IXMLDOMNodeList_nextNode(list, resultNode);
 643         IXMLDOMNodeList_Release(list);
 644     }
 645     return r;
 646 }
 647
 648 static HRESULT WINAPI xmlnode_get_parsed(
 649     IXMLDOMNode *iface,
 650     VARIANT_BOOL* isParsed)
 651 {
 652     FIXME("\n");
 653     return E_NOTIMPL;
 654 }
 655
 656 static HRESULT WINAPI xmlnode_get_namespaceURI(
 657     IXMLDOMNode *iface,
 658     BSTR* namespaceURI)
 659 {
 660     FIXME("\n");
 661     return E_NOTIMPL;
 662 }
 663
 664 static HRESULT WINAPI xmlnode_get_prefix(
 665     IXMLDOMNode *iface,
 666     BSTR* prefixString)
 667 {
 668     FIXME("\n");
 669     return E_NOTIMPL;
 670 }
 671
 672 static HRESULT WINAPI xmlnode_get_baseName(
 673     IXMLDOMNode *iface,
 674     BSTR* nameString)
 675 {
 676     xmlnode *This = impl_from_IXMLDOMNode( iface );
 677     BSTR str = NULL;
 678     HRESULT r = S_FALSE;
 679
 680     TRACE("%p %p\n", This, nameString );
 681
 682     if ( !nameString )
 683         return E_INVALIDARG;
 684
 685     switch ( This->node->type )
 686     {
 687     case XML_ELEMENT_NODE:
 688     case XML_ATTRIBUTE_NODE:
 689         str = bstr_from_xmlChar( This->node->name );
 690         r = S_OK;
 691         break;
 692     case XML_TEXT_NODE:
 693         break;
 694     default:
 695         ERR("Unhandled type %d\n", This->node->type );
 696         break;
 697     }
 698
 699     TRACE("returning %08lx str = %s\n", r, debugstr_w( str ) );
 700
 701     *nameString = str;
 702     return r;
 703 }
 704
 705 static HRESULT WINAPI xmlnode_transformNodeToObject(
 706     IXMLDOMNode *iface,
 707     IXMLDOMNode* stylesheet,
 708     VARIANT outputObject)
 709 {
 710     FIXME("\n");
 711     return E_NOTIMPL;
 712 }
 713
 714 static const struct IXMLDOMNodeVtbl xmlnode_vtbl =
 715 {
 716     xmlnode_QueryInterface,
 717     xmlnode_AddRef,
 718     xmlnode_Release,
 719     xmlnode_GetTypeInfoCount,
 720     xmlnode_GetTypeInfo,
 721     xmlnode_GetIDsOfNames,
 722     xmlnode_Invoke,
 723     xmlnode_get_nodeName,
 724     xmlnode_get_nodeValue,
 725     xmlnode_put_nodeValue,
 726     xmlnode_get_nodeType,
 727     xmlnode_get_parentNode,
 728     xmlnode_get_childNodes,
 729     xmlnode_get_firstChild,
 730     xmlnode_get_lastChild,
 731     xmlnode_get_previousSibling,
 732     xmlnode_get_nextSibling,
 733     xmlnode_get_attributes,
 734     xmlnode_insertBefore,
 735     xmlnode_replaceChild,
 736     xmlnode_removeChild,
 737     xmlnode_appendChild,
 738     xmlnode_hasChildNodes,
 739     xmlnode_get_ownerDocument,
 740     xmlnode_cloneNode,
 741     xmlnode_get_nodeTypeString,
 742     xmlnode_get_text,
 743     xmlnode_put_text,
 744     xmlnode_get_specified,
 745     xmlnode_get_definition,
 746     xmlnode_get_nodeTypedValue,
 747     xmlnode_put_nodeTypedValue,
 748     xmlnode_get_dataType,
 749     xmlnode_put_dataType,
 750     xmlnode_get_xml,
 751     xmlnode_transformNode,
 752     xmlnode_selectNodes,
 753     xmlnode_selectSingleNode,
 754     xmlnode_get_parsed,
 755     xmlnode_get_namespaceURI,
 756     xmlnode_get_prefix,
 757     xmlnode_get_baseName,
 758     xmlnode_transformNodeToObject,
 759 };
 760
 761 static HRESULT WINAPI Internal_QueryInterface(
 762     IUnknown *iface,
 763     REFIID riid,
 764     void** ppvObject )
 765 {
 766     xmlnode *This = impl_from_InternalUnknown( iface );
 767
 768     TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
 769
 770
 771     if ( IsEqualGUID( riid, &IID_IUnknown ))
 772         *ppvObject = iface;
 773     else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
 774               IsEqualGUID( riid, &IID_IXMLDOMNode ) )
 775         *ppvObject = &This->lpVtbl;
 776     else
 777     {
 778         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 779         *ppvObject = NULL;
 780         return E_NOINTERFACE;
 781     }
 782
 783     IUnknown_AddRef( (IUnknown*)*ppvObject );
 784
 785     return S_OK;
 786 }
 787
 788 static ULONG WINAPI Internal_AddRef(
 789                  IUnknown *iface )
 790 {
 791     xmlnode *This = impl_from_InternalUnknown( iface );
 792     return InterlockedIncrement( &This->ref );
 793 }
 794
 795 static ULONG WINAPI Internal_Release(
 796     IUnknown *iface )
 797 {
 798     xmlnode *This = impl_from_InternalUnknown( iface );
 799     ULONG ref;
 800
 801     ref = InterlockedDecrement( &This->ref );
 802     if ( ref == 0 )
 803     {
 804         if( This->node )
 805             xmldoc_release( This->node->doc );
 806         HeapFree( GetProcessHeap(), 0, This );
 807     }
 808
 809     return ref;
 810 }
 811
 812 static const struct IUnknownVtbl internal_unk_vtbl =
 813 {
 814     Internal_QueryInterface,
 815     Internal_AddRef,
 816     Internal_Release
 817 };
 818
 819 IUnknown *create_basic_node( xmlNodePtr node, IUnknown *pUnkOuter )
 820 {
 821     xmlnode *This;
 822
 823     This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
 824     if ( !This )
 825         return NULL;
 826
 827     if(node)
 828         xmldoc_add_ref( node->doc );
 829
 830     This->lpVtbl = &xmlnode_vtbl;
 831     This->lpInternalUnkVtbl = &internal_unk_vtbl;
 832
 833     if(pUnkOuter)
 834         This->pUnkOuter = pUnkOuter; /* Don't take a ref on outer Unknown */
 835     else
 836         This->pUnkOuter = (IUnknown *)&This->lpInternalUnkVtbl;
 837
 838     This->ref = 1;
 839     This->node = node;
 840
 841     return (IUnknown*)&This->lpInternalUnkVtbl;
 842 }
 843
 844 IXMLDOMNode *create_node( xmlNodePtr node )
 845 {
 846     IUnknown *pUnk;
 847     IXMLDOMNode *ret;
 848     HRESULT hr;
 849
 850     if ( !node )
 851         return NULL;
 852
 853     TRACE("type %d\n", node->type);
 854     switch(node->type)
 855     {
 856     case XML_ATTRIBUTE_NODE:
 857         pUnk = create_attribute( node );
 858         break;
 859     case XML_ELEMENT_NODE:
 860         pUnk = create_element( node );
 861         break;
 862     case XML_TEXT_NODE:
 863         pUnk = create_text( node );
 864         break;
 865     case XML_DOCUMENT_NODE:
 866         ERR("shouldn't be here!\n");
 867         return NULL;
 868     default:
 869         FIXME("only creating basic node for type %d\n", node->type);
 870         pUnk = create_basic_node( node, NULL );
 871     }
 872
 873     hr = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMNode, (LPVOID*)&ret);
 874     IUnknown_Release(pUnk);
 875     if(FAILED(hr)) return NULL;
 876     return ret;
 877 }
 878 #endif