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