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 static inline xmlnode *impl_from_InternalUnknown( IUnknown *iface )
  43 {
  44     return (xmlnode *)((char*)iface - FIELD_OFFSET(xmlnode, lpInternalUnkVtbl));
  45 }
  46
  47 xmlNodePtr xmlNodePtr_from_domnode( IXMLDOMNode *iface, xmlElementType type )
  48 {
  49     xmlnode *This;
  50
  51     if ( !iface )
  52         return NULL;
  53     This = impl_from_IXMLDOMNode( iface );
  54     if ( !This->node )
  55         return NULL;
  56     if ( type && This->node->type != type )
  57         return NULL;
  58     return This->node;
  59 }
  60
  61 void attach_xmlnode( IXMLDOMNode *node, xmlNodePtr xml )
  62 {
  63     xmlnode *This = impl_from_IXMLDOMNode( node );
  64
  65     if(This->node)
  66         xmldoc_release(This->node->doc);
  67
  68     This->node = xml;
  69     if(This->node)
  70         xmldoc_add_ref(This->node->doc);
  71
  72     return;
  73 }
  74
  75 static HRESULT WINAPI xmlnode_QueryInterface(
  76     IXMLDOMNode *iface,
  77     REFIID riid,
  78     void** ppvObject )
  79 {
  80     xmlnode *This = impl_from_IXMLDOMNode( iface );
  81     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
  82
  83     return IUnknown_QueryInterface(This->pUnkOuter, riid, ppvObject);
  84 }
  85
  86 static ULONG WINAPI xmlnode_AddRef(
  87     IXMLDOMNode *iface )
  88 {
  89     xmlnode *This = impl_from_IXMLDOMNode( iface );
  90     return IUnknown_AddRef(This->pUnkOuter);
  91 }
  92
  93 static ULONG WINAPI xmlnode_Release(
  94     IXMLDOMNode *iface )
  95 {
  96     xmlnode *This = impl_from_IXMLDOMNode( iface );
  97     return IUnknown_Release(This->pUnkOuter);
  98 }
  99
 100 static HRESULT WINAPI xmlnode_GetTypeInfoCount(
 101     IXMLDOMNode *iface,
 102     UINT* pctinfo )
 103 {
 104     FIXME("\n");
 105     return E_NOTIMPL;
 106 }
 107
 108 static HRESULT WINAPI xmlnode_GetTypeInfo(
 109     IXMLDOMNode *iface,
 110     UINT iTInfo,
 111     LCID lcid,
 112     ITypeInfo** ppTInfo )
 113 {
 114     FIXME("\n");
 115     return E_NOTIMPL;
 116 }
 117
 118 static HRESULT WINAPI xmlnode_GetIDsOfNames(
 119     IXMLDOMNode *iface,
 120     REFIID riid,
 121     LPOLESTR* rgszNames,
 122     UINT cNames,
 123     LCID lcid,
 124     DISPID* rgDispId )
 125 {
 126     FIXME("\n");
 127     return E_NOTIMPL;
 128 }
 129
 130 static HRESULT WINAPI xmlnode_Invoke(
 131     IXMLDOMNode *iface,
 132     DISPID dispIdMember,
 133     REFIID riid,
 134     LCID lcid,
 135     WORD wFlags,
 136     DISPPARAMS* pDispParams,
 137     VARIANT* pVarResult,
 138     EXCEPINFO* pExcepInfo,
 139     UINT* puArgErr )
 140 {
 141     FIXME("\n");
 142     return E_NOTIMPL;
 143 }
 144
 145 static HRESULT WINAPI xmlnode_get_nodeName(
 146     IXMLDOMNode *iface,
 147     BSTR* name)
 148 {
 149     xmlnode *This = impl_from_IXMLDOMNode( iface );
 150     const xmlChar *str;
 151
 152     TRACE("%p\n", This );
 153
 154     if (!name)
 155         return E_INVALIDARG;
 156
 157     if ( !This->node )
 158         return E_FAIL;
 159
 160     switch( This->node->type )
 161     {
 162     case XML_CDATA_SECTION_NODE:
 163         str = (const xmlChar*) "#cdata-section";
 164         break;
 165     case XML_COMMENT_NODE:
 166         str = (const xmlChar*) "#comment";
 167         break;
 168     case XML_DOCUMENT_FRAG_NODE:
 169         str = (const xmlChar*) "#document-fragment";
 170         break;
 171     case XML_TEXT_NODE:
 172          str = (const xmlChar*) "#text";
 173          break;
 174     case XML_DOCUMENT_NODE:
 175          str = (const xmlChar*) "#document";
 176             break;
 177         case XML_ATTRIBUTE_NODE:
 178         case XML_ELEMENT_NODE:
 179         str = This->node->name;
 180             break;
 181     default:
 182         FIXME("nodeName not mapped correctly (%d)\n", This->node->type);
 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     IXMLDOMNode *pAttr = NULL;
 486     VARIANT var;
 487
 488     TRACE("(%p)->(%p,%p)\n", This, newChild, outNewChild);
 489
 490     /* Cannot Append an Attribute node. */
 491     IUnknown_QueryInterface(newChild, &IID_IXMLDOMNode, (LPVOID*)&pAttr);
 492     if(pAttr)
 493     {
 494         xmlnode *ThisNew = impl_from_IXMLDOMNode( pAttr );
 495
 496         if(ThisNew->node->type == XML_ATTRIBUTE_NODE)
 497         {
 498             if(outNewChild) *outNewChild = NULL;
 499
 500             IUnknown_Release(pAttr);
 501
 502             return E_FAIL;
 503         }
 504
 505         IUnknown_Release(pAttr);
 506     }
 507
 508     VariantInit(&var);
 509     return IXMLDOMNode_insertBefore(iface, newChild, var, outNewChild);
 510 }
 511
 512 static HRESULT WINAPI xmlnode_hasChildNodes(
 513     IXMLDOMNode *iface,
 514     VARIANT_BOOL* hasChild)
 515 {
 516     xmlnode *This = impl_from_IXMLDOMNode( iface );
 517
 518     TRACE("%p\n", This);
 519
 520     if (!hasChild)
 521         return E_INVALIDARG;
 522     if (!This->node->children)
 523     {
 524         *hasChild = VARIANT_FALSE;
 525         return S_FALSE;
 526     }
 527
 528     *hasChild = VARIANT_TRUE;
 529     return S_OK;
 530 }
 531
 532 static HRESULT WINAPI xmlnode_get_ownerDocument(
 533     IXMLDOMNode *iface,
 534     IXMLDOMDocument** DOMDocument)
 535 {
 536     FIXME("\n");
 537     return E_NOTIMPL;
 538 }
 539
 540 static HRESULT WINAPI xmlnode_cloneNode(
 541     IXMLDOMNode *iface,
 542     VARIANT_BOOL deep,
 543     IXMLDOMNode** cloneRoot)
 544 {
 545     xmlnode *This = impl_from_IXMLDOMNode( iface );
 546     xmlNodePtr pClone = NULL;
 547     IXMLDOMNode *pNode = NULL;
 548
 549     TRACE("%p (%d)\n", This, deep);
 550
 551     if(!cloneRoot)
 552         return E_INVALIDARG;
 553
 554     pClone = xmlCopyNode(This->node, deep ? 1 : 2);
 555     if(pClone)
 556     {
 557         pClone->doc = This->node->doc;
 558
 559         pNode = create_node(pClone);
 560         if(!pNode)
 561         {
 562             ERR("Copy failed\n");
 563             return E_FAIL;
 564         }
 565
 566         *cloneRoot = pNode;
 567     }
 568     else
 569     {
 570         ERR("Copy failed\n");
 571         return E_FAIL;
 572     }
 573
 574     return S_OK;
 575 }
 576
 577 static HRESULT WINAPI xmlnode_get_nodeTypeString(
 578     IXMLDOMNode *iface,
 579     BSTR* xmlnodeType)
 580 {
 581     FIXME("\n");
 582     return E_NOTIMPL;
 583 }
 584
 585 static HRESULT WINAPI xmlnode_get_text(
 586     IXMLDOMNode *iface,
 587     BSTR* text)
 588 {
 589     xmlnode *This = impl_from_IXMLDOMNode( iface );
 590     BSTR str = NULL;
 591
 592     TRACE("%p\n", This);
 593
 594     if ( !text )
 595         return E_INVALIDARG;
 596
 597     switch(This->node->type)
 598     {
 599     case XML_ELEMENT_NODE:
 600     case XML_ATTRIBUTE_NODE:
 601     {
 602         xmlNodePtr child = This->node->children;
 603         if ( child && child->type == XML_TEXT_NODE )
 604             str = bstr_from_xmlChar( child->content );
 605         break;
 606     }
 607
 608     case XML_TEXT_NODE:
 609     case XML_CDATA_SECTION_NODE:
 610     case XML_PI_NODE:
 611     case XML_COMMENT_NODE:
 612         str = bstr_from_xmlChar( This->node->content );
 613         break;
 614
 615     default:
 616         FIXME("Unhandled node type %d\n", This->node->type);
 617     }
 618
 619     /* Always return a string. */
 620     if (!str) str = SysAllocStringLen( NULL, 0 );
 621
 622     TRACE("%p %s\n", This, debugstr_w(str) );
 623     *text = str;
 624
 625     return S_OK;
 626 }
 627
 628 static HRESULT WINAPI xmlnode_put_text(
 629     IXMLDOMNode *iface,
 630     BSTR text)
 631 {
 632     FIXME("\n");
 633     return E_NOTIMPL;
 634 }
 635
 636 static HRESULT WINAPI xmlnode_get_specified(
 637     IXMLDOMNode *iface,
 638     VARIANT_BOOL* isSpecified)
 639 {
 640     FIXME("\n");
 641     return E_NOTIMPL;
 642 }
 643
 644 static HRESULT WINAPI xmlnode_get_definition(
 645     IXMLDOMNode *iface,
 646     IXMLDOMNode** definitionNode)
 647 {
 648     FIXME("\n");
 649     return E_NOTIMPL;
 650 }
 651
 652 static HRESULT WINAPI xmlnode_get_nodeTypedValue(
 653     IXMLDOMNode *iface,
 654     VARIANT* typedValue)
 655 {
 656     FIXME("ignoring data type\n");
 657     return xmlnode_get_nodeValue(iface, typedValue);
 658 }
 659
 660 static HRESULT WINAPI xmlnode_put_nodeTypedValue(
 661     IXMLDOMNode *iface,
 662     VARIANT typedValue)
 663 {
 664     FIXME("\n");
 665     return E_NOTIMPL;
 666 }
 667
 668 static HRESULT WINAPI xmlnode_get_dataType(
 669     IXMLDOMNode *iface,
 670     VARIANT* dataTypeName)
 671 {
 672     FIXME("\n");
 673     return E_NOTIMPL;
 674 }
 675
 676 static HRESULT WINAPI xmlnode_put_dataType(
 677     IXMLDOMNode *iface,
 678     BSTR dataTypeName)
 679 {
 680     FIXME("\n");
 681     return E_NOTIMPL;
 682 }
 683
 684 static HRESULT WINAPI xmlnode_get_xml(
 685     IXMLDOMNode *iface,
 686     BSTR* xmlString)
 687 {
 688     xmlnode *This = impl_from_IXMLDOMNode( iface );
 689     xmlBufferPtr pXmlBuf;
 690     int nSize;
 691
 692     TRACE("iface %p\n", iface);
 693
 694     if(!xmlString)
 695         return E_INVALIDARG;
 696
 697     *xmlString = NULL;
 698
 699     pXmlBuf = xmlBufferCreate();
 700     if(pXmlBuf)
 701     {
 702         nSize = xmlNodeDump(pXmlBuf, This->node->doc, This->node, 0, 0);
 703         if(nSize > 0)
 704         {
 705             const xmlChar *pContent;
 706
 707             /* Attribute Nodes return a space infront of their name */
 708             pContent = xmlBufferContent(pXmlBuf);
 709             if( ((char*)pContent)[0] == ' ')
 710                 *xmlString = bstr_from_xmlChar(pContent+1);
 711             else
 712                 *xmlString = bstr_from_xmlChar(pContent);
 713
 714
 715             xmlBufferFree(pXmlBuf);
 716         }
 717     }
 718
 719     /* Always returns a string. */
 720     if(*xmlString == NULL)  *xmlString = SysAllocStringLen( NULL, 0 );
 721
 722     return S_OK;
 723 }
 724
 725 static HRESULT WINAPI xmlnode_transformNode(
 726     IXMLDOMNode *iface,
 727     IXMLDOMNode* styleSheet,
 728     BSTR* xmlString)
 729 {
 730     FIXME("\n");
 731     return E_NOTIMPL;
 732 }
 733
 734 static HRESULT WINAPI xmlnode_selectNodes(
 735     IXMLDOMNode *iface,
 736     BSTR queryString,
 737     IXMLDOMNodeList** resultList)
 738 {
 739     xmlnode *This = impl_from_IXMLDOMNode( iface );
 740
 741     TRACE("%p %s %p\n", This, debugstr_w(queryString), resultList );
 742
 743     return queryresult_create( This->node, queryString, resultList );
 744 }
 745
 746 static HRESULT WINAPI xmlnode_selectSingleNode(
 747     IXMLDOMNode *iface,
 748     BSTR queryString,
 749     IXMLDOMNode** resultNode)
 750 {
 751     xmlnode *This = impl_from_IXMLDOMNode( iface );
 752     IXMLDOMNodeList *list;
 753     HRESULT r;
 754
 755     TRACE("%p %s %p\n", This, debugstr_w(queryString), resultNode );
 756
 757     *resultNode = NULL;
 758     r = IXMLDOMNode_selectNodes(iface, queryString, &list);
 759     if(r == S_OK)
 760     {
 761         r = IXMLDOMNodeList_nextNode(list, resultNode);
 762         IXMLDOMNodeList_Release(list);
 763     }
 764     return r;
 765 }
 766
 767 static HRESULT WINAPI xmlnode_get_parsed(
 768     IXMLDOMNode *iface,
 769     VARIANT_BOOL* isParsed)
 770 {
 771     FIXME("\n");
 772     return E_NOTIMPL;
 773 }
 774
 775 static HRESULT WINAPI xmlnode_get_namespaceURI(
 776     IXMLDOMNode *iface,
 777     BSTR* namespaceURI)
 778 {
 779     FIXME("\n");
 780     return E_NOTIMPL;
 781 }
 782
 783 static HRESULT WINAPI xmlnode_get_prefix(
 784     IXMLDOMNode *iface,
 785     BSTR* prefixString)
 786 {
 787     FIXME("\n");
 788     return E_NOTIMPL;
 789 }
 790
 791 static HRESULT WINAPI xmlnode_get_baseName(
 792     IXMLDOMNode *iface,
 793     BSTR* nameString)
 794 {
 795     xmlnode *This = impl_from_IXMLDOMNode( iface );
 796     BSTR str = NULL;
 797     HRESULT r = S_FALSE;
 798
 799     TRACE("%p %p\n", This, nameString );
 800
 801     if ( !nameString )
 802         return E_INVALIDARG;
 803
 804     switch ( This->node->type )
 805     {
 806     case XML_ELEMENT_NODE:
 807     case XML_ATTRIBUTE_NODE:
 808         str = bstr_from_xmlChar( This->node->name );
 809         r = S_OK;
 810         break;
 811     case XML_TEXT_NODE:
 812         break;
 813     default:
 814         ERR("Unhandled type %d\n", This->node->type );
 815         break;
 816     }
 817
 818     TRACE("returning %08x str = %s\n", r, debugstr_w( str ) );
 819
 820     *nameString = str;
 821     return r;
 822 }
 823
 824 static HRESULT WINAPI xmlnode_transformNodeToObject(
 825     IXMLDOMNode *iface,
 826     IXMLDOMNode* stylesheet,
 827     VARIANT outputObject)
 828 {
 829     FIXME("\n");
 830     return E_NOTIMPL;
 831 }
 832
 833 static const struct IXMLDOMNodeVtbl xmlnode_vtbl =
 834 {
 835     xmlnode_QueryInterface,
 836     xmlnode_AddRef,
 837     xmlnode_Release,
 838     xmlnode_GetTypeInfoCount,
 839     xmlnode_GetTypeInfo,
 840     xmlnode_GetIDsOfNames,
 841     xmlnode_Invoke,
 842     xmlnode_get_nodeName,
 843     xmlnode_get_nodeValue,
 844     xmlnode_put_nodeValue,
 845     xmlnode_get_nodeType,
 846     xmlnode_get_parentNode,
 847     xmlnode_get_childNodes,
 848     xmlnode_get_firstChild,
 849     xmlnode_get_lastChild,
 850     xmlnode_get_previousSibling,
 851     xmlnode_get_nextSibling,
 852     xmlnode_get_attributes,
 853     xmlnode_insertBefore,
 854     xmlnode_replaceChild,
 855     xmlnode_removeChild,
 856     xmlnode_appendChild,
 857     xmlnode_hasChildNodes,
 858     xmlnode_get_ownerDocument,
 859     xmlnode_cloneNode,
 860     xmlnode_get_nodeTypeString,
 861     xmlnode_get_text,
 862     xmlnode_put_text,
 863     xmlnode_get_specified,
 864     xmlnode_get_definition,
 865     xmlnode_get_nodeTypedValue,
 866     xmlnode_put_nodeTypedValue,
 867     xmlnode_get_dataType,
 868     xmlnode_put_dataType,
 869     xmlnode_get_xml,
 870     xmlnode_transformNode,
 871     xmlnode_selectNodes,
 872     xmlnode_selectSingleNode,
 873     xmlnode_get_parsed,
 874     xmlnode_get_namespaceURI,
 875     xmlnode_get_prefix,
 876     xmlnode_get_baseName,
 877     xmlnode_transformNodeToObject,
 878 };
 879
 880 static HRESULT WINAPI Internal_QueryInterface(
 881     IUnknown *iface,
 882     REFIID riid,
 883     void** ppvObject )
 884 {
 885     xmlnode *This = impl_from_InternalUnknown( iface );
 886
 887     TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
 888
 889
 890     if ( IsEqualGUID( riid, &IID_IUnknown ))
 891         *ppvObject = iface;
 892     else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
 893               IsEqualGUID( riid, &IID_IXMLDOMNode ) )
 894         *ppvObject = &This->lpVtbl;
 895     else
 896     {
 897         FIXME("interface %s not implemented\n", debugstr_guid(riid));
 898         *ppvObject = NULL;
 899         return E_NOINTERFACE;
 900     }
 901
 902     IUnknown_AddRef( (IUnknown*)*ppvObject );
 903
 904     return S_OK;
 905 }
 906
 907 static ULONG WINAPI Internal_AddRef(
 908                  IUnknown *iface )
 909 {
 910     xmlnode *This = impl_from_InternalUnknown( iface );
 911     return InterlockedIncrement( &This->ref );
 912 }
 913
 914 static ULONG WINAPI Internal_Release(
 915     IUnknown *iface )
 916 {
 917     xmlnode *This = impl_from_InternalUnknown( iface );
 918     ULONG ref;
 919
 920     ref = InterlockedDecrement( &This->ref );
 921     if ( ref == 0 )
 922     {
 923         if( This->node )
 924             xmldoc_release( This->node->doc );
 925         HeapFree( GetProcessHeap(), 0, This );
 926     }
 927
 928     return ref;
 929 }
 930
 931 static const struct IUnknownVtbl internal_unk_vtbl =
 932 {
 933     Internal_QueryInterface,
 934     Internal_AddRef,
 935     Internal_Release
 936 };
 937
 938 IUnknown *create_basic_node( xmlNodePtr node, IUnknown *pUnkOuter )
 939 {
 940     xmlnode *This;
 941
 942     This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
 943     if ( !This )
 944         return NULL;
 945
 946     if(node)
 947         xmldoc_add_ref( node->doc );
 948
 949     This->lpVtbl = &xmlnode_vtbl;
 950     This->lpInternalUnkVtbl = &internal_unk_vtbl;
 951
 952     if(pUnkOuter)
 953         This->pUnkOuter = pUnkOuter; /* Don't take a ref on outer Unknown */
 954     else
 955         This->pUnkOuter = (IUnknown *)&This->lpInternalUnkVtbl;
 956
 957     This->ref = 1;
 958     This->node = node;
 959
 960     return (IUnknown*)&This->lpInternalUnkVtbl;
 961 }
 962
 963 IXMLDOMNode *create_node( xmlNodePtr node )
 964 {
 965     IUnknown *pUnk;
 966     IXMLDOMNode *ret;
 967     HRESULT hr;
 968
 969     if ( !node )
 970         return NULL;
 971
 972     TRACE("type %d\n", node->type);
 973     switch(node->type)
 974     {
 975     case XML_ELEMENT_NODE:
 976         pUnk = create_element( node, NULL );
 977         break;
 978     case XML_ATTRIBUTE_NODE:
 979         pUnk = create_attribute( node );
 980         break;
 981     case XML_TEXT_NODE:
 982         pUnk = create_text( node );
 983         break;
 984     case XML_COMMENT_NODE:
 985         pUnk = create_comment( node );
 986         break;
 987     case XML_DOCUMENT_NODE:
 988         ERR("shouldn't be here!\n");
 989         return NULL;
 990     default:
 991         FIXME("only creating basic node for type %d\n", node->type);
 992         pUnk = create_basic_node( node, NULL );
 993     }
 994
 995     hr = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMNode, (LPVOID*)&ret);
 996     IUnknown_Release(pUnk);
 997     if(FAILED(hr)) return NULL;
 998     return ret;
 999 }
1000 #endif