wined3d: Allow color fills on FBO attachable surfaces in ffp_blit_supported().
[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 };
475
476 static const tid_t HTMLElementCollection_iface_tids[] = {
477     IHTMLElementCollection_tid,
478     0
479 };
480
481 static dispex_static_data_t HTMLElementCollection_dispex = {
482     &HTMLElementColection_dispex_vtbl,
483     DispHTMLElementCollection_tid,
484     NULL,
485     HTMLElementCollection_iface_tids
486 };
487
488 static void create_all_list(HTMLDocumentNode *doc, HTMLDOMNode *elem, elem_vector_t *buf)
489 {
490     nsIDOMNodeList *nsnode_list;
491     nsIDOMNode *iter;
492     PRUint32 list_len = 0, i;
493     nsresult nsres;
494     HRESULT hres;
495
496     nsres = nsIDOMNode_GetChildNodes(elem->nsnode, &nsnode_list);
497     if(NS_FAILED(nsres)) {
498         ERR("GetChildNodes failed: %08x\n", nsres);
499         return;
500     }
501
502     nsIDOMNodeList_GetLength(nsnode_list, &list_len);
503     if(!list_len)
504         return;
505
506     for(i=0; i<list_len; i++) {
507         nsres = nsIDOMNodeList_Item(nsnode_list, i, &iter);
508         if(NS_FAILED(nsres)) {
509             ERR("Item failed: %08x\n", nsres);
510             continue;
511         }
512
513         if(is_elem_node(iter)) {
514             HTMLDOMNode *node;
515
516             hres = get_node(doc, iter, TRUE, &node);
517             if(FAILED(hres)) {
518                 FIXME("get_node failed: %08x\n", hres);
519                 continue;
520             }
521
522             elem_vector_add(buf, elem_from_HTMLDOMNode(node));
523             create_all_list(doc, node, buf);
524         }
525     }
526 }
527
528 IHTMLElementCollection *create_all_collection(HTMLDOMNode *node, BOOL include_root)
529 {
530     elem_vector_t buf = {NULL, 0, 8};
531
532     buf.buf = heap_alloc(buf.size*sizeof(HTMLElement**));
533
534     if(include_root)
535         elem_vector_add(&buf, elem_from_HTMLDOMNode(node));
536     create_all_list(node->doc, node, &buf);
537     elem_vector_normalize(&buf);
538
539     return HTMLElementCollection_Create((IUnknown*)&node->IHTMLDOMNode_iface, buf.buf, buf.len);
540 }
541
542 IHTMLElementCollection *create_collection_from_nodelist(HTMLDocumentNode *doc, IUnknown *unk, nsIDOMNodeList *nslist)
543 {
544     PRUint32 length = 0, i;
545     HTMLDOMNode *node;
546     elem_vector_t buf;
547     HRESULT hres;
548
549     nsIDOMNodeList_GetLength(nslist, &length);
550
551     buf.len = 0;
552     buf.size = length;
553     if(length) {
554         nsIDOMNode *nsnode;
555
556         buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
557
558         for(i=0; i<length; i++) {
559             nsIDOMNodeList_Item(nslist, i, &nsnode);
560             if(is_elem_node(nsnode)) {
561                 hres = get_node(doc, nsnode, TRUE, &node);
562                 if(FAILED(hres))
563                     continue;
564                 buf.buf[buf.len++] = elem_from_HTMLDOMNode(node);
565             }
566             nsIDOMNode_Release(nsnode);
567         }
568
569         elem_vector_normalize(&buf);
570     }else {
571         buf.buf = NULL;
572     }
573
574     return HTMLElementCollection_Create(unk, buf.buf, buf.len);
575 }
576
577 IHTMLElementCollection *create_collection_from_htmlcol(HTMLDocumentNode *doc, IUnknown *unk, nsIDOMHTMLCollection *nscol)
578 {
579     PRUint32 length = 0, i;
580     elem_vector_t buf;
581     HTMLDOMNode *node;
582     HRESULT hres = S_OK;
583
584     nsIDOMHTMLCollection_GetLength(nscol, &length);
585
586     buf.len = buf.size = length;
587     if(buf.len) {
588         nsIDOMNode *nsnode;
589
590         buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
591
592         for(i=0; i<length; i++) {
593             nsIDOMHTMLCollection_Item(nscol, i, &nsnode);
594             hres = get_node(doc, nsnode, TRUE, &node);
595             nsIDOMNode_Release(nsnode);
596             if(FAILED(hres))
597                 break;
598             buf.buf[i] = elem_from_HTMLDOMNode(node);
599         }
600     }else {
601         buf.buf = NULL;
602     }
603
604     if(FAILED(hres)) {
605         heap_free(buf.buf);
606         return NULL;
607     }
608
609     return HTMLElementCollection_Create(unk, buf.buf, buf.len);
610 }
611
612 static IHTMLElementCollection *HTMLElementCollection_Create(IUnknown *ref_unk,
613             HTMLElement **elems, DWORD len)
614 {
615     HTMLElementCollection *ret = heap_alloc_zero(sizeof(HTMLElementCollection));
616
617     ret->IHTMLElementCollection_iface.lpVtbl = &HTMLElementCollectionVtbl;
618     ret->ref = 1;
619     ret->elems = elems;
620     ret->len = len;
621
622     init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLElementCollection_iface,
623             &HTMLElementCollection_dispex);
624
625     IUnknown_AddRef(ref_unk);
626     ret->ref_unk = ref_unk;
627
628     TRACE("ret=%p len=%d\n", ret, len);
629
630     return &ret->IHTMLElementCollection_iface;
631 }