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