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     if(IsEqualGUID(riid, &IID_IUnknown)) {
 108         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 109         *ppv = &This->IEnumVARIANT_iface;
 110     }else if(IsEqualGUID(riid, &IID_IEnumVARIANT)) {
 111         TRACE("(%p)->(IID_IEnumVARIANT %p)\n", This, ppv);
 112         *ppv = &This->IEnumVARIANT_iface;
 113     }else {
 114         FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 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     *ppv = NULL;
 221
 222     if(IsEqualGUID(&IID_IUnknown, riid)) {
 223         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 224         *ppv = &This->IHTMLElementCollection_iface;
 225     }else if(IsEqualGUID(&IID_IHTMLElementCollection, riid)) {
 226         TRACE("(%p)->(IID_IHTMLElementCollection %p)\n", This, ppv);
 227         *ppv = &This->IHTMLElementCollection_iface;
 228     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 229         return *ppv ? S_OK : E_NOINTERFACE;
 230     }
 231
 232     if(*ppv) {
 233         IHTMLElementCollection_AddRef(&This->IHTMLElementCollection_iface);
 234         return S_OK;
 235     }
 236
 237     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 238     return E_NOINTERFACE;
 239 }
 240
 241 static ULONG WINAPI HTMLElementCollection_AddRef(IHTMLElementCollection *iface)
 242 {
 243     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 244     LONG ref = InterlockedIncrement(&This->ref);
 245
 246     TRACE("(%p) ref=%d\n", This, ref);
 247
 248     return ref;
 249 }
 250
 251 static ULONG WINAPI HTMLElementCollection_Release(IHTMLElementCollection *iface)
 252 {
 253     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 254     LONG ref = InterlockedDecrement(&This->ref);
 255
 256     TRACE("(%p) ref=%d\n", This, ref);
 257
 258     if(!ref) {
 259         unsigned i;
 260
 261         for(i=0; i < This->len; i++)
 262             node_release(&This->elems[i]->node);
 263         heap_free(This->elems);
 264
 265         release_dispex(&This->dispex);
 266         heap_free(This);
 267     }
 268
 269     return ref;
 270 }
 271
 272 static HRESULT WINAPI HTMLElementCollection_GetTypeInfoCount(IHTMLElementCollection *iface,
 273                                                              UINT *pctinfo)
 274 {
 275     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 276     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 277 }
 278
 279 static HRESULT WINAPI HTMLElementCollection_GetTypeInfo(IHTMLElementCollection *iface,
 280         UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 281 {
 282     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 283     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 284 }
 285
 286 static HRESULT WINAPI HTMLElementCollection_GetIDsOfNames(IHTMLElementCollection *iface,
 287         REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 288 {
 289     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 290     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 291             lcid, rgDispId);
 292 }
 293
 294 static HRESULT WINAPI HTMLElementCollection_Invoke(IHTMLElementCollection *iface,
 295         DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 296         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 297 {
 298     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 299     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 300             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 301 }
 302
 303 static HRESULT WINAPI HTMLElementCollection_toString(IHTMLElementCollection *iface,
 304                                                      BSTR *String)
 305 {
 306     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 307     FIXME("(%p)->(%p)\n", This, String);
 308     return E_NOTIMPL;
 309 }
 310
 311 static HRESULT WINAPI HTMLElementCollection_put_length(IHTMLElementCollection *iface,
 312                                                        LONG v)
 313 {
 314     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 315     FIXME("(%p)->(%d)\n", This, v);
 316     return E_NOTIMPL;
 317 }
 318
 319 static HRESULT WINAPI HTMLElementCollection_get_length(IHTMLElementCollection *iface,
 320                                                        LONG *p)
 321 {
 322     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 323
 324     TRACE("(%p)->(%p)\n", This, p);
 325
 326     *p = This->len;
 327     return S_OK;
 328 }
 329
 330 static HRESULT WINAPI HTMLElementCollection_get__newEnum(IHTMLElementCollection *iface,
 331                                                          IUnknown **p)
 332 {
 333     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 334     HTMLElementCollectionEnum *ret;
 335
 336     TRACE("(%p)->(%p)\n", This, p);
 337
 338     ret = heap_alloc(sizeof(*ret));
 339     if(!ret)
 340         return E_OUTOFMEMORY;
 341
 342     ret->IEnumVARIANT_iface.lpVtbl = &HTMLElementCollectionEnumVtbl;
 343     ret->ref = 1;
 344     ret->iter = 0;
 345
 346     IHTMLElementCollection_AddRef(&This->IHTMLElementCollection_iface);
 347     ret->col = This;
 348
 349     *p = (IUnknown*)&ret->IEnumVARIANT_iface;
 350     return S_OK;
 351 }
 352
 353 static BOOL is_elem_id(HTMLElement *elem, LPCWSTR name)
 354 {
 355     BSTR elem_id;
 356     HRESULT hres;
 357
 358     hres = IHTMLElement_get_id(&elem->IHTMLElement_iface, &elem_id);
 359     if(FAILED(hres)){
 360         WARN("IHTMLElement_get_id failed: 0x%08x\n", hres);
 361         return FALSE;
 362     }
 363
 364     if(elem_id && !strcmpW(elem_id, name)) {
 365         SysFreeString(elem_id);
 366         return TRUE;
 367     }
 368
 369     SysFreeString(elem_id);
 370     return FALSE;
 371 }
 372
 373 static BOOL is_elem_name(HTMLElement *elem, LPCWSTR name)
 374 {
 375     const PRUnichar *str;
 376     nsAString nsstr, nsname;
 377     BOOL ret = FALSE;
 378     nsresult nsres;
 379
 380     static const PRUnichar nameW[] = {'n','a','m','e',0};
 381
 382     if(!elem->nselem)
 383         return FALSE;
 384
 385     nsAString_Init(&nsstr, NULL);
 386     nsIDOMHTMLElement_GetId(elem->nselem, &nsstr);
 387     nsAString_GetData(&nsstr, &str);
 388     if(!strcmpiW(str, name)) {
 389         nsAString_Finish(&nsstr);
 390         return TRUE;
 391     }
 392
 393     nsAString_InitDepend(&nsname, nameW);
 394     nsres =  nsIDOMHTMLElement_GetAttribute(elem->nselem, &nsname, &nsstr);
 395     nsAString_Finish(&nsname);
 396     if(NS_SUCCEEDED(nsres)) {
 397         nsAString_GetData(&nsstr, &str);
 398         ret = !strcmpiW(str, name);
 399     }
 400
 401     nsAString_Finish(&nsstr);
 402     return ret;
 403 }
 404
 405 static HRESULT get_item_idx(HTMLElementCollection *This, UINT idx, IDispatch **ret)
 406 {
 407     if(idx < This->len) {
 408         *ret = (IDispatch*)This->elems[idx];
 409         IDispatch_AddRef(*ret);
 410     }
 411
 412     return S_OK;
 413 }
 414
 415 static HRESULT WINAPI HTMLElementCollection_item(IHTMLElementCollection *iface,
 416         VARIANT name, VARIANT index, IDispatch **pdisp)
 417 {
 418     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 419     HRESULT hres = S_OK;
 420
 421     TRACE("(%p)->(%s %s %p)\n", This, debugstr_variant(&name), debugstr_variant(&index), pdisp);
 422
 423     *pdisp = NULL;
 424
 425     switch(V_VT(&name)) {
 426     case VT_I4:
 427         if(V_I4(&name) < 0)
 428             return E_INVALIDARG;
 429         hres = get_item_idx(This, V_I4(&name), pdisp);
 430         break;
 431
 432     case VT_UINT:
 433         hres = get_item_idx(This, V_UINT(&name), pdisp);
 434         break;
 435
 436     case VT_BSTR: {
 437         DWORD i;
 438
 439         if(V_VT(&index) == VT_I4) {
 440             LONG idx = V_I4(&index);
 441
 442             if(idx < 0)
 443                 return E_INVALIDARG;
 444
 445             for(i=0; i<This->len; i++) {
 446                 if(is_elem_name(This->elems[i], V_BSTR(&name)) && !idx--)
 447                     break;
 448             }
 449
 450             if(i != This->len) {
 451                 *pdisp = (IDispatch*)&This->elems[i]->IHTMLElement_iface;
 452                 IDispatch_AddRef(*pdisp);
 453             }
 454         }else {
 455             elem_vector_t buf = {NULL, 0, 8};
 456
 457             buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 458
 459             for(i=0; i<This->len; i++) {
 460                 if(is_elem_name(This->elems[i], V_BSTR(&name))) {
 461                     node_addref(&This->elems[i]->node);
 462                     elem_vector_add(&buf, This->elems[i]);
 463                 }
 464             }
 465
 466             if(buf.len > 1) {
 467                 elem_vector_normalize(&buf);
 468                 *pdisp = (IDispatch*)HTMLElementCollection_Create(buf.buf, buf.len);
 469             }else {
 470                 if(buf.len == 1) {
 471                     /* Already AddRef-ed */
 472                     *pdisp = (IDispatch*)&buf.buf[0]->IHTMLElement_iface;
 473                 }
 474
 475                 heap_free(buf.buf);
 476             }
 477         }
 478         break;
 479     }
 480
 481     default:
 482         FIXME("Unsupported name %s\n", debugstr_variant(&name));
 483         hres = E_NOTIMPL;
 484     }
 485
 486     if(SUCCEEDED(hres))
 487         TRACE("returning %p\n", *pdisp);
 488     return hres;
 489 }
 490
 491 static HRESULT WINAPI HTMLElementCollection_tags(IHTMLElementCollection *iface,
 492                                                  VARIANT tagName, IDispatch **pdisp)
 493 {
 494     HTMLElementCollection *This = impl_from_IHTMLElementCollection(iface);
 495     DWORD i;
 496     nsAString tag_str;
 497     const PRUnichar *tag;
 498     elem_vector_t buf = {NULL, 0, 8};
 499
 500     if(V_VT(&tagName) != VT_BSTR) {
 501         WARN("Invalid arg\n");
 502         return DISP_E_MEMBERNOTFOUND;
 503     }
 504
 505     TRACE("(%p)->(%s %p)\n", This, debugstr_w(V_BSTR(&tagName)), pdisp);
 506
 507     buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 508
 509     nsAString_Init(&tag_str, NULL);
 510
 511     for(i=0; i<This->len; i++) {
 512         if(!This->elems[i]->nselem)
 513             continue;
 514
 515         nsIDOMHTMLElement_GetTagName(This->elems[i]->nselem, &tag_str);
 516         nsAString_GetData(&tag_str, &tag);
 517
 518         if(CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, tag, -1,
 519                           V_BSTR(&tagName), -1) == CSTR_EQUAL) {
 520             node_addref(&This->elems[i]->node);
 521             elem_vector_add(&buf, This->elems[i]);
 522         }
 523     }
 524
 525     nsAString_Finish(&tag_str);
 526     elem_vector_normalize(&buf);
 527
 528     TRACE("fount %d tags\n", buf.len);
 529
 530     *pdisp = (IDispatch*)HTMLElementCollection_Create(buf.buf, buf.len);
 531     return S_OK;
 532 }
 533
 534 static const IHTMLElementCollectionVtbl HTMLElementCollectionVtbl = {
 535     HTMLElementCollection_QueryInterface,
 536     HTMLElementCollection_AddRef,
 537     HTMLElementCollection_Release,
 538     HTMLElementCollection_GetTypeInfoCount,
 539     HTMLElementCollection_GetTypeInfo,
 540     HTMLElementCollection_GetIDsOfNames,
 541     HTMLElementCollection_Invoke,
 542     HTMLElementCollection_toString,
 543     HTMLElementCollection_put_length,
 544     HTMLElementCollection_get_length,
 545     HTMLElementCollection_get__newEnum,
 546     HTMLElementCollection_item,
 547     HTMLElementCollection_tags
 548 };
 549
 550 static inline HTMLElementCollection *impl_from_DispatchEx(DispatchEx *iface)
 551 {
 552     return CONTAINING_RECORD(iface, HTMLElementCollection, dispex);
 553 }
 554
 555 #define DISPID_ELEMCOL_0 MSHTML_DISPID_CUSTOM_MIN
 556
 557 static HRESULT HTMLElementCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
 558 {
 559     HTMLElementCollection *This = impl_from_DispatchEx(dispex);
 560     WCHAR *ptr;
 561     DWORD idx=0;
 562
 563     if(!*name)
 564         return DISP_E_UNKNOWNNAME;
 565
 566     for(ptr = name; *ptr && isdigitW(*ptr); ptr++)
 567         idx = idx*10 + (*ptr-'0');
 568
 569     if(*ptr) {
 570         /* the name contains alpha characters, so search by name & id */
 571         for(idx = 0; idx < This->len; ++idx) {
 572             if(is_elem_id(This->elems[idx], name) ||
 573                     is_elem_name(This->elems[idx], name))
 574                 break;
 575         }
 576     }
 577
 578     if(idx >= This->len)
 579         return DISP_E_UNKNOWNNAME;
 580
 581     *dispid = DISPID_ELEMCOL_0 + idx;
 582     TRACE("ret %x\n", *dispid);
 583     return S_OK;
 584 }
 585
 586 static HRESULT HTMLElementCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
 587         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
 588 {
 589     HTMLElementCollection *This = impl_from_DispatchEx(dispex);
 590     DWORD idx;
 591
 592     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, flags, params, res, ei, caller);
 593
 594     idx = id - DISPID_ELEMCOL_0;
 595     if(idx >= This->len)
 596         return DISP_E_UNKNOWNNAME;
 597
 598     switch(flags) {
 599     case DISPATCH_PROPERTYGET:
 600         V_VT(res) = VT_DISPATCH;
 601         V_DISPATCH(res) = (IDispatch*)&This->elems[idx]->IHTMLElement_iface;
 602         IHTMLElement_AddRef(&This->elems[idx]->IHTMLElement_iface);
 603         break;
 604     default:
 605         FIXME("unimplemented flags %x\n", flags);
 606         return E_NOTIMPL;
 607     }
 608
 609     return S_OK;
 610 }
 611
 612 static const dispex_static_data_vtbl_t HTMLElementColection_dispex_vtbl = {
 613     NULL,
 614     HTMLElementCollection_get_dispid,
 615     HTMLElementCollection_invoke,
 616     NULL
 617 };
 618
 619 static const tid_t HTMLElementCollection_iface_tids[] = {
 620     IHTMLElementCollection_tid,
 621     0
 622 };
 623
 624 static dispex_static_data_t HTMLElementCollection_dispex = {
 625     &HTMLElementColection_dispex_vtbl,
 626     DispHTMLElementCollection_tid,
 627     NULL,
 628     HTMLElementCollection_iface_tids
 629 };
 630
 631 static void create_all_list(HTMLDocumentNode *doc, HTMLDOMNode *elem, elem_vector_t *buf)
 632 {
 633     nsIDOMNodeList *nsnode_list;
 634     nsIDOMNode *iter;
 635     UINT32 list_len = 0, i;
 636     nsresult nsres;
 637     HRESULT hres;
 638
 639     nsres = nsIDOMNode_GetChildNodes(elem->nsnode, &nsnode_list);
 640     if(NS_FAILED(nsres)) {
 641         ERR("GetChildNodes failed: %08x\n", nsres);
 642         return;
 643     }
 644
 645     nsIDOMNodeList_GetLength(nsnode_list, &list_len);
 646     if(!list_len)
 647         return;
 648
 649     for(i=0; i<list_len; i++) {
 650         nsres = nsIDOMNodeList_Item(nsnode_list, i, &iter);
 651         if(NS_FAILED(nsres)) {
 652             ERR("Item failed: %08x\n", nsres);
 653             continue;
 654         }
 655
 656         if(is_elem_node(iter)) {
 657             HTMLDOMNode *node;
 658
 659             hres = get_node(doc, iter, TRUE, &node);
 660             if(FAILED(hres)) {
 661                 FIXME("get_node failed: %08x\n", hres);
 662                 continue;
 663             }
 664
 665             elem_vector_add(buf, elem_from_HTMLDOMNode(node));
 666             create_all_list(doc, node, buf);
 667         }
 668     }
 669 }
 670
 671 IHTMLElementCollection *create_all_collection(HTMLDOMNode *node, BOOL include_root)
 672 {
 673     elem_vector_t buf = {NULL, 0, 8};
 674
 675     buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 676
 677     if(include_root) {
 678         node_addref(node);
 679         elem_vector_add(&buf, elem_from_HTMLDOMNode(node));
 680     }
 681     create_all_list(node->doc, node, &buf);
 682     elem_vector_normalize(&buf);
 683
 684     return HTMLElementCollection_Create(buf.buf, buf.len);
 685 }
 686
 687 IHTMLElementCollection *create_collection_from_nodelist(HTMLDocumentNode *doc, nsIDOMNodeList *nslist)
 688 {
 689     UINT32 length = 0, i;
 690     HTMLDOMNode *node;
 691     elem_vector_t buf;
 692     HRESULT hres;
 693
 694     nsIDOMNodeList_GetLength(nslist, &length);
 695
 696     buf.len = 0;
 697     buf.size = length;
 698     if(length) {
 699         nsIDOMNode *nsnode;
 700
 701         buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 702
 703         for(i=0; i<length; i++) {
 704             nsIDOMNodeList_Item(nslist, i, &nsnode);
 705             if(is_elem_node(nsnode)) {
 706                 hres = get_node(doc, nsnode, TRUE, &node);
 707                 if(FAILED(hres))
 708                     continue;
 709                 buf.buf[buf.len++] = elem_from_HTMLDOMNode(node);
 710             }
 711             nsIDOMNode_Release(nsnode);
 712         }
 713
 714         elem_vector_normalize(&buf);
 715     }else {
 716         buf.buf = NULL;
 717     }
 718
 719     return HTMLElementCollection_Create(buf.buf, buf.len);
 720 }
 721
 722 IHTMLElementCollection *create_collection_from_htmlcol(HTMLDocumentNode *doc, nsIDOMHTMLCollection *nscol)
 723 {
 724     UINT32 length = 0, i;
 725     elem_vector_t buf;
 726     HTMLDOMNode *node;
 727     HRESULT hres = S_OK;
 728
 729     nsIDOMHTMLCollection_GetLength(nscol, &length);
 730
 731     buf.len = buf.size = length;
 732     if(buf.len) {
 733         nsIDOMNode *nsnode;
 734
 735         buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
 736
 737         for(i=0; i<length; i++) {
 738             nsIDOMHTMLCollection_Item(nscol, i, &nsnode);
 739             hres = get_node(doc, nsnode, TRUE, &node);
 740             nsIDOMNode_Release(nsnode);
 741             if(FAILED(hres))
 742                 break;
 743             buf.buf[i] = elem_from_HTMLDOMNode(node);
 744         }
 745     }else {
 746         buf.buf = NULL;
 747     }
 748
 749     if(FAILED(hres)) {
 750         heap_free(buf.buf);
 751         return NULL;
 752     }
 753
 754     return HTMLElementCollection_Create(buf.buf, buf.len);
 755 }
 756
 757 static IHTMLElementCollection *HTMLElementCollection_Create(HTMLElement **elems, DWORD len)
 758 {
 759     HTMLElementCollection *ret = heap_alloc_zero(sizeof(HTMLElementCollection));
 760
 761     ret->IHTMLElementCollection_iface.lpVtbl = &HTMLElementCollectionVtbl;
 762     ret->ref = 1;
 763     ret->elems = elems;
 764     ret->len = len;
 765
 766     init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLElementCollection_iface,
 767             &HTMLElementCollection_dispex);
 768
 769     TRACE("ret=%p len=%d\n", ret, len);
 770
 771     return &ret->IHTMLElementCollection_iface;
 772 }