mshtml: Use jscript.dll for JavaScript for all zones except untrusted.
[wine] / dlls / mshtml / htmlnode.c
1 /*
2  * Copyright 2006 Jacek Caban for CodeWeavers
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include <stdarg.h>
20
21 #define COBJMACROS
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winuser.h"
26 #include "ole2.h"
27
28 #include "wine/debug.h"
29
30 #include "mshtml_private.h"
31 #include "htmlevent.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
34
35 static HTMLDOMNode *get_node_obj(HTMLDocumentNode*,IUnknown*);
36 static HRESULT create_node(HTMLDocumentNode*,nsIDOMNode*,HTMLDOMNode**);
37
38 typedef struct {
39     DispatchEx dispex;
40     IHTMLDOMChildrenCollection IHTMLDOMChildrenCollection_iface;
41
42     LONG ref;
43
44     /* FIXME: implement weak reference */
45     HTMLDocumentNode *doc;
46
47     nsIDOMNodeList *nslist;
48 } HTMLDOMChildrenCollection;
49
50 static inline HTMLDOMChildrenCollection *impl_from_IHTMLDOMChildrenCollection(IHTMLDOMChildrenCollection *iface)
51 {
52     return CONTAINING_RECORD(iface, HTMLDOMChildrenCollection, IHTMLDOMChildrenCollection_iface);
53 }
54
55 static HRESULT WINAPI HTMLDOMChildrenCollection_QueryInterface(IHTMLDOMChildrenCollection *iface, REFIID riid, void **ppv)
56 {
57     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
58
59     *ppv = NULL;
60
61     if(IsEqualGUID(&IID_IUnknown, riid)) {
62         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
63         *ppv = &This->IHTMLDOMChildrenCollection_iface;
64     }else if(IsEqualGUID(&IID_IHTMLDOMChildrenCollection, riid)) {
65         TRACE("(%p)->(IID_IHTMLDOMChildrenCollection %p)\n", This, ppv);
66         *ppv = &This->IHTMLDOMChildrenCollection_iface;
67     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
68         return *ppv ? S_OK : E_NOINTERFACE;
69     }
70
71     if(*ppv) {
72         IUnknown_AddRef((IUnknown*)*ppv);
73         return S_OK;
74     }
75
76     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
77     return E_NOINTERFACE;
78 }
79
80 static ULONG WINAPI HTMLDOMChildrenCollection_AddRef(IHTMLDOMChildrenCollection *iface)
81 {
82     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
83     LONG ref = InterlockedIncrement(&This->ref);
84
85     TRACE("(%p) ref=%d\n", This, ref);
86
87     return ref;
88 }
89
90 static ULONG WINAPI HTMLDOMChildrenCollection_Release(IHTMLDOMChildrenCollection *iface)
91 {
92     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
93     LONG ref = InterlockedDecrement(&This->ref);
94
95     TRACE("(%p) ref=%d\n", This, ref);
96
97     if(!ref) {
98         nsIDOMNodeList_Release(This->nslist);
99         heap_free(This);
100     }
101
102     return ref;
103 }
104
105 static HRESULT WINAPI HTMLDOMChildrenCollection_GetTypeInfoCount(IHTMLDOMChildrenCollection *iface, UINT *pctinfo)
106 {
107     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
108     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
109 }
110
111 static HRESULT WINAPI HTMLDOMChildrenCollection_GetTypeInfo(IHTMLDOMChildrenCollection *iface, UINT iTInfo,
112         LCID lcid, ITypeInfo **ppTInfo)
113 {
114     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
115     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
116 }
117
118 static HRESULT WINAPI HTMLDOMChildrenCollection_GetIDsOfNames(IHTMLDOMChildrenCollection *iface, REFIID riid,
119         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
120 {
121     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
122     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
123             lcid, rgDispId);
124 }
125
126 static HRESULT WINAPI HTMLDOMChildrenCollection_Invoke(IHTMLDOMChildrenCollection *iface, DISPID dispIdMember,
127         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
128         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
129 {
130     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
131     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
132             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
133 }
134
135 static HRESULT WINAPI HTMLDOMChildrenCollection_get_length(IHTMLDOMChildrenCollection *iface, LONG *p)
136 {
137     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
138     PRUint32 length=0;
139
140     TRACE("(%p)->(%p)\n", This, p);
141
142     nsIDOMNodeList_GetLength(This->nslist, &length);
143     *p = length;
144     return S_OK;
145 }
146
147 static HRESULT WINAPI HTMLDOMChildrenCollection__newEnum(IHTMLDOMChildrenCollection *iface, IUnknown **p)
148 {
149     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
150     FIXME("(%p)->(%p)\n", This, p);
151     return E_NOTIMPL;
152 }
153
154 static HRESULT WINAPI HTMLDOMChildrenCollection_item(IHTMLDOMChildrenCollection *iface, LONG index, IDispatch **ppItem)
155 {
156     HTMLDOMChildrenCollection *This = impl_from_IHTMLDOMChildrenCollection(iface);
157     nsIDOMNode *nsnode = NULL;
158     HTMLDOMNode *node;
159     PRUint32 length=0;
160     nsresult nsres;
161     HRESULT hres;
162
163     TRACE("(%p)->(%d %p)\n", This, index, ppItem);
164
165     if (ppItem)
166         *ppItem = NULL;
167     else
168         return E_POINTER;
169
170     nsIDOMNodeList_GetLength(This->nslist, &length);
171     if(index < 0 || index >= length)
172         return E_INVALIDARG;
173
174     nsres = nsIDOMNodeList_Item(This->nslist, index, &nsnode);
175     if(NS_FAILED(nsres) || !nsnode) {
176         ERR("Item failed: %08x\n", nsres);
177         return E_FAIL;
178     }
179
180     hres = get_node(This->doc, nsnode, TRUE, &node);
181     if(FAILED(hres))
182         return hres;
183
184     *ppItem = (IDispatch*)&node->IHTMLDOMNode_iface;
185     IDispatch_AddRef(*ppItem);
186     return S_OK;
187 }
188
189 static const IHTMLDOMChildrenCollectionVtbl HTMLDOMChildrenCollectionVtbl = {
190     HTMLDOMChildrenCollection_QueryInterface,
191     HTMLDOMChildrenCollection_AddRef,
192     HTMLDOMChildrenCollection_Release,
193     HTMLDOMChildrenCollection_GetTypeInfoCount,
194     HTMLDOMChildrenCollection_GetTypeInfo,
195     HTMLDOMChildrenCollection_GetIDsOfNames,
196     HTMLDOMChildrenCollection_Invoke,
197     HTMLDOMChildrenCollection_get_length,
198     HTMLDOMChildrenCollection__newEnum,
199     HTMLDOMChildrenCollection_item
200 };
201
202 static inline HTMLDOMChildrenCollection *impl_from_DispatchEx(DispatchEx *iface)
203 {
204     return CONTAINING_RECORD(iface, HTMLDOMChildrenCollection, dispex);
205 }
206
207 #define DISPID_CHILDCOL_0 MSHTML_DISPID_CUSTOM_MIN
208
209 static HRESULT HTMLDOMChildrenCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
210 {
211     HTMLDOMChildrenCollection *This = impl_from_DispatchEx(dispex);
212     WCHAR *ptr;
213     DWORD idx=0;
214     PRUint32 len = 0;
215
216     for(ptr = name; *ptr && isdigitW(*ptr); ptr++)
217         idx = idx*10 + (*ptr-'0');
218     if(*ptr)
219         return DISP_E_UNKNOWNNAME;
220
221     nsIDOMNodeList_GetLength(This->nslist, &len);
222     if(idx >= len)
223         return DISP_E_UNKNOWNNAME;
224
225     *dispid = DISPID_CHILDCOL_0 + idx;
226     TRACE("ret %x\n", *dispid);
227     return S_OK;
228 }
229
230 static HRESULT HTMLDOMChildrenCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
231         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
232 {
233     HTMLDOMChildrenCollection *This = impl_from_DispatchEx(dispex);
234
235     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, flags, params, res, ei, caller);
236
237     switch(flags) {
238     case DISPATCH_PROPERTYGET: {
239         IDispatch *disp = NULL;
240         HRESULT hres;
241
242         hres = IHTMLDOMChildrenCollection_item(&This->IHTMLDOMChildrenCollection_iface,
243                 id - DISPID_CHILDCOL_0, &disp);
244         if(FAILED(hres))
245             return hres;
246
247         V_VT(res) = VT_DISPATCH;
248         V_DISPATCH(res) = disp;
249         break;
250     }
251
252     default:
253         FIXME("unimplemented flags %x\n", flags);
254         return E_NOTIMPL;
255     }
256
257     return S_OK;
258 }
259
260 static const dispex_static_data_vtbl_t HTMLDOMChildrenCollection_dispex_vtbl = {
261     NULL,
262     HTMLDOMChildrenCollection_get_dispid,
263     HTMLDOMChildrenCollection_invoke,
264     NULL
265 };
266
267 static const tid_t HTMLDOMChildrenCollection_iface_tids[] = {
268     IHTMLDOMChildrenCollection_tid,
269     0
270 };
271
272 static dispex_static_data_t HTMLDOMChildrenCollection_dispex = {
273     &HTMLDOMChildrenCollection_dispex_vtbl,
274     DispDOMChildrenCollection_tid,
275     NULL,
276     HTMLDOMChildrenCollection_iface_tids
277 };
278
279 static IHTMLDOMChildrenCollection *create_child_collection(HTMLDocumentNode *doc, nsIDOMNodeList *nslist)
280 {
281     HTMLDOMChildrenCollection *ret;
282
283     ret = heap_alloc_zero(sizeof(*ret));
284     ret->IHTMLDOMChildrenCollection_iface.lpVtbl = &HTMLDOMChildrenCollectionVtbl;
285     ret->ref = 1;
286
287     nsIDOMNodeList_AddRef(nslist);
288     ret->nslist = nslist;
289     ret->doc = doc;
290
291     init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLDOMChildrenCollection_iface,
292             &HTMLDOMChildrenCollection_dispex);
293
294     return &ret->IHTMLDOMChildrenCollection_iface;
295 }
296
297 static inline HTMLDOMNode *impl_from_IHTMLDOMNode(IHTMLDOMNode *iface)
298 {
299     return CONTAINING_RECORD(iface, HTMLDOMNode, IHTMLDOMNode_iface);
300 }
301
302 static HRESULT WINAPI HTMLDOMNode_QueryInterface(IHTMLDOMNode *iface,
303                                                  REFIID riid, void **ppv)
304 {
305     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
306
307     return This->vtbl->qi(This, riid, ppv);
308 }
309
310 static ULONG WINAPI HTMLDOMNode_AddRef(IHTMLDOMNode *iface)
311 {
312     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
313     LONG ref = InterlockedIncrement(&This->ref);
314
315     TRACE("(%p) ref=%d\n", This, ref);
316
317     return ref;
318 }
319
320 static ULONG WINAPI HTMLDOMNode_Release(IHTMLDOMNode *iface)
321 {
322     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
323     LONG ref = InterlockedDecrement(&This->ref);
324
325     TRACE("(%p) ref=%d\n", This, ref);
326
327     if(!ref) {
328         This->vtbl->destructor(This);
329         release_dispex(&This->dispex);
330         heap_free(This);
331     }
332
333     return ref;
334 }
335
336 static HRESULT WINAPI HTMLDOMNode_GetTypeInfoCount(IHTMLDOMNode *iface, UINT *pctinfo)
337 {
338     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
339     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
340 }
341
342 static HRESULT WINAPI HTMLDOMNode_GetTypeInfo(IHTMLDOMNode *iface, UINT iTInfo,
343                                               LCID lcid, ITypeInfo **ppTInfo)
344 {
345     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
346     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
347 }
348
349 static HRESULT WINAPI HTMLDOMNode_GetIDsOfNames(IHTMLDOMNode *iface, REFIID riid,
350                                                 LPOLESTR *rgszNames, UINT cNames,
351                                                 LCID lcid, DISPID *rgDispId)
352 {
353     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
354     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
355             lcid, rgDispId);
356 }
357
358 static HRESULT WINAPI HTMLDOMNode_Invoke(IHTMLDOMNode *iface, DISPID dispIdMember,
359                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
360                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
361 {
362     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
363     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
364             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
365 }
366
367 static HRESULT WINAPI HTMLDOMNode_get_nodeType(IHTMLDOMNode *iface, LONG *p)
368 {
369     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
370     PRUint16 type = -1;
371
372     TRACE("(%p)->(%p)\n", This, p);
373
374     nsIDOMNode_GetNodeType(This->nsnode, &type);
375
376     switch(type) {
377     case ELEMENT_NODE:
378         *p = 1;
379         break;
380     case TEXT_NODE:
381         *p = 3;
382         break;
383     case COMMENT_NODE:
384         *p = 8;
385         break;
386     case DOCUMENT_NODE:
387         *p = 9;
388         break;
389     case DOCUMENT_FRAGMENT_NODE:
390         *p = 11;
391         break;
392     default:
393         /*
394          * FIXME:
395          * According to MSDN only ELEMENT_NODE and TEXT_NODE are supported.
396          * It needs more tests.
397          */
398         FIXME("type %u\n", type);
399         *p = 0;
400     }
401
402     return S_OK;
403 }
404
405 static HRESULT WINAPI HTMLDOMNode_get_parentNode(IHTMLDOMNode *iface, IHTMLDOMNode **p)
406 {
407     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
408     HTMLDOMNode *node;
409     nsIDOMNode *nsnode;
410     nsresult nsres;
411     HRESULT hres;
412
413     TRACE("(%p)->(%p)\n", This, p);
414
415     nsres = nsIDOMNode_GetParentNode(This->nsnode, &nsnode);
416     if(NS_FAILED(nsres)) {
417         ERR("GetParentNode failed: %08x\n", nsres);
418         return E_FAIL;
419     }
420
421     if(!nsnode) {
422         *p = NULL;
423         return S_OK;
424     }
425
426     hres = get_node(This->doc, nsnode, TRUE, &node);
427     nsIDOMNode_Release(nsnode);
428     if(FAILED(hres))
429         return hres;
430
431     *p = &node->IHTMLDOMNode_iface;
432     IHTMLDOMNode_AddRef(*p);
433     return S_OK;
434 }
435
436 static HRESULT WINAPI HTMLDOMNode_hasChildNodes(IHTMLDOMNode *iface, VARIANT_BOOL *fChildren)
437 {
438     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
439     cpp_bool has_child = FALSE;
440     nsresult nsres;
441
442     TRACE("(%p)->(%p)\n", This, fChildren);
443
444     nsres = nsIDOMNode_HasChildNodes(This->nsnode, &has_child);
445     if(NS_FAILED(nsres))
446         ERR("HasChildNodes failed: %08x\n", nsres);
447
448     *fChildren = has_child ? VARIANT_TRUE : VARIANT_FALSE;
449     return S_OK;
450 }
451
452 static HRESULT WINAPI HTMLDOMNode_get_childNodes(IHTMLDOMNode *iface, IDispatch **p)
453 {
454     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
455     nsIDOMNodeList *nslist;
456     nsresult nsres;
457
458     TRACE("(%p)->(%p)\n", This, p);
459
460     nsres = nsIDOMNode_GetChildNodes(This->nsnode, &nslist);
461     if(NS_FAILED(nsres)) {
462         ERR("GetChildNodes failed: %08x\n", nsres);
463         return E_FAIL;
464     }
465
466     *p = (IDispatch*)create_child_collection(This->doc, nslist);
467     nsIDOMNodeList_Release(nslist);
468
469     return S_OK;
470 }
471
472 static HRESULT WINAPI HTMLDOMNode_get_attributes(IHTMLDOMNode *iface, IDispatch **p)
473 {
474     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
475     HTMLAttributeCollection *col;
476     HRESULT hres;
477
478     TRACE("(%p)->(%p)\n", This, p);
479
480     if(This->vtbl->get_attr_col) {
481         hres = This->vtbl->get_attr_col(This, &col);
482         if(FAILED(hres))
483             return hres;
484
485         *p = (IDispatch*)&col->IHTMLAttributeCollection_iface;
486         return S_OK;
487     }
488
489     *p = NULL;
490     return S_OK;
491 }
492
493 static HRESULT WINAPI HTMLDOMNode_insertBefore(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
494                                                VARIANT refChild, IHTMLDOMNode **node)
495 {
496     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
497     nsIDOMNode *nsnode, *nsref = NULL;
498     HTMLDOMNode *new_child;
499     HTMLDOMNode *node_obj;
500     nsresult nsres;
501     HRESULT hres;
502
503     TRACE("(%p)->(%p %s %p)\n", This, newChild, debugstr_variant(&refChild), node);
504
505     new_child = get_node_obj(This->doc, (IUnknown*)newChild);
506     if(!new_child) {
507         ERR("invalid newChild\n");
508         return E_INVALIDARG;
509     }
510
511     switch(V_VT(&refChild)) {
512     case VT_NULL:
513         break;
514     case VT_DISPATCH: {
515         HTMLDOMNode *ref_node;
516
517         ref_node = get_node_obj(This->doc, (IUnknown*)V_DISPATCH(&refChild));
518         if(!ref_node) {
519             ERR("unvalid node\n");
520             return E_FAIL;
521         }
522
523         nsref = ref_node->nsnode;
524         break;
525     }
526     default:
527         FIXME("unimplemented vt %d\n", V_VT(&refChild));
528         return E_NOTIMPL;
529     }
530
531     nsres = nsIDOMNode_InsertBefore(This->nsnode, new_child->nsnode, nsref, &nsnode);
532     if(NS_FAILED(nsres)) {
533         ERR("InsertBefore failed: %08x\n", nsres);
534         return E_FAIL;
535     }
536
537     hres = get_node(This->doc, nsnode, TRUE, &node_obj);
538     nsIDOMNode_Release(nsnode);
539     if(FAILED(hres))
540         return hres;
541
542     *node = &node_obj->IHTMLDOMNode_iface;
543     IHTMLDOMNode_AddRef(*node);
544     return S_OK;
545 }
546
547 static HRESULT WINAPI HTMLDOMNode_removeChild(IHTMLDOMNode *iface, IHTMLDOMNode *oldChild,
548                                               IHTMLDOMNode **node)
549 {
550     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
551     HTMLDOMNode *node_obj;
552     nsIDOMNode *nsnode;
553     nsresult nsres;
554     HRESULT hres;
555
556     TRACE("(%p)->(%p %p)\n", This, oldChild, node);
557
558     node_obj = get_node_obj(This->doc, (IUnknown*)oldChild);
559     if(!node_obj)
560         return E_FAIL;
561
562     nsres = nsIDOMNode_RemoveChild(This->nsnode, node_obj->nsnode, &nsnode);
563     if(NS_FAILED(nsres)) {
564         ERR("RemoveChild failed: %08x\n", nsres);
565         return E_FAIL;
566     }
567
568     hres = get_node(This->doc, nsnode, TRUE, &node_obj);
569     nsIDOMNode_Release(nsnode);
570     if(FAILED(hres))
571         return hres;
572
573     /* FIXME: Make sure that node != newChild */
574     *node = &node_obj->IHTMLDOMNode_iface;
575     IHTMLDOMNode_AddRef(*node);
576     return S_OK;
577 }
578
579 static HRESULT WINAPI HTMLDOMNode_replaceChild(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
580                                                IHTMLDOMNode *oldChild, IHTMLDOMNode **node)
581 {
582     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
583     HTMLDOMNode *node_new;
584     HTMLDOMNode *node_old;
585     nsIDOMNode *nsnode;
586     nsresult nsres;
587     HRESULT hres;
588
589     TRACE("(%p)->(%p %p %p)\n", This, newChild, oldChild, node);
590
591     node_new = get_node_obj(This->doc, (IUnknown*)newChild);
592     if(!node_new)
593         return E_FAIL;
594
595     node_old = get_node_obj(This->doc, (IUnknown*)oldChild);
596     if(!node_old)
597         return E_FAIL;
598
599     nsres = nsIDOMNode_ReplaceChild(This->nsnode, node_new->nsnode, node_old->nsnode, &nsnode);
600     if(NS_FAILED(nsres)) {
601         return E_FAIL;
602     }
603
604     nsnode = node_new->nsnode;
605
606     hres = get_node(This->doc, nsnode, TRUE, &node_new);
607     nsIDOMNode_Release(nsnode);
608     if(FAILED(hres))
609         return hres;
610
611     *node = &node_new->IHTMLDOMNode_iface;
612     IHTMLDOMNode_AddRef(*node);
613     return S_OK;
614 }
615
616 static HRESULT WINAPI HTMLDOMNode_cloneNode(IHTMLDOMNode *iface, VARIANT_BOOL fDeep,
617                                             IHTMLDOMNode **clonedNode)
618 {
619     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
620     HTMLDOMNode *new_node;
621     nsIDOMNode *nsnode;
622     nsresult nsres;
623     HRESULT hres;
624
625     TRACE("(%p)->(%x %p)\n", This, fDeep, clonedNode);
626
627     nsres = nsIDOMNode_CloneNode(This->nsnode, fDeep != VARIANT_FALSE, &nsnode);
628     if(NS_FAILED(nsres) || !nsnode) {
629         ERR("CloneNode failed: %08x\n", nsres);
630         return E_FAIL;
631     }
632
633     hres = This->vtbl->clone(This, nsnode, &new_node);
634     if(FAILED(hres))
635         return hres;
636
637     *clonedNode = &new_node->IHTMLDOMNode_iface;
638     return S_OK;
639 }
640
641 static HRESULT WINAPI HTMLDOMNode_removeNode(IHTMLDOMNode *iface, VARIANT_BOOL fDeep,
642                                              IHTMLDOMNode **removed)
643 {
644     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
645     FIXME("(%p)->(%x %p)\n", This, fDeep, removed);
646     return E_NOTIMPL;
647 }
648
649 static HRESULT WINAPI HTMLDOMNode_swapNode(IHTMLDOMNode *iface, IHTMLDOMNode *otherNode,
650                                            IHTMLDOMNode **swappedNode)
651 {
652     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
653     FIXME("(%p)->(%p %p)\n", This, otherNode, swappedNode);
654     return E_NOTIMPL;
655 }
656
657 static HRESULT WINAPI HTMLDOMNode_replaceNode(IHTMLDOMNode *iface, IHTMLDOMNode *replacement,
658                                               IHTMLDOMNode **replaced)
659 {
660     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
661     FIXME("(%p)->(%p %p)\n", This, replacement, replaced);
662     return E_NOTIMPL;
663 }
664
665 static HRESULT WINAPI HTMLDOMNode_appendChild(IHTMLDOMNode *iface, IHTMLDOMNode *newChild,
666                                               IHTMLDOMNode **node)
667 {
668     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
669     HTMLDOMNode *node_obj;
670     nsIDOMNode *nsnode;
671     nsresult nsres;
672     HRESULT hres;
673
674     TRACE("(%p)->(%p %p)\n", This, newChild, node);
675
676     node_obj = get_node_obj(This->doc, (IUnknown*)newChild);
677     if(!node_obj)
678         return E_FAIL;
679
680     nsres = nsIDOMNode_AppendChild(This->nsnode, node_obj->nsnode, &nsnode);
681     if(NS_FAILED(nsres)) {
682         WARN("AppendChild failed: %08x\n", nsres);
683         nsnode = node_obj->nsnode;
684     }
685
686     hres = get_node(This->doc, nsnode, TRUE, &node_obj);
687     nsIDOMNode_Release(nsnode);
688     if(FAILED(hres))
689         return hres;
690
691     /* FIXME: Make sure that node != newChild */
692     *node = &node_obj->IHTMLDOMNode_iface;
693     IHTMLDOMNode_AddRef(*node);
694     return S_OK;
695 }
696
697 static HRESULT WINAPI HTMLDOMNode_get_nodeName(IHTMLDOMNode *iface, BSTR *p)
698 {
699     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
700
701     TRACE("(%p)->(%p)\n", This, p);
702
703     *p = NULL;
704
705     if(This->nsnode) {
706         nsAString name_str;
707         const PRUnichar *name;
708         nsresult nsres;
709
710         nsAString_Init(&name_str, NULL);
711         nsres = nsIDOMNode_GetNodeName(This->nsnode, &name_str);
712
713         if(NS_SUCCEEDED(nsres)) {
714             nsAString_GetData(&name_str, &name);
715             *p = SysAllocString(name);
716         }else {
717             ERR("GetNodeName failed: %08x\n", nsres);
718         }
719
720         nsAString_Finish(&name_str);
721     }
722
723     return S_OK;
724 }
725
726 static HRESULT WINAPI HTMLDOMNode_put_nodeValue(IHTMLDOMNode *iface, VARIANT v)
727 {
728     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
729
730     TRACE("(%p)->()\n", This);
731
732     switch(V_VT(&v)) {
733     case VT_BSTR: {
734         nsAString val_str;
735
736         TRACE("bstr %s\n", debugstr_w(V_BSTR(&v)));
737
738         nsAString_InitDepend(&val_str, V_BSTR(&v));
739         nsIDOMNode_SetNodeValue(This->nsnode, &val_str);
740         nsAString_Finish(&val_str);
741
742         return S_OK;
743     }
744
745     default:
746         FIXME("unsupported vt %d\n", V_VT(&v));
747     }
748
749     return E_NOTIMPL;
750 }
751
752 static HRESULT WINAPI HTMLDOMNode_get_nodeValue(IHTMLDOMNode *iface, VARIANT *p)
753 {
754     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
755     const PRUnichar *val;
756     nsAString val_str;
757
758     TRACE("(%p)->(%p)\n", This, p);
759
760     nsAString_Init(&val_str, NULL);
761     nsIDOMNode_GetNodeValue(This->nsnode, &val_str);
762     nsAString_GetData(&val_str, &val);
763
764     if(*val) {
765         V_VT(p) = VT_BSTR;
766         V_BSTR(p) = SysAllocString(val);
767     }else {
768         V_VT(p) = VT_NULL;
769     }
770
771     nsAString_Finish(&val_str);
772
773     return S_OK;
774 }
775
776 static HRESULT WINAPI HTMLDOMNode_get_firstChild(IHTMLDOMNode *iface, IHTMLDOMNode **p)
777 {
778     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
779     nsIDOMNode *nschild = NULL;
780     HTMLDOMNode *node;
781     HRESULT hres;
782
783     TRACE("(%p)->(%p)\n", This, p);
784
785     nsIDOMNode_GetFirstChild(This->nsnode, &nschild);
786     if(!nschild) {
787         *p = NULL;
788         return S_OK;
789     }
790
791     hres = get_node(This->doc, nschild, TRUE, &node);
792     nsIDOMNode_Release(nschild);
793     if(FAILED(hres))
794         return hres;
795
796     *p = &node->IHTMLDOMNode_iface;
797     IHTMLDOMNode_AddRef(*p);
798     return S_OK;
799 }
800
801 static HRESULT WINAPI HTMLDOMNode_get_lastChild(IHTMLDOMNode *iface, IHTMLDOMNode **p)
802 {
803     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
804     nsIDOMNode *nschild = NULL;
805     HTMLDOMNode *node;
806     HRESULT hres;
807
808     TRACE("(%p)->(%p)\n", This, p);
809
810     nsIDOMNode_GetLastChild(This->nsnode, &nschild);
811     if(!nschild) {
812         *p = NULL;
813         return S_OK;
814     }
815
816     hres = get_node(This->doc, nschild, TRUE, &node);
817     nsIDOMNode_Release(nschild);
818     if(FAILED(hres))
819         return hres;
820
821     *p = &node->IHTMLDOMNode_iface;
822     IHTMLDOMNode_AddRef(*p);
823     return S_OK;
824 }
825
826 static HRESULT WINAPI HTMLDOMNode_get_previousSibling(IHTMLDOMNode *iface, IHTMLDOMNode **p)
827 {
828     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
829     nsIDOMNode *nschild = NULL;
830     HTMLDOMNode *node;
831     HRESULT hres;
832
833     TRACE("(%p)->(%p)\n", This, p);
834
835     nsIDOMNode_GetPreviousSibling(This->nsnode, &nschild);
836     if(!nschild) {
837         *p = NULL;
838         return S_OK;
839     }
840
841     hres = get_node(This->doc, nschild, TRUE, &node);
842     nsIDOMNode_Release(nschild);
843     if(FAILED(hres))
844         return hres;
845
846     *p = &node->IHTMLDOMNode_iface;
847     IHTMLDOMNode_AddRef(*p);
848     return S_OK;
849 }
850
851 static HRESULT WINAPI HTMLDOMNode_get_nextSibling(IHTMLDOMNode *iface, IHTMLDOMNode **p)
852 {
853     HTMLDOMNode *This = impl_from_IHTMLDOMNode(iface);
854     nsIDOMNode *nssibling = NULL;
855     HTMLDOMNode *node;
856     HRESULT hres;
857
858     TRACE("(%p)->(%p)\n", This, p);
859
860     nsIDOMNode_GetNextSibling(This->nsnode, &nssibling);
861     if(!nssibling) {
862         *p = NULL;
863         return S_OK;
864     }
865
866     hres = get_node(This->doc, nssibling, TRUE, &node);
867     nsIDOMNode_Release(nssibling);
868     if(FAILED(hres))
869         return hres;
870
871     *p = &node->IHTMLDOMNode_iface;
872     IHTMLDOMNode_AddRef(*p);
873     return S_OK;
874 }
875
876 static const IHTMLDOMNodeVtbl HTMLDOMNodeVtbl = {
877     HTMLDOMNode_QueryInterface,
878     HTMLDOMNode_AddRef,
879     HTMLDOMNode_Release,
880     HTMLDOMNode_GetTypeInfoCount,
881     HTMLDOMNode_GetTypeInfo,
882     HTMLDOMNode_GetIDsOfNames,
883     HTMLDOMNode_Invoke,
884     HTMLDOMNode_get_nodeType,
885     HTMLDOMNode_get_parentNode,
886     HTMLDOMNode_hasChildNodes,
887     HTMLDOMNode_get_childNodes,
888     HTMLDOMNode_get_attributes,
889     HTMLDOMNode_insertBefore,
890     HTMLDOMNode_removeChild,
891     HTMLDOMNode_replaceChild,
892     HTMLDOMNode_cloneNode,
893     HTMLDOMNode_removeNode,
894     HTMLDOMNode_swapNode,
895     HTMLDOMNode_replaceNode,
896     HTMLDOMNode_appendChild,
897     HTMLDOMNode_get_nodeName,
898     HTMLDOMNode_put_nodeValue,
899     HTMLDOMNode_get_nodeValue,
900     HTMLDOMNode_get_firstChild,
901     HTMLDOMNode_get_lastChild,
902     HTMLDOMNode_get_previousSibling,
903     HTMLDOMNode_get_nextSibling
904 };
905
906 static inline HTMLDOMNode *impl_from_IHTMLDOMNode2(IHTMLDOMNode2 *iface)
907 {
908     return CONTAINING_RECORD(iface, HTMLDOMNode, IHTMLDOMNode2_iface);
909 }
910
911 static HRESULT WINAPI HTMLDOMNode2_QueryInterface(IHTMLDOMNode2 *iface,
912         REFIID riid, void **ppv)
913 {
914     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
915
916     return IHTMLDOMNode_QueryInterface(&This->IHTMLDOMNode_iface, riid, ppv);
917 }
918
919 static ULONG WINAPI HTMLDOMNode2_AddRef(IHTMLDOMNode2 *iface)
920 {
921     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
922
923     return IHTMLDOMNode_AddRef(&This->IHTMLDOMNode_iface);
924 }
925
926 static ULONG WINAPI HTMLDOMNode2_Release(IHTMLDOMNode2 *iface)
927 {
928     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
929
930     return IHTMLDOMNode_Release(&This->IHTMLDOMNode_iface);
931 }
932
933 static HRESULT WINAPI HTMLDOMNode2_GetTypeInfoCount(IHTMLDOMNode2 *iface, UINT *pctinfo)
934 {
935     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
936     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
937 }
938
939 static HRESULT WINAPI HTMLDOMNode2_GetTypeInfo(IHTMLDOMNode2 *iface, UINT iTInfo,
940         LCID lcid, ITypeInfo **ppTInfo)
941 {
942     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
943     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
944 }
945
946 static HRESULT WINAPI HTMLDOMNode2_GetIDsOfNames(IHTMLDOMNode2 *iface, REFIID riid,
947                                                 LPOLESTR *rgszNames, UINT cNames,
948                                                 LCID lcid, DISPID *rgDispId)
949 {
950     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
951     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
952             lcid, rgDispId);
953 }
954
955 static HRESULT WINAPI HTMLDOMNode2_Invoke(IHTMLDOMNode2 *iface, DISPID dispIdMember,
956         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
957         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
958 {
959     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
960     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
961             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
962 }
963
964 static HRESULT WINAPI HTMLDOMNode2_get_ownerDocument(IHTMLDOMNode2 *iface, IDispatch **p)
965 {
966     HTMLDOMNode *This = impl_from_IHTMLDOMNode2(iface);
967
968     TRACE("(%p)->(%p)\n", This, p);
969
970     /* FIXME: Better check for document node */
971     if(This == &This->doc->node) {
972         *p = NULL;
973     }else {
974         *p = (IDispatch*)&This->doc->basedoc.IHTMLDocument2_iface;
975         IDispatch_AddRef(*p);
976     }
977     return S_OK;
978 }
979
980 static const IHTMLDOMNode2Vtbl HTMLDOMNode2Vtbl = {
981     HTMLDOMNode2_QueryInterface,
982     HTMLDOMNode2_AddRef,
983     HTMLDOMNode2_Release,
984     HTMLDOMNode2_GetTypeInfoCount,
985     HTMLDOMNode2_GetTypeInfo,
986     HTMLDOMNode2_GetIDsOfNames,
987     HTMLDOMNode2_Invoke,
988     HTMLDOMNode2_get_ownerDocument
989 };
990
991 HRESULT HTMLDOMNode_QI(HTMLDOMNode *This, REFIID riid, void **ppv)
992 {
993     *ppv = NULL;
994
995     if(IsEqualGUID(&IID_IUnknown, riid)) {
996         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
997         *ppv = &This->IHTMLDOMNode_iface;
998     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
999         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
1000         *ppv = &This->IHTMLDOMNode_iface;
1001     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
1002         if(This->dispex.data) {
1003             TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
1004             *ppv = &This->dispex.IDispatchEx_iface;
1005         }else {
1006             FIXME("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
1007             return E_NOINTERFACE;
1008         }
1009     }else if(IsEqualGUID(&IID_IHTMLDOMNode, riid)) {
1010         TRACE("(%p)->(IID_IHTMLDOMNode %p)\n", This, ppv);
1011         *ppv = &This->IHTMLDOMNode_iface;
1012     }else if(IsEqualGUID(&IID_IHTMLDOMNode2, riid)) {
1013         TRACE("(%p)->(IID_IHTMLDOMNode2 %p)\n", This, ppv);
1014         *ppv = &This->IHTMLDOMNode2_iface;
1015     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1016         return *ppv ? S_OK : E_NOINTERFACE;
1017     }
1018
1019     if(*ppv) {
1020         IUnknown_AddRef((IUnknown*)*ppv);
1021         return S_OK;
1022     }
1023
1024     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
1025     return E_NOINTERFACE;
1026 }
1027
1028 void HTMLDOMNode_destructor(HTMLDOMNode *This)
1029 {
1030     if(This->nsnode)
1031         nsIDOMNode_Release(This->nsnode);
1032     if(This->event_target)
1033         release_event_target(This->event_target);
1034 }
1035
1036 static HRESULT HTMLDOMNode_clone(HTMLDOMNode *This, nsIDOMNode *nsnode, HTMLDOMNode **ret)
1037 {
1038     HRESULT hres;
1039
1040     hres = create_node(This->doc, nsnode, ret);
1041     if(FAILED(hres))
1042         return hres;
1043
1044     IHTMLDOMNode_AddRef(&(*ret)->IHTMLDOMNode_iface);
1045     return S_OK;
1046 }
1047
1048 static const NodeImplVtbl HTMLDOMNodeImplVtbl = {
1049     HTMLDOMNode_QI,
1050     HTMLDOMNode_destructor,
1051     HTMLDOMNode_clone
1052 };
1053
1054 void HTMLDOMNode_Init(HTMLDocumentNode *doc, HTMLDOMNode *node, nsIDOMNode *nsnode)
1055 {
1056     node->IHTMLDOMNode_iface.lpVtbl = &HTMLDOMNodeVtbl;
1057     node->IHTMLDOMNode2_iface.lpVtbl = &HTMLDOMNode2Vtbl;
1058     node->ref = 1;
1059     node->doc = doc;
1060
1061     if(nsnode)
1062         nsIDOMNode_AddRef(nsnode);
1063     node->nsnode = nsnode;
1064
1065     node->next = doc->nodes;
1066     doc->nodes = node;
1067 }
1068
1069 static HRESULT create_node(HTMLDocumentNode *doc, nsIDOMNode *nsnode, HTMLDOMNode **ret)
1070 {
1071     PRUint16 node_type;
1072     HRESULT hres;
1073
1074     nsIDOMNode_GetNodeType(nsnode, &node_type);
1075
1076     switch(node_type) {
1077     case ELEMENT_NODE: {
1078         HTMLElement *elem;
1079         hres = HTMLElement_Create(doc, nsnode, FALSE, &elem);
1080         if(FAILED(hres))
1081             return hres;
1082         *ret = &elem->node;
1083         break;
1084     }
1085     case TEXT_NODE:
1086         hres = HTMLDOMTextNode_Create(doc, nsnode, ret);
1087         if(FAILED(hres))
1088             return hres;
1089         break;
1090     case COMMENT_NODE: {
1091         HTMLElement *comment;
1092         hres = HTMLCommentElement_Create(doc, nsnode, &comment);
1093         if(FAILED(hres))
1094             return hres;
1095         *ret = &comment->node;
1096         break;
1097     }
1098     case ATTRIBUTE_NODE:
1099         ERR("Called on attribute node\n");
1100         return E_UNEXPECTED;
1101     default: {
1102         HTMLDOMNode *node;
1103
1104         node = heap_alloc_zero(sizeof(HTMLDOMNode));
1105         if(!node)
1106             return E_OUTOFMEMORY;
1107
1108         node->vtbl = &HTMLDOMNodeImplVtbl;
1109         HTMLDOMNode_Init(doc, node, nsnode);
1110         *ret = node;
1111     }
1112     }
1113
1114     TRACE("type %d ret %p\n", node_type, *ret);
1115     return S_OK;
1116 }
1117
1118 /*
1119  * FIXME
1120  * List looks really ugly here. We should use a better data structure or
1121  * (better) find a way to store HTMLDOMelement pointer in nsIDOMNode.
1122  */
1123
1124 HRESULT get_node(HTMLDocumentNode *This, nsIDOMNode *nsnode, BOOL create, HTMLDOMNode **ret)
1125 {
1126     HTMLDOMNode *iter = This->nodes;
1127
1128     while(iter) {
1129         if(iter->nsnode == nsnode)
1130             break;
1131         iter = iter->next;
1132     }
1133
1134     if(iter || !create) {
1135         *ret = iter;
1136         return S_OK;
1137     }
1138
1139     return create_node(This, nsnode, ret);
1140 }
1141
1142 /*
1143  * FIXME
1144  * We should use better way for getting node object (like private interface)
1145  * or avoid it at all.
1146  */
1147 static HTMLDOMNode *get_node_obj(HTMLDocumentNode *This, IUnknown *iface)
1148 {
1149     HTMLDOMNode *iter = This->nodes;
1150     IHTMLDOMNode *node;
1151
1152     IUnknown_QueryInterface(iface, &IID_IHTMLDOMNode, (void**)&node);
1153     IHTMLDOMNode_Release(node);
1154
1155     while(iter) {
1156         if(&iter->IHTMLDOMNode_iface == node)
1157             return iter;
1158         iter = iter->next;
1159     }
1160
1161     FIXME("Not found %p\n", iface);
1162     return NULL;
1163 }
1164
1165 void release_nodes(HTMLDocumentNode *This)
1166 {
1167     HTMLDOMNode *iter, *next;
1168
1169     if(!This->nodes)
1170         return;
1171
1172     for(iter = This->nodes; iter; iter = next) {
1173         next = iter->next;
1174         iter->doc = NULL;
1175         if(&This->node != iter)
1176             IHTMLDOMNode_Release(&iter->IHTMLDOMNode_iface);
1177     }
1178 }