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