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