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     if(!value)
 223         return E_INVALIDARG;
 224
 225     V_BSTR(value) = NULL;
 226     V_VT(value) = VT_NULL;
 227
 228     switch ( This->node->type )
 229     {
 230     case XML_ATTRIBUTE_NODE:
 231       {
 232         xmlChar *content = xmlNodeGetContent(This->node);
 233         V_VT(value) = VT_BSTR;
 234         V_BSTR(value) = bstr_from_xmlChar( content );
 235         xmlFree(content);
 236         r = S_OK;
 237         break;
 238       }
 239     case XML_TEXT_NODE:
 240         V_VT(value) = VT_BSTR;
 241         V_BSTR(value) = bstr_from_xmlChar( This->node->content );
 242         r = S_OK;
 243         break;
 244     case XML_ELEMENT_NODE:
 245     case XML_DOCUMENT_NODE:
 246         /* these seem to return NULL */
 247         break;
 248     case XML_PI_NODE:
 249     default:
 250         FIXME("node %p type %d\n", This, This->node->type);
 251     }
 252
 253     TRACE("%p returned %s\n", This, debugstr_w( V_BSTR(value) ) );
 254
 255     return r;
 256 }
 257
 258 static HRESULT WINAPI xmlnode_put_nodeValue(
 259     IXMLDOMNode *iface,
 260     VARIANT value)
 261 {
 262     FIXME("\n");
 263     return E_NOTIMPL;
 264 }
 265
 266 static HRESULT WINAPI xmlnode_get_nodeType(
 267     IXMLDOMNode *iface,
 268     DOMNodeType* type)
 269 {
 270     xmlnode *This = impl_from_IXMLDOMNode( iface );
 271
 272     TRACE("%p %p\n", This, type);
 273
 274     assert( NODE_ELEMENT == XML_ELEMENT_NODE );
 275     assert( NODE_NOTATION == XML_NOTATION_NODE );
 276
 277     *type = This->node->type;
 278
 279     return S_OK;
 280 }
 281
 282 static HRESULT get_node(
 283     xmlnode *This,
 284     const char *name,
 285     xmlNodePtr node,
 286     IXMLDOMNode **out )
 287 {
 288     TRACE("%p->%s %p\n", This, name, node );
 289
 290     if ( !out )
 291         return E_INVALIDARG;
 292     *out = create_node( node );
 293     if (!*out)
 294         return S_FALSE;
 295     return S_OK;
 296 }
 297
 298 static HRESULT WINAPI xmlnode_get_parentNode(
 299     IXMLDOMNode *iface,
 300     IXMLDOMNode** parent)
 301 {
 302     xmlnode *This = impl_from_IXMLDOMNode( iface );
 303     return get_node( This, "parent", This->node->parent, parent );
 304 }
 305
 306 static HRESULT WINAPI xmlnode_get_childNodes(
 307     IXMLDOMNode *iface,
 308     IXMLDOMNodeList** childList)
 309 {
 310     xmlnode *This = impl_from_IXMLDOMNode( iface );
 311
 312     TRACE("%p %p\n", This, childList );
 313
 314     if ( !childList )
 315         return E_INVALIDARG;
 316
 317     *childList = create_children_nodelist(This->node);
 318     if (*childList == NULL)
 319         return E_OUTOFMEMORY;
 320
 321     return S_OK;
 322 }
 323
 324 static HRESULT WINAPI xmlnode_get_firstChild(
 325     IXMLDOMNode *iface,
 326     IXMLDOMNode** firstChild)
 327 {
 328     xmlnode *This = impl_from_IXMLDOMNode( iface );
 329     return get_node( This, "firstChild", This->node->children, firstChild );
 330 }
 331
 332 static HRESULT WINAPI xmlnode_get_lastChild(
 333     IXMLDOMNode *iface,
 334     IXMLDOMNode** lastChild)
 335 {
 336     xmlnode *This = impl_from_IXMLDOMNode( iface );
 337     return get_node( This, "lastChild", This->node->last, lastChild );
 338 }
 339
 340 static HRESULT WINAPI xmlnode_get_previousSibling(
 341     IXMLDOMNode *iface,
 342     IXMLDOMNode** previousSibling)
 343 {
 344     xmlnode *This = impl_from_IXMLDOMNode( iface );
 345     return get_node( This, "previous", This->node->prev, previousSibling );
 346 }
 347
 348 static HRESULT WINAPI xmlnode_get_nextSibling(
 349     IXMLDOMNode *iface,
 350     IXMLDOMNode** nextSibling)
 351 {
 352     xmlnode *This = impl_from_IXMLDOMNode( iface );
 353     return get_node( This, "next", This->node->next, nextSibling );
 354 }
 355
 356 static HRESULT WINAPI xmlnode_get_attributes(
 357     IXMLDOMNode *iface,
 358     IXMLDOMNamedNodeMap** attributeMap)
 359 {
 360     xmlnode *This = impl_from_IXMLDOMNode( iface );
 361     TRACE("%p\n", This);
 362     *attributeMap = create_nodemap( iface );
 363     return S_OK;
 364 }
 365
 366 static HRESULT WINAPI xmlnode_insertBefore(
 367     IXMLDOMNode *iface,
 368     IXMLDOMNode* newChild,
 369     VARIANT refChild,
 370     IXMLDOMNode** outNewChild)
 371 {
 372     xmlnode *This = impl_from_IXMLDOMNode( iface );
 373     xmlNodePtr before_node, new_child_node;
 374     IXMLDOMNode *before = NULL, *new;
 375     HRESULT hr;
 376
 377     TRACE("(%p)->(%p,var,%p)\n",This,newChild,outNewChild);
 378
 379     if (!newChild)
 380         return E_INVALIDARG;
 381
 382     switch(V_VT(&refChild))
 383     {
 384     case VT_EMPTY:
 385     case VT_NULL:
 386         break;
 387
 388     case VT_UNKNOWN:
 389         hr = IUnknown_QueryInterface(V_UNKNOWN(&refChild), &IID_IXMLDOMNode, (LPVOID)&before);
 390         if(FAILED(hr)) return hr;
 391         break;
 392
 393     case VT_DISPATCH:
 394         hr = IDispatch_QueryInterface(V_DISPATCH(&refChild), &IID_IXMLDOMNode, (LPVOID)&before);
 395         if(FAILED(hr)) return hr;
 396         break;
 397
 398     default:
 399         FIXME("refChild var type %x\n", V_VT(&refChild));
 400         return E_FAIL;
 401     }
 402
 403     IXMLDOMNode_QueryInterface(newChild, &IID_IXMLDOMNode, (LPVOID)&new);
 404     new_child_node = impl_from_IXMLDOMNode(new)->node;
 405     TRACE("new_child_node %p This->node %p\n", new_child_node, This->node);
 406
 407     if(before)
 408     {
 409         before_node = impl_from_IXMLDOMNode(before)->node;
 410         xmlAddPrevSibling(before_node, new_child_node);
 411         IXMLDOMNode_Release(before);
 412     }
 413     else
 414     {
 415         xmlAddChild(This->node, new_child_node);
 416     }
 417
 418     IXMLDOMNode_Release(new);
 419     IXMLDOMNode_AddRef(newChild);
 420     if(outNewChild)
 421         *outNewChild = newChild;
 422
 423     TRACE("ret S_OK\n");
 424     return S_OK;
 425 }
 426
 427 static HRESULT WINAPI xmlnode_replaceChild(
 428     IXMLDOMNode *iface,
 429     IXMLDOMNode* newChild,
 430     IXMLDOMNode* oldChild,
 431     IXMLDOMNode** outOldChild)
 432 {
 433     FIXME("\n");
 434     return E_NOTIMPL;
 435 }
 436
 437 static HRESULT WINAPI xmlnode_removeChild(
 438     IXMLDOMNode *iface,
 439     IXMLDOMNode* childNode,
 440     IXMLDOMNode** oldChild)
 441 {
 442     xmlnode *This = impl_from_IXMLDOMNode( iface );
 443     xmlNode *ancestor, *child_node_ptr;
 444     HRESULT hr;
 445     IXMLDOMNode *child;
 446
 447     TRACE("%p->(%p, %p)\n", This, childNode, oldChild);
 448
 449     *oldChild = NULL;
 450
 451     if(!childNode) return E_INVALIDARG;
 452
 453     hr = IXMLDOMNode_QueryInterface(childNode, &IID_IXMLDOMNode, (LPVOID)&child);
 454     if(FAILED(hr))
 455         return hr;
 456
 457     child_node_ptr = ancestor = impl_from_IXMLDOMNode(child)->node;
 458     while(ancestor->parent)
 459     {
 460         if(ancestor->parent == This->node)
 461             break;
 462         ancestor = ancestor->parent;
 463     }
 464     if(!ancestor->parent)
 465     {
 466         WARN("childNode %p is not a child of %p\n", childNode, iface);
 467         IXMLDOMNode_Release(child);
 468         return E_INVALIDARG;
 469     }
 470
 471     xmlUnlinkNode(child_node_ptr);
 472
 473     IXMLDOMNode_Release(child);
 474     IXMLDOMNode_AddRef(childNode);
 475     *oldChild = childNode;
 476     return S_OK;
 477 }
 478
 479 static HRESULT WINAPI xmlnode_appendChild(
 480     IXMLDOMNode *iface,
 481     IXMLDOMNode* newChild,
 482     IXMLDOMNode** outNewChild)
 483 {
 484     xmlnode *This = impl_from_IXMLDOMNode( iface );
 485     VARIANT var;
 486
 487     TRACE("(%p)->(%p,%p)\n", This, newChild, outNewChild);
 488     VariantInit(&var);
 489     return IXMLDOMNode_insertBefore(iface, newChild, var, outNewChild);
 490 }
 491
 492 static HRESULT WINAPI xmlnode_hasChildNodes(
 493     IXMLDOMNode *iface,
 494     VARIANT_BOOL* hasChild)
 495 {
 496     xmlnode *This = impl_from_IXMLDOMNode( iface );
 497
 498     TRACE("%p\n", This);
 499
 500     if (!hasChild)
 501         return E_INVALIDARG;
 502     if (!This->node->children)
 503     {
 504         *hasChild = VARIANT_FALSE;
 505         return S_FALSE;
 506     }
 507
 508     *hasChild = VARIANT_TRUE;
 509     return S_OK;
 510 }
 511
 512 static HRESULT WINAPI xmlnode_get_ownerDocument(
 513     IXMLDOMNode *iface,
 514     IXMLDOMDocument** DOMDocument)
 515 {
 516     FIXME("\n");
 517     return E_NOTIMPL;
 518 }
 519
 520 static HRESULT WINAPI xmlnode_cloneNode(
 521     IXMLDOMNode *iface,
 522     VARIANT_BOOL deep,
 523     IXMLDOMNode** cloneRoot)
 524 {
 525     xmlnode *This = impl_from_IXMLDOMNode( iface );
 526     xmlNodePtr pClone = NULL;
 527     IXMLDOMNode *pNode = NULL;
 528
 529     TRACE("%p (%d)\n", This, deep);
 530
 531     if(!cloneRoot)
 532         return E_INVALIDARG;
 533
 534     pClone = xmlCopyNode(This->node, deep ? 1 : 2);
 535     if(pClone)
 536     {
 537         pClone->doc = This->node->doc;
 538
 539         pNode = create_node(pClone);
 540         if(!pNode)
 541         {
 542             ERR("Copy failed\n");
 543             return E_FAIL;
 544         }
 545
 546         *cloneRoot = pNode;
 547     }
 548     else
 549     {
 550         ERR("Copy failed\n");
 551         return E_FAIL;
 552     }
 553
 554     return S_OK;
 555 }
 556
 557 static HRESULT WINAPI xmlnode_get_nodeTypeString(
 558     IXMLDOMNode *iface,
 559     BSTR* xmlnodeType)
 560 {
 561     FIXME("\n");
 562     return E_NOTIMPL;
 563 }
 564
 565 static HRESULT WINAPI xmlnode_get_text(
 566     IXMLDOMNode *iface,
 567     BSTR* text)
 568 {
 569     xmlnode *This = impl_from_IXMLDOMNode( iface );
 570     BSTR str = NULL;
 571
 572     TRACE("%p\n", This);
 573
 574     if ( !text )
 575         return E_INVALIDARG;
 576
 577     switch(This->node->type)
 578     {
 579     case XML_ELEMENT_NODE:
 580     case XML_ATTRIBUTE_NODE:
 581     {
 582         xmlNodePtr child = This->node->children;
 583         if ( child && child->type == XML_TEXT_NODE )
 584             str = bstr_from_xmlChar( child->content );
 585         break;
 586     }
 587
 588     case XML_TEXT_NODE:
 589     case XML_CDATA_SECTION_NODE:
 590     case XML_PI_NODE:
 591     case XML_COMMENT_NODE:
 592         str = bstr_from_xmlChar( This->node->content );
 593         break;
 594
 595     default:
 596         FIXME("Unhandled node type %d\n", This->node->type);
 597     }
 598
 599     /* Always return a string. */
 600     if (!str) str = SysAllocStringLen( NULL, 0 );
 601
 602     TRACE("%p %s\n", This, debugstr_w(str) );
 603     *text = str;
 604
 605     return S_OK;
 606 }
 607
 608 static HRESULT WINAPI xmlnode_put_text(
 609     IXMLDOMNode *iface,
 610     BSTR text)
 611 {
 612     FIXME("\n");
 613     return E_NOTIMPL;
 614 }
 615
 616 static HRESULT WINAPI xmlnode_get_specified(
 617     IXMLDOMNode *iface,
 618     VARIANT_BOOL* isSpecified)
 619 {
 620     FIXME("\n");
 621     return E_NOTIMPL;
 622 }
 623
 624 static HRESULT WINAPI xmlnode_get_definition(
 625     IXMLDOMNode *iface,
 626     IXMLDOMNode** definitionNode)
 627 {
 628     FIXME("\n");
 629     return E_NOTIMPL;
 630 }
 631
 632 static HRESULT WINAPI xmlnode_get_nodeTypedValue(
 633     IXMLDOMNode *iface,
 634     VARIANT* typedValue)
 635 {
 636     FIXME("ignoring data type\n");
 637     return xmlnode_get_nodeValue(iface, typedValue);
 638 }
 639
 640 static HRESULT WINAPI xmlnode_put_nodeTypedValue(
 641     IXMLDOMNode *iface,
 642     VARIANT typedValue)
 643 {
 644     FIXME("\n");
 645     return E_NOTIMPL;
 646 }
 647
 648 static HRESULT WINAPI xmlnode_get_dataType(
 649     IXMLDOMNode *iface,
 650     VARIANT* dataTypeName)
 651 {
 652     FIXME("\n");
 653     return E_NOTIMPL;
 654 }
 655
 656 static HRESULT WINAPI xmlnode_put_dataType(
 657     IXMLDOMNode *iface,
 658     BSTR dataTypeName)
 659 {
 660     FIXME("\n");
 661     return E_NOTIMPL;
 662 }
 663
 664 static HRESULT WINAPI xmlnode_get_xml(
 665     IXMLDOMNode *iface,
 666     BSTR* xmlString)
 667 {
 668     FIXME("\n");
 669     return E_NOTIMPL;
 670 }
 671
 672 static HRESULT WINAPI xmlnode_transformNode(
 673     IXMLDOMNode *iface,
 674     IXMLDOMNode* styleSheet,
 675     BSTR* xmlString)
 676 {
 677     FIXME("\n");
 678     return E_NOTIMPL;
 679 }
 680
 681 static HRESULT WINAPI xmlnode_selectNodes(
 682     IXMLDOMNode *iface,
 683     BSTR queryString,
 684     IXMLDOMNodeList** resultList)
 685 {
 686     xmlnode *This = impl_from_IXMLDOMNode( iface );
 687
 688     TRACE("%p %s %p\n", This, debugstr_w(queryString), resultList );
 689
 690     return queryresult_create( This->node, queryString, resultList );
 691 }
 692
 693 static HRESULT WINAPI xmlnode_selectSingleNode(
 694     IXMLDOMNode *iface,
 695     BSTR queryString,
 696     IXMLDOMNode** resultNode)
 697 {
 698     xmlnode *This = impl_from_IXMLDOMNode( iface );
 699     IXMLDOMNodeList *list;
 700     HRESULT r;
 701
 702     TRACE("%p %s %p\n", This, debugstr_w(queryString), resultNode );
 703
 704     *resultNode = NULL;
 705     r = IXMLDOMNode_selectNodes(iface, queryString, &list);
 706     if(r == S_OK)
 707     {
 708         r = IXMLDOMNodeList_nextNode(list, resultNode);
 709         IXMLDOMNodeList_Release(list);
 710     }
 711     return r;
 712 }
 713
 714 static HRESULT WINAPI xmlnode_get_parsed(
 715     IXMLDOMNode *iface,
 716     VARIANT_BOOL* isParsed)
 717 {
 718     FIXME("\n");
 719     return E_NOTIMPL;
 720 }
 721
 722 static HRESULT WINAPI xmlnode_get_namespaceURI(
 723     IXMLDOMNode *iface,
 724     BSTR* namespaceURI)
 725 {
 726     FIXME("\n");
 727     return E_NOTIMPL;
 728 }
 729
 730 static HRESULT WINAPI xmlnode_get_prefix(
 731     IXMLDOMNode *iface,
 732     BSTR* prefixString)
 733 {
 734     FIXME("\n");
 735     return E_NOTIMPL;
 736 }
 737
 738 static HRESULT WINAPI xmlnode_get_baseName(
 739     IXMLDOMNode *iface,
 740     BSTR* nameString)
 741 {
 742     xmlnode *This = impl_from_IXMLDOMNode( iface );
 743     BSTR str = NULL;
 744     HRESULT r = S_FALSE;
 745
 746     TRACE("%p %p\n", This, nameString );
 747
 748     if ( !nameString )
 749         return E_INVALIDARG;
 750
 751     switch ( This->node->type )
 752     {
 753     case XML_ELEMENT_NODE:
 754     case XML_ATTRIBUTE_NODE:
 755         str = bstr_from_xmlChar( This->node->name );
 756         r = S_OK;
 757         break;
 758     case XML_TEXT_NODE:
 759         break;
 760     default:
 761         ERR("Unhandled type %d\n", This->node->type );
 762         break;
 763     }
 764
 765     TRACE("returning %08x str = %s\n", r, debugstr_w( str ) );
 766
 767     *nameString = str;
 768     return r;
 769 }
 770
 771 static HRESULT WINAPI xmlnode_transformNodeToObject(
 772     IXMLDOMNode *iface,
 773     IXMLDOMNode* stylesheet,
 774     VARIANT outputObject)
 775 {
 776     FIXME("\n");
 777     return E_NOTIMPL;
 778 }
 779
 780 static const struct IXMLDOMNodeVtbl xmlnode_vtbl =
 781 {
 782     xmlnode_QueryInterface,
 783     xmlnode_AddRef,
 784     xmlnode_Release,
 785     xmlnode_GetTypeInfoCount,
 786     xmlnode_GetTypeInfo,
 787     xmlnode_GetIDsOfNames,
 788     xmlnode_Invoke,
 789     xmlnode_get_nodeName,
 790     xmlnode_get_nodeValue,
 791     xmlnode_put_nodeValue,
 792     xmlnode_get_nodeType,
 793     xmlnode_get_parentNode,
 794     xmlnode_get_childNodes,
 795     xmlnode_get_firstChild,
 796     xmlnode_get_lastChild,
 797     xmlnode_get_previousSibling,
 798     xmlnode_get_nextSibling,
 799     xmlnode_get_attributes,
 800     xmlnode_insertBefore,
 801     xmlnode_replaceChild,
 802     xmlnode_removeChild,
 803     xmlnode_appendChild,
 804     xmlnode_hasChildNodes,
 805     xmlnode_get_ownerDocument,
 806     xmlnode_cloneNode,
 807     xmlnode_get_nodeTypeString,
 808     xmlnode_get_text,
 809     xmlnode_put_text,
 810     xmlnode_get_specified,
 811     xmlnode_get_definition,
 812     xmlnode_get_nodeTypedValue,
 813     xmlnode_put_nodeTypedValue,
 814     xmlnode_get_dataType,
 815     xmlnode_put_dataType,
 816     xmlnode_get_xml,
 817     xmlnode_transformNode,
 818     xmlnode_selectNodes,
 819     xmlnode_selectSingleNode,
 820     xmlnode_get_parsed,
 821     xmlnode_get_namespaceURI,
 822     xmlnode_get_prefix,
 823     xmlnode_get_baseName,
 824     xmlnode_transformNodeToObject,
 825 };
 826
 827 static HRESULT WINAPI Internal_QueryInterface(
 828     IUnknown *iface,
 829     REFIID riid,
 830     void** ppvObject )
 831 {
 832     xmlnode *This = impl_from_InternalUnknown( iface );
 833
 834     TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
 835
 836
 837     if ( IsEqualGUID( riid, &IID_IUnknown ))
 838         *ppvObject = iface;
 839     else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
 840               IsEqualGUID( riid, &IID_IXMLDOMNode ) )
 841         *ppvObject = &This->lpVtbl;
 842     else
 843     {
 844         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 845         *ppvObject = NULL;
 846         return E_NOINTERFACE;
 847     }
 848
 849     IUnknown_AddRef( (IUnknown*)*ppvObject );
 850
 851     return S_OK;
 852 }
 853
 854 static ULONG WINAPI Internal_AddRef(
 855                  IUnknown *iface )
 856 {
 857     xmlnode *This = impl_from_InternalUnknown( iface );
 858     return InterlockedIncrement( &This->ref );
 859 }
 860
 861 static ULONG WINAPI Internal_Release(
 862     IUnknown *iface )
 863 {
 864     xmlnode *This = impl_from_InternalUnknown( iface );
 865     ULONG ref;
 866
 867     ref = InterlockedDecrement( &This->ref );
 868     if ( ref == 0 )
 869     {
 870         if( This->node )
 871             xmldoc_release( This->node->doc );
 872         HeapFree( GetProcessHeap(), 0, This );
 873     }
 874
 875     return ref;
 876 }
 877
 878 static const struct IUnknownVtbl internal_unk_vtbl =
 879 {
 880     Internal_QueryInterface,
 881     Internal_AddRef,
 882     Internal_Release
 883 };
 884
 885 IUnknown *create_basic_node( xmlNodePtr node, IUnknown *pUnkOuter )
 886 {
 887     xmlnode *This;
 888
 889     This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
 890     if ( !This )
 891         return NULL;
 892
 893     if(node)
 894         xmldoc_add_ref( node->doc );
 895
 896     This->lpVtbl = &xmlnode_vtbl;
 897     This->lpInternalUnkVtbl = &internal_unk_vtbl;
 898
 899     if(pUnkOuter)
 900         This->pUnkOuter = pUnkOuter; /* Don't take a ref on outer Unknown */
 901     else
 902         This->pUnkOuter = (IUnknown *)&This->lpInternalUnkVtbl;
 903
 904     This->ref = 1;
 905     This->node = node;
 906
 907     return (IUnknown*)&This->lpInternalUnkVtbl;
 908 }
 909
 910 IXMLDOMNode *create_node( xmlNodePtr node )
 911 {
 912     IUnknown *pUnk;
 913     IXMLDOMNode *ret;
 914     HRESULT hr;
 915
 916     if ( !node )
 917         return NULL;
 918
 919     TRACE("type %d\n", node->type);
 920     switch(node->type)
 921     {
 922     case XML_ELEMENT_NODE:
 923         pUnk = create_element( node, NULL );
 924         break;
 925     case XML_ATTRIBUTE_NODE:
 926         pUnk = create_attribute( node );
 927         break;
 928     case XML_TEXT_NODE:
 929         pUnk = create_text( node );
 930         break;
 931     case XML_COMMENT_NODE:
 932         pUnk = create_comment( node );
 933         break;
 934     case XML_DOCUMENT_NODE:
 935         ERR("shouldn't be here!\n");
 936         return NULL;
 937     default:
 938         FIXME("only creating basic node for type %d\n", node->type);
 939         pUnk = create_basic_node( node, NULL );
 940     }
 941
 942     hr = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMNode, (LPVOID*)&ret);
 943     IUnknown_Release(pUnk);
 944     if(FAILED(hr)) return NULL;
 945     return ret;
 946 }
 947 #endif