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
  27 #ifdef HAVE_LIBXML2
  28 # include <libxml/parser.h>
  29 # include <libxml/xmlerror.h>
  30 # include <libxml/HTMLtree.h>
  31 # ifdef SONAME_LIBXSLT
  32 #  ifdef HAVE_LIBXSLT_PATTERN_H
  33 #   include <libxslt/pattern.h>
  34 #  endif
  35 #  ifdef HAVE_LIBXSLT_TRANSFORM_H
  36 #   include <libxslt/transform.h>
  37 #  endif
  38 #  include <libxslt/xsltutils.h>
  39 #  include <libxslt/xsltInternals.h>
  40 # endif
  41 #endif
  42
  43 #include "windef.h"
  44 #include "winbase.h"
  45 #include "winuser.h"
  46 #include "winnls.h"
  47 #include "ole2.h"
  48 #include "msxml6.h"
  49
  50 #include "msxml_private.h"
  51
  52 #include "wine/debug.h"
  53
  54 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  55
  56 #ifdef HAVE_LIBXML2
  57
  58 #ifdef SONAME_LIBXSLT
  59 extern void* libxslt_handle;
  60 # define MAKE_FUNCPTR(f) extern typeof(f) * p##f
  61 MAKE_FUNCPTR(xsltApplyStylesheet);
  62 MAKE_FUNCPTR(xsltCleanupGlobals);
  63 MAKE_FUNCPTR(xsltFreeStylesheet);
  64 MAKE_FUNCPTR(xsltParseStylesheetDoc);
  65 # undef MAKE_FUNCPTR
  66 #endif
  67
  68 static const IID IID_xmlnode = {0x4f2f4ba2,0xb822,0x11df,{0x8b,0x8a,0x68,0x50,0xdf,0xd7,0x20,0x85}};
  69
  70 xmlNodePtr xmlNodePtr_from_domnode( IXMLDOMNode *iface, xmlElementType type )
  71 {
  72     xmlnode *This;
  73
  74     if ( !iface )
  75         return NULL;
  76     This = get_node_obj( iface );
  77     if ( !This || !This->node )
  78         return NULL;
  79     if ( type && This->node->type != type )
  80         return NULL;
  81     return This->node;
  82 }
  83
  84 BOOL node_query_interface(xmlnode *This, REFIID riid, void **ppv)
  85 {
  86     if(IsEqualGUID(&IID_xmlnode, riid)) {
  87         TRACE("(%p)->(IID_xmlnode %p)\n", This, ppv);
  88         *ppv = This;
  89         return TRUE;
  90     }
  91
  92     return dispex_query_interface(&This->dispex, riid, ppv);
  93 }
  94
  95 /* common ISupportErrorInfo implementation */
  96 typedef struct {
  97    ISupportErrorInfo ISupportErrorInfo_iface;
  98    LONG ref;
  99
 100    const tid_t* iids;
 101 } SupportErrorInfo;
 102
 103 static inline SupportErrorInfo *impl_from_ISupportErrorInfo(ISupportErrorInfo *iface)
 104 {
 105     return CONTAINING_RECORD(iface, SupportErrorInfo, ISupportErrorInfo_iface);
 106 }
 107
 108 static HRESULT WINAPI SupportErrorInfo_QueryInterface(ISupportErrorInfo *iface, REFIID riid, void **obj)
 109 {
 110     SupportErrorInfo *This = impl_from_ISupportErrorInfo(iface);
 111     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), obj);
 112
 113     *obj = NULL;
 114
 115     if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISupportErrorInfo)) {
 116         *obj = iface;
 117         ISupportErrorInfo_AddRef(iface);
 118         return S_OK;
 119     }
 120
 121     return E_NOINTERFACE;
 122 }
 123
 124 static ULONG WINAPI SupportErrorInfo_AddRef(ISupportErrorInfo *iface)
 125 {
 126     SupportErrorInfo *This = impl_from_ISupportErrorInfo(iface);
 127     ULONG ref = InterlockedIncrement(&This->ref);
 128     TRACE("(%p)->(%d)\n", This, ref );
 129     return ref;
 130 }
 131
 132 static ULONG WINAPI SupportErrorInfo_Release(ISupportErrorInfo *iface)
 133 {
 134     SupportErrorInfo *This = impl_from_ISupportErrorInfo(iface);
 135     LONG ref = InterlockedDecrement(&This->ref);
 136
 137     TRACE("(%p)->(%d)\n", This, ref);
 138
 139     if (ref == 0)
 140         heap_free(This);
 141
 142     return ref;
 143 }
 144
 145 static HRESULT WINAPI SupportErrorInfo_InterfaceSupportsErrorInfo(ISupportErrorInfo *iface, REFIID riid)
 146 {
 147     SupportErrorInfo *This = impl_from_ISupportErrorInfo(iface);
 148     enum tid_t const *tid;
 149
 150     TRACE("(%p)->(%s)\n", This, debugstr_guid(riid));
 151
 152     tid = This->iids;
 153     while (*tid)
 154     {
 155         if (IsEqualGUID(riid, get_riid_from_tid(*tid)))
 156             return S_OK;
 157         tid++;
 158     }
 159
 160     return S_FALSE;
 161 }
 162
 163 static const struct ISupportErrorInfoVtbl SupportErrorInfoVtbl = {
 164     SupportErrorInfo_QueryInterface,
 165     SupportErrorInfo_AddRef,
 166     SupportErrorInfo_Release,
 167     SupportErrorInfo_InterfaceSupportsErrorInfo
 168 };
 169
 170 HRESULT node_create_supporterrorinfo(enum tid_t const *iids, void **obj)
 171 {
 172     SupportErrorInfo *This;
 173
 174     This = heap_alloc(sizeof(*This));
 175     if (!This) return E_OUTOFMEMORY;
 176
 177     This->ISupportErrorInfo_iface.lpVtbl = &SupportErrorInfoVtbl;
 178     This->ref = 1;
 179     This->iids = iids;
 180
 181     *obj = &This->ISupportErrorInfo_iface;
 182
 183     return S_OK;
 184 }
 185
 186 xmlnode *get_node_obj(IXMLDOMNode *node)
 187 {
 188     xmlnode *obj = NULL;
 189     HRESULT hres;
 190
 191     hres = IXMLDOMNode_QueryInterface(node, &IID_xmlnode, (void**)&obj);
 192     if (!obj) WARN("node is not our IXMLDOMNode implementation\n");
 193     return SUCCEEDED(hres) ? obj : NULL;
 194 }
 195
 196 HRESULT node_get_nodeName(xmlnode *This, BSTR *name)
 197 {
 198     BSTR prefix, base;
 199     HRESULT hr;
 200
 201     if (!name)
 202         return E_INVALIDARG;
 203
 204     hr = node_get_base_name(This, &base);
 205     if (hr != S_OK) return hr;
 206
 207     hr = node_get_prefix(This, &prefix);
 208     if (hr == S_OK)
 209     {
 210         static const WCHAR colW = ':';
 211         WCHAR *ptr;
 212
 213         /* +1 for ':' */
 214         ptr = *name = SysAllocStringLen(NULL, SysStringLen(base) + SysStringLen(prefix) + 1);
 215         memcpy(ptr, prefix, SysStringByteLen(prefix));
 216         ptr += SysStringLen(prefix);
 217         memcpy(ptr++, &colW, sizeof(WCHAR));
 218         memcpy(ptr, base, SysStringByteLen(base));
 219
 220         SysFreeString(base);
 221         SysFreeString(prefix);
 222     }
 223     else
 224         *name = base;
 225
 226     return S_OK;
 227 }
 228
 229 HRESULT node_get_content(xmlnode *This, VARIANT *value)
 230 {
 231     xmlChar *content;
 232
 233     if(!value)
 234         return E_INVALIDARG;
 235
 236     content = xmlNodeGetContent(This->node);
 237     V_VT(value) = VT_BSTR;
 238     V_BSTR(value) = bstr_from_xmlChar( content );
 239     xmlFree(content);
 240
 241     TRACE("%p returned %s\n", This, debugstr_w(V_BSTR(value)));
 242     return S_OK;
 243 }
 244
 245 HRESULT node_set_content(xmlnode *This, LPCWSTR value)
 246 {
 247     xmlChar *str;
 248
 249     TRACE("(%p)->(%s)\n", This, debugstr_w(value));
 250     str = xmlchar_from_wchar(value);
 251     if(!str)
 252         return E_OUTOFMEMORY;
 253
 254     xmlNodeSetContent(This->node, str);
 255     heap_free(str);
 256     return S_OK;
 257 }
 258
 259 static HRESULT node_set_content_escaped(xmlnode *This, LPCWSTR value)
 260 {
 261     xmlChar *str, *escaped;
 262
 263     TRACE("(%p)->(%s)\n", This, debugstr_w(value));
 264     str = xmlchar_from_wchar(value);
 265     if(!str)
 266         return E_OUTOFMEMORY;
 267
 268     escaped = xmlEncodeSpecialChars(NULL, str);
 269     if(!escaped)
 270     {
 271         heap_free(str);
 272         return E_OUTOFMEMORY;
 273     }
 274
 275     xmlNodeSetContent(This->node, escaped);
 276
 277     heap_free(str);
 278     xmlFree(escaped);
 279
 280     return S_OK;
 281 }
 282
 283 HRESULT node_put_value(xmlnode *This, VARIANT *value)
 284 {
 285     VARIANT string_value;
 286     HRESULT hr;
 287
 288     VariantInit(&string_value);
 289     hr = VariantChangeType(&string_value, value, 0, VT_BSTR);
 290     if(FAILED(hr)) {
 291         WARN("Couldn't convert to VT_BSTR\n");
 292         return hr;
 293     }
 294
 295     hr = node_set_content(This, V_BSTR(&string_value));
 296     VariantClear(&string_value);
 297
 298     return hr;
 299 }
 300
 301 HRESULT node_put_value_escaped(xmlnode *This, VARIANT *value)
 302 {
 303     VARIANT string_value;
 304     HRESULT hr;
 305
 306     VariantInit(&string_value);
 307     hr = VariantChangeType(&string_value, value, 0, VT_BSTR);
 308     if(FAILED(hr)) {
 309         WARN("Couldn't convert to VT_BSTR\n");
 310         return hr;
 311     }
 312
 313     hr = node_set_content_escaped(This, V_BSTR(&string_value));
 314     VariantClear(&string_value);
 315
 316     return hr;
 317 }
 318
 319 static HRESULT get_node(
 320     xmlnode *This,
 321     const char *name,
 322     xmlNodePtr node,
 323     IXMLDOMNode **out )
 324 {
 325     TRACE("(%p)->(%s %p %p)\n", This, name, node, out );
 326
 327     if ( !out )
 328         return E_INVALIDARG;
 329
 330     /* if we don't have a doc, use our parent. */
 331     if(node && !node->doc && node->parent)
 332         node->doc = node->parent->doc;
 333
 334     *out = create_node( node );
 335     if (!*out)
 336         return S_FALSE;
 337     return S_OK;
 338 }
 339
 340 HRESULT node_get_parent(xmlnode *This, IXMLDOMNode **parent)
 341 {
 342     return get_node( This, "parent", This->node->parent, parent );
 343 }
 344
 345 HRESULT node_get_child_nodes(xmlnode *This, IXMLDOMNodeList **ret)
 346 {
 347     if(!ret)
 348         return E_INVALIDARG;
 349
 350     *ret = create_children_nodelist(This->node);
 351     if(!*ret)
 352         return E_OUTOFMEMORY;
 353
 354     return S_OK;
 355 }
 356
 357 HRESULT node_get_first_child(xmlnode *This, IXMLDOMNode **ret)
 358 {
 359     return get_node(This, "firstChild", This->node->children, ret);
 360 }
 361
 362 HRESULT node_get_last_child(xmlnode *This, IXMLDOMNode **ret)
 363 {
 364     return get_node(This, "lastChild", This->node->last, ret);
 365 }
 366
 367 HRESULT node_get_previous_sibling(xmlnode *This, IXMLDOMNode **ret)
 368 {
 369     return get_node(This, "previous", This->node->prev, ret);
 370 }
 371
 372 HRESULT node_get_next_sibling(xmlnode *This, IXMLDOMNode **ret)
 373 {
 374     return get_node(This, "next", This->node->next, ret);
 375 }
 376
 377 HRESULT node_insert_before(xmlnode *This, IXMLDOMNode *new_child, const VARIANT *ref_child,
 378         IXMLDOMNode **ret)
 379 {
 380     IXMLDOMNode *before = NULL;
 381     xmlnode *node_obj;
 382     xmlDocPtr doc;
 383     HRESULT hr;
 384
 385     if(!new_child)
 386         return E_INVALIDARG;
 387
 388     node_obj = get_node_obj(new_child);
 389     if(!node_obj) return E_FAIL;
 390
 391     switch(V_VT(ref_child))
 392     {
 393     case VT_EMPTY:
 394     case VT_NULL:
 395         break;
 396
 397     case VT_UNKNOWN:
 398     case VT_DISPATCH:
 399         if (V_UNKNOWN(ref_child))
 400         {
 401             hr = IUnknown_QueryInterface(V_UNKNOWN(ref_child), &IID_IXMLDOMNode, (void**)&before);
 402             if(FAILED(hr)) return hr;
 403         }
 404         break;
 405
 406     default:
 407         FIXME("refChild var type %x\n", V_VT(ref_child));
 408         return E_FAIL;
 409     }
 410
 411     TRACE("new child %p, This->node %p\n", node_obj->node, This->node);
 412
 413     if(!node_obj->node->parent)
 414         if(xmldoc_remove_orphan(node_obj->node->doc, node_obj->node) != S_OK)
 415             WARN("%p is not an orphan of %p\n", node_obj->node, node_obj->node->doc);
 416
 417     if(before)
 418     {
 419         xmlnode *before_node_obj = get_node_obj(before);
 420         IXMLDOMNode_Release(before);
 421         if(!before_node_obj) return E_FAIL;
 422
 423         /* unlink from current parent first */
 424         if(node_obj->parent)
 425         {
 426             hr = IXMLDOMNode_removeChild(node_obj->parent, node_obj->iface, NULL);
 427             if (hr == S_OK) xmldoc_remove_orphan(node_obj->node->doc, node_obj->node);
 428         }
 429         doc = node_obj->node->doc;
 430         xmldoc_add_ref(before_node_obj->node->doc);
 431         xmlAddPrevSibling(before_node_obj->node, node_obj->node);
 432         xmldoc_release(doc);
 433         node_obj->parent = This->parent;
 434     }
 435     else
 436     {
 437         /* unlink from current parent first */
 438         if(node_obj->parent)
 439         {
 440             hr = IXMLDOMNode_removeChild(node_obj->parent, node_obj->iface, NULL);
 441             if (hr == S_OK) xmldoc_remove_orphan(node_obj->node->doc, node_obj->node);
 442         }
 443         doc = node_obj->node->doc;
 444         xmldoc_add_ref(This->node->doc);
 445         /* xmlAddChild doesn't unlink node from previous parent */
 446         xmlUnlinkNode(node_obj->node);
 447         xmlAddChild(This->node, node_obj->node);
 448         xmldoc_release(doc);
 449         node_obj->parent = This->iface;
 450     }
 451
 452     if(ret)
 453     {
 454         IXMLDOMNode_AddRef(new_child);
 455         *ret = new_child;
 456     }
 457
 458     TRACE("ret S_OK\n");
 459     return S_OK;
 460 }
 461
 462 HRESULT node_replace_child(xmlnode *This, IXMLDOMNode *newChild, IXMLDOMNode *oldChild,
 463         IXMLDOMNode **ret)
 464 {
 465     xmlnode *old_child, *new_child;
 466     xmlDocPtr leaving_doc;
 467     xmlNode *my_ancestor;
 468
 469     /* Do not believe any documentation telling that newChild == NULL
 470        means removal. It does certainly *not* apply to msxml3! */
 471     if(!newChild || !oldChild)
 472         return E_INVALIDARG;
 473
 474     if(ret)
 475         *ret = NULL;
 476
 477     old_child = get_node_obj(oldChild);
 478     if(!old_child) return E_FAIL;
 479
 480     if(old_child->node->parent != This->node)
 481     {
 482         WARN("childNode %p is not a child of %p\n", oldChild, This);
 483         return E_INVALIDARG;
 484     }
 485
 486     new_child = get_node_obj(newChild);
 487     if(!new_child) return E_FAIL;
 488
 489     my_ancestor = This->node;
 490     while(my_ancestor)
 491     {
 492         if(my_ancestor == new_child->node)
 493         {
 494             WARN("tried to create loop\n");
 495             return E_FAIL;
 496         }
 497         my_ancestor = my_ancestor->parent;
 498     }
 499
 500     if(!new_child->node->parent)
 501         if(xmldoc_remove_orphan(new_child->node->doc, new_child->node) != S_OK)
 502             WARN("%p is not an orphan of %p\n", new_child->node, new_child->node->doc);
 503
 504     leaving_doc = new_child->node->doc;
 505     xmldoc_add_ref(old_child->node->doc);
 506     xmlReplaceNode(old_child->node, new_child->node);
 507     xmldoc_release(leaving_doc);
 508     new_child->parent = old_child->parent;
 509     old_child->parent = NULL;
 510
 511     xmldoc_add_orphan(old_child->node->doc, old_child->node);
 512
 513     if(ret)
 514     {
 515         IXMLDOMNode_AddRef(oldChild);
 516         *ret = oldChild;
 517     }
 518
 519     return S_OK;
 520 }
 521
 522 HRESULT node_remove_child(xmlnode *This, IXMLDOMNode* child, IXMLDOMNode** oldChild)
 523 {
 524     xmlnode *child_node;
 525
 526     if(!child) return E_INVALIDARG;
 527
 528     if(oldChild)
 529         *oldChild = NULL;
 530
 531     child_node = get_node_obj(child);
 532     if(!child_node) return E_FAIL;
 533
 534     if(child_node->node->parent != This->node)
 535     {
 536         WARN("childNode %p is not a child of %p\n", child, This);
 537         return E_INVALIDARG;
 538     }
 539
 540     xmlUnlinkNode(child_node->node);
 541     child_node->parent = NULL;
 542     xmldoc_add_orphan(child_node->node->doc, child_node->node);
 543
 544     if(oldChild)
 545     {
 546         IXMLDOMNode_AddRef(child);
 547         *oldChild = child;
 548     }
 549
 550     return S_OK;
 551 }
 552
 553 HRESULT node_append_child(xmlnode *This, IXMLDOMNode *child, IXMLDOMNode **outChild)
 554 {
 555     DOMNodeType type;
 556     VARIANT var;
 557     HRESULT hr;
 558
 559     hr = IXMLDOMNode_get_nodeType(child, &type);
 560     if(FAILED(hr) || type == NODE_ATTRIBUTE) {
 561         if (outChild) *outChild = NULL;
 562         return E_FAIL;
 563     }
 564
 565     VariantInit(&var);
 566     return IXMLDOMNode_insertBefore(This->iface, child, var, outChild);
 567 }
 568
 569 HRESULT node_has_childnodes(const xmlnode *This, VARIANT_BOOL *ret)
 570 {
 571     if (!ret) return E_INVALIDARG;
 572
 573     if (!This->node->children)
 574     {
 575         *ret = VARIANT_FALSE;
 576         return S_FALSE;
 577     }
 578
 579     *ret = VARIANT_TRUE;
 580     return S_OK;
 581 }
 582
 583 HRESULT node_get_owner_doc(const xmlnode *This, IXMLDOMDocument **doc)
 584 {
 585     return get_domdoc_from_xmldoc(This->node->doc, (IXMLDOMDocument3**)doc);
 586 }
 587
 588 HRESULT node_clone(xmlnode *This, VARIANT_BOOL deep, IXMLDOMNode **cloneNode)
 589 {
 590     IXMLDOMNode *node;
 591     xmlNodePtr clone;
 592
 593     if(!cloneNode) return E_INVALIDARG;
 594
 595     clone = xmlCopyNode(This->node, deep ? 1 : 2);
 596     if (clone)
 597     {
 598         clone->doc = This->node->doc;
 599         xmldoc_add_orphan(clone->doc, clone);
 600
 601         node = create_node(clone);
 602         if (!node)
 603         {
 604             ERR("Copy failed\n");
 605             xmldoc_remove_orphan(clone->doc, clone);
 606             xmlFreeNode(clone);
 607             return E_FAIL;
 608         }
 609
 610         *cloneNode = node;
 611     }
 612     else
 613     {
 614         ERR("Copy failed\n");
 615         return E_FAIL;
 616     }
 617
 618     return S_OK;
 619 }
 620
 621 static inline xmlChar* trim_whitespace(xmlChar* str)
 622 {
 623     xmlChar* ret = str;
 624     int len;
 625
 626     if (!str)
 627         return NULL;
 628
 629     while (*ret && isspace(*ret))
 630         ++ret;
 631     len = xmlStrlen(ret);
 632     if (len)
 633         while (isspace(ret[len-1])) --len;
 634
 635     ret = xmlStrndup(ret, len);
 636     xmlFree(str);
 637     return ret;
 638 }
 639
 640 static xmlChar* do_get_text(xmlNodePtr node)
 641 {
 642     xmlNodePtr child;
 643     xmlChar* str;
 644     BOOL preserving = is_preserving_whitespace(node);
 645
 646     if (!node->children)
 647     {
 648         str = xmlNodeGetContent(node);
 649     }
 650     else
 651     {
 652         xmlElementType prev_type = XML_TEXT_NODE;
 653         xmlChar* tmp;
 654         str = xmlStrdup(BAD_CAST "");
 655         for (child = node->children; child != NULL; child = child->next)
 656         {
 657             switch (child->type)
 658             {
 659             case XML_ELEMENT_NODE:
 660                 tmp = do_get_text(child);
 661                 break;
 662             case XML_TEXT_NODE:
 663             case XML_CDATA_SECTION_NODE:
 664             case XML_ENTITY_REF_NODE:
 665             case XML_ENTITY_NODE:
 666                 tmp = xmlNodeGetContent(child);
 667                 break;
 668             default:
 669                 tmp = NULL;
 670                 break;
 671             }
 672
 673             if (tmp)
 674             {
 675                 if (*tmp)
 676                 {
 677                     if (prev_type == XML_ELEMENT_NODE && child->type == XML_ELEMENT_NODE)
 678                         str = xmlStrcat(str, BAD_CAST " ");
 679                     str = xmlStrcat(str, tmp);
 680                     prev_type = child->type;
 681                 }
 682                 xmlFree(tmp);
 683             }
 684         }
 685     }
 686
 687     switch (node->type)
 688     {
 689     case XML_ELEMENT_NODE:
 690     case XML_TEXT_NODE:
 691     case XML_ENTITY_REF_NODE:
 692     case XML_ENTITY_NODE:
 693     case XML_DOCUMENT_NODE:
 694     case XML_DOCUMENT_FRAG_NODE:
 695         if (!preserving)
 696             str = trim_whitespace(str);
 697         break;
 698     default:
 699         break;
 700     }
 701
 702     return str;
 703 }
 704
 705 HRESULT node_get_text(const xmlnode *This, BSTR *text)
 706 {
 707     BSTR str = NULL;
 708     xmlChar *content;
 709
 710     if (!text) return E_INVALIDARG;
 711
 712     content = do_get_text(This->node);
 713     if (content)
 714     {
 715         str = bstr_from_xmlChar(content);
 716         xmlFree(content);
 717     }
 718
 719     /* Always return a string. */
 720     if (!str) str = SysAllocStringLen( NULL, 0 );
 721
 722     TRACE("%p %s\n", This, debugstr_w(str) );
 723     *text = str;
 724
 725     return S_OK;
 726 }
 727
 728 HRESULT node_put_text(xmlnode *This, BSTR text)
 729 {
 730     xmlChar *str, *str2;
 731
 732     TRACE("(%p)->(%s)\n", This, debugstr_w(text));
 733
 734     str = xmlchar_from_wchar(text);
 735
 736     /* Escape the string. */
 737     str2 = xmlEncodeEntitiesReentrant(This->node->doc, str);
 738     heap_free(str);
 739
 740     xmlNodeSetContent(This->node, str2);
 741     xmlFree(str2);
 742
 743     return S_OK;
 744 }
 745
 746 BSTR EnsureCorrectEOL(BSTR sInput)
 747 {
 748     int nNum = 0;
 749     BSTR sNew;
 750     int nLen;
 751     int i;
 752
 753     nLen = SysStringLen(sInput);
 754     /* Count line endings */
 755     for(i=0; i < nLen; i++)
 756     {
 757         if(sInput[i] == '\n')
 758             nNum++;
 759     }
 760
 761     TRACE("len=%d, num=%d\n", nLen, nNum);
 762
 763     /* Add linefeed as needed */
 764     if(nNum > 0)
 765     {
 766         int nPlace = 0;
 767         sNew = SysAllocStringLen(NULL, nLen + nNum);
 768         for(i=0; i < nLen; i++)
 769         {
 770             if(sInput[i] == '\n')
 771             {
 772                 sNew[i+nPlace] = '\r';
 773                 nPlace++;
 774             }
 775             sNew[i+nPlace] = sInput[i];
 776         }
 777
 778         SysFreeString(sInput);
 779     }
 780     else
 781     {
 782         sNew = sInput;
 783     }
 784
 785     TRACE("len %d\n", SysStringLen(sNew));
 786
 787     return sNew;
 788 }
 789
 790 /*
 791  * We are trying to replicate the same behaviour as msxml by converting
 792  * line endings to \r\n and using indents as \t. The problem is that msxml
 793  * only formats nodes that have a line ending. Using libxml we cannot
 794  * reproduce behaviour exactly.
 795  *
 796  */
 797 HRESULT node_get_xml(xmlnode *This, BOOL ensure_eol, BSTR *ret)
 798 {
 799     xmlBufferPtr xml_buf;
 800     xmlNodePtr xmldecl;
 801     int size;
 802
 803     if(!ret)
 804         return E_INVALIDARG;
 805
 806     *ret = NULL;
 807
 808     xml_buf = xmlBufferCreate();
 809     if(!xml_buf)
 810         return E_OUTOFMEMORY;
 811
 812     xmldecl = xmldoc_unlink_xmldecl( This->node->doc );
 813
 814     size = xmlNodeDump(xml_buf, This->node->doc, This->node, 0, 1);
 815     if(size > 0) {
 816         const xmlChar *buf_content;
 817         BSTR content;
 818
 819         /* Attribute Nodes return a space in front of their name */
 820         buf_content = xmlBufferContent(xml_buf);
 821
 822         content = bstr_from_xmlChar(buf_content + (buf_content[0] == ' ' ? 1 : 0));
 823         if(ensure_eol)
 824             content = EnsureCorrectEOL(content);
 825
 826         *ret = content;
 827     }else {
 828         *ret = SysAllocStringLen(NULL, 0);
 829     }
 830
 831     xmlBufferFree(xml_buf);
 832     xmldoc_link_xmldecl( This->node->doc, xmldecl );
 833     return *ret ? S_OK : E_OUTOFMEMORY;
 834 }
 835
 836 HRESULT node_transform_node(const xmlnode *This, IXMLDOMNode *stylesheet, BSTR *p)
 837 {
 838 #ifdef SONAME_LIBXSLT
 839     xsltStylesheetPtr xsltSS;
 840     xmlnode *sheet;
 841
 842     if (!libxslt_handle) return E_NOTIMPL;
 843     if (!stylesheet || !p) return E_INVALIDARG;
 844
 845     *p = NULL;
 846
 847     sheet = get_node_obj(stylesheet);
 848     if(!sheet) return E_FAIL;
 849
 850     xsltSS = pxsltParseStylesheetDoc(sheet->node->doc);
 851     if(xsltSS)
 852     {
 853         xmlDocPtr result = pxsltApplyStylesheet(xsltSS, This->node->doc, NULL);
 854         if(result)
 855         {
 856             const xmlChar *content;
 857
 858             if(result->type == XML_HTML_DOCUMENT_NODE)
 859             {
 860                 xmlOutputBufferPtr output = xmlAllocOutputBuffer(NULL);
 861                 if (output)
 862                 {
 863                     htmlDocContentDumpOutput(output, result->doc, NULL);
 864                     content = xmlBufferContent(output->buffer);
 865                     *p = bstr_from_xmlChar(content);
 866                     xmlOutputBufferClose(output);
 867                 }
 868             }
 869             else
 870             {
 871                 xmlBufferPtr buf = xmlBufferCreate();
 872                 if (buf)
 873                 {
 874                     int size = xmlNodeDump(buf, NULL, (xmlNodePtr)result, 0, 0);
 875                     if(size > 0)
 876                     {
 877                         content = xmlBufferContent(buf);
 878                         *p = bstr_from_xmlChar(content);
 879                     }
 880                     xmlBufferFree(buf);
 881                 }
 882             }
 883             xmlFreeDoc(result);
 884         }
 885         /* libxslt "helpfully" frees the XML document the stylesheet was
 886            generated from, too */
 887         xsltSS->doc = NULL;
 888         pxsltFreeStylesheet(xsltSS);
 889     }
 890
 891     if(!*p) *p = SysAllocStringLen(NULL, 0);
 892
 893     return S_OK;
 894 #else
 895     FIXME("libxslt headers were not found at compile time\n");
 896     return E_NOTIMPL;
 897 #endif
 898 }
 899
 900 HRESULT node_select_nodes(const xmlnode *This, BSTR query, IXMLDOMNodeList **nodes)
 901 {
 902     xmlChar* str;
 903     HRESULT hr;
 904
 905     if (!query || !nodes) return E_INVALIDARG;
 906
 907     str = xmlchar_from_wchar(query);
 908     hr = create_selection(This->node, str, nodes);
 909     heap_free(str);
 910
 911     return hr;
 912 }
 913
 914 HRESULT node_select_singlenode(const xmlnode *This, BSTR query, IXMLDOMNode **node)
 915 {
 916     IXMLDOMNodeList *list;
 917     HRESULT hr;
 918
 919     hr = node_select_nodes(This, query, &list);
 920     if (hr == S_OK)
 921     {
 922         hr = IXMLDOMNodeList_nextNode(list, node);
 923         IXMLDOMNodeList_Release(list);
 924     }
 925     return hr;
 926 }
 927
 928 HRESULT node_get_namespaceURI(xmlnode *This, BSTR *namespaceURI)
 929 {
 930     xmlNsPtr ns = This->node->ns;
 931
 932     if(!namespaceURI)
 933         return E_INVALIDARG;
 934
 935     *namespaceURI = NULL;
 936
 937     if (ns && ns->href)
 938         *namespaceURI = bstr_from_xmlChar(ns->href);
 939
 940     TRACE("uri: %s\n", debugstr_w(*namespaceURI));
 941
 942     return *namespaceURI ? S_OK : S_FALSE;
 943 }
 944
 945 HRESULT node_get_prefix(xmlnode *This, BSTR *prefix)
 946 {
 947     xmlNsPtr ns = This->node->ns;
 948
 949     if (!prefix) return E_INVALIDARG;
 950
 951     *prefix = NULL;
 952
 953     if (ns && ns->prefix)
 954         *prefix = bstr_from_xmlChar(ns->prefix);
 955
 956     TRACE("prefix: %s\n", debugstr_w(*prefix));
 957
 958     return *prefix ? S_OK : S_FALSE;
 959 }
 960
 961 HRESULT node_get_base_name(xmlnode *This, BSTR *name)
 962 {
 963     if (!name) return E_INVALIDARG;
 964
 965     *name = bstr_from_xmlChar(This->node->name);
 966     if (!*name) return E_OUTOFMEMORY;
 967
 968     TRACE("returning %s\n", debugstr_w(*name));
 969
 970     return S_OK;
 971 }
 972
 973 void destroy_xmlnode(xmlnode *This)
 974 {
 975     if(This->node)
 976         xmldoc_release(This->node->doc);
 977     release_dispex(&This->dispex);
 978 }
 979
 980 void init_xmlnode(xmlnode *This, xmlNodePtr node, IXMLDOMNode *node_iface, dispex_static_data_t *dispex_data)
 981 {
 982     if(node)
 983         xmldoc_add_ref( node->doc );
 984
 985     This->node = node;
 986     This->iface = node_iface;
 987     This->parent = NULL;
 988
 989     init_dispex(&This->dispex, (IUnknown*)This->iface, dispex_data);
 990 }
 991
 992 typedef struct {
 993     xmlnode node;
 994     IXMLDOMNode IXMLDOMNode_iface;
 995     LONG ref;
 996 } unknode;
 997
 998 static inline unknode *unknode_from_IXMLDOMNode(IXMLDOMNode *iface)
 999 {
1000     return CONTAINING_RECORD(iface, unknode, IXMLDOMNode_iface);
1001 }
1002
1003 static HRESULT WINAPI unknode_QueryInterface(
1004     IXMLDOMNode *iface,
1005     REFIID riid,
1006     void** ppvObject )
1007 {
1008     unknode *This = unknode_from_IXMLDOMNode( iface );
1009
1010     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObject);
1011
1012     if (IsEqualGUID(riid, &IID_IUnknown)) {
1013         *ppvObject = iface;
1014     }else if (IsEqualGUID( riid, &IID_IDispatch) ||
1015               IsEqualGUID( riid, &IID_IXMLDOMNode)) {
1016         *ppvObject = &This->IXMLDOMNode_iface;
1017     }else if(node_query_interface(&This->node, riid, ppvObject)) {
1018         return *ppvObject ? S_OK : E_NOINTERFACE;
1019     }else  {
1020         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1021         *ppvObject = NULL;
1022         return E_NOINTERFACE;
1023     }
1024
1025     IUnknown_AddRef((IUnknown*)*ppvObject);
1026     return S_OK;
1027 }
1028
1029 static ULONG WINAPI unknode_AddRef(
1030     IXMLDOMNode *iface )
1031 {
1032     unknode *This = unknode_from_IXMLDOMNode( iface );
1033
1034     return InterlockedIncrement(&This->ref);
1035 }
1036
1037 static ULONG WINAPI unknode_Release(
1038     IXMLDOMNode *iface )
1039 {
1040     unknode *This = unknode_from_IXMLDOMNode( iface );
1041     LONG ref;
1042
1043     ref = InterlockedDecrement( &This->ref );
1044     if(!ref) {
1045         destroy_xmlnode(&This->node);
1046         heap_free(This);
1047     }
1048
1049     return ref;
1050 }
1051
1052 static HRESULT WINAPI unknode_GetTypeInfoCount(
1053     IXMLDOMNode *iface,
1054     UINT* pctinfo )
1055 {
1056     unknode *This = unknode_from_IXMLDOMNode( iface );
1057
1058     TRACE("(%p)->(%p)\n", This, pctinfo);
1059
1060     *pctinfo = 1;
1061
1062     return S_OK;
1063 }
1064
1065 static HRESULT WINAPI unknode_GetTypeInfo(
1066     IXMLDOMNode *iface,
1067     UINT iTInfo,
1068     LCID lcid,
1069     ITypeInfo** ppTInfo )
1070 {
1071     unknode *This = unknode_from_IXMLDOMNode( iface );
1072     HRESULT hr;
1073
1074     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1075
1076     hr = get_typeinfo(IXMLDOMNode_tid, ppTInfo);
1077
1078     return hr;
1079 }
1080
1081 static HRESULT WINAPI unknode_GetIDsOfNames(
1082     IXMLDOMNode *iface,
1083     REFIID riid,
1084     LPOLESTR* rgszNames,
1085     UINT cNames,
1086     LCID lcid,
1087     DISPID* rgDispId )
1088 {
1089     unknode *This = unknode_from_IXMLDOMNode( iface );
1090
1091     ITypeInfo *typeinfo;
1092     HRESULT hr;
1093
1094     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1095           lcid, rgDispId);
1096
1097     if(!rgszNames || cNames == 0 || !rgDispId)
1098         return E_INVALIDARG;
1099
1100     hr = get_typeinfo(IXMLDOMNode_tid, &typeinfo);
1101     if(SUCCEEDED(hr))
1102     {
1103         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
1104         ITypeInfo_Release(typeinfo);
1105     }
1106
1107     return hr;
1108 }
1109
1110 static HRESULT WINAPI unknode_Invoke(
1111     IXMLDOMNode *iface,
1112     DISPID dispIdMember,
1113     REFIID riid,
1114     LCID lcid,
1115     WORD wFlags,
1116     DISPPARAMS* pDispParams,
1117     VARIANT* pVarResult,
1118     EXCEPINFO* pExcepInfo,
1119     UINT* puArgErr )
1120 {
1121     unknode *This = unknode_from_IXMLDOMNode( iface );
1122     ITypeInfo *typeinfo;
1123     HRESULT hr;
1124
1125     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1126           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1127
1128     hr = get_typeinfo(IXMLDOMNode_tid, &typeinfo);
1129     if(SUCCEEDED(hr))
1130     {
1131         hr = ITypeInfo_Invoke(typeinfo, &This->IXMLDOMNode_iface, dispIdMember, wFlags, pDispParams,
1132                 pVarResult, pExcepInfo, puArgErr);
1133         ITypeInfo_Release(typeinfo);
1134     }
1135
1136     return hr;
1137 }
1138
1139 static HRESULT WINAPI unknode_get_nodeName(
1140     IXMLDOMNode *iface,
1141     BSTR* p )
1142 {
1143     unknode *This = unknode_from_IXMLDOMNode( iface );
1144
1145     FIXME("(%p)->(%p)\n", This, p);
1146
1147     return node_get_nodeName(&This->node, p);
1148 }
1149
1150 static HRESULT WINAPI unknode_get_nodeValue(
1151     IXMLDOMNode *iface,
1152     VARIANT* value)
1153 {
1154     unknode *This = unknode_from_IXMLDOMNode( iface );
1155
1156     FIXME("(%p)->(%p)\n", This, value);
1157
1158     if(!value)
1159         return E_INVALIDARG;
1160
1161     V_VT(value) = VT_NULL;
1162     return S_FALSE;
1163 }
1164
1165 static HRESULT WINAPI unknode_put_nodeValue(
1166     IXMLDOMNode *iface,
1167     VARIANT value)
1168 {
1169     unknode *This = unknode_from_IXMLDOMNode( iface );
1170     FIXME("(%p)->(v%d)\n", This, V_VT(&value));
1171     return E_FAIL;
1172 }
1173
1174 static HRESULT WINAPI unknode_get_nodeType(
1175     IXMLDOMNode *iface,
1176     DOMNodeType* domNodeType )
1177 {
1178     unknode *This = unknode_from_IXMLDOMNode( iface );
1179
1180     FIXME("(%p)->(%p)\n", This, domNodeType);
1181
1182     *domNodeType = This->node.node->type;
1183     return S_OK;
1184 }
1185
1186 static HRESULT WINAPI unknode_get_parentNode(
1187     IXMLDOMNode *iface,
1188     IXMLDOMNode** parent )
1189 {
1190     unknode *This = unknode_from_IXMLDOMNode( iface );
1191     FIXME("(%p)->(%p)\n", This, parent);
1192     if (!parent) return E_INVALIDARG;
1193     *parent = NULL;
1194     return S_FALSE;
1195 }
1196
1197 static HRESULT WINAPI unknode_get_childNodes(
1198     IXMLDOMNode *iface,
1199     IXMLDOMNodeList** outList)
1200 {
1201     unknode *This = unknode_from_IXMLDOMNode( iface );
1202
1203     TRACE("(%p)->(%p)\n", This, outList);
1204
1205     return node_get_child_nodes(&This->node, outList);
1206 }
1207
1208 static HRESULT WINAPI unknode_get_firstChild(
1209     IXMLDOMNode *iface,
1210     IXMLDOMNode** domNode)
1211 {
1212     unknode *This = unknode_from_IXMLDOMNode( iface );
1213
1214     TRACE("(%p)->(%p)\n", This, domNode);
1215
1216     return node_get_first_child(&This->node, domNode);
1217 }
1218
1219 static HRESULT WINAPI unknode_get_lastChild(
1220     IXMLDOMNode *iface,
1221     IXMLDOMNode** domNode)
1222 {
1223     unknode *This = unknode_from_IXMLDOMNode( iface );
1224
1225     TRACE("(%p)->(%p)\n", This, domNode);
1226
1227     return node_get_last_child(&This->node, domNode);
1228 }
1229
1230 static HRESULT WINAPI unknode_get_previousSibling(
1231     IXMLDOMNode *iface,
1232     IXMLDOMNode** domNode)
1233 {
1234     unknode *This = unknode_from_IXMLDOMNode( iface );
1235
1236     TRACE("(%p)->(%p)\n", This, domNode);
1237
1238     return node_get_previous_sibling(&This->node, domNode);
1239 }
1240
1241 static HRESULT WINAPI unknode_get_nextSibling(
1242     IXMLDOMNode *iface,
1243     IXMLDOMNode** domNode)
1244 {
1245     unknode *This = unknode_from_IXMLDOMNode( iface );
1246
1247     TRACE("(%p)->(%p)\n", This, domNode);
1248
1249     return node_get_next_sibling(&This->node, domNode);
1250 }
1251
1252 static HRESULT WINAPI unknode_get_attributes(
1253     IXMLDOMNode *iface,
1254     IXMLDOMNamedNodeMap** attributeMap)
1255 {
1256     unknode *This = unknode_from_IXMLDOMNode( iface );
1257
1258     FIXME("(%p)->(%p)\n", This, attributeMap);
1259
1260     return return_null_ptr((void**)attributeMap);
1261 }
1262
1263 static HRESULT WINAPI unknode_insertBefore(
1264     IXMLDOMNode *iface,
1265     IXMLDOMNode* newNode, VARIANT refChild,
1266     IXMLDOMNode** outOldNode)
1267 {
1268     unknode *This = unknode_from_IXMLDOMNode( iface );
1269
1270     FIXME("(%p)->(%p x%d %p)\n", This, newNode, V_VT(&refChild), outOldNode);
1271
1272     return node_insert_before(&This->node, newNode, &refChild, outOldNode);
1273 }
1274
1275 static HRESULT WINAPI unknode_replaceChild(
1276     IXMLDOMNode *iface,
1277     IXMLDOMNode* newNode,
1278     IXMLDOMNode* oldNode,
1279     IXMLDOMNode** outOldNode)
1280 {
1281     unknode *This = unknode_from_IXMLDOMNode( iface );
1282
1283     FIXME("(%p)->(%p %p %p)\n", This, newNode, oldNode, outOldNode);
1284
1285     return node_replace_child(&This->node, newNode, oldNode, outOldNode);
1286 }
1287
1288 static HRESULT WINAPI unknode_removeChild(
1289     IXMLDOMNode *iface,
1290     IXMLDOMNode* domNode, IXMLDOMNode** oldNode)
1291 {
1292     unknode *This = unknode_from_IXMLDOMNode( iface );
1293     return node_remove_child(&This->node, domNode, oldNode);
1294 }
1295
1296 static HRESULT WINAPI unknode_appendChild(
1297     IXMLDOMNode *iface,
1298     IXMLDOMNode* newNode, IXMLDOMNode** outNewNode)
1299 {
1300     unknode *This = unknode_from_IXMLDOMNode( iface );
1301     return node_append_child(&This->node, newNode, outNewNode);
1302 }
1303
1304 static HRESULT WINAPI unknode_hasChildNodes(
1305     IXMLDOMNode *iface,
1306     VARIANT_BOOL* pbool)
1307 {
1308     unknode *This = unknode_from_IXMLDOMNode( iface );
1309     return node_has_childnodes(&This->node, pbool);
1310 }
1311
1312 static HRESULT WINAPI unknode_get_ownerDocument(
1313     IXMLDOMNode *iface,
1314     IXMLDOMDocument** domDocument)
1315 {
1316     unknode *This = unknode_from_IXMLDOMNode( iface );
1317     return node_get_owner_doc(&This->node, domDocument);
1318 }
1319
1320 static HRESULT WINAPI unknode_cloneNode(
1321     IXMLDOMNode *iface,
1322     VARIANT_BOOL pbool, IXMLDOMNode** outNode)
1323 {
1324     unknode *This = unknode_from_IXMLDOMNode( iface );
1325     return node_clone(&This->node, pbool, outNode );
1326 }
1327
1328 static HRESULT WINAPI unknode_get_nodeTypeString(
1329     IXMLDOMNode *iface,
1330     BSTR* p)
1331 {
1332     unknode *This = unknode_from_IXMLDOMNode( iface );
1333
1334     FIXME("(%p)->(%p)\n", This, p);
1335
1336     return node_get_nodeName(&This->node, p);
1337 }
1338
1339 static HRESULT WINAPI unknode_get_text(
1340     IXMLDOMNode *iface,
1341     BSTR* p)
1342 {
1343     unknode *This = unknode_from_IXMLDOMNode( iface );
1344     return node_get_text(&This->node, p);
1345 }
1346
1347 static HRESULT WINAPI unknode_put_text(
1348     IXMLDOMNode *iface,
1349     BSTR p)
1350 {
1351     unknode *This = unknode_from_IXMLDOMNode( iface );
1352     return node_put_text(&This->node, p);
1353 }
1354
1355 static HRESULT WINAPI unknode_get_specified(
1356     IXMLDOMNode *iface,
1357     VARIANT_BOOL* isSpecified)
1358 {
1359     unknode *This = unknode_from_IXMLDOMNode( iface );
1360     FIXME("(%p)->(%p) stub!\n", This, isSpecified);
1361     *isSpecified = VARIANT_TRUE;
1362     return S_OK;
1363 }
1364
1365 static HRESULT WINAPI unknode_get_definition(
1366     IXMLDOMNode *iface,
1367     IXMLDOMNode** definitionNode)
1368 {
1369     unknode *This = unknode_from_IXMLDOMNode( iface );
1370     FIXME("(%p)->(%p)\n", This, definitionNode);
1371     return E_NOTIMPL;
1372 }
1373
1374 static HRESULT WINAPI unknode_get_nodeTypedValue(
1375     IXMLDOMNode *iface,
1376     VARIANT* var1)
1377 {
1378     unknode *This = unknode_from_IXMLDOMNode( iface );
1379     FIXME("(%p)->(%p)\n", This, var1);
1380     return return_null_var(var1);
1381 }
1382
1383 static HRESULT WINAPI unknode_put_nodeTypedValue(
1384     IXMLDOMNode *iface,
1385     VARIANT typedValue)
1386 {
1387     unknode *This = unknode_from_IXMLDOMNode( iface );
1388     FIXME("(%p)->(%s)\n", This, debugstr_variant(&typedValue));
1389     return E_NOTIMPL;
1390 }
1391
1392 static HRESULT WINAPI unknode_get_dataType(
1393     IXMLDOMNode *iface,
1394     VARIANT* var1)
1395 {
1396     unknode *This = unknode_from_IXMLDOMNode( iface );
1397     TRACE("(%p)->(%p)\n", This, var1);
1398     return return_null_var(var1);
1399 }
1400
1401 static HRESULT WINAPI unknode_put_dataType(
1402     IXMLDOMNode *iface,
1403     BSTR p)
1404 {
1405     unknode *This = unknode_from_IXMLDOMNode( iface );
1406
1407     FIXME("(%p)->(%s)\n", This, debugstr_w(p));
1408
1409     if(!p)
1410         return E_INVALIDARG;
1411
1412     return E_FAIL;
1413 }
1414
1415 static HRESULT WINAPI unknode_get_xml(
1416     IXMLDOMNode *iface,
1417     BSTR* p)
1418 {
1419     unknode *This = unknode_from_IXMLDOMNode( iface );
1420
1421     FIXME("(%p)->(%p)\n", This, p);
1422
1423     return node_get_xml(&This->node, FALSE, p);
1424 }
1425
1426 static HRESULT WINAPI unknode_transformNode(
1427     IXMLDOMNode *iface,
1428     IXMLDOMNode* domNode, BSTR* p)
1429 {
1430     unknode *This = unknode_from_IXMLDOMNode( iface );
1431     return node_transform_node(&This->node, domNode, p);
1432 }
1433
1434 static HRESULT WINAPI unknode_selectNodes(
1435     IXMLDOMNode *iface,
1436     BSTR p, IXMLDOMNodeList** outList)
1437 {
1438     unknode *This = unknode_from_IXMLDOMNode( iface );
1439     return node_select_nodes(&This->node, p, outList);
1440 }
1441
1442 static HRESULT WINAPI unknode_selectSingleNode(
1443     IXMLDOMNode *iface,
1444     BSTR p, IXMLDOMNode** outNode)
1445 {
1446     unknode *This = unknode_from_IXMLDOMNode( iface );
1447     return node_select_singlenode(&This->node, p, outNode);
1448 }
1449
1450 static HRESULT WINAPI unknode_get_parsed(
1451     IXMLDOMNode *iface,
1452     VARIANT_BOOL* isParsed)
1453 {
1454     unknode *This = unknode_from_IXMLDOMNode( iface );
1455     FIXME("(%p)->(%p) stub!\n", This, isParsed);
1456     *isParsed = VARIANT_TRUE;
1457     return S_OK;
1458 }
1459
1460 static HRESULT WINAPI unknode_get_namespaceURI(
1461     IXMLDOMNode *iface,
1462     BSTR* p)
1463 {
1464     unknode *This = unknode_from_IXMLDOMNode( iface );
1465     TRACE("(%p)->(%p)\n", This, p);
1466     return node_get_namespaceURI(&This->node, p);
1467 }
1468
1469 static HRESULT WINAPI unknode_get_prefix(
1470     IXMLDOMNode *iface,
1471     BSTR* p)
1472 {
1473     unknode *This = unknode_from_IXMLDOMNode( iface );
1474     return node_get_prefix(&This->node, p);
1475 }
1476
1477 static HRESULT WINAPI unknode_get_baseName(
1478     IXMLDOMNode *iface,
1479     BSTR* p)
1480 {
1481     unknode *This = unknode_from_IXMLDOMNode( iface );
1482     return node_get_base_name(&This->node, p);
1483 }
1484
1485 static HRESULT WINAPI unknode_transformNodeToObject(
1486     IXMLDOMNode *iface,
1487     IXMLDOMNode* domNode, VARIANT var1)
1488 {
1489     unknode *This = unknode_from_IXMLDOMNode( iface );
1490     FIXME("(%p)->(%p %s)\n", This, domNode, debugstr_variant(&var1));
1491     return E_NOTIMPL;
1492 }
1493
1494 static const struct IXMLDOMNodeVtbl unknode_vtbl =
1495 {
1496     unknode_QueryInterface,
1497     unknode_AddRef,
1498     unknode_Release,
1499     unknode_GetTypeInfoCount,
1500     unknode_GetTypeInfo,
1501     unknode_GetIDsOfNames,
1502     unknode_Invoke,
1503     unknode_get_nodeName,
1504     unknode_get_nodeValue,
1505     unknode_put_nodeValue,
1506     unknode_get_nodeType,
1507     unknode_get_parentNode,
1508     unknode_get_childNodes,
1509     unknode_get_firstChild,
1510     unknode_get_lastChild,
1511     unknode_get_previousSibling,
1512     unknode_get_nextSibling,
1513     unknode_get_attributes,
1514     unknode_insertBefore,
1515     unknode_replaceChild,
1516     unknode_removeChild,
1517     unknode_appendChild,
1518     unknode_hasChildNodes,
1519     unknode_get_ownerDocument,
1520     unknode_cloneNode,
1521     unknode_get_nodeTypeString,
1522     unknode_get_text,
1523     unknode_put_text,
1524     unknode_get_specified,
1525     unknode_get_definition,
1526     unknode_get_nodeTypedValue,
1527     unknode_put_nodeTypedValue,
1528     unknode_get_dataType,
1529     unknode_put_dataType,
1530     unknode_get_xml,
1531     unknode_transformNode,
1532     unknode_selectNodes,
1533     unknode_selectSingleNode,
1534     unknode_get_parsed,
1535     unknode_get_namespaceURI,
1536     unknode_get_prefix,
1537     unknode_get_baseName,
1538     unknode_transformNodeToObject
1539 };
1540
1541 IXMLDOMNode *create_node( xmlNodePtr node )
1542 {
1543     IUnknown *pUnk;
1544     IXMLDOMNode *ret;
1545     HRESULT hr;
1546
1547     if ( !node )
1548         return NULL;
1549
1550     TRACE("type %d\n", node->type);
1551     switch(node->type)
1552     {
1553     case XML_ELEMENT_NODE:
1554         pUnk = create_element( node );
1555         break;
1556     case XML_ATTRIBUTE_NODE:
1557         pUnk = create_attribute( node );
1558         break;
1559     case XML_TEXT_NODE:
1560         pUnk = create_text( node );
1561         break;
1562     case XML_CDATA_SECTION_NODE:
1563         pUnk = create_cdata( node );
1564         break;
1565     case XML_ENTITY_REF_NODE:
1566         pUnk = create_doc_entity_ref( node );
1567         break;
1568     case XML_PI_NODE:
1569         pUnk = create_pi( node );
1570         break;
1571     case XML_COMMENT_NODE:
1572         pUnk = create_comment( node );
1573         break;
1574     case XML_DOCUMENT_NODE:
1575         pUnk = create_domdoc( node );
1576         break;
1577     case XML_DOCUMENT_FRAG_NODE:
1578         pUnk = create_doc_fragment( node );
1579         break;
1580     case XML_DTD_NODE:
1581         pUnk = create_doc_type( node );
1582         break;
1583     default: {
1584         unknode *new_node;
1585
1586         FIXME("only creating basic node for type %d\n", node->type);
1587
1588         new_node = heap_alloc(sizeof(unknode));
1589         if(!new_node)
1590             return NULL;
1591
1592         new_node->IXMLDOMNode_iface.lpVtbl = &unknode_vtbl;
1593         new_node->ref = 1;
1594         init_xmlnode(&new_node->node, node, &new_node->IXMLDOMNode_iface, NULL);
1595         pUnk = (IUnknown*)&new_node->IXMLDOMNode_iface;
1596     }
1597     }
1598
1599     hr = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMNode, (LPVOID*)&ret);
1600     IUnknown_Release(pUnk);
1601     if(FAILED(hr)) return NULL;
1602     return ret;
1603 }
1604 #endif