mshtml: Recognize UTF-8 BOM.
[wine] / dlls / mshtml / htmlelemcol.c
1 /*
2  * Copyright 2006-2008 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
32 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
33
34 typedef struct {
35     DispatchEx dispex;
36     IHTMLElementCollection IHTMLElementCollection_iface;
37
38     IUnknown *ref_unk;
39     HTMLElement **elems;
40     DWORD len;
41
42     LONG ref;
43 } HTMLElementCollection;
44
45 typedef struct {
46     HTMLElement **buf;
47     DWORD len;
48     DWORD size;
49 } elem_vector_t;
50
51 /* FIXME: Handle it better way */
52 static inline HTMLElement *elem_from_HTMLDOMNode(HTMLDOMNode *iface)
53 {
54     return CONTAINING_RECORD(iface, HTMLElement, node);
55 }
56
57 static IHTMLElementCollection *HTMLElementCollection_Create(IUnknown *ref_unk,
58                                                             HTMLElement **elems, DWORD len);
59
60 static void elem_vector_add(elem_vector_t *buf, HTMLElement *elem)
61 {
62     if(buf->len == buf->size) {
63         buf->size <<= 1;
64         buf->buf = heap_realloc(buf->buf, buf->size*sizeof(HTMLElement*));
65     }
66
67     buf->buf[buf->len++] = elem;
68 }
69
70 static void elem_vector_normalize(elem_vector_t *buf)
71 {
72     if(!buf->len) {
73         heap_free(buf->buf);
74         buf->buf = NULL;
75     }else if(buf->size > buf->len) {
76         buf->buf = heap_realloc(buf->buf, buf->len*sizeof(HTMLElement*));
77     }
78
79     buf->size = buf->len;
80 }
81
82 static inline BOOL is_elem_node(nsIDOMNode *node)
83 {
84     PRUint16 type=0;
85
86     nsIDOMNode_GetNodeType(node, &type);
87
88     return type == ELEMENT_NODE || type == COMMENT_NODE;
89 }
90
91 static inline HTMLElementCollection *impl_from_IHTMLElementCollection(IHTMLElementCollection *iface)
92 {
93     return CONTAINING_RECORD(iface, HTMLElementCollection, IHTMLElementCollection_iface);
94 }
95
96 static HRESULT WINAPI HTMLElementCollection_QueryInterface(IHTMLElementCollection *iface,
97                                                            REFIID riid, void **ppv)
98 {
99     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
100
101     *ppv = NULL;
102
103     if(IsEqualGUID(&IID_IUnknown, riid)) {
104         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
105         *ppv = &This->IHTMLElementCollection_iface;
106     }else if(IsEqualGUID(&IID_IHTMLElementCollection, riid)) {
107         TRACE("(%p)->(IID_IHTMLElementCollection %p)\n", This, ppv);
108         *ppv = &This->IHTMLElementCollection_iface;
109     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
110         return *ppv ? S_OK : E_NOINTERFACE;
111     }
112
113     if(*ppv) {
114         IHTMLElementCollection_AddRef(&This->IHTMLElementCollection_iface);
115         return S_OK;
116     }
117
118     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
119     return E_NOINTERFACE;
120 }
121
122 static ULONG WINAPI HTMLElementCollection_AddRef(IHTMLElementCollection *iface)
123 {
124     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
125     LONG ref = InterlockedIncrement(&This->ref);
126
127     TRACE("(%p) ref=%d\n", This, ref);
128
129     return ref;
130 }
131
132 static ULONG WINAPI HTMLElementCollection_Release(IHTMLElementCollection *iface)
133 {
134     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
135     LONG ref = InterlockedDecrement(&This->ref);
136
137     TRACE("(%p) ref=%d\n", This, ref);
138
139     if(!ref) {
140         IUnknown_Release(This->ref_unk);
141         release_dispex(&This->dispex);
142         heap_free(This->elems);
143         heap_free(This);
144     }
145
146     return ref;
147 }
148
149 static HRESULT WINAPI HTMLElementCollection_GetTypeInfoCount(IHTMLElementCollection *iface,
150                                                              UINT *pctinfo)
151 {
152     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
153     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
154 }
155
156 static HRESULT WINAPI HTMLElementCollection_GetTypeInfo(IHTMLElementCollection *iface,
157         UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
158 {
159     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
160     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
161 }
162
163 static HRESULT WINAPI HTMLElementCollection_GetIDsOfNames(IHTMLElementCollection *iface,
164         REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
165 {
166     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
167     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
168             lcid, rgDispId);
169 }
170
171 static HRESULT WINAPI HTMLElementCollection_Invoke(IHTMLElementCollection *iface,
172         DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
173         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
174 {
175     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
176     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
177             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
178 }
179
180 static HRESULT WINAPI HTMLElementCollection_toString(IHTMLElementCollection *iface,
181                                                      BSTR *String)
182 {
183     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
184     FIXME("(%p)->(%p)\n", This, String);
185     return E_NOTIMPL;
186 }
187
188 static HRESULT WINAPI HTMLElementCollection_put_length(IHTMLElementCollection *iface,
189                                                        LONG v)
190 {
191     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
192     FIXME("(%p)->(%d)\n", This, v);
193     return E_NOTIMPL;
194 }
195
196 static HRESULT WINAPI HTMLElementCollection_get_length(IHTMLElementCollection *iface,
197                                                        LONG *p)
198 {
199     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
200
201     TRACE("(%p)->(%p)\n", This, p);
202
203     *p = This->len;
204     return S_OK;
205 }
206
207 static HRESULT WINAPI HTMLElementCollection_get__newEnum(IHTMLElementCollection *iface,
208                                                          IUnknown **p)
209 {
210     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
211     FIXME("(%p)->(%p)\n", This, p);
212     return E_NOTIMPL;
213 }
214
215 static BOOL is_elem_id(HTMLElement *elem, LPCWSTR name)
216 {
217     BSTR elem_id;
218     HRESULT hres;
219
220     hres = IHTMLElement_get_id(&elem->IHTMLElement_iface, &elem_id);
221     if(FAILED(hres)){
222         WARN("IHTMLElement_get_id failed: 0x%08x\n", hres);
223         return FALSE;
224     }
225
226     if(elem_id && !strcmpW(elem_id, name)) {
227         SysFreeString(elem_id);
228         return TRUE;
229     }
230
231     SysFreeString(elem_id);
232     return FALSE;
233 }
234
235 static BOOL is_elem_name(HTMLElement *elem, LPCWSTR name)
236 {
237     const PRUnichar *str;
238     nsAString nsstr, nsname;
239     BOOL ret = FALSE;
240     nsresult nsres;
241
242     static const PRUnichar nameW[] = {'n','a','m','e',0};
243
244     if(!elem->nselem)
245         return FALSE;
246
247     nsAString_Init(&nsstr, NULL);
248     nsIDOMHTMLElement_GetId(elem->nselem, &nsstr);
249     nsAString_GetData(&nsstr, &str);
250     if(!strcmpiW(str, name)) {
251         nsAString_Finish(&nsstr);
252         return TRUE;
253     }
254
255     nsAString_InitDepend(&nsname, nameW);
256     nsres =  nsIDOMHTMLElement_GetAttribute(elem->nselem, &nsname, &nsstr);
257     nsAString_Finish(&nsname);
258     if(NS_SUCCEEDED(nsres)) {
259         nsAString_GetData(&nsstr, &str);
260         ret = !strcmpiW(str, name);
261     }
262
263     nsAString_Finish(&nsstr);
264     return ret;
265 }
266
267 static HRESULT get_item_idx(HTMLElementCollection *This, UINT idx, IDispatch **ret)
268 {
269     if(idx < This->len) {
270         *ret = (IDispatch*)This->elems[idx];
271         IDispatch_AddRef(*ret);
272     }
273
274     return S_OK;
275 }
276
277 static HRESULT WINAPI HTMLElementCollection_item(IHTMLElementCollection *iface,
278         VARIANT name, VARIANT index, IDispatch **pdisp)
279 {
280     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
281     HRESULT hres = S_OK;
282
283     TRACE("(%p)->(%s %s %p)\n", This, debugstr_variant(&name), debugstr_variant(&index), pdisp);
284
285     *pdisp = NULL;
286
287     switch(V_VT(&name)) {
288     case VT_I4:
289         if(V_I4(&name) < 0)
290             return E_INVALIDARG;
291         hres = get_item_idx(This, V_I4(&name), pdisp);
292         break;
293
294     case VT_UINT:
295         hres = get_item_idx(This, V_UINT(&name), pdisp);
296         break;
297
298     case VT_BSTR: {
299         DWORD i;
300
301         if(V_VT(&index) == VT_I4) {
302             LONG idx = V_I4(&index);
303
304             if(idx < 0)
305                 return E_INVALIDARG;
306
307             for(i=0; i<This->len; i++) {
308                 if(is_elem_name(This->elems[i], V_BSTR(&name)) && !idx--)
309                     break;
310             }
311
312             if(i != This->len) {
313                 *pdisp = (IDispatch*)&This->elems[i]->IHTMLElement_iface;
314                 IDispatch_AddRef(*pdisp);
315             }
316         }else {
317             elem_vector_t buf = {NULL, 0, 8};
318
319             buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
320
321             for(i=0; i<This->len; i++) {
322                 if(is_elem_name(This->elems[i], V_BSTR(&name)))
323                     elem_vector_add(&buf, This->elems[i]);
324             }
325
326             if(buf.len > 1) {
327                 elem_vector_normalize(&buf);
328                 *pdisp = (IDispatch*)HTMLElementCollection_Create(This->ref_unk, buf.buf, buf.len);
329             }else {
330                 if(buf.len == 1) {
331                     *pdisp = (IDispatch*)&buf.buf[0]->IHTMLElement_iface;
332                     IDispatch_AddRef(*pdisp);
333                 }
334
335                 heap_free(buf.buf);
336             }
337         }
338         break;
339     }
340
341     default:
342         FIXME("Unsupported name %s\n", debugstr_variant(&name));
343         hres = E_NOTIMPL;
344     }
345
346     if(SUCCEEDED(hres))
347         TRACE("returning %p\n", *pdisp);
348     return hres;
349 }
350
351 static HRESULT WINAPI HTMLElementCollection_tags(IHTMLElementCollection *iface,
352                                                  VARIANT tagName, IDispatch **pdisp)
353 {
354     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
355     DWORD i;
356     nsAString tag_str;
357     const PRUnichar *tag;
358     elem_vector_t buf = {NULL, 0, 8};
359
360     if(V_VT(&tagName) != VT_BSTR) {
361         WARN("Invalid arg\n");
362         return DISP_E_MEMBERNOTFOUND;
363     }
364
365     TRACE("(%p)->(%s %p)\n", This, debugstr_w(V_BSTR(&tagName)), pdisp);
366
367     buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
368
369     nsAString_Init(&tag_str, NULL);
370
371     for(i=0; i<This->len; i++) {
372         if(!This->elems[i]->nselem)
373             continue;
374
375         nsIDOMElement_GetTagName(This->elems[i]->nselem, &tag_str);
376         nsAString_GetData(&tag_str, &tag);
377
378         if(CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, tag, -1,
379                           V_BSTR(&tagName), -1) == CSTR_EQUAL)
380             elem_vector_add(&buf, This->elems[i]);
381     }
382
383     nsAString_Finish(&tag_str);
384     elem_vector_normalize(&buf);
385
386     TRACE("fount %d tags\n", buf.len);
387
388     *pdisp = (IDispatch*)HTMLElementCollection_Create(This->ref_unk, buf.buf, buf.len);
389     return S_OK;
390 }
391
392 static const IHTMLElementCollectionVtbl HTMLElementCollectionVtbl = {
393     HTMLElementCollection_QueryInterface,
394     HTMLElementCollection_AddRef,
395     HTMLElementCollection_Release,
396     HTMLElementCollection_GetTypeInfoCount,
397     HTMLElementCollection_GetTypeInfo,
398     HTMLElementCollection_GetIDsOfNames,
399     HTMLElementCollection_Invoke,
400     HTMLElementCollection_toString,
401     HTMLElementCollection_put_length,
402     HTMLElementCollection_get_length,
403     HTMLElementCollection_get__newEnum,
404     HTMLElementCollection_item,
405     HTMLElementCollection_tags
406 };
407
408 static inline HTMLElementCollection *impl_from_DispatchEx(DispatchEx *iface)
409 {
410     return CONTAINING_RECORD(iface, HTMLElementCollection, dispex);
411 }
412
413 #define DISPID_ELEMCOL_0 MSHTML_DISPID_CUSTOM_MIN
414
415 static HRESULT HTMLElementCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
416 {
417     HTMLElementCollection *This = impl_from_DispatchEx(dispex);
418     WCHAR *ptr;
419     DWORD idx=0;
420
421     if(!*name)
422         return DISP_E_UNKNOWNNAME;
423
424     for(ptr = name; *ptr && isdigitW(*ptr); ptr++)
425         idx = idx*10 + (*ptr-'0');
426
427     if(*ptr) {
428         /* the name contains alpha characters, so search by name & id */
429         for(idx = 0; idx < This->len; ++idx) {
430             if(is_elem_id(This->elems[idx], name) ||
431                     is_elem_name(This->elems[idx], name))
432                 break;
433         }
434     }
435
436     if(idx >= This->len)
437         return DISP_E_UNKNOWNNAME;
438
439     *dispid = DISPID_ELEMCOL_0 + idx;
440     TRACE("ret %x\n", *dispid);
441     return S_OK;
442 }
443
444 static HRESULT HTMLElementCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
445         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
446 {
447     HTMLElementCollection *This = impl_from_DispatchEx(dispex);
448     DWORD idx;
449
450     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, flags, params, res, ei, caller);
451
452     idx = id - DISPID_ELEMCOL_0;
453     if(idx >= This->len)
454         return DISP_E_UNKNOWNNAME;
455
456     switch(flags) {
457     case DISPATCH_PROPERTYGET:
458         V_VT(res) = VT_DISPATCH;
459         V_DISPATCH(res) = (IDispatch*)&This->elems[idx]->IHTMLElement_iface;
460         IHTMLElement_AddRef(&This->elems[idx]->IHTMLElement_iface);
461         break;
462     default:
463         FIXME("unimplemented flags %x\n", flags);
464         return E_NOTIMPL;
465     }
466
467     return S_OK;
468 }
469
470 static const dispex_static_data_vtbl_t HTMLElementColection_dispex_vtbl = {
471     NULL,
472     HTMLElementCollection_get_dispid,
473     HTMLElementCollection_invoke,
474     NULL
475 };
476
477 static const tid_t HTMLElementCollection_iface_tids[] = {
478     IHTMLElementCollection_tid,
479     0
480 };
481
482 static dispex_static_data_t HTMLElementCollection_dispex = {
483     &HTMLElementColection_dispex_vtbl,
484     DispHTMLElementCollection_tid,
485     NULL,
486     HTMLElementCollection_iface_tids
487 };
488
489 static void create_all_list(HTMLDocumentNode *doc, HTMLDOMNode *elem, elem_vector_t *buf)
490 {
491     nsIDOMNodeList *nsnode_list;
492     nsIDOMNode *iter;
493     PRUint32 list_len = 0, i;
494     nsresult nsres;
495     HRESULT hres;
496
497     nsres = nsIDOMNode_GetChildNodes(elem->nsnode, &nsnode_list);
498     if(NS_FAILED(nsres)) {
499         ERR("GetChildNodes failed: %08x\n", nsres);
500         return;
501     }
502
503     nsIDOMNodeList_GetLength(nsnode_list, &list_len);
504     if(!list_len)
505         return;
506
507     for(i=0; i<list_len; i++) {
508         nsres = nsIDOMNodeList_Item(nsnode_list, i, &iter);
509         if(NS_FAILED(nsres)) {
510             ERR("Item failed: %08x\n", nsres);
511             continue;
512         }
513
514         if(is_elem_node(iter)) {
515             HTMLDOMNode *node;
516
517             hres = get_node(doc, iter, TRUE, &node);
518             if(FAILED(hres)) {
519                 FIXME("get_node failed: %08x\n", hres);
520                 continue;
521             }
522
523             elem_vector_add(buf, elem_from_HTMLDOMNode(node));
524             create_all_list(doc, node, buf);
525         }
526     }
527 }
528
529 IHTMLElementCollection *create_all_collection(HTMLDOMNode *node, BOOL include_root)
530 {
531     elem_vector_t buf = {NULL, 0, 8};
532
533     buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
534
535     if(include_root)
536         elem_vector_add(&buf, elem_from_HTMLDOMNode(node));
537     create_all_list(node->doc, node, &buf);
538     elem_vector_normalize(&buf);
539
540     return HTMLElementCollection_Create((IUnknown*)&node->IHTMLDOMNode_iface, buf.buf, buf.len);
541 }
542
543 IHTMLElementCollection *create_collection_from_nodelist(HTMLDocumentNode *doc, IUnknown *unk, nsIDOMNodeList *nslist)
544 {
545     PRUint32 length = 0, i;
546     HTMLDOMNode *node;
547     elem_vector_t buf;
548     HRESULT hres;
549
550     nsIDOMNodeList_GetLength(nslist, &length);
551
552     buf.len = 0;
553     buf.size = length;
554     if(length) {
555         nsIDOMNode *nsnode;
556
557         buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
558
559         for(i=0; i<length; i++) {
560             nsIDOMNodeList_Item(nslist, i, &nsnode);
561             if(is_elem_node(nsnode)) {
562                 hres = get_node(doc, nsnode, TRUE, &node);
563                 if(FAILED(hres))
564                     continue;
565                 buf.buf[buf.len++] = elem_from_HTMLDOMNode(node);
566             }
567             nsIDOMNode_Release(nsnode);
568         }
569
570         elem_vector_normalize(&buf);
571     }else {
572         buf.buf = NULL;
573     }
574
575     return HTMLElementCollection_Create(unk, buf.buf, buf.len);
576 }
577
578 IHTMLElementCollection *create_collection_from_htmlcol(HTMLDocumentNode *doc, IUnknown *unk, nsIDOMHTMLCollection *nscol)
579 {
580     PRUint32 length = 0, i;
581     elem_vector_t buf;
582     HTMLDOMNode *node;
583     HRESULT hres = S_OK;
584
585     nsIDOMHTMLCollection_GetLength(nscol, &length);
586
587     buf.len = buf.size = length;
588     if(buf.len) {
589         nsIDOMNode *nsnode;
590
591         buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
592
593         for(i=0; i<length; i++) {
594             nsIDOMHTMLCollection_Item(nscol, i, &nsnode);
595             hres = get_node(doc, nsnode, TRUE, &node);
596             nsIDOMNode_Release(nsnode);
597             if(FAILED(hres))
598                 break;
599             buf.buf[i] = elem_from_HTMLDOMNode(node);
600         }
601     }else {
602         buf.buf = NULL;
603     }
604
605     if(FAILED(hres)) {
606         heap_free(buf.buf);
607         return NULL;
608     }
609
610     return HTMLElementCollection_Create(unk, buf.buf, buf.len);
611 }
612
613 static IHTMLElementCollection *HTMLElementCollection_Create(IUnknown *ref_unk,
614             HTMLElement **elems, DWORD len)
615 {
616     HTMLElementCollection *ret = heap_alloc_zero(sizeof(HTMLElementCollection));
617
618     ret->IHTMLElementCollection_iface.lpVtbl = &HTMLElementCollectionVtbl;
619     ret->ref = 1;
620     ret->elems = elems;
621     ret->len = len;
622
623     init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLElementCollection_iface,
624             &HTMLElementCollection_dispex);
625
626     IUnknown_AddRef(ref_unk);
627     ret->ref_unk = ref_unk;
628
629     TRACE("ret=%p len=%d\n", ret, len);
630
631     return &ret->IHTMLElementCollection_iface;
632 }