dlls/msxml3/node.c

   1 /*
   2  *    Node implementation
   3  *
   4  * Copyright 2005 Mike McCormack
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22
  23 #define COBJMACROS
  24
  25 #include <stdarg.h>
  26 #include <assert.h>
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "winnls.h"
  31 #include "ole2.h"
  32 #include "msxml2.h"
  33
  34 #include "msxml_private.h"
  35
  36 #include "wine/debug.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  39
  40 #ifdef HAVE_LIBXML2
  41
  42 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     *childList = create_children_nodelist(This->node);
 315     if (*childList == NULL)
 316         return E_OUTOFMEMORY;
 317
 318     return S_OK;
 319 }
 320
 321 static HRESULT WINAPI xmlnode_get_firstChild(
 322     IXMLDOMNode *iface,
 323     IXMLDOMNode** firstChild)
 324 {
 325     xmlnode *This = impl_from_IXMLDOMNode( iface );
 326     return get_node( This, "firstChild", This->node->children, firstChild );
 327 }
 328
 329 static HRESULT WINAPI xmlnode_get_lastChild(
 330     IXMLDOMNode *iface,
 331     IXMLDOMNode** lastChild)
 332 {
 333     xmlnode *This = impl_from_IXMLDOMNode( iface );
 334     return get_node( This, "lastChild", This->node->last, lastChild );
 335 }
 336
 337 static HRESULT WINAPI xmlnode_get_previousSibling(
 338     IXMLDOMNode *iface,
 339     IXMLDOMNode** previousSibling)
 340 {
 341     xmlnode *This = impl_from_IXMLDOMNode( iface );
 342     return get_node( This, "previous", This->node->prev, previousSibling );
 343 }
 344
 345 static HRESULT WINAPI xmlnode_get_nextSibling(
 346     IXMLDOMNode *iface,
 347     IXMLDOMNode** nextSibling)
 348 {
 349     xmlnode *This = impl_from_IXMLDOMNode( iface );
 350     return get_node( This, "next", This->node->next, nextSibling );
 351 }
 352
 353 static HRESULT WINAPI xmlnode_get_attributes(
 354     IXMLDOMNode *iface,
 355     IXMLDOMNamedNodeMap** attributeMap)
 356 {
 357     xmlnode *This = impl_from_IXMLDOMNode( iface );
 358     TRACE("%p\n", This);
 359     *attributeMap = create_nodemap( iface );
 360     return S_OK;
 361 }
 362
 363 static HRESULT WINAPI xmlnode_insertBefore(
 364     IXMLDOMNode *iface,
 365     IXMLDOMNode* newChild,
 366     VARIANT refChild,
 367     IXMLDOMNode** outNewChild)
 368 {
 369     xmlnode *This = impl_from_IXMLDOMNode( iface );
 370     xmlNodePtr before_node, new_child_node;
 371     IXMLDOMNode *before = NULL, *new;
 372     HRESULT hr;
 373
 374     TRACE("(%p)->(%p,var,%p)\n",This,newChild,outNewChild);
 375
 376     if (!newChild)
 377         return E_INVALIDARG;
 378
 379     switch(V_VT(&refChild))
 380     {
 381     case VT_EMPTY:
 382     case VT_NULL:
 383         break;
 384
 385     case VT_UNKNOWN:
 386         hr = IUnknown_QueryInterface(V_UNKNOWN(&refChild), &IID_IXMLDOMNode, (LPVOID)&before);
 387         if(FAILED(hr)) return hr;
 388         break;
 389
 390     case VT_DISPATCH:
 391         hr = IDispatch_QueryInterface(V_DISPATCH(&refChild), &IID_IXMLDOMNode, (LPVOID)&before);
 392         if(FAILED(hr)) return hr;
 393         break;
 394
 395     default:
 396         FIXME("refChild var type %x\n", V_VT(&refChild));
 397         return E_FAIL;
 398     }
 399
 400     IXMLDOMNode_QueryInterface(newChild, &IID_IXMLDOMNode, (LPVOID)&new);
 401     new_child_node = impl_from_IXMLDOMNode(new)->node;
 402     TRACE("new_child_node %p This->node %p\n", new_child_node, This->node);
 403
 404     if(before)
 405     {
 406         before_node = impl_from_IXMLDOMNode(before)->node;
 407         xmlAddPrevSibling(before_node, new_child_node);
 408         IXMLDOMNode_Release(before);
 409     }
 410     else
 411     {
 412         xmlAddChild(This->node, new_child_node);
 413     }
 414
 415     IXMLDOMNode_Release(new);
 416     IXMLDOMNode_AddRef(newChild);
 417     if(outNewChild)
 418         *outNewChild = newChild;
 419
 420     TRACE("ret S_OK\n");
 421     return S_OK;
 422 }
 423
 424 static HRESULT WINAPI xmlnode_replaceChild(
 425     IXMLDOMNode *iface,
 426     IXMLDOMNode* newChild,
 427     IXMLDOMNode* oldChild,
 428     IXMLDOMNode** outOldChild)
 429 {
 430     FIXME("\n");
 431     return E_NOTIMPL;
 432 }
 433
 434 static HRESULT WINAPI xmlnode_removeChild(
 435     IXMLDOMNode *iface,
 436     IXMLDOMNode* childNode,
 437     IXMLDOMNode** oldChild)
 438 {
 439     xmlnode *This = impl_from_IXMLDOMNode( iface );
 440     xmlNode *ancestor, *child_node_ptr;
 441     HRESULT hr;
 442     IXMLDOMNode *child;
 443
 444     TRACE("%p->(%p, %p)\n", This, childNode, oldChild);
 445
 446     *oldChild = NULL;
 447
 448     if(!childNode) return E_INVALIDARG;
 449
 450     hr = IXMLDOMNode_QueryInterface(childNode, &IID_IXMLDOMNode, (LPVOID)&child);
 451     if(FAILED(hr))
 452         return hr;
 453
 454     child_node_ptr = ancestor = impl_from_IXMLDOMNode(child)->node;
 455     while(ancestor->parent)
 456     {
 457         if(ancestor->parent == This->node)
 458             break;
 459         ancestor = ancestor->parent;
 460     }
 461     if(!ancestor->parent)
 462     {
 463         WARN("childNode %p is not a child of %p\n", childNode, iface);
 464         IXMLDOMNode_Release(child);
 465         return E_INVALIDARG;
 466     }
 467
 468     xmlUnlinkNode(child_node_ptr);
 469
 470     IXMLDOMNode_Release(child);
 471     IXMLDOMNode_AddRef(childNode);
 472     *oldChild = childNode;
 473     return S_OK;
 474 }
 475
 476 static HRESULT WINAPI xmlnode_appendChild(
 477     IXMLDOMNode *iface,
 478     IXMLDOMNode* newChild,
 479     IXMLDOMNode** outNewChild)
 480 {
 481     xmlnode *This = impl_from_IXMLDOMNode( iface );
 482     VARIANT var;
 483
 484     TRACE("(%p)->(%p,%p)\n", This, newChild, outNewChild);
 485     VariantInit(&var);
 486     return IXMLDOMNode_insertBefore(iface, newChild, var, outNewChild);
 487 }
 488
 489 static HRESULT WINAPI xmlnode_hasChildNodes(
 490     IXMLDOMNode *iface,
 491     VARIANT_BOOL* hasChild)
 492 {
 493     xmlnode *This = impl_from_IXMLDOMNode( iface );
 494
 495     TRACE("%p\n", This);
 496
 497     if (!hasChild)
 498         return E_INVALIDARG;
 499     if (!This->node->children)
 500     {
 501         *hasChild = VARIANT_FALSE;
 502         return S_FALSE;
 503     }
 504
 505     *hasChild = VARIANT_TRUE;
 506     return S_OK;
 507 }
 508
 509 static HRESULT WINAPI xmlnode_get_ownerDocument(
 510     IXMLDOMNode *iface,
 511     IXMLDOMDocument** DOMDocument)
 512 {
 513     FIXME("\n");
 514     return E_NOTIMPL;
 515 }
 516
 517 static HRESULT WINAPI xmlnode_cloneNode(
 518     IXMLDOMNode *iface,
 519     VARIANT_BOOL deep,
 520     IXMLDOMNode** cloneRoot)
 521 {
 522     xmlnode *This = impl_from_IXMLDOMNode( iface );
 523     xmlNodePtr pClone = NULL;
 524     IXMLDOMNode *pNode = NULL;
 525
 526     TRACE("%p (%d)\n", This, deep);
 527
 528     if(!cloneRoot)
 529         return E_INVALIDARG;
 530
 531     pClone = xmlCopyNode(This->node, deep ? 1 : 2);
 532     if(pClone)
 533     {
 534         pClone->doc = This->node->doc;
 535
 536         pNode = create_node(pClone);
 537         if(!pNode)
 538         {
 539             ERR("Copy failed\n");
 540             return E_FAIL;
 541         }
 542
 543         *cloneRoot = pNode;
 544     }
 545     else
 546     {
 547         ERR("Copy failed\n");
 548         return E_FAIL;
 549     }
 550
 551     return S_OK;
 552 }
 553
 554 static HRESULT WINAPI xmlnode_get_nodeTypeString(
 555     IXMLDOMNode *iface,
 556     BSTR* xmlnodeType)
 557 {
 558     FIXME("\n");
 559     return E_NOTIMPL;
 560 }
 561
 562 static HRESULT WINAPI xmlnode_get_text(
 563     IXMLDOMNode *iface,
 564     BSTR* text)
 565 {
 566     xmlnode *This = impl_from_IXMLDOMNode( iface );
 567     BSTR str = NULL;
 568
 569     TRACE("%p\n", This);
 570
 571     if ( !text )
 572         return E_INVALIDARG;
 573
 574     switch(This->node->type)
 575     {
 576     case XML_ELEMENT_NODE:
 577     case XML_ATTRIBUTE_NODE:
 578     {
 579         xmlNodePtr child = This->node->children;
 580         if ( child && child->type == XML_TEXT_NODE )
 581             str = bstr_from_xmlChar( child->content );
 582         break;
 583     }
 584
 585     case XML_TEXT_NODE:
 586     case XML_CDATA_SECTION_NODE:
 587     case XML_PI_NODE:
 588     case XML_COMMENT_NODE:
 589         str = bstr_from_xmlChar( This->node->content );
 590         break;
 591
 592     default:
 593         FIXME("Unhandled node type %d\n", This->node->type);
 594     }
 595
 596     /* Always return a string. */
 597     if (!str) str = SysAllocStringLen( NULL, 0 );
 598
 599     TRACE("%p %s\n", This, debugstr_w(str) );
 600     *text = str;
 601
 602     return S_OK;
 603 }
 604
 605 static HRESULT WINAPI xmlnode_put_text(
 606     IXMLDOMNode *iface,
 607     BSTR text)
 608 {
 609     FIXME("\n");
 610     return E_NOTIMPL;
 611 }
 612
 613 static HRESULT WINAPI xmlnode_get_specified(
 614     IXMLDOMNode *iface,
 615     VARIANT_BOOL* isSpecified)
 616 {
 617     FIXME("\n");
 618     return E_NOTIMPL;
 619 }
 620
 621 static HRESULT WINAPI xmlnode_get_definition(
 622     IXMLDOMNode *iface,
 623     IXMLDOMNode** definitionNode)
 624 {
 625     FIXME("\n");
 626     return E_NOTIMPL;
 627 }
 628
 629 static HRESULT WINAPI xmlnode_get_nodeTypedValue(
 630     IXMLDOMNode *iface,
 631     VARIANT* typedValue)
 632 {
 633     FIXME("ignoring data type\n");
 634     return xmlnode_get_nodeValue(iface, typedValue);
 635 }
 636
 637 static HRESULT WINAPI xmlnode_put_nodeTypedValue(
 638     IXMLDOMNode *iface,
 639     VARIANT typedValue)
 640 {
 641     FIXME("\n");
 642     return E_NOTIMPL;
 643 }
 644
 645 static HRESULT WINAPI xmlnode_get_dataType(
 646     IXMLDOMNode *iface,
 647     VARIANT* dataTypeName)
 648 {
 649     FIXME("\n");
 650     return E_NOTIMPL;
 651 }
 652
 653 static HRESULT WINAPI xmlnode_put_dataType(
 654     IXMLDOMNode *iface,
 655     BSTR dataTypeName)
 656 {
 657     FIXME("\n");
 658     return E_NOTIMPL;
 659 }
 660
 661 static HRESULT WINAPI xmlnode_get_xml(
 662     IXMLDOMNode *iface,
 663     BSTR* xmlString)
 664 {
 665     FIXME("\n");
 666     return E_NOTIMPL;
 667 }
 668
 669 static HRESULT WINAPI xmlnode_transformNode(
 670     IXMLDOMNode *iface,
 671     IXMLDOMNode* styleSheet,
 672     BSTR* xmlString)
 673 {
 674     FIXME("\n");
 675     return E_NOTIMPL;
 676 }
 677
 678 static HRESULT WINAPI xmlnode_selectNodes(
 679     IXMLDOMNode *iface,
 680     BSTR queryString,
 681     IXMLDOMNodeList** resultList)
 682 {
 683     xmlnode *This = impl_from_IXMLDOMNode( iface );
 684
 685     TRACE("%p %s %p\n", This, debugstr_w(queryString), resultList );
 686
 687     return queryresult_create( This->node, queryString, resultList );
 688 }
 689
 690 static HRESULT WINAPI xmlnode_selectSingleNode(
 691     IXMLDOMNode *iface,
 692     BSTR queryString,
 693     IXMLDOMNode** resultNode)
 694 {
 695     xmlnode *This = impl_from_IXMLDOMNode( iface );
 696     IXMLDOMNodeList *list;
 697     HRESULT r;
 698
 699     TRACE("%p %s %p\n", This, debugstr_w(queryString), resultNode );
 700
 701     *resultNode = NULL;
 702     r = IXMLDOMNode_selectNodes(iface, queryString, &list);
 703     if(r == S_OK)
 704     {
 705         r = IXMLDOMNodeList_nextNode(list, resultNode);
 706         IXMLDOMNodeList_Release(list);
 707     }
 708     return r;
 709 }
 710
 711 static HRESULT WINAPI xmlnode_get_parsed(
 712     IXMLDOMNode *iface,
 713     VARIANT_BOOL* isParsed)
 714 {
 715     FIXME("\n");
 716     return E_NOTIMPL;
 717 }
 718
 719 static HRESULT WINAPI xmlnode_get_namespaceURI(
 720     IXMLDOMNode *iface,
 721     BSTR* namespaceURI)
 722 {
 723     FIXME("\n");
 724     return E_NOTIMPL;
 725 }
 726
 727 static HRESULT WINAPI xmlnode_get_prefix(
 728     IXMLDOMNode *iface,
 729     BSTR* prefixString)
 730 {
 731     FIXME("\n");
 732     return E_NOTIMPL;
 733 }
 734
 735 static HRESULT WINAPI xmlnode_get_baseName(
 736     IXMLDOMNode *iface,
 737     BSTR* nameString)
 738 {
 739     xmlnode *This = impl_from_IXMLDOMNode( iface );
 740     BSTR str = NULL;
 741     HRESULT r = S_FALSE;
 742
 743     TRACE("%p %p\n", This, nameString );
 744
 745     if ( !nameString )
 746         return E_INVALIDARG;
 747
 748     switch ( This->node->type )
 749     {
 750     case XML_ELEMENT_NODE:
 751     case XML_ATTRIBUTE_NODE:
 752         str = bstr_from_xmlChar( This->node->name );
 753         r = S_OK;
 754         break;
 755     case XML_TEXT_NODE:
 756         break;
 757     default:
 758         ERR("Unhandled type %d\n", This->node->type );
 759         break;
 760     }
 761
 762     TRACE("returning %08x str = %s\n", r, debugstr_w( str ) );
 763
 764     *nameString = str;
 765     return r;
 766 }
 767
 768 static HRESULT WINAPI xmlnode_transformNodeToObject(
 769     IXMLDOMNode *iface,
 770     IXMLDOMNode* stylesheet,
 771     VARIANT outputObject)
 772 {
 773     FIXME("\n");
 774     return E_NOTIMPL;
 775 }
 776
 777 static const struct IXMLDOMNodeVtbl xmlnode_vtbl =
 778 {
 779     xmlnode_QueryInterface,
 780     xmlnode_AddRef,
 781     xmlnode_Release,
 782     xmlnode_GetTypeInfoCount,
 783     xmlnode_GetTypeInfo,
 784     xmlnode_GetIDsOfNames,
 785     xmlnode_Invoke,
 786     xmlnode_get_nodeName,
 787     xmlnode_get_nodeValue,
 788     xmlnode_put_nodeValue,
 789     xmlnode_get_nodeType,
 790     xmlnode_get_parentNode,
 791     xmlnode_get_childNodes,
 792     xmlnode_get_firstChild,
 793     xmlnode_get_lastChild,
 794     xmlnode_get_previousSibling,
 795     xmlnode_get_nextSibling,
 796     xmlnode_get_attributes,
 797     xmlnode_insertBefore,
 798     xmlnode_replaceChild,
 799     xmlnode_removeChild,
 800     xmlnode_appendChild,
 801     xmlnode_hasChildNodes,
 802     xmlnode_get_ownerDocument,
 803     xmlnode_cloneNode,
 804     xmlnode_get_nodeTypeString,
 805     xmlnode_get_text,
 806     xmlnode_put_text,
 807     xmlnode_get_specified,
 808     xmlnode_get_definition,
 809     xmlnode_get_nodeTypedValue,
 810     xmlnode_put_nodeTypedValue,
 811     xmlnode_get_dataType,
 812     xmlnode_put_dataType,
 813     xmlnode_get_xml,
 814     xmlnode_transformNode,
 815     xmlnode_selectNodes,
 816     xmlnode_selectSingleNode,
 817     xmlnode_get_parsed,
 818     xmlnode_get_namespaceURI,
 819     xmlnode_get_prefix,
 820     xmlnode_get_baseName,
 821     xmlnode_transformNodeToObject,
 822 };
 823
 824 static HRESULT WINAPI Internal_QueryInterface(
 825     IUnknown *iface,
 826     REFIID riid,
 827     void** ppvObject )
 828 {
 829     xmlnode *This = impl_from_InternalUnknown( iface );
 830
 831     TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
 832
 833
 834     if ( IsEqualGUID( riid, &IID_IUnknown ))
 835         *ppvObject = iface;
 836     else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
 837               IsEqualGUID( riid, &IID_IXMLDOMNode ) )
 838         *ppvObject = &This->lpVtbl;
 839     else
 840     {
 841         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 842         *ppvObject = NULL;
 843         return E_NOINTERFACE;
 844     }
 845
 846     IUnknown_AddRef( (IUnknown*)*ppvObject );
 847
 848     return S_OK;
 849 }
 850
 851 static ULONG WINAPI Internal_AddRef(
 852                  IUnknown *iface )
 853 {
 854     xmlnode *This = impl_from_InternalUnknown( iface );
 855     return InterlockedIncrement( &This->ref );
 856 }
 857
 858 static ULONG WINAPI Internal_Release(
 859     IUnknown *iface )
 860 {
 861     xmlnode *This = impl_from_InternalUnknown( iface );
 862     ULONG ref;
 863
 864     ref = InterlockedDecrement( &This->ref );
 865     if ( ref == 0 )
 866     {
 867         if( This->node )
 868             xmldoc_release( This->node->doc );
 869         HeapFree( GetProcessHeap(), 0, This );
 870     }
 871
 872     return ref;
 873 }
 874
 875 static const struct IUnknownVtbl internal_unk_vtbl =
 876 {
 877     Internal_QueryInterface,
 878     Internal_AddRef,
 879     Internal_Release
 880 };
 881
 882 IUnknown *create_basic_node( xmlNodePtr node, IUnknown *pUnkOuter )
 883 {
 884     xmlnode *This;
 885
 886     This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
 887     if ( !This )
 888         return NULL;
 889
 890     if(node)
 891         xmldoc_add_ref( node->doc );
 892
 893     This->lpVtbl = &xmlnode_vtbl;
 894     This->lpInternalUnkVtbl = &internal_unk_vtbl;
 895
 896     if(pUnkOuter)
 897         This->pUnkOuter = pUnkOuter; /* Don't take a ref on outer Unknown */
 898     else
 899         This->pUnkOuter = (IUnknown *)&This->lpInternalUnkVtbl;
 900
 901     This->ref = 1;
 902     This->node = node;
 903
 904     return (IUnknown*)&This->lpInternalUnkVtbl;
 905 }
 906
 907 IXMLDOMNode *create_node( xmlNodePtr node )
 908 {
 909     IUnknown *pUnk;
 910     IXMLDOMNode *ret;
 911     HRESULT hr;
 912
 913     if ( !node )
 914         return NULL;
 915
 916     TRACE("type %d\n", node->type);
 917     switch(node->type)
 918     {
 919     case XML_ELEMENT_NODE:
 920         pUnk = create_element( node, NULL );
 921         break;
 922     case XML_ATTRIBUTE_NODE:
 923         pUnk = create_attribute( node );
 924         break;
 925     case XML_TEXT_NODE:
 926         pUnk = create_text( node );
 927         break;
 928     case XML_COMMENT_NODE:
 929         pUnk = create_comment( node );
 930         break;
 931     case XML_DOCUMENT_NODE:
 932         ERR("shouldn't be here!\n");
 933         return NULL;
 934     default:
 935         FIXME("only creating basic node for type %d\n", node->type);
 936         pUnk = create_basic_node( node, NULL );
 937     }
 938
 939     hr = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMNode, (LPVOID*)&ret);
 940     IUnknown_Release(pUnk);
 941     if(FAILED(hr)) return NULL;
 942     return ret;
 943 }
 944 #endif