d3d8: Get rid of basetexture.c.
[wine] / 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 #ifdef HAVE_LIBXML2
37 # include <libxml/HTMLtree.h>
38 #endif
39
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
43
44 #ifdef HAVE_LIBXML2
45
46 static const WCHAR szBinBase64[]  = {'b','i','n','.','b','a','s','e','6','4',0};
47 static const WCHAR szString[]     = {'s','t','r','i','n','g',0};
48 static const WCHAR szNumber[]     = {'n','u','m','b','e','r',0};
49 static const WCHAR szInt[]        = {'I','n','t',0};
50 static const WCHAR szFixed[]      = {'F','i','x','e','d','.','1','4','.','4',0};
51 static const WCHAR szBoolean[]    = {'B','o','o','l','e','a','n',0};
52 static const WCHAR szDateTime[]   = {'d','a','t','e','T','i','m','e',0};
53 static const WCHAR szDateTimeTZ[] = {'d','a','t','e','T','i','m','e','.','t','z',0};
54 static const WCHAR szDate[]       = {'D','a','t','e',0};
55 static const WCHAR szTime[]       = {'T','i','m','e',0};
56 static const WCHAR szTimeTZ[]     = {'T','i','m','e','.','t','z',0};
57 static const WCHAR szI1[]         = {'i','1',0};
58 static const WCHAR szI2[]         = {'i','2',0};
59 static const WCHAR szI4[]         = {'i','4',0};
60 static const WCHAR szIU1[]        = {'u','i','1',0};
61 static const WCHAR szIU2[]        = {'u','i','2',0};
62 static const WCHAR szIU4[]        = {'u','i','4',0};
63 static const WCHAR szR4[]         = {'r','4',0};
64 static const WCHAR szR8[]         = {'r','8',0};
65 static const WCHAR szFloat[]      = {'f','l','o','a','t',0};
66 static const WCHAR szUUID[]       = {'u','u','i','d',0};
67 static const WCHAR szBinHex[]     = {'b','i','n','.','h','e','x',0};
68
69 static inline xmlnode *impl_from_InternalUnknown( IUnknown *iface )
70 {
71     return (xmlnode *)((char*)iface - FIELD_OFFSET(xmlnode, lpInternalUnkVtbl));
72 }
73
74 xmlNodePtr xmlNodePtr_from_domnode( IXMLDOMNode *iface, xmlElementType type )
75 {
76     xmlnode *This;
77
78     if ( !iface )
79         return NULL;
80     This = impl_from_IXMLDOMNode( iface );
81     if ( !This->node )
82         return NULL;
83     if ( type && This->node->type != type )
84         return NULL;
85     return This->node;
86 }
87
88 static HRESULT WINAPI xmlnode_QueryInterface(
89     IXMLDOMNode *iface,
90     REFIID riid,
91     void** ppvObject )
92 {
93     xmlnode *This = impl_from_IXMLDOMNode( iface );
94     TRACE("%p %s %p\n", This, debugstr_guid(riid), ppvObject);
95
96     return IUnknown_QueryInterface(This->pUnkOuter, riid, ppvObject);
97 }
98
99 static ULONG WINAPI xmlnode_AddRef(
100     IXMLDOMNode *iface )
101 {
102     xmlnode *This = impl_from_IXMLDOMNode( iface );
103     return IUnknown_AddRef(This->pUnkOuter);
104 }
105
106 static ULONG WINAPI xmlnode_Release(
107     IXMLDOMNode *iface )
108 {
109     xmlnode *This = impl_from_IXMLDOMNode( iface );
110     return IUnknown_Release(This->pUnkOuter);
111 }
112
113 static HRESULT WINAPI xmlnode_GetTypeInfoCount(
114     IXMLDOMNode *iface,
115     UINT* pctinfo )
116 {
117     xmlnode *This = impl_from_IXMLDOMNode( iface );
118
119     TRACE("(%p)->(%p)\n", This, pctinfo);
120
121     *pctinfo = 1;
122
123     return S_OK;
124 }
125
126 static HRESULT WINAPI xmlnode_GetTypeInfo(
127     IXMLDOMNode *iface,
128     UINT iTInfo,
129     LCID lcid,
130     ITypeInfo** ppTInfo )
131 {
132     xmlnode *This = impl_from_IXMLDOMNode( iface );
133     HRESULT hr;
134
135     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
136
137     hr = get_typeinfo(IXMLDOMNode_tid, ppTInfo);
138
139     return hr;
140 }
141
142 static HRESULT WINAPI xmlnode_GetIDsOfNames(
143     IXMLDOMNode *iface,
144     REFIID riid,
145     LPOLESTR* rgszNames,
146     UINT cNames,
147     LCID lcid,
148     DISPID* rgDispId )
149 {
150     xmlnode *This = impl_from_IXMLDOMNode( iface );
151
152     ITypeInfo *typeinfo;
153     HRESULT hr;
154
155     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
156           lcid, rgDispId);
157
158     if(!rgszNames || cNames == 0 || !rgDispId)
159         return E_INVALIDARG;
160
161     hr = get_typeinfo(IXMLDOMNode_tid, &typeinfo);
162     if(SUCCEEDED(hr))
163     {
164         hr = ITypeInfo_GetIDsOfNames(typeinfo, rgszNames, cNames, rgDispId);
165         ITypeInfo_Release(typeinfo);
166     }
167
168     return hr;
169 }
170
171 static HRESULT WINAPI xmlnode_Invoke(
172     IXMLDOMNode *iface,
173     DISPID dispIdMember,
174     REFIID riid,
175     LCID lcid,
176     WORD wFlags,
177     DISPPARAMS* pDispParams,
178     VARIANT* pVarResult,
179     EXCEPINFO* pExcepInfo,
180     UINT* puArgErr )
181 {
182     xmlnode *This = impl_from_IXMLDOMNode( iface );
183     ITypeInfo *typeinfo;
184     HRESULT hr;
185
186     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
187           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
188
189     hr = get_typeinfo(IXMLDOMNode_tid, &typeinfo);
190     if(SUCCEEDED(hr))
191     {
192         hr = ITypeInfo_Invoke(typeinfo, &(This->lpVtbl), dispIdMember, wFlags, pDispParams,
193                 pVarResult, pExcepInfo, puArgErr);
194         ITypeInfo_Release(typeinfo);
195     }
196
197     return hr;
198 }
199
200 static HRESULT WINAPI xmlnode_get_nodeName(
201     IXMLDOMNode *iface,
202     BSTR* name)
203 {
204     xmlnode *This = impl_from_IXMLDOMNode( iface );
205     const xmlChar *str;
206
207     TRACE("%p\n", This );
208
209     if (!name)
210         return E_INVALIDARG;
211
212     if ( !This->node )
213         return E_FAIL;
214
215     switch( This->node->type )
216     {
217     case XML_CDATA_SECTION_NODE:
218         str = (const xmlChar*) "#cdata-section";
219         break;
220     case XML_COMMENT_NODE:
221         str = (const xmlChar*) "#comment";
222         break;
223     case XML_DOCUMENT_FRAG_NODE:
224         str = (const xmlChar*) "#document-fragment";
225         break;
226     case XML_TEXT_NODE:
227          str = (const xmlChar*) "#text";
228          break;
229     case XML_DOCUMENT_NODE:
230          str = (const xmlChar*) "#document";
231             break;
232         case XML_ATTRIBUTE_NODE:
233         case XML_ELEMENT_NODE:
234         case XML_PI_NODE:
235         str = This->node->name;
236             break;
237     default:
238         FIXME("nodeName not mapped correctly (%d)\n", This->node->type);
239         str = This->node->name;
240         break;
241     }
242
243     *name = bstr_from_xmlChar( str );
244     if (!*name)
245         return S_FALSE;
246
247     return S_OK;
248 }
249
250 BSTR bstr_from_xmlChar( const xmlChar *buf )
251 {
252     DWORD len;
253     LPWSTR str;
254     BSTR bstr;
255
256     if ( !buf )
257         return NULL;
258
259     len = MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) buf, -1, NULL, 0 );
260     str = HeapAlloc( GetProcessHeap(), 0, len * sizeof (WCHAR) );
261     if ( !str )
262         return NULL;
263     MultiByteToWideChar( CP_UTF8, 0, (LPCSTR) buf, -1, str, len );
264     bstr = SysAllocString( str );
265     HeapFree( GetProcessHeap(), 0, str );
266     return bstr;
267 }
268
269 static HRESULT WINAPI xmlnode_get_nodeValue(
270     IXMLDOMNode *iface,
271     VARIANT* value)
272 {
273     xmlnode *This = impl_from_IXMLDOMNode( iface );
274     HRESULT r = S_FALSE;
275
276     TRACE("%p %p\n", This, value);
277
278     if(!value)
279         return E_INVALIDARG;
280
281     V_BSTR(value) = NULL;
282     V_VT(value) = VT_NULL;
283
284     switch ( This->node->type )
285     {
286     case XML_CDATA_SECTION_NODE:
287     case XML_COMMENT_NODE:
288     case XML_PI_NODE:
289     case XML_ATTRIBUTE_NODE:
290       {
291         xmlChar *content = xmlNodeGetContent(This->node);
292         V_VT(value) = VT_BSTR;
293         V_BSTR(value) = bstr_from_xmlChar( content );
294         xmlFree(content);
295         r = S_OK;
296         break;
297       }
298     case XML_TEXT_NODE:
299         V_VT(value) = VT_BSTR;
300         V_BSTR(value) = bstr_from_xmlChar( This->node->content );
301         r = S_OK;
302         break;
303     case XML_ELEMENT_NODE:
304     case XML_DOCUMENT_NODE:
305         /* these seem to return NULL */
306         break;
307
308     default:
309         FIXME("node %p type %d\n", This, This->node->type);
310     }
311  
312     TRACE("%p returned %s\n", This, debugstr_w( V_BSTR(value) ) );
313
314     return r;
315 }
316
317 static HRESULT WINAPI xmlnode_put_nodeValue(
318     IXMLDOMNode *iface,
319     VARIANT value)
320 {
321     xmlnode *This = impl_from_IXMLDOMNode( iface );
322     HRESULT hr;
323     xmlChar *str = NULL;
324     VARIANT string_value;
325
326     TRACE("%p type(%d)\n", This, This->node->type);
327
328     VariantInit(&string_value);
329     hr = VariantChangeType(&string_value, &value, 0, VT_BSTR);
330     if(FAILED(hr))
331     {
332         VariantClear(&string_value);
333         WARN("Couldn't convert to VT_BSTR\n");
334         return hr;
335     }
336
337     hr = S_FALSE;
338     /* Document, Document Fragment, Document Type, Element,
339         Entity, Entity Reference, Notation aren't supported. */
340     switch ( This->node->type )
341     {
342     case XML_ATTRIBUTE_NODE:
343     case XML_CDATA_SECTION_NODE:
344     case XML_COMMENT_NODE:
345     case XML_PI_NODE:
346     case XML_TEXT_NODE:
347       {
348         str = xmlChar_from_wchar(V_BSTR(&string_value));
349         xmlNodeSetContent(This->node, str);
350         HeapFree(GetProcessHeap(),0,str);
351         hr = S_OK;
352         break;
353       }
354     default:
355         /* Do nothing for unsupported types. */
356         break;
357     }
358
359     VariantClear(&string_value);
360
361     return hr;
362 }
363
364 static HRESULT WINAPI xmlnode_get_nodeType(
365     IXMLDOMNode *iface,
366     DOMNodeType* type)
367 {
368     xmlnode *This = impl_from_IXMLDOMNode( iface );
369
370     TRACE("%p %p\n", This, type);
371
372     assert( NODE_ELEMENT == XML_ELEMENT_NODE );
373     assert( NODE_NOTATION == XML_NOTATION_NODE );
374
375     *type = This->node->type;
376
377     return S_OK;
378 }
379
380 static HRESULT get_node(
381     xmlnode *This,
382     const char *name,
383     xmlNodePtr node,
384     IXMLDOMNode **out )
385 {
386     TRACE("%p->%s %p\n", This, name, node );
387
388     if ( !out )
389         return E_INVALIDARG;
390
391     /* if we dont have a doc, use our parent. */
392     if(node && !node->doc && node->parent)
393         node->doc = node->parent->doc;
394
395     *out = create_node( node );
396     if (!*out)
397         return S_FALSE;
398     return S_OK;
399 }
400
401 static HRESULT WINAPI xmlnode_get_parentNode(
402     IXMLDOMNode *iface,
403     IXMLDOMNode** parent)
404 {
405     xmlnode *This = impl_from_IXMLDOMNode( iface );
406     return get_node( This, "parent", This->node->parent, parent );
407 }
408
409 static HRESULT WINAPI xmlnode_get_childNodes(
410     IXMLDOMNode *iface,
411     IXMLDOMNodeList** childList)
412 {
413     xmlnode *This = impl_from_IXMLDOMNode( iface );
414
415     TRACE("%p %p\n", This, childList );
416
417     if ( !childList )
418         return E_INVALIDARG;
419
420     *childList = create_children_nodelist(This->node);
421     if (*childList == NULL)
422         return E_OUTOFMEMORY;
423
424     return S_OK;
425 }
426
427 static HRESULT WINAPI xmlnode_get_firstChild(
428     IXMLDOMNode *iface,
429     IXMLDOMNode** firstChild)
430 {
431     xmlnode *This = impl_from_IXMLDOMNode( iface );
432     return get_node( This, "firstChild", This->node->children, firstChild );
433 }
434
435 static HRESULT WINAPI xmlnode_get_lastChild(
436     IXMLDOMNode *iface,
437     IXMLDOMNode** lastChild)
438 {
439     xmlnode *This = impl_from_IXMLDOMNode( iface );
440
441     TRACE("%p\n", This );
442
443     if (!lastChild)
444         return E_INVALIDARG;
445
446     switch( This->node->type )
447     {
448     /* CDATASection, Comment, PI and Text Nodes do not support lastChild */
449     case XML_TEXT_NODE:
450     case XML_CDATA_SECTION_NODE:
451     case XML_PI_NODE:
452     case XML_COMMENT_NODE:
453         *lastChild = NULL;
454         return S_FALSE;
455     default:
456         return get_node( This, "lastChild", This->node->last, lastChild );
457     }
458 }
459
460 static HRESULT WINAPI xmlnode_get_previousSibling(
461     IXMLDOMNode *iface,
462     IXMLDOMNode** previousSibling)
463 {
464     xmlnode *This = impl_from_IXMLDOMNode( iface );
465
466     TRACE("%p\n", This );
467
468     if (!previousSibling)
469         return E_INVALIDARG;
470
471     switch( This->node->type )
472     {
473     /* Attribute, Document and Document Fragment Nodes do not support previousSibling */
474     case XML_DOCUMENT_NODE:
475     case XML_DOCUMENT_FRAG_NODE:
476     case XML_ATTRIBUTE_NODE:
477         *previousSibling = NULL;
478         return S_FALSE;
479     default:
480         return get_node( This, "previous", This->node->prev, previousSibling );
481     }
482 }
483
484 static HRESULT WINAPI xmlnode_get_nextSibling(
485     IXMLDOMNode *iface,
486     IXMLDOMNode** nextSibling)
487 {
488     xmlnode *This = impl_from_IXMLDOMNode( iface );
489
490     TRACE("%p\n", This );
491
492     if (!nextSibling)
493         return E_INVALIDARG;
494
495     switch( This->node->type )
496     {
497     /* Attribute, Document and Document Fragment Nodes do not support nextSibling */
498     case XML_DOCUMENT_NODE:
499     case XML_DOCUMENT_FRAG_NODE:
500     case XML_ATTRIBUTE_NODE:
501         *nextSibling = NULL;
502         return S_FALSE;
503     default:
504         return get_node( This, "next", This->node->next, nextSibling );
505     }
506 }
507
508 static HRESULT WINAPI xmlnode_get_attributes(
509     IXMLDOMNode *iface,
510     IXMLDOMNamedNodeMap** attributeMap)
511 {
512     xmlnode *This = impl_from_IXMLDOMNode( iface );
513     TRACE("%p\n", This);
514
515     if (!attributeMap)
516         return E_INVALIDARG;
517
518     switch( This->node->type )
519     {
520     /* Attribute, CDataSection, Comment, Documents, Documents Fragments,
521        Entity and Text Nodes does not support get_attributes */
522     case XML_ATTRIBUTE_NODE:
523     case XML_CDATA_SECTION_NODE:
524     case XML_COMMENT_NODE:
525     case XML_DOCUMENT_NODE:
526     case XML_DOCUMENT_FRAG_NODE:
527     case XML_ENTITY_NODE:
528     case XML_ENTITY_REF_NODE:
529     case XML_TEXT_NODE:
530         *attributeMap = NULL;
531         return S_FALSE;
532     default:
533         *attributeMap = create_nodemap( iface );
534         return S_OK;
535     }
536 }
537
538 static HRESULT WINAPI xmlnode_insertBefore(
539     IXMLDOMNode *iface,
540     IXMLDOMNode* newChild,
541     VARIANT refChild,
542     IXMLDOMNode** outNewChild)
543 {
544     xmlnode *This = impl_from_IXMLDOMNode( iface );
545     xmlNodePtr before_node, new_child_node;
546     IXMLDOMNode *before = NULL, *new;
547     HRESULT hr;
548
549     TRACE("(%p)->(%p,var,%p)\n",This,newChild,outNewChild);
550
551     if (!newChild)
552         return E_INVALIDARG;
553
554     switch(V_VT(&refChild))
555     {
556     case VT_EMPTY:
557     case VT_NULL:
558         break;
559
560     case VT_UNKNOWN:
561         hr = IUnknown_QueryInterface(V_UNKNOWN(&refChild), &IID_IXMLDOMNode, (LPVOID)&before);
562         if(FAILED(hr)) return hr;
563         break;
564
565     case VT_DISPATCH:
566         hr = IDispatch_QueryInterface(V_DISPATCH(&refChild), &IID_IXMLDOMNode, (LPVOID)&before);
567         if(FAILED(hr)) return hr;
568         break;
569
570     default:
571         FIXME("refChild var type %x\n", V_VT(&refChild));
572         return E_FAIL;
573     }
574
575     IXMLDOMNode_QueryInterface(newChild, &IID_IXMLDOMNode, (LPVOID)&new);
576     new_child_node = impl_from_IXMLDOMNode(new)->node;
577     TRACE("new_child_node %p This->node %p\n", new_child_node, This->node);
578
579     if(!new_child_node->parent)
580         if(xmldoc_remove_orphan(new_child_node->doc, new_child_node) != S_OK)
581             WARN("%p is not an orphan of %p\n", new_child_node, new_child_node->doc);
582
583     if(before)
584     {
585         before_node = impl_from_IXMLDOMNode(before)->node;
586         xmlAddPrevSibling(before_node, new_child_node);
587         IXMLDOMNode_Release(before);
588     }
589     else
590     {
591         xmlAddChild(This->node, new_child_node);
592     }
593
594     IXMLDOMNode_Release(new);
595     IXMLDOMNode_AddRef(newChild);
596     if(outNewChild)
597         *outNewChild = newChild;
598
599     TRACE("ret S_OK\n");
600     return S_OK;
601 }
602
603 static HRESULT WINAPI xmlnode_replaceChild(
604     IXMLDOMNode *iface,
605     IXMLDOMNode* newChild,
606     IXMLDOMNode* oldChild,
607     IXMLDOMNode** outOldChild)
608 {
609     xmlnode *This = impl_from_IXMLDOMNode( iface );
610     xmlNode *old_child_ptr, *new_child_ptr;
611     xmlDocPtr leaving_doc;
612     xmlNode *my_ancestor;
613     IXMLDOMNode *realOldChild;
614     HRESULT hr;
615
616     TRACE("%p->(%p,%p,%p)\n",This,newChild,oldChild,outOldChild);
617
618     /* Do not believe any documentation telling that newChild == NULL
619        means removal. It does certainly *not* apply to msxml3! */
620     if(!newChild || !oldChild)
621         return E_INVALIDARG;
622
623     if(outOldChild)
624         *outOldChild = NULL;
625
626     hr = IXMLDOMNode_QueryInterface(oldChild,&IID_IXMLDOMNode,(LPVOID*)&realOldChild);
627     if(FAILED(hr))
628         return hr;
629
630     old_child_ptr = impl_from_IXMLDOMNode(realOldChild)->node;
631     IXMLDOMNode_Release(realOldChild);
632     if(old_child_ptr->parent != This->node)
633     {
634         WARN("childNode %p is not a child of %p\n", oldChild, iface);
635         return E_INVALIDARG;
636     }
637
638     new_child_ptr = impl_from_IXMLDOMNode(newChild)->node;
639     my_ancestor = This->node;
640     while(my_ancestor)
641     {
642         if(my_ancestor == new_child_ptr)
643         {
644             WARN("tried to create loop\n");
645             return E_FAIL;
646         }
647         my_ancestor = my_ancestor->parent;
648     }
649
650     if(!new_child_ptr->parent)
651         if(xmldoc_remove_orphan(new_child_ptr->doc, new_child_ptr) != S_OK)
652             WARN("%p is not an orphan of %p\n", new_child_ptr, new_child_ptr->doc);
653
654     leaving_doc = new_child_ptr->doc;
655     xmldoc_add_ref(old_child_ptr->doc);
656     xmlReplaceNode(old_child_ptr, new_child_ptr);
657     xmldoc_release(leaving_doc);
658
659     xmldoc_add_orphan(old_child_ptr->doc, old_child_ptr);
660
661     if(outOldChild)
662     {
663         IXMLDOMNode_AddRef(oldChild);
664         *outOldChild = oldChild;
665     }
666
667     return S_OK;
668 }
669
670 static HRESULT WINAPI xmlnode_removeChild(
671     IXMLDOMNode *iface,
672     IXMLDOMNode* childNode,
673     IXMLDOMNode** oldChild)
674 {
675     xmlnode *This = impl_from_IXMLDOMNode( iface );
676     xmlNode *child_node_ptr;
677     HRESULT hr;
678     IXMLDOMNode *child;
679
680     TRACE("%p->(%p, %p)\n", This, childNode, oldChild);
681
682     if(!childNode) return E_INVALIDARG;
683
684     if(oldChild)
685         *oldChild = NULL;
686
687     hr = IXMLDOMNode_QueryInterface(childNode, &IID_IXMLDOMNode, (LPVOID)&child);
688     if(FAILED(hr))
689         return hr;
690
691     child_node_ptr = impl_from_IXMLDOMNode(child)->node;
692     if(child_node_ptr->parent != This->node)
693     {
694         WARN("childNode %p is not a child of %p\n", childNode, iface);
695         IXMLDOMNode_Release(child);
696         return E_INVALIDARG;
697     }
698
699     xmlUnlinkNode(child_node_ptr);
700
701     IXMLDOMNode_Release(child);
702
703     if(oldChild)
704     {
705         IXMLDOMNode_AddRef(childNode);
706         *oldChild = childNode;
707     }
708
709     return S_OK;
710 }
711
712 static HRESULT WINAPI xmlnode_appendChild(
713     IXMLDOMNode *iface,
714     IXMLDOMNode* newChild,
715     IXMLDOMNode** outNewChild)
716 {
717     xmlnode *This = impl_from_IXMLDOMNode( iface );
718     DOMNodeType type;
719     VARIANT var;
720     HRESULT hr;
721
722     TRACE("(%p)->(%p,%p)\n", This, newChild, outNewChild);
723
724     hr = IXMLDOMNode_get_nodeType(newChild, &type);
725     if(FAILED(hr) || type == NODE_ATTRIBUTE) {
726         if(outNewChild) *outNewChild = NULL;
727         return E_FAIL;
728     }
729
730     VariantInit(&var);
731     return IXMLDOMNode_insertBefore(iface, newChild, var, outNewChild);
732 }
733
734 static HRESULT WINAPI xmlnode_hasChildNodes(
735     IXMLDOMNode *iface,
736     VARIANT_BOOL* hasChild)
737 {
738     xmlnode *This = impl_from_IXMLDOMNode( iface );
739
740     TRACE("%p\n", This);
741
742     if (!hasChild)
743         return E_INVALIDARG;
744     if (!This->node->children)
745     {
746         *hasChild = VARIANT_FALSE;
747         return S_FALSE;
748     }
749
750     *hasChild = VARIANT_TRUE;
751     return S_OK;
752 }
753
754 static HRESULT WINAPI xmlnode_get_ownerDocument(
755     IXMLDOMNode *iface,
756     IXMLDOMDocument** DOMDocument)
757 {
758     xmlnode *This = impl_from_IXMLDOMNode( iface );
759
760     TRACE("%p (%p)\n", This, DOMDocument);
761
762     return DOMDocument_create_from_xmldoc(This->node->doc, (IXMLDOMDocument2**)DOMDocument);
763 }
764
765 static HRESULT WINAPI xmlnode_cloneNode(
766     IXMLDOMNode *iface,
767     VARIANT_BOOL deep,
768     IXMLDOMNode** cloneRoot)
769 {
770     xmlnode *This = impl_from_IXMLDOMNode( iface );
771     xmlNodePtr pClone = NULL;
772     IXMLDOMNode *pNode = NULL;
773
774     TRACE("%p (%d)\n", This, deep);
775
776     if(!cloneRoot)
777         return E_INVALIDARG;
778
779     pClone = xmlCopyNode(This->node, deep ? 1 : 2);
780     if(pClone)
781     {
782         pClone->doc = This->node->doc;
783         xmldoc_add_orphan(pClone->doc, pClone);
784
785         pNode = create_node(pClone);
786         if(!pNode)
787         {
788             ERR("Copy failed\n");
789             return E_FAIL;
790         }
791
792         *cloneRoot = pNode;
793     }
794     else
795     {
796         ERR("Copy failed\n");
797         return E_FAIL;
798     }
799
800     return S_OK;
801 }
802
803 static HRESULT WINAPI xmlnode_get_nodeTypeString(
804     IXMLDOMNode *iface,
805     BSTR* xmlnodeType)
806 {
807     xmlnode *This = impl_from_IXMLDOMNode( iface );
808     const xmlChar *str;
809
810     TRACE("%p\n", This );
811
812     if (!xmlnodeType)
813         return E_INVALIDARG;
814
815     if ( !This->node )
816         return E_FAIL;
817
818     switch( This->node->type )
819     {
820     case XML_ATTRIBUTE_NODE:
821         str = (const xmlChar*) "attribute";
822         break;
823     case XML_CDATA_SECTION_NODE:
824         str = (const xmlChar*) "cdatasection";
825         break;
826     case XML_COMMENT_NODE:
827         str = (const xmlChar*) "comment";
828         break;
829     case XML_DOCUMENT_NODE:
830         str = (const xmlChar*) "document";
831         break;
832     case XML_DOCUMENT_FRAG_NODE:
833         str = (const xmlChar*) "documentfragment";
834         break;
835     case XML_ELEMENT_NODE:
836         str = (const xmlChar*) "element";
837         break;
838     case XML_ENTITY_NODE:
839         str = (const xmlChar*) "entity";
840         break;
841     case XML_ENTITY_REF_NODE:
842         str = (const xmlChar*) "entityreference";
843         break;
844     case XML_NOTATION_NODE:
845         str = (const xmlChar*) "notation";
846         break;
847     case XML_PI_NODE:
848         str = (const xmlChar*) "processinginstruction";
849         break;
850     case XML_TEXT_NODE:
851         str = (const xmlChar*) "text";
852         break;
853     default:
854         FIXME("Unknown node type (%d)\n", This->node->type);
855         str = This->node->name;
856         break;
857     }
858
859     *xmlnodeType = bstr_from_xmlChar( str );
860     if (!*xmlnodeType)
861         return S_FALSE;
862
863     return S_OK;
864 }
865
866 static HRESULT WINAPI xmlnode_get_text(
867     IXMLDOMNode *iface,
868     BSTR* text)
869 {
870     xmlnode *This = impl_from_IXMLDOMNode( iface );
871     BSTR str = NULL;
872     xmlChar *pContent;
873
874     TRACE("%p type %d\n", This, This->node->type);
875
876     if ( !text )
877         return E_INVALIDARG;
878
879     pContent = xmlNodeGetContent((xmlNodePtr)This->node);
880     if(pContent)
881     {
882         str = bstr_from_xmlChar(pContent);
883         xmlFree(pContent);
884     }
885
886     /* Always return a string. */
887     if (!str) str = SysAllocStringLen( NULL, 0 );
888
889     TRACE("%p %s\n", This, debugstr_w(str) );
890     *text = str;
891  
892     return S_OK;
893 }
894
895 static HRESULT WINAPI xmlnode_put_text(
896     IXMLDOMNode *iface,
897     BSTR text)
898 {
899     xmlnode *This = impl_from_IXMLDOMNode( iface );
900     xmlChar *str, *str2;
901
902     TRACE("%p\n", This);
903
904     switch(This->node->type)
905     {
906     case XML_DOCUMENT_NODE:
907         return E_FAIL;
908     default:
909         break;
910     }
911
912     str = xmlChar_from_wchar(text);
913
914     /* Escape the string. */
915     str2 = xmlEncodeEntitiesReentrant(This->node->doc, str);
916     HeapFree(GetProcessHeap(), 0, str);
917
918     xmlNodeSetContent(This->node, str2);
919     xmlFree(str2);
920
921     return S_OK;
922 }
923
924 static HRESULT WINAPI xmlnode_get_specified(
925     IXMLDOMNode *iface,
926     VARIANT_BOOL* isSpecified)
927 {
928     FIXME("\n");
929     return E_NOTIMPL;
930 }
931
932 static HRESULT WINAPI xmlnode_get_definition(
933     IXMLDOMNode *iface,
934     IXMLDOMNode** definitionNode)
935 {
936     FIXME("\n");
937     return E_NOTIMPL;
938 }
939
940 static HRESULT WINAPI xmlnode_get_nodeTypedValue(
941     IXMLDOMNode *iface,
942     VARIANT* typedValue)
943 {
944     xmlnode *This = impl_from_IXMLDOMNode( iface );
945     HRESULT r = S_FALSE;
946
947     FIXME("ignoring data type %p %p\n", This, typedValue);
948
949     if(!typedValue)
950         return E_INVALIDARG;
951
952     V_VT(typedValue) = VT_NULL;
953
954     switch ( This->node->type )
955     {
956     case XML_ELEMENT_NODE:
957     {
958         xmlChar *content = xmlNodeGetContent(This->node);
959         V_VT(typedValue) = VT_BSTR;
960         V_BSTR(typedValue) = bstr_from_xmlChar( content );
961         xmlFree(content);
962         r = S_OK;
963         break;
964     }
965     default:
966         r = xmlnode_get_nodeValue(iface, typedValue);
967     }
968
969     return r;
970 }
971
972 static HRESULT WINAPI xmlnode_put_nodeTypedValue(
973     IXMLDOMNode *iface,
974     VARIANT typedValue)
975 {
976     FIXME("\n");
977     return E_NOTIMPL;
978 }
979
980 static HRESULT WINAPI xmlnode_get_dataType(
981     IXMLDOMNode *iface,
982     VARIANT* dataTypeName)
983 {
984     xmlnode *This = impl_from_IXMLDOMNode( iface );
985     xmlChar *pVal;
986
987     TRACE("iface %p\n", iface);
988
989     if(!dataTypeName)
990         return E_INVALIDARG;
991
992     /* Attribute, CDATA Section, Comment, Document, Document Fragment,
993         Entity, Notation, PI, and Text Node are non-typed. */
994     V_BSTR(dataTypeName) = NULL;
995     V_VT(dataTypeName) = VT_NULL;
996
997     switch ( This->node->type )
998     {
999     case XML_ELEMENT_NODE:
1000         pVal = xmlGetNsProp(This->node, (xmlChar*)"dt",
1001                             (xmlChar*)"urn:schemas-microsoft-com:datatypes");
1002         if (pVal)
1003         {
1004             V_VT(dataTypeName) = VT_BSTR;
1005             V_BSTR(dataTypeName) = bstr_from_xmlChar( pVal );
1006             xmlFree(pVal);
1007         }
1008         break;
1009     case XML_ENTITY_REF_NODE:
1010         FIXME("XML_ENTITY_REF_NODE should return a valid value.\n");
1011         break;
1012     default:
1013         TRACE("Type %d returning NULL\n", This->node->type);
1014     }
1015
1016     /* non-typed nodes return S_FALSE */
1017     if(V_VT(dataTypeName) == VT_NULL)
1018     {
1019         return S_FALSE;
1020     }
1021
1022     return S_OK;
1023 }
1024
1025 static HRESULT WINAPI xmlnode_put_dataType(
1026     IXMLDOMNode *iface,
1027     BSTR dataTypeName)
1028 {
1029     xmlnode *This = impl_from_IXMLDOMNode( iface );
1030     HRESULT hr = E_FAIL;
1031
1032     TRACE("iface %p\n", iface);
1033
1034     if(dataTypeName == NULL)
1035         return E_INVALIDARG;
1036
1037     /* An example of this is. The Text in the node needs to be a 0 or 1 for a boolean type.
1038        This applies to changing types (string->bool) or setting a new one
1039      */
1040     FIXME("Need to Validate the data before allowing a type to be set.\n");
1041
1042     /* Check all supported types. */
1043     if(lstrcmpiW(dataTypeName,szString) == 0  ||
1044        lstrcmpiW(dataTypeName,szNumber) == 0  ||
1045        lstrcmpiW(dataTypeName,szUUID) == 0    ||
1046        lstrcmpiW(dataTypeName,szInt) == 0     ||
1047        lstrcmpiW(dataTypeName,szI4) == 0      ||
1048        lstrcmpiW(dataTypeName,szFixed) == 0   ||
1049        lstrcmpiW(dataTypeName,szBoolean) == 0 ||
1050        lstrcmpiW(dataTypeName,szDateTime) == 0 ||
1051        lstrcmpiW(dataTypeName,szDateTimeTZ) == 0 ||
1052        lstrcmpiW(dataTypeName,szDate) == 0    ||
1053        lstrcmpiW(dataTypeName,szTime) == 0    ||
1054        lstrcmpiW(dataTypeName,szTimeTZ) == 0  ||
1055        lstrcmpiW(dataTypeName,szI1) == 0      ||
1056        lstrcmpiW(dataTypeName,szI2) == 0      ||
1057        lstrcmpiW(dataTypeName,szIU1) == 0     ||
1058        lstrcmpiW(dataTypeName,szIU2) == 0     ||
1059        lstrcmpiW(dataTypeName,szIU4) == 0     ||
1060        lstrcmpiW(dataTypeName,szR4) == 0      ||
1061        lstrcmpiW(dataTypeName,szR8) == 0      ||
1062        lstrcmpiW(dataTypeName,szFloat) == 0   ||
1063        lstrcmpiW(dataTypeName,szBinHex) == 0  ||
1064        lstrcmpiW(dataTypeName,szBinBase64) == 0)
1065     {
1066         xmlNsPtr pNS = NULL;
1067         xmlAttrPtr pAttr = NULL;
1068         xmlChar* str = xmlChar_from_wchar(dataTypeName);
1069
1070         pAttr = xmlHasNsProp(This->node, (xmlChar*)"dt",
1071                             (xmlChar*)"urn:schemas-microsoft-com:datatypes");
1072         if (pAttr)
1073         {
1074             pAttr = xmlSetNsProp(This->node, pAttr->ns, (xmlChar*)"dt", str);
1075
1076             hr = S_OK;
1077         }
1078         else
1079         {
1080             pNS = xmlNewNs(This->node, (xmlChar*)"urn:schemas-microsoft-com:datatypes", (xmlChar*)"dt");
1081             if(pNS)
1082             {
1083                 pAttr = xmlNewNsProp(This->node, pNS, (xmlChar*)"dt", str);
1084                 if(pAttr)
1085                 {
1086                     xmlAddChild(This->node, (xmlNodePtr)pAttr);
1087
1088                     hr = S_OK;
1089                 }
1090                 else
1091                     ERR("Failed to create Attribute\n");
1092             }
1093             else
1094                 ERR("Failed to Create Namepsace\n");
1095         }
1096         HeapFree( GetProcessHeap(), 0, str );
1097     }
1098
1099     return hr;
1100 }
1101
1102 static BSTR EnsureCorrectEOL(BSTR sInput)
1103 {
1104     static const WCHAR SZ_RETURN[] = {'\n',0};
1105     static const WCHAR SZ_LINEFEED[] = {'\r',0};
1106     int nNum = 0;
1107     BSTR sNew;
1108     int nLen;
1109     int i;
1110
1111     nLen = lstrlenW(sInput);
1112     /* Count line endings */
1113     for(i=0; i < nLen; i++)
1114     {
1115         if(sInput[i] == SZ_RETURN[0])
1116             nNum++;
1117     }
1118
1119     TRACE("len=%d, num=%d\n", nLen, nNum);
1120
1121     /* Add linefeed as needed */
1122     if(nNum > 0)
1123     {
1124         int nPlace = 0;
1125         sNew = SysAllocStringLen(NULL, nLen + nNum+1);
1126         for(i=0; i < nLen; i++)
1127         {
1128             if(sInput[i] == SZ_RETURN[0])
1129             {
1130                 sNew[i+nPlace] = SZ_LINEFEED[0];
1131                 nPlace++;
1132             }
1133             sNew[i+nPlace] = sInput[i];
1134         }
1135
1136         SysFreeString(sInput);
1137     }
1138     else
1139     {
1140         sNew = sInput;
1141     }
1142
1143     TRACE("len %d\n", lstrlenW(sNew));
1144
1145     return sNew;
1146 }
1147
1148 /* Removes encoding information and last character (nullbyte) */
1149 static BSTR EnsureNoEncoding(BSTR sInput)
1150 {
1151     static const WCHAR wszEncoding[] = {'e','n','c','o','d','i','n','g','='};
1152     BSTR sNew;
1153     WCHAR *pBeg, *pEnd;
1154
1155     pBeg = sInput;
1156     while(*pBeg != '\n' && memcmp(pBeg, wszEncoding, sizeof(wszEncoding)))
1157         pBeg++;
1158
1159     if(*pBeg == '\n')
1160     {
1161         SysReAllocStringLen(&sInput, sInput, SysStringLen(sInput)-1);
1162         return sInput;
1163     }
1164     pBeg--;
1165
1166     pEnd = pBeg + sizeof(wszEncoding)/sizeof(WCHAR) + 2;
1167     while(*pEnd != '\"') pEnd++;
1168     pEnd++;
1169
1170     sNew = SysAllocStringLen(NULL,
1171             pBeg-sInput + SysStringLen(sInput)-(pEnd-sInput)-1);
1172     memcpy(sNew, sInput, (pBeg-sInput)*sizeof(WCHAR));
1173     memcpy(&sNew[pBeg-sInput], pEnd, (SysStringLen(sInput)-(pEnd-sInput)-1)*sizeof(WCHAR));
1174
1175     SysFreeString(sInput);
1176     return sNew;
1177 }
1178
1179 /*
1180  * We are trying to replicate the same behaviour as msxml by converting
1181  * line endings to \r\n and using idents as \t. The problem is that msxml
1182  * only formats nodes that have a line ending. Using libxml we cannot
1183  * reproduce behaviour exactly.
1184  *
1185  */
1186 static HRESULT WINAPI xmlnode_get_xml(
1187     IXMLDOMNode *iface,
1188     BSTR* xmlString)
1189 {
1190     xmlnode *This = impl_from_IXMLDOMNode( iface );
1191     xmlBufferPtr pXmlBuf;
1192     int nSize;
1193
1194     TRACE("iface %p %d\n", iface, This->node->type);
1195
1196     if(!xmlString)
1197         return E_INVALIDARG;
1198
1199     *xmlString = NULL;
1200
1201     pXmlBuf = xmlBufferCreate();
1202     if(pXmlBuf)
1203     {
1204         nSize = xmlNodeDump(pXmlBuf, This->node->doc, This->node, 0, 1);
1205         if(nSize > 0)
1206         {
1207             const xmlChar *pContent;
1208             BSTR bstrContent;
1209
1210             /* Attribute Nodes return a space in front of their name */
1211             pContent = xmlBufferContent(pXmlBuf);
1212             if( ((char*)pContent)[0] == ' ')
1213                 bstrContent = bstr_from_xmlChar(pContent+1);
1214             else
1215                 bstrContent = bstr_from_xmlChar(pContent);
1216
1217             switch(This->node->type)
1218             {
1219                 case XML_ELEMENT_NODE:
1220                     *xmlString = EnsureCorrectEOL(bstrContent);
1221                     break;
1222                 case XML_DOCUMENT_NODE:
1223                     *xmlString = EnsureCorrectEOL(bstrContent);
1224                     *xmlString = EnsureNoEncoding(*xmlString);
1225                     break;
1226                 default:
1227                     *xmlString = bstrContent;
1228             }
1229         }
1230
1231         xmlBufferFree(pXmlBuf);
1232     }
1233
1234     /* Always returns a string. */
1235     if(*xmlString == NULL)  *xmlString = SysAllocStringLen( NULL, 0 );
1236
1237     return S_OK;
1238 }
1239
1240 static HRESULT WINAPI xmlnode_transformNode(
1241     IXMLDOMNode *iface,
1242     IXMLDOMNode* styleSheet,
1243     BSTR* xmlString)
1244 {
1245 #ifdef SONAME_LIBXSLT
1246     xmlnode *This = impl_from_IXMLDOMNode( iface );
1247     xmlnode *pStyleSheet = NULL;
1248     xsltStylesheetPtr xsltSS = NULL;
1249     xmlDocPtr result = NULL;
1250     IXMLDOMNode *ssNew;
1251
1252     TRACE("%p %p %p\n", This, styleSheet, xmlString);
1253
1254     if (!libxslt_handle)
1255         return E_NOTIMPL;
1256     if(!styleSheet || !xmlString)
1257         return E_INVALIDARG;
1258
1259     *xmlString = NULL;
1260
1261     if(IXMLDOMNode_QueryInterface(styleSheet, &IID_IXMLDOMNode, (LPVOID)&ssNew) == S_OK)
1262     {
1263         pStyleSheet = impl_from_IXMLDOMNode( ssNew );
1264
1265         xsltSS = pxsltParseStylesheetDoc( pStyleSheet->node->doc);
1266         if(xsltSS)
1267         {
1268             result = pxsltApplyStylesheet(xsltSS, This->node->doc, NULL);
1269             if(result)
1270             {
1271                 const xmlChar *pContent;
1272
1273                 if(result->type == XML_HTML_DOCUMENT_NODE)
1274                 {
1275                     xmlOutputBufferPtr  pOutput = xmlAllocOutputBuffer(NULL);
1276                     if(pOutput)
1277                     {
1278                         htmlDocContentDumpOutput(pOutput, result->doc, NULL);
1279                         pContent = xmlBufferContent(pOutput->buffer);
1280                         *xmlString = bstr_from_xmlChar(pContent);
1281                         xmlOutputBufferClose(pOutput);
1282                     }
1283                 }
1284                 else
1285                 {
1286                     xmlBufferPtr pXmlBuf;
1287                     int nSize;
1288
1289                     pXmlBuf = xmlBufferCreate();
1290                     if(pXmlBuf)
1291                     {
1292                         nSize = xmlNodeDump(pXmlBuf, NULL, (xmlNodePtr)result, 0, 0);
1293                         if(nSize > 0)
1294                         {
1295                             pContent = xmlBufferContent(pXmlBuf);
1296                             *xmlString = bstr_from_xmlChar(pContent);
1297                         }
1298                         xmlBufferFree(pXmlBuf);
1299                     }
1300                 }
1301                 xmlFreeDoc(result);
1302             }
1303             /* libxslt "helpfully" frees the XML document the stylesheet was
1304                generated from, too */
1305             xsltSS->doc = NULL;
1306             pxsltFreeStylesheet(xsltSS);
1307         }
1308
1309         IXMLDOMNode_Release(ssNew);
1310     }
1311
1312     if(*xmlString == NULL)
1313         *xmlString = SysAllocStringLen(NULL, 0);
1314
1315     return S_OK;
1316 #else
1317     FIXME("libxslt headers were not found at compile time\n");
1318     return E_NOTIMPL;
1319 #endif
1320 }
1321
1322 static HRESULT WINAPI xmlnode_selectNodes(
1323     IXMLDOMNode *iface,
1324     BSTR queryString,
1325     IXMLDOMNodeList** resultList)
1326 {
1327     xmlnode *This = impl_from_IXMLDOMNode( iface );
1328
1329     TRACE("%p %s %p\n", This, debugstr_w(queryString), resultList );
1330
1331     return queryresult_create( This->node, queryString, resultList );
1332 }
1333
1334 static HRESULT WINAPI xmlnode_selectSingleNode(
1335     IXMLDOMNode *iface,
1336     BSTR queryString,
1337     IXMLDOMNode** resultNode)
1338 {
1339     xmlnode *This = impl_from_IXMLDOMNode( iface );
1340     IXMLDOMNodeList *list;
1341     HRESULT r;
1342
1343     TRACE("%p %s %p\n", This, debugstr_w(queryString), resultNode );
1344
1345     *resultNode = NULL;
1346     r = IXMLDOMNode_selectNodes(iface, queryString, &list);
1347     if(r == S_OK)
1348     {
1349         r = IXMLDOMNodeList_nextNode(list, resultNode);
1350         IXMLDOMNodeList_Release(list);
1351     }
1352     return r;
1353 }
1354
1355 static HRESULT WINAPI xmlnode_get_parsed(
1356     IXMLDOMNode *iface,
1357     VARIANT_BOOL* isParsed)
1358 {
1359     FIXME("\n");
1360     return E_NOTIMPL;
1361 }
1362
1363 static HRESULT WINAPI xmlnode_get_namespaceURI(
1364     IXMLDOMNode *iface,
1365     BSTR* namespaceURI)
1366 {
1367     xmlnode *This = impl_from_IXMLDOMNode( iface );
1368     HRESULT hr = S_FALSE;
1369     xmlNsPtr *pNSList;
1370
1371     TRACE("%p %p\n", This, namespaceURI );
1372
1373     if(!namespaceURI)
1374         return E_INVALIDARG;
1375
1376     *namespaceURI = NULL;
1377
1378     pNSList = xmlGetNsList(This->node->doc, This->node);
1379     if(pNSList)
1380     {
1381         *namespaceURI = bstr_from_xmlChar( pNSList[0]->href );
1382
1383         xmlFree( pNSList );
1384         hr = S_OK;
1385     }
1386
1387     return hr;
1388 }
1389
1390 static HRESULT WINAPI xmlnode_get_prefix(
1391     IXMLDOMNode *iface,
1392     BSTR* prefixString)
1393 {
1394     xmlnode *This = impl_from_IXMLDOMNode( iface );
1395     HRESULT hr = S_FALSE;
1396     xmlNsPtr *pNSList;
1397
1398     TRACE("%p %p\n", This, prefixString );
1399
1400     if(!prefixString)
1401         return E_INVALIDARG;
1402
1403     *prefixString = NULL;
1404
1405     pNSList = xmlGetNsList(This->node->doc, This->node);
1406     if(pNSList)
1407     {
1408         *prefixString = bstr_from_xmlChar( pNSList[0]->prefix );
1409
1410         xmlFree(pNSList);
1411         hr = S_OK;
1412     }
1413
1414     return hr;
1415 }
1416
1417 static HRESULT WINAPI xmlnode_get_baseName(
1418     IXMLDOMNode *iface,
1419     BSTR* nameString)
1420 {
1421     xmlnode *This = impl_from_IXMLDOMNode( iface );
1422     BSTR str = NULL;
1423     HRESULT r = S_FALSE;
1424
1425     TRACE("%p %p\n", This, nameString );
1426
1427     if ( !nameString )
1428         return E_INVALIDARG;
1429
1430     switch ( This->node->type )
1431     {
1432     case XML_ELEMENT_NODE:
1433     case XML_ATTRIBUTE_NODE:
1434         str = bstr_from_xmlChar( This->node->name );
1435         r = S_OK;
1436         break;
1437     case XML_TEXT_NODE:
1438         break;
1439     default:
1440         ERR("Unhandled type %d\n", This->node->type );
1441         break;
1442     }
1443
1444     TRACE("returning %08x str = %s\n", r, debugstr_w( str ) );
1445
1446     *nameString = str;
1447     return r;
1448 }
1449
1450 static HRESULT WINAPI xmlnode_transformNodeToObject(
1451     IXMLDOMNode *iface,
1452     IXMLDOMNode* stylesheet,
1453     VARIANT outputObject)
1454 {
1455     FIXME("\n");
1456     return E_NOTIMPL;
1457 }
1458
1459 static const struct IXMLDOMNodeVtbl xmlnode_vtbl =
1460 {
1461     xmlnode_QueryInterface,
1462     xmlnode_AddRef,
1463     xmlnode_Release,
1464     xmlnode_GetTypeInfoCount,
1465     xmlnode_GetTypeInfo,
1466     xmlnode_GetIDsOfNames,
1467     xmlnode_Invoke,
1468     xmlnode_get_nodeName,
1469     xmlnode_get_nodeValue,
1470     xmlnode_put_nodeValue,
1471     xmlnode_get_nodeType,
1472     xmlnode_get_parentNode,
1473     xmlnode_get_childNodes,
1474     xmlnode_get_firstChild,
1475     xmlnode_get_lastChild,
1476     xmlnode_get_previousSibling,
1477     xmlnode_get_nextSibling,
1478     xmlnode_get_attributes,
1479     xmlnode_insertBefore,
1480     xmlnode_replaceChild,
1481     xmlnode_removeChild,
1482     xmlnode_appendChild,
1483     xmlnode_hasChildNodes,
1484     xmlnode_get_ownerDocument,
1485     xmlnode_cloneNode,
1486     xmlnode_get_nodeTypeString,
1487     xmlnode_get_text,
1488     xmlnode_put_text,
1489     xmlnode_get_specified,
1490     xmlnode_get_definition,
1491     xmlnode_get_nodeTypedValue,
1492     xmlnode_put_nodeTypedValue,
1493     xmlnode_get_dataType,
1494     xmlnode_put_dataType,
1495     xmlnode_get_xml,
1496     xmlnode_transformNode,
1497     xmlnode_selectNodes,
1498     xmlnode_selectSingleNode,
1499     xmlnode_get_parsed,
1500     xmlnode_get_namespaceURI,
1501     xmlnode_get_prefix,
1502     xmlnode_get_baseName,
1503     xmlnode_transformNodeToObject,
1504 };
1505
1506 static HRESULT WINAPI Internal_QueryInterface(
1507     IUnknown *iface,
1508     REFIID riid,
1509     void** ppvObject )
1510 {
1511     xmlnode *This = impl_from_InternalUnknown( iface );
1512
1513     TRACE("%p %s %p\n", iface, debugstr_guid(riid), ppvObject);
1514
1515
1516     if ( IsEqualGUID( riid, &IID_IUnknown ))
1517         *ppvObject = iface;
1518     else if ( IsEqualGUID( riid, &IID_IDispatch ) ||
1519               IsEqualGUID( riid, &IID_IXMLDOMNode ) )
1520         *ppvObject = &This->lpVtbl;
1521     else
1522     {
1523         FIXME("interface %s not implemented\n", debugstr_guid(riid));
1524         *ppvObject = NULL;
1525         return E_NOINTERFACE;
1526     }
1527
1528     IUnknown_AddRef( (IUnknown*)*ppvObject );
1529
1530     return S_OK;
1531 }
1532
1533 static ULONG WINAPI Internal_AddRef(
1534                  IUnknown *iface )
1535 {
1536     xmlnode *This = impl_from_InternalUnknown( iface );
1537     return InterlockedIncrement( &This->ref );
1538 }
1539
1540 static ULONG WINAPI Internal_Release(
1541     IUnknown *iface )
1542 {
1543     xmlnode *This = impl_from_InternalUnknown( iface );
1544     ULONG ref;
1545
1546     ref = InterlockedDecrement( &This->ref );
1547     if ( ref == 0 )
1548     {
1549         if( This->node )
1550             xmldoc_release( This->node->doc );
1551         HeapFree( GetProcessHeap(), 0, This );
1552     }
1553
1554     return ref;
1555 }
1556
1557 static const struct IUnknownVtbl internal_unk_vtbl =
1558 {
1559     Internal_QueryInterface,
1560     Internal_AddRef,
1561     Internal_Release
1562 };
1563
1564 IUnknown *create_basic_node( xmlNodePtr node, IUnknown *pUnkOuter )
1565 {
1566     xmlnode *This;
1567
1568     This = HeapAlloc( GetProcessHeap(), 0, sizeof *This );
1569     if ( !This )
1570         return NULL;
1571
1572     if(node)
1573         xmldoc_add_ref( node->doc );
1574
1575     This->lpVtbl = &xmlnode_vtbl;
1576     This->lpInternalUnkVtbl = &internal_unk_vtbl;
1577
1578     if(pUnkOuter)
1579         This->pUnkOuter = pUnkOuter; /* Don't take a ref on outer Unknown */
1580     else
1581         This->pUnkOuter = (IUnknown *)&This->lpInternalUnkVtbl;
1582
1583     This->ref = 1;
1584     This->node = node;
1585
1586     return (IUnknown*)&This->lpInternalUnkVtbl;
1587 }
1588
1589 IXMLDOMNode *create_node( xmlNodePtr node )
1590 {
1591     IUnknown *pUnk;
1592     IXMLDOMNode *ret;
1593     HRESULT hr;
1594
1595     if ( !node )
1596         return NULL;
1597
1598     TRACE("type %d\n", node->type);
1599     switch(node->type)
1600     {
1601     case XML_ELEMENT_NODE:
1602         pUnk = create_element( node, NULL );
1603         break;
1604     case XML_ATTRIBUTE_NODE:
1605         pUnk = create_attribute( node );
1606         break;
1607     case XML_TEXT_NODE:
1608         pUnk = create_text( node );
1609         break;
1610     case XML_CDATA_SECTION_NODE:
1611         pUnk = create_cdata( node );
1612         break;
1613     case XML_COMMENT_NODE:
1614         pUnk = create_comment( node );
1615         break;
1616     case XML_DOCUMENT_NODE:
1617         pUnk = create_domdoc( node );
1618         break;
1619     default:
1620         FIXME("only creating basic node for type %d\n", node->type);
1621         pUnk = create_basic_node( node, NULL );
1622     }
1623
1624     hr = IUnknown_QueryInterface(pUnk, &IID_IXMLDOMNode, (LPVOID*)&ret);
1625     IUnknown_Release(pUnk);
1626     if(FAILED(hr)) return NULL;
1627     return ret;
1628 }
1629 #endif