git.oblomov.eu Git - wine/blob - dlls/mshtml/htmlelem.c

   1 /*
   2  * Copyright 2006 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
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "winreg.h"
  28 #include "ole2.h"
  29 #include "shlwapi.h"
  30
  31 #include "wine/debug.h"
  32 #include "wine/unicode.h"
  33
  34 #include "mshtml_private.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  37
  38 static IHTMLElementCollection *HTMLElementCollection_Create(IUnknown*,HTMLElement**,DWORD);
  39
  40 typedef struct {
  41     HTMLElement **buf;
  42     DWORD len;
  43     DWORD size;
  44 } elem_vector;
  45
  46 static void elem_vector_add(elem_vector *buf, HTMLElement *elem)
  47 {
  48     if(buf->len == buf->size) {
  49         buf->size <<= 1;
  50         buf->buf = heap_realloc(buf->buf, buf->size*sizeof(HTMLElement**));
  51     }
  52
  53     buf->buf[buf->len++] = elem;
  54 }
  55
  56 static void elem_vector_normalize(elem_vector *buf)
  57 {
  58     if(!buf->len) {
  59         heap_free(buf->buf);
  60         buf->buf = NULL;
  61     }else if(buf->size > buf->len) {
  62         buf->buf = heap_realloc(buf->buf, buf->len*sizeof(HTMLElement**));
  63     }
  64
  65     buf->size = buf->len;
  66 }
  67
  68 static BOOL is_elem_node(nsIDOMNode *node)
  69 {
  70     PRUint16 type=0;
  71
  72     nsIDOMNode_GetNodeType(node, &type);
  73
  74     return type == ELEMENT_NODE || type == COMMENT_NODE;
  75 }
  76
  77 #define HTMLELEM_THIS(iface) DEFINE_THIS(HTMLElement, HTMLElement, iface)
  78
  79 #define HTMLELEM_NODE_THIS(iface) DEFINE_THIS2(HTMLElement, node, iface)
  80
  81 static HRESULT WINAPI HTMLElement_QueryInterface(IHTMLElement *iface,
  82                                                  REFIID riid, void **ppv)
  83 {
  84     HTMLElement *This = HTMLELEM_THIS(iface);
  85
  86     return IHTMLDOMNode_QueryInterface(HTMLDOMNODE(&This->node), riid, ppv);
  87 }
  88
  89 static ULONG WINAPI HTMLElement_AddRef(IHTMLElement *iface)
  90 {
  91     HTMLElement *This = HTMLELEM_THIS(iface);
  92
  93     return IHTMLDOMNode_AddRef(HTMLDOMNODE(&This->node));
  94 }
  95
  96 static ULONG WINAPI HTMLElement_Release(IHTMLElement *iface)
  97 {
  98     HTMLElement *This = HTMLELEM_THIS(iface);
  99
 100     return IHTMLDOMNode_Release(HTMLDOMNODE(&This->node));
 101 }
 102
 103 static HRESULT WINAPI HTMLElement_GetTypeInfoCount(IHTMLElement *iface, UINT *pctinfo)
 104 {
 105     HTMLElement *This = HTMLELEM_THIS(iface);
 106     FIXME("(%p)->(%p)\n", This, pctinfo);
 107     return E_NOTIMPL;
 108 }
 109
 110 static HRESULT WINAPI HTMLElement_GetTypeInfo(IHTMLElement *iface, UINT iTInfo,
 111                                               LCID lcid, ITypeInfo **ppTInfo)
 112 {
 113     HTMLElement *This = HTMLELEM_THIS(iface);
 114     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 115     return E_NOTIMPL;
 116 }
 117
 118 static HRESULT WINAPI HTMLElement_GetIDsOfNames(IHTMLElement *iface, REFIID riid,
 119                                                 LPOLESTR *rgszNames, UINT cNames,
 120                                                 LCID lcid, DISPID *rgDispId)
 121 {
 122     HTMLElement *This = HTMLELEM_THIS(iface);
 123     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 124                                         lcid, rgDispId);
 125     return E_NOTIMPL;
 126 }
 127
 128 static HRESULT WINAPI HTMLElement_Invoke(IHTMLElement *iface, DISPID dispIdMember,
 129                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 130                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 131 {
 132     HTMLElement *This = HTMLELEM_THIS(iface);
 133     FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 134             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 135     return E_NOTIMPL;
 136 }
 137
 138 static HRESULT WINAPI HTMLElement_setAttribute(IHTMLElement *iface, BSTR strAttributeName,
 139                                                VARIANT AttributeValue, LONG lFlags)
 140 {
 141     HTMLElement *This = HTMLELEM_THIS(iface);
 142     nsAString attr_str;
 143     nsAString value_str;
 144     nsresult nsres;
 145     HRESULT hres;
 146     VARIANT AttributeValueChanged;
 147
 148     WARN("(%p)->(%s . %08x)\n", This, debugstr_w(strAttributeName), lFlags);
 149
 150     if(!This->nselem) {
 151         FIXME("NULL nselem\n");
 152         return E_NOTIMPL;
 153     }
 154
 155     VariantInit(&AttributeValueChanged);
 156
 157     hres = VariantChangeType(&AttributeValueChanged, &AttributeValue, 0, VT_BSTR);
 158     if (FAILED(hres)) {
 159         WARN("couldn't convert input attribute value %d to VT_BSTR\n", V_VT(&AttributeValue));
 160         return hres;
 161     }
 162
 163     nsAString_Init(&attr_str, strAttributeName);
 164     nsAString_Init(&value_str, V_BSTR(&AttributeValueChanged));
 165
 166     TRACE("setting %s to %s\n", debugstr_w(strAttributeName),
 167         debugstr_w(V_BSTR(&AttributeValueChanged)));
 168
 169     nsres = nsIDOMHTMLElement_SetAttribute(This->nselem, &attr_str, &value_str);
 170     nsAString_Finish(&attr_str);
 171     nsAString_Finish(&value_str);
 172
 173     if(NS_SUCCEEDED(nsres)) {
 174         hres = S_OK;
 175     }else {
 176         ERR("SetAttribute failed: %08x\n", nsres);
 177         hres = E_FAIL;
 178     }
 179
 180     return hres;
 181 }
 182
 183 static HRESULT WINAPI HTMLElement_getAttribute(IHTMLElement *iface, BSTR strAttributeName,
 184                                                LONG lFlags, VARIANT *AttributeValue)
 185 {
 186     HTMLElement *This = HTMLELEM_THIS(iface);
 187     nsAString attr_str;
 188     nsAString value_str;
 189     const PRUnichar *value;
 190     nsresult nsres;
 191     HRESULT hres = S_OK;
 192
 193     WARN("(%p)->(%s %08x %p)\n", This, debugstr_w(strAttributeName), lFlags, AttributeValue);
 194
 195     if(!This->nselem) {
 196         FIXME("NULL nselem\n");
 197         V_VT(AttributeValue) = VT_NULL;
 198         return S_OK;
 199     }
 200
 201     V_VT(AttributeValue) = VT_NULL;
 202
 203     nsAString_Init(&attr_str, strAttributeName);
 204     nsAString_Init(&value_str, NULL);
 205
 206     nsres = nsIDOMHTMLElement_GetAttribute(This->nselem, &attr_str, &value_str);
 207     nsAString_Finish(&attr_str);
 208
 209     if(NS_SUCCEEDED(nsres)) {
 210         static const WCHAR wszSRC[] = {'s','r','c',0};
 211         nsAString_GetData(&value_str, &value);
 212         if(!strcmpiW(strAttributeName, wszSRC))
 213         {
 214             WCHAR buffer[256];
 215             DWORD len;
 216             BSTR bstrBaseUrl;
 217             hres = IHTMLDocument2_get_URL(HTMLDOC(This->node.doc), &bstrBaseUrl);
 218             if(SUCCEEDED(hres)) {
 219                 hres = CoInternetCombineUrl(bstrBaseUrl, value,
 220                                             URL_ESCAPE_SPACES_ONLY|URL_DONT_ESCAPE_EXTRA_INFO,
 221                                             buffer, sizeof(buffer)/sizeof(WCHAR), &len, 0);
 222                 SysFreeString(bstrBaseUrl);
 223                 if(SUCCEEDED(hres)) {
 224                     V_VT(AttributeValue) = VT_BSTR;
 225                     V_BSTR(AttributeValue) = SysAllocString(buffer);
 226                     TRACE("attr_value=%s\n", debugstr_w(V_BSTR(AttributeValue)));
 227                 }
 228             }
 229         }else if(*value) {
 230             V_VT(AttributeValue) = VT_BSTR;
 231             V_BSTR(AttributeValue) = SysAllocString(value);
 232             TRACE("attr_value=%s\n", debugstr_w(V_BSTR(AttributeValue)));
 233         }
 234     }else {
 235         ERR("GetAttribute failed: %08x\n", nsres);
 236         hres = E_FAIL;
 237     }
 238
 239     nsAString_Finish(&value_str);
 240
 241     return hres;
 242 }
 243
 244 static HRESULT WINAPI HTMLElement_removeAttribute(IHTMLElement *iface, BSTR strAttributeName,
 245                                                   LONG lFlags, VARIANT_BOOL *pfSuccess)
 246 {
 247     HTMLElement *This = HTMLELEM_THIS(iface);
 248     FIXME("(%p)->()\n", This);
 249     return E_NOTIMPL;
 250 }
 251
 252 static HRESULT WINAPI HTMLElement_put_className(IHTMLElement *iface, BSTR v)
 253 {
 254     HTMLElement *This = HTMLELEM_THIS(iface);
 255     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 256     return E_NOTIMPL;
 257 }
 258
 259 static HRESULT WINAPI HTMLElement_get_className(IHTMLElement *iface, BSTR *p)
 260 {
 261     HTMLElement *This = HTMLELEM_THIS(iface);
 262     nsAString class_str;
 263     nsresult nsres;
 264     HRESULT hres = S_OK;
 265
 266     TRACE("(%p)->(%p)\n", This, p);
 267
 268     if(!This->nselem) {
 269         FIXME("NULL nselem\n");
 270         return E_NOTIMPL;
 271     }
 272
 273     nsAString_Init(&class_str, NULL);
 274     nsres = nsIDOMHTMLElement_GetClassName(This->nselem, &class_str);
 275
 276     if(NS_SUCCEEDED(nsres)) {
 277         const PRUnichar *class;
 278         nsAString_GetData(&class_str, &class);
 279         *p = SysAllocString(class);
 280     }else {
 281         ERR("GetClassName failed: %08x\n", nsres);
 282         hres = E_FAIL;
 283     }
 284
 285     nsAString_Finish(&class_str);
 286
 287     TRACE("className=%s\n", debugstr_w(*p));
 288     return hres;
 289 }
 290
 291 static HRESULT WINAPI HTMLElement_put_id(IHTMLElement *iface, BSTR v)
 292 {
 293     HTMLElement *This = HTMLELEM_THIS(iface);
 294     nsAString id_str;
 295     nsresult nsres;
 296
 297     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 298
 299     if(!This->nselem) {
 300         FIXME("nselem == NULL\n");
 301         return S_OK;
 302     }
 303
 304     nsAString_Init(&id_str, v);
 305     nsres = nsIDOMHTMLElement_SetId(This->nselem, &id_str);
 306     nsAString_Finish(&id_str);
 307     if(NS_FAILED(nsres))
 308         ERR("SetId failed: %08x\n", nsres);
 309
 310     return S_OK;
 311 }
 312
 313 static HRESULT WINAPI HTMLElement_get_id(IHTMLElement *iface, BSTR *p)
 314 {
 315     HTMLElement *This = HTMLELEM_THIS(iface);
 316     const PRUnichar *id;
 317     nsAString id_str;
 318     nsresult nsres;
 319
 320     TRACE("(%p)->(%p)\n", This, p);
 321
 322     *p = NULL;
 323
 324     if(!This->nselem)
 325         return S_OK;
 326
 327     nsAString_Init(&id_str, NULL);
 328     nsres = nsIDOMHTMLElement_GetId(This->nselem, &id_str);
 329     nsAString_GetData(&id_str, &id);
 330
 331     if(NS_FAILED(nsres))
 332         ERR("GetId failed: %08x\n", nsres);
 333     else if(*id)
 334         *p = SysAllocString(id);
 335
 336     nsAString_Finish(&id_str);
 337     return S_OK;
 338 }
 339
 340 static HRESULT WINAPI HTMLElement_get_tagName(IHTMLElement *iface, BSTR *p)
 341 {
 342     HTMLElement *This = HTMLELEM_THIS(iface);
 343     const PRUnichar *tag;
 344     nsAString tag_str;
 345     nsresult nsres;
 346
 347     TRACE("(%p)->(%p)\n", This, p);
 348
 349     if(!This->nselem) {
 350         static const WCHAR comment_tagW[] = {'!',0};
 351
 352         WARN("NULL nselem, assuming comment\n");
 353
 354         *p = SysAllocString(comment_tagW);
 355         return S_OK;
 356     }
 357
 358     nsAString_Init(&tag_str, NULL);
 359     nsres = nsIDOMHTMLElement_GetTagName(This->nselem, &tag_str);
 360     if(NS_SUCCEEDED(nsres)) {
 361         nsAString_GetData(&tag_str, &tag);
 362         *p = SysAllocString(tag);
 363     }else {
 364         ERR("GetTagName failed: %08x\n", nsres);
 365         *p = NULL;
 366     }
 367     nsAString_Finish(&tag_str);
 368
 369     return S_OK;
 370 }
 371
 372 static HRESULT WINAPI HTMLElement_get_parentElement(IHTMLElement *iface, IHTMLElement **p)
 373 {
 374     HTMLElement *This = HTMLELEM_THIS(iface);
 375     FIXME("(%p)->(%p)\n", This, p);
 376     return E_NOTIMPL;
 377 }
 378
 379 static HRESULT WINAPI HTMLElement_get_style(IHTMLElement *iface, IHTMLStyle **p)
 380 {
 381     HTMLElement *This = HTMLELEM_THIS(iface);
 382     nsIDOMElementCSSInlineStyle *nselemstyle;
 383     nsIDOMCSSStyleDeclaration *nsstyle;
 384     nsresult nsres;
 385
 386     TRACE("(%p)->(%p)\n", This, p);
 387
 388     if(!This->nselem) {
 389         FIXME("NULL nselem\n");
 390         return E_NOTIMPL;
 391     }
 392
 393     nsres = nsIDOMHTMLElement_QueryInterface(This->nselem, &IID_nsIDOMElementCSSInlineStyle,
 394                                              (void**)&nselemstyle);
 395     if(NS_FAILED(nsres)) {
 396         ERR("Coud not get nsIDOMCSSStyleDeclaration interface: %08x\n", nsres);
 397         return E_FAIL;
 398     }
 399
 400     nsres = nsIDOMElementCSSInlineStyle_GetStyle(nselemstyle, &nsstyle);
 401     nsIDOMElementCSSInlineStyle_Release(nselemstyle);
 402     if(NS_FAILED(nsres)) {
 403         ERR("GetStyle failed: %08x\n", nsres);
 404         return E_FAIL;
 405     }
 406
 407     /* FIXME: Store style instead of creating a new instance in each call */
 408     *p = HTMLStyle_Create(nsstyle);
 409
 410     nsIDOMCSSStyleDeclaration_Release(nsstyle);
 411     return S_OK;
 412 }
 413
 414 static HRESULT WINAPI HTMLElement_put_onhelp(IHTMLElement *iface, VARIANT v)
 415 {
 416     HTMLElement *This = HTMLELEM_THIS(iface);
 417     FIXME("(%p)->()\n", This);
 418     return E_NOTIMPL;
 419 }
 420
 421 static HRESULT WINAPI HTMLElement_get_onhelp(IHTMLElement *iface, VARIANT *p)
 422 {
 423     HTMLElement *This = HTMLELEM_THIS(iface);
 424     FIXME("(%p)->(%p)\n", This, p);
 425     return E_NOTIMPL;
 426 }
 427
 428 static HRESULT WINAPI HTMLElement_put_onclick(IHTMLElement *iface, VARIANT v)
 429 {
 430     HTMLElement *This = HTMLELEM_THIS(iface);
 431     FIXME("(%p)->()\n", This);
 432     return E_NOTIMPL;
 433 }
 434
 435 static HRESULT WINAPI HTMLElement_get_onclick(IHTMLElement *iface, VARIANT *p)
 436 {
 437     HTMLElement *This = HTMLELEM_THIS(iface);
 438     FIXME("(%p)->(%p)\n", This, p);
 439     return E_NOTIMPL;
 440 }
 441
 442 static HRESULT WINAPI HTMLElement_put_ondblclick(IHTMLElement *iface, VARIANT v)
 443 {
 444     HTMLElement *This = HTMLELEM_THIS(iface);
 445     FIXME("(%p)->()\n", This);
 446     return E_NOTIMPL;
 447 }
 448
 449 static HRESULT WINAPI HTMLElement_get_ondblclick(IHTMLElement *iface, VARIANT *p)
 450 {
 451     HTMLElement *This = HTMLELEM_THIS(iface);
 452     FIXME("(%p)->(%p)\n", This, p);
 453     return E_NOTIMPL;
 454 }
 455
 456 static HRESULT WINAPI HTMLElement_put_onkeydown(IHTMLElement *iface, VARIANT v)
 457 {
 458     HTMLElement *This = HTMLELEM_THIS(iface);
 459     FIXME("(%p)->()\n", This);
 460     return E_NOTIMPL;
 461 }
 462
 463 static HRESULT WINAPI HTMLElement_get_onkeydown(IHTMLElement *iface, VARIANT *p)
 464 {
 465     HTMLElement *This = HTMLELEM_THIS(iface);
 466     FIXME("(%p)->(%p)\n", This, p);
 467     return E_NOTIMPL;
 468 }
 469
 470 static HRESULT WINAPI HTMLElement_put_onkeyup(IHTMLElement *iface, VARIANT v)
 471 {
 472     HTMLElement *This = HTMLELEM_THIS(iface);
 473     FIXME("(%p)->()\n", This);
 474     return E_NOTIMPL;
 475 }
 476
 477 static HRESULT WINAPI HTMLElement_get_onkeyup(IHTMLElement *iface, VARIANT *p)
 478 {
 479     HTMLElement *This = HTMLELEM_THIS(iface);
 480     FIXME("(%p)->(%p)\n", This, p);
 481     return E_NOTIMPL;
 482 }
 483
 484 static HRESULT WINAPI HTMLElement_put_onkeypress(IHTMLElement *iface, VARIANT v)
 485 {
 486     HTMLElement *This = HTMLELEM_THIS(iface);
 487     FIXME("(%p)->()\n", This);
 488     return E_NOTIMPL;
 489 }
 490
 491 static HRESULT WINAPI HTMLElement_get_onkeypress(IHTMLElement *iface, VARIANT *p)
 492 {
 493     HTMLElement *This = HTMLELEM_THIS(iface);
 494     FIXME("(%p)->(%p)\n", This, p);
 495     return E_NOTIMPL;
 496 }
 497
 498 static HRESULT WINAPI HTMLElement_put_onmouseout(IHTMLElement *iface, VARIANT v)
 499 {
 500     HTMLElement *This = HTMLELEM_THIS(iface);
 501     FIXME("(%p)->()\n", This);
 502     return E_NOTIMPL;
 503 }
 504
 505 static HRESULT WINAPI HTMLElement_get_onmouseout(IHTMLElement *iface, VARIANT *p)
 506 {
 507     HTMLElement *This = HTMLELEM_THIS(iface);
 508     FIXME("(%p)->(%p)\n", This, p);
 509     return E_NOTIMPL;
 510 }
 511
 512 static HRESULT WINAPI HTMLElement_put_onmouseover(IHTMLElement *iface, VARIANT v)
 513 {
 514     HTMLElement *This = HTMLELEM_THIS(iface);
 515     FIXME("(%p)->()\n", This);
 516     return E_NOTIMPL;
 517 }
 518
 519 static HRESULT WINAPI HTMLElement_get_onmouseover(IHTMLElement *iface, VARIANT *p)
 520 {
 521     HTMLElement *This = HTMLELEM_THIS(iface);
 522     FIXME("(%p)->(%p)\n", This, p);
 523     return E_NOTIMPL;
 524 }
 525
 526 static HRESULT WINAPI HTMLElement_put_onmousemove(IHTMLElement *iface, VARIANT v)
 527 {
 528     HTMLElement *This = HTMLELEM_THIS(iface);
 529     FIXME("(%p)->()\n", This);
 530     return E_NOTIMPL;
 531 }
 532
 533 static HRESULT WINAPI HTMLElement_get_onmousemove(IHTMLElement *iface, VARIANT *p)
 534 {
 535     HTMLElement *This = HTMLELEM_THIS(iface);
 536     FIXME("(%p)->(%p)\n", This, p);
 537     return E_NOTIMPL;
 538 }
 539
 540 static HRESULT WINAPI HTMLElement_put_onmousedown(IHTMLElement *iface, VARIANT v)
 541 {
 542     HTMLElement *This = HTMLELEM_THIS(iface);
 543     FIXME("(%p)->()\n", This);
 544     return E_NOTIMPL;
 545 }
 546
 547 static HRESULT WINAPI HTMLElement_get_onmousedown(IHTMLElement *iface, VARIANT *p)
 548 {
 549     HTMLElement *This = HTMLELEM_THIS(iface);
 550     FIXME("(%p)->(%p)\n", This, p);
 551     return E_NOTIMPL;
 552 }
 553
 554 static HRESULT WINAPI HTMLElement_put_onmouseup(IHTMLElement *iface, VARIANT v)
 555 {
 556     HTMLElement *This = HTMLELEM_THIS(iface);
 557     FIXME("(%p)->()\n", This);
 558     return E_NOTIMPL;
 559 }
 560
 561 static HRESULT WINAPI HTMLElement_get_onmouseup(IHTMLElement *iface, VARIANT *p)
 562 {
 563     HTMLElement *This = HTMLELEM_THIS(iface);
 564     FIXME("(%p)->(%p)\n", This, p);
 565     return E_NOTIMPL;
 566 }
 567
 568 static HRESULT WINAPI HTMLElement_get_document(IHTMLElement *iface, IDispatch **p)
 569 {
 570     HTMLElement *This = HTMLELEM_THIS(iface);
 571     FIXME("(%p)->(%p)\n", This, p);
 572     return E_NOTIMPL;
 573 }
 574
 575 static HRESULT WINAPI HTMLElement_put_title(IHTMLElement *iface, BSTR v)
 576 {
 577     HTMLElement *This = HTMLELEM_THIS(iface);
 578     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 579     return E_NOTIMPL;
 580 }
 581
 582 static HRESULT WINAPI HTMLElement_get_title(IHTMLElement *iface, BSTR *p)
 583 {
 584     HTMLElement *This = HTMLELEM_THIS(iface);
 585     FIXME("(%p)->(%p)\n", This, p);
 586     return E_NOTIMPL;
 587 }
 588
 589 static HRESULT WINAPI HTMLElement_put_language(IHTMLElement *iface, BSTR v)
 590 {
 591     HTMLElement *This = HTMLELEM_THIS(iface);
 592     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 593     return E_NOTIMPL;
 594 }
 595
 596 static HRESULT WINAPI HTMLElement_get_language(IHTMLElement *iface, BSTR *p)
 597 {
 598     HTMLElement *This = HTMLELEM_THIS(iface);
 599     FIXME("(%p)->(%p)\n", This, p);
 600     return E_NOTIMPL;
 601 }
 602
 603 static HRESULT WINAPI HTMLElement_put_onselectstart(IHTMLElement *iface, VARIANT v)
 604 {
 605     HTMLElement *This = HTMLELEM_THIS(iface);
 606     FIXME("(%p)->()\n", This);
 607     return E_NOTIMPL;
 608 }
 609
 610 static HRESULT WINAPI HTMLElement_get_onselectstart(IHTMLElement *iface, VARIANT *p)
 611 {
 612     HTMLElement *This = HTMLELEM_THIS(iface);
 613     FIXME("(%p)->(%p)\n", This, p);
 614     return E_NOTIMPL;
 615 }
 616
 617 static HRESULT WINAPI HTMLElement_scrollIntoView(IHTMLElement *iface, VARIANT varargStart)
 618 {
 619     HTMLElement *This = HTMLELEM_THIS(iface);
 620     FIXME("(%p)->()\n", This);
 621     return E_NOTIMPL;
 622 }
 623
 624 static HRESULT WINAPI HTMLElement_contains(IHTMLElement *iface, IHTMLElement *pChild,
 625                                            VARIANT_BOOL *pfResult)
 626 {
 627     HTMLElement *This = HTMLELEM_THIS(iface);
 628     FIXME("(%p)->(%p %p)\n", This, pChild, pfResult);
 629     return E_NOTIMPL;
 630 }
 631
 632 static HRESULT WINAPI HTMLElement_get_sourceIndex(IHTMLElement *iface, long *p)
 633 {
 634     HTMLElement *This = HTMLELEM_THIS(iface);
 635     FIXME("(%p)->(%p)\n", This, p);
 636     return E_NOTIMPL;
 637 }
 638
 639 static HRESULT WINAPI HTMLElement_get_recordNumber(IHTMLElement *iface, VARIANT *p)
 640 {
 641     HTMLElement *This = HTMLELEM_THIS(iface);
 642     FIXME("(%p)->(%p)\n", This, p);
 643     return E_NOTIMPL;
 644 }
 645
 646 static HRESULT WINAPI HTMLElement_put_lang(IHTMLElement *iface, BSTR v)
 647 {
 648     HTMLElement *This = HTMLELEM_THIS(iface);
 649     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 650     return E_NOTIMPL;
 651 }
 652
 653 static HRESULT WINAPI HTMLElement_get_lang(IHTMLElement *iface, BSTR *p)
 654 {
 655     HTMLElement *This = HTMLELEM_THIS(iface);
 656     FIXME("(%p)->(%p)\n", This, p);
 657     return E_NOTIMPL;
 658 }
 659
 660 static HRESULT WINAPI HTMLElement_get_offsetLeft(IHTMLElement *iface, long *p)
 661 {
 662     HTMLElement *This = HTMLELEM_THIS(iface);
 663     FIXME("(%p)->(%p)\n", This, p);
 664     return E_NOTIMPL;
 665 }
 666
 667 static HRESULT WINAPI HTMLElement_get_offsetTop(IHTMLElement *iface, long *p)
 668 {
 669     HTMLElement *This = HTMLELEM_THIS(iface);
 670     FIXME("(%p)->(%p)\n", This, p);
 671     return E_NOTIMPL;
 672 }
 673
 674 static HRESULT WINAPI HTMLElement_get_offsetWidth(IHTMLElement *iface, long *p)
 675 {
 676     HTMLElement *This = HTMLELEM_THIS(iface);
 677     FIXME("(%p)->(%p)\n", This, p);
 678     return E_NOTIMPL;
 679 }
 680
 681 static HRESULT WINAPI HTMLElement_get_offsetHeight(IHTMLElement *iface, long *p)
 682 {
 683     HTMLElement *This = HTMLELEM_THIS(iface);
 684     FIXME("(%p)->(%p)\n", This, p);
 685     return E_NOTIMPL;
 686 }
 687
 688 static HRESULT WINAPI HTMLElement_get_offsetParent(IHTMLElement *iface, IHTMLElement **p)
 689 {
 690     HTMLElement *This = HTMLELEM_THIS(iface);
 691     FIXME("(%p)->(%p)\n", This, p);
 692     return E_NOTIMPL;
 693 }
 694
 695 static HRESULT WINAPI HTMLElement_put_innerHTML(IHTMLElement *iface, BSTR v)
 696 {
 697     HTMLElement *This = HTMLELEM_THIS(iface);
 698     nsIDOMNSHTMLElement *nselem;
 699     nsAString html_str;
 700     nsresult nsres;
 701
 702     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 703
 704     if(!This->nselem) {
 705         FIXME("NULL nselem\n");
 706         return E_NOTIMPL;
 707     }
 708
 709     nsres = nsIDOMHTMLElement_QueryInterface(This->nselem, &IID_nsIDOMNSHTMLElement, (void**)&nselem);
 710     if(NS_FAILED(nsres)) {
 711         ERR("Could not get nsIDOMNSHTMLElement: %08x\n", nsres);
 712         return E_FAIL;
 713     }
 714
 715     nsAString_Init(&html_str, v);
 716     nsres = nsIDOMNSHTMLElement_SetInnerHTML(nselem, &html_str);
 717     nsAString_Finish(&html_str);
 718
 719     if(NS_FAILED(nsres)) {
 720         FIXME("SetInnerHtml failed %08x\n", nsres);
 721         return E_FAIL;
 722     }
 723
 724     return S_OK;
 725 }
 726
 727 static HRESULT WINAPI HTMLElement_get_innerHTML(IHTMLElement *iface, BSTR *p)
 728 {
 729     HTMLElement *This = HTMLELEM_THIS(iface);
 730     FIXME("(%p)->(%p)\n", This, p);
 731     return E_NOTIMPL;
 732 }
 733
 734 static HRESULT WINAPI HTMLElement_put_innerText(IHTMLElement *iface, BSTR v)
 735 {
 736     HTMLElement *This = HTMLELEM_THIS(iface);
 737     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 738     return E_NOTIMPL;
 739 }
 740
 741 static HRESULT WINAPI HTMLElement_get_innerText(IHTMLElement *iface, BSTR *p)
 742 {
 743     HTMLElement *This = HTMLELEM_THIS(iface);
 744     FIXME("(%p)->(%p)\n", This, p);
 745     return E_NOTIMPL;
 746 }
 747
 748 static HRESULT WINAPI HTMLElement_put_outerHTML(IHTMLElement *iface, BSTR v)
 749 {
 750     HTMLElement *This = HTMLELEM_THIS(iface);
 751     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 752     return E_NOTIMPL;
 753 }
 754
 755 static HRESULT WINAPI HTMLElement_get_outerHTML(IHTMLElement *iface, BSTR *p)
 756 {
 757     HTMLElement *This = HTMLELEM_THIS(iface);
 758     FIXME("(%p)->(%p)\n", This, p);
 759     return E_NOTIMPL;
 760 }
 761
 762 static HRESULT WINAPI HTMLElement_put_outerText(IHTMLElement *iface, BSTR v)
 763 {
 764     HTMLElement *This = HTMLELEM_THIS(iface);
 765     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 766     return E_NOTIMPL;
 767 }
 768
 769 static HRESULT WINAPI HTMLElement_get_outerText(IHTMLElement *iface, BSTR *p)
 770 {
 771     HTMLElement *This = HTMLELEM_THIS(iface);
 772     FIXME("(%p)->(%p)\n", This, p);
 773     return E_NOTIMPL;
 774 }
 775
 776 static HRESULT HTMLElement_InsertAdjacentNode(HTMLElement *This, BSTR where, nsIDOMNode *nsnode)
 777 {
 778     static const WCHAR wszBeforeBegin[] = {'b','e','f','o','r','e','B','e','g','i','n',0};
 779     static const WCHAR wszAfterBegin[] = {'a','f','t','e','r','B','e','g','i','n',0};
 780     static const WCHAR wszBeforeEnd[] = {'b','e','f','o','r','e','E','n','d',0};
 781     static const WCHAR wszAfterEnd[] = {'a','f','t','e','r','E','n','d',0};
 782     nsresult nsres;
 783
 784     if(!This->nselem) {
 785         FIXME("NULL nselem\n");
 786         return E_NOTIMPL;
 787     }
 788
 789     if (!strcmpiW(where, wszBeforeBegin))
 790     {
 791         nsIDOMNode *unused;
 792         nsIDOMNode *parent;
 793         nsres = nsIDOMNode_GetParentNode(This->nselem, &parent);
 794         if (!parent) return E_INVALIDARG;
 795         nsres = nsIDOMNode_InsertBefore(parent, nsnode,
 796                                         (nsIDOMNode *)This->nselem, &unused);
 797         if (unused) nsIDOMNode_Release(unused);
 798         nsIDOMNode_Release(parent);
 799     }
 800     else if (!strcmpiW(where, wszAfterBegin))
 801     {
 802         nsIDOMNode *unused;
 803         nsIDOMNode *first_child;
 804         nsIDOMNode_GetFirstChild(This->nselem, &first_child);
 805         nsres = nsIDOMNode_InsertBefore(This->nselem, nsnode, first_child, &unused);
 806         if (unused) nsIDOMNode_Release(unused);
 807         if (first_child) nsIDOMNode_Release(first_child);
 808     }
 809     else if (!strcmpiW(where, wszBeforeEnd))
 810     {
 811         nsIDOMNode *unused;
 812         nsres = nsIDOMNode_AppendChild(This->nselem, nsnode, &unused);
 813         if (unused) nsIDOMNode_Release(unused);
 814     }
 815     else if (!strcmpiW(where, wszAfterEnd))
 816     {
 817         nsIDOMNode *unused;
 818         nsIDOMNode *next_sibling;
 819         nsIDOMNode *parent;
 820         nsIDOMNode_GetParentNode(This->nselem, &parent);
 821         if (!parent) return E_INVALIDARG;
 822
 823         nsIDOMNode_GetNextSibling(This->nselem, &next_sibling);
 824         if (next_sibling)
 825         {
 826             nsres = nsIDOMNode_InsertBefore(parent, nsnode, next_sibling, &unused);
 827             nsIDOMNode_Release(next_sibling);
 828         }
 829         else
 830             nsres = nsIDOMNode_AppendChild(parent, nsnode, &unused);
 831         nsIDOMNode_Release(parent);
 832         if (unused) nsIDOMNode_Release(unused);
 833     }
 834     else
 835     {
 836         ERR("invalid where: %s\n", debugstr_w(where));
 837         return E_INVALIDARG;
 838     }
 839
 840     if (NS_FAILED(nsres))
 841         return E_FAIL;
 842     else
 843         return S_OK;
 844 }
 845
 846 static HRESULT WINAPI HTMLElement_insertAdjacentHTML(IHTMLElement *iface, BSTR where,
 847                                                      BSTR html)
 848 {
 849     HTMLElement *This = HTMLELEM_THIS(iface);
 850     nsresult nsres;
 851     nsIDOMDocument *nsdoc;
 852     nsIDOMDocumentRange *nsdocrange;
 853     nsIDOMRange *range;
 854     nsIDOMNSRange *nsrange;
 855     nsIDOMNode *nsnode;
 856     nsAString ns_html;
 857     HRESULT hr;
 858
 859     TRACE("(%p)->(%s %s)\n", This, debugstr_w(where), debugstr_w(html));
 860
 861     nsres = nsIWebNavigation_GetDocument(This->node.doc->nscontainer->navigation, &nsdoc);
 862     if(NS_FAILED(nsres))
 863     {
 864         ERR("GetDocument failed: %08x\n", nsres);
 865         return E_FAIL;
 866     }
 867
 868     nsres = nsIDOMDocument_QueryInterface(nsdoc, &IID_nsIDOMDocumentRange, (void **)&nsdocrange);
 869     nsIDOMDocument_Release(nsdoc);
 870     if(NS_FAILED(nsres))
 871     {
 872         ERR("getting nsIDOMDocumentRange failed: %08x\n", nsres);
 873         return E_FAIL;
 874     }
 875     nsres = nsIDOMDocumentRange_CreateRange(nsdocrange, &range);
 876     nsIDOMDocumentRange_Release(nsdocrange);
 877     if(NS_FAILED(nsres))
 878     {
 879         ERR("CreateRange failed: %08x\n", nsres);
 880         return E_FAIL;
 881     }
 882
 883     nsIDOMRange_SetStartBefore(range, (nsIDOMNode *)This->nselem);
 884
 885     nsIDOMRange_QueryInterface(range, &IID_nsIDOMNSRange, (void **)&nsrange);
 886     nsIDOMRange_Release(range);
 887     if(NS_FAILED(nsres))
 888     {
 889         ERR("getting nsIDOMNSRange failed: %08x\n", nsres);
 890         return E_FAIL;
 891     }
 892
 893     nsAString_Init(&ns_html, html);
 894
 895     nsres = nsIDOMNSRange_CreateContextualFragment(nsrange, &ns_html, (nsIDOMDocumentFragment **)&nsnode);
 896     nsIDOMNSRange_Release(nsrange);
 897     nsAString_Finish(&ns_html);
 898
 899     if(NS_FAILED(nsres) || !nsnode)
 900     {
 901         ERR("CreateTextNode failed: %08x\n", nsres);
 902         return E_FAIL;
 903     }
 904
 905     hr = HTMLElement_InsertAdjacentNode(This, where, nsnode);
 906     nsIDOMNode_Release(nsnode);
 907
 908     return hr;
 909 }
 910
 911 static HRESULT WINAPI HTMLElement_insertAdjacentText(IHTMLElement *iface, BSTR where,
 912                                                      BSTR text)
 913 {
 914     HTMLElement *This = HTMLELEM_THIS(iface);
 915     nsresult nsres;
 916     nsIDOMDocument *nsdoc;
 917     nsIDOMNode *nsnode;
 918     nsAString ns_text;
 919     HRESULT hr;
 920
 921     TRACE("(%p)->(%s %s)\n", This, debugstr_w(where), debugstr_w(text));
 922
 923     nsres = nsIWebNavigation_GetDocument(This->node.doc->nscontainer->navigation, &nsdoc);
 924     if(NS_FAILED(nsres) || !nsdoc)
 925     {
 926         ERR("GetDocument failed: %08x\n", nsres);
 927         return E_FAIL;
 928     }
 929
 930     nsAString_Init(&ns_text, text);
 931
 932     nsres = nsIDOMDocument_CreateTextNode(nsdoc, &ns_text, (nsIDOMText **)&nsnode);
 933     nsIDOMDocument_Release(nsdoc);
 934     nsAString_Finish(&ns_text);
 935
 936     if(NS_FAILED(nsres) || !nsnode)
 937     {
 938         ERR("CreateTextNode failed: %08x\n", nsres);
 939         return E_FAIL;
 940     }
 941
 942     hr = HTMLElement_InsertAdjacentNode(This, where, nsnode);
 943     nsIDOMNode_Release(nsnode);
 944
 945     return hr;
 946 }
 947
 948 static HRESULT WINAPI HTMLElement_get_parentTextEdit(IHTMLElement *iface, IHTMLElement **p)
 949 {
 950     HTMLElement *This = HTMLELEM_THIS(iface);
 951     FIXME("(%p)->(%p)\n", This, p);
 952     return E_NOTIMPL;
 953 }
 954
 955 static HRESULT WINAPI HTMLElement_get_isTextEdit(IHTMLElement *iface, VARIANT_BOOL *p)
 956 {
 957     HTMLElement *This = HTMLELEM_THIS(iface);
 958     FIXME("(%p)->(%p)\n", This, p);
 959     return E_NOTIMPL;
 960 }
 961
 962 static HRESULT WINAPI HTMLElement_click(IHTMLElement *iface)
 963 {
 964     HTMLElement *This = HTMLELEM_THIS(iface);
 965     FIXME("(%p)\n", This);
 966     return E_NOTIMPL;
 967 }
 968
 969 static HRESULT WINAPI HTMLElement_get_filters(IHTMLElement *iface,
 970                                               IHTMLFiltersCollection **p)
 971 {
 972     HTMLElement *This = HTMLELEM_THIS(iface);
 973     FIXME("(%p)->(%p)\n", This, p);
 974     return E_NOTIMPL;
 975 }
 976
 977 static HRESULT WINAPI HTMLElement_put_ondragstart(IHTMLElement *iface, VARIANT v)
 978 {
 979     HTMLElement *This = HTMLELEM_THIS(iface);
 980     FIXME("(%p)->()\n", This);
 981     return E_NOTIMPL;
 982 }
 983
 984 static HRESULT WINAPI HTMLElement_get_ondragstart(IHTMLElement *iface, VARIANT *p)
 985 {
 986     HTMLElement *This = HTMLELEM_THIS(iface);
 987     FIXME("(%p)->(%p)\n", This, p);
 988     return E_NOTIMPL;
 989 }
 990
 991 static HRESULT WINAPI HTMLElement_toString(IHTMLElement *iface, BSTR *String)
 992 {
 993     HTMLElement *This = HTMLELEM_THIS(iface);
 994     FIXME("(%p)->(%p)\n", This, String);
 995     return E_NOTIMPL;
 996 }
 997
 998 static HRESULT WINAPI HTMLElement_put_onbeforeupdate(IHTMLElement *iface, VARIANT v)
 999 {
1000     HTMLElement *This = HTMLELEM_THIS(iface);
1001     FIXME("(%p)->()\n", This);
1002     return E_NOTIMPL;
1003 }
1004
1005 static HRESULT WINAPI HTMLElement_get_onbeforeupdate(IHTMLElement *iface, VARIANT *p)
1006 {
1007     HTMLElement *This = HTMLELEM_THIS(iface);
1008     FIXME("(%p)->(%p)\n", This, p);
1009     return E_NOTIMPL;
1010 }
1011
1012 static HRESULT WINAPI HTMLElement_put_onafterupdate(IHTMLElement *iface, VARIANT v)
1013 {
1014     HTMLElement *This = HTMLELEM_THIS(iface);
1015     FIXME("(%p)->()\n", This);
1016     return E_NOTIMPL;
1017 }
1018
1019 static HRESULT WINAPI HTMLElement_get_onafterupdate(IHTMLElement *iface, VARIANT *p)
1020 {
1021     HTMLElement *This = HTMLELEM_THIS(iface);
1022     FIXME("(%p)->(%p)\n", This, p);
1023     return E_NOTIMPL;
1024 }
1025
1026 static HRESULT WINAPI HTMLElement_put_onerrorupdate(IHTMLElement *iface, VARIANT v)
1027 {
1028     HTMLElement *This = HTMLELEM_THIS(iface);
1029     FIXME("(%p)->()\n", This);
1030     return E_NOTIMPL;
1031 }
1032
1033 static HRESULT WINAPI HTMLElement_get_onerrorupdate(IHTMLElement *iface, VARIANT *p)
1034 {
1035     HTMLElement *This = HTMLELEM_THIS(iface);
1036     FIXME("(%p)->(%p)\n", This, p);
1037     return E_NOTIMPL;
1038 }
1039
1040 static HRESULT WINAPI HTMLElement_put_onrowexit(IHTMLElement *iface, VARIANT v)
1041 {
1042     HTMLElement *This = HTMLELEM_THIS(iface);
1043     FIXME("(%p)->()\n", This);
1044     return E_NOTIMPL;
1045 }
1046
1047 static HRESULT WINAPI HTMLElement_get_onrowexit(IHTMLElement *iface, VARIANT *p)
1048 {
1049     HTMLElement *This = HTMLELEM_THIS(iface);
1050     FIXME("(%p)->(%p)\n", This, p);
1051     return E_NOTIMPL;
1052 }
1053
1054 static HRESULT WINAPI HTMLElement_put_onrowenter(IHTMLElement *iface, VARIANT v)
1055 {
1056     HTMLElement *This = HTMLELEM_THIS(iface);
1057     FIXME("(%p)->()\n", This);
1058     return E_NOTIMPL;
1059 }
1060
1061 static HRESULT WINAPI HTMLElement_get_onrowenter(IHTMLElement *iface, VARIANT *p)
1062 {
1063     HTMLElement *This = HTMLELEM_THIS(iface);
1064     FIXME("(%p)->(%p)\n", This, p);
1065     return E_NOTIMPL;
1066 }
1067
1068 static HRESULT WINAPI HTMLElement_put_ondatasetchanged(IHTMLElement *iface, VARIANT v)
1069 {
1070     HTMLElement *This = HTMLELEM_THIS(iface);
1071     FIXME("(%p)->()\n", This);
1072     return E_NOTIMPL;
1073 }
1074
1075 static HRESULT WINAPI HTMLElement_get_ondatasetchanged(IHTMLElement *iface, VARIANT *p)
1076 {
1077     HTMLElement *This = HTMLELEM_THIS(iface);
1078     FIXME("(%p)->(%p)\n", This, p);
1079     return E_NOTIMPL;
1080 }
1081
1082 static HRESULT WINAPI HTMLElement_put_ondataavailable(IHTMLElement *iface, VARIANT v)
1083 {
1084     HTMLElement *This = HTMLELEM_THIS(iface);
1085     FIXME("(%p)->()\n", This);
1086     return E_NOTIMPL;
1087 }
1088
1089 static HRESULT WINAPI HTMLElement_get_ondataavailable(IHTMLElement *iface, VARIANT *p)
1090 {
1091     HTMLElement *This = HTMLELEM_THIS(iface);
1092     FIXME("(%p)->(%p)\n", This, p);
1093     return E_NOTIMPL;
1094 }
1095
1096 static HRESULT WINAPI HTMLElement_put_ondatasetcomplete(IHTMLElement *iface, VARIANT v)
1097 {
1098     HTMLElement *This = HTMLELEM_THIS(iface);
1099     FIXME("(%p)->()\n", This);
1100     return E_NOTIMPL;
1101 }
1102
1103 static HRESULT WINAPI HTMLElement_get_ondatasetcomplete(IHTMLElement *iface, VARIANT *p)
1104 {
1105     HTMLElement *This = HTMLELEM_THIS(iface);
1106     FIXME("(%p)->(%p)\n", This, p);
1107     return E_NOTIMPL;
1108 }
1109
1110 static HRESULT WINAPI HTMLElement_put_onfilterchange(IHTMLElement *iface, VARIANT v)
1111 {
1112     HTMLElement *This = HTMLELEM_THIS(iface);
1113     FIXME("(%p)->()\n", This);
1114     return E_NOTIMPL;
1115 }
1116
1117 static HRESULT WINAPI HTMLElement_get_onfilterchange(IHTMLElement *iface, VARIANT *p)
1118 {
1119     HTMLElement *This = HTMLELEM_THIS(iface);
1120     FIXME("(%p)->(%p)\n", This, p);
1121     return E_NOTIMPL;
1122 }
1123
1124 static void create_child_list(HTMLDocument *doc, HTMLElement *elem, elem_vector *buf)
1125 {
1126     nsIDOMNodeList *nsnode_list;
1127     nsIDOMNode *iter;
1128     PRUint32 list_len = 0, i;
1129     nsresult nsres;
1130
1131     nsres = nsIDOMNode_GetChildNodes(elem->node.nsnode, &nsnode_list);
1132     if(NS_FAILED(nsres)) {
1133         ERR("GetChildNodes failed: %08x\n", nsres);
1134         return;
1135     }
1136
1137     nsIDOMNodeList_GetLength(nsnode_list, &list_len);
1138     if(!list_len)
1139         return;
1140
1141     buf->size = list_len;
1142     buf->buf = heap_alloc(buf->size*sizeof(HTMLElement**));
1143
1144     for(i=0; i<list_len; i++) {
1145         nsres = nsIDOMNodeList_Item(nsnode_list, i, &iter);
1146         if(NS_FAILED(nsres)) {
1147             ERR("Item failed: %08x\n", nsres);
1148             continue;
1149         }
1150
1151         if(is_elem_node(iter))
1152             elem_vector_add(buf, HTMLELEM_NODE_THIS(get_node(doc, iter, TRUE)));
1153     }
1154 }
1155
1156 static HRESULT WINAPI HTMLElement_get_children(IHTMLElement *iface, IDispatch **p)
1157 {
1158     HTMLElement *This = HTMLELEM_THIS(iface);
1159     elem_vector buf = {NULL, 0, 0};
1160
1161     TRACE("(%p)->(%p)\n", This, p);
1162
1163     create_child_list(This->node.doc, This, &buf);
1164
1165     *p = (IDispatch*)HTMLElementCollection_Create((IUnknown*)HTMLELEM(This), buf.buf, buf.len);
1166     return S_OK;
1167 }
1168
1169 static void create_all_list(HTMLDocument *doc, HTMLDOMNode *elem, elem_vector *buf)
1170 {
1171     nsIDOMNodeList *nsnode_list;
1172     nsIDOMNode *iter;
1173     PRUint32 list_len = 0, i;
1174     nsresult nsres;
1175
1176     nsres = nsIDOMNode_GetChildNodes(elem->nsnode, &nsnode_list);
1177     if(NS_FAILED(nsres)) {
1178         ERR("GetChildNodes failed: %08x\n", nsres);
1179         return;
1180     }
1181
1182     nsIDOMNodeList_GetLength(nsnode_list, &list_len);
1183     if(!list_len)
1184         return;
1185
1186     for(i=0; i<list_len; i++) {
1187         nsres = nsIDOMNodeList_Item(nsnode_list, i, &iter);
1188         if(NS_FAILED(nsres)) {
1189             ERR("Item failed: %08x\n", nsres);
1190             continue;
1191         }
1192
1193         if(is_elem_node(iter)) {
1194             HTMLDOMNode *node = get_node(doc, iter, TRUE);
1195
1196             elem_vector_add(buf, HTMLELEM_NODE_THIS(node));
1197             create_all_list(doc, node, buf);
1198         }
1199     }
1200 }
1201
1202 static HRESULT WINAPI HTMLElement_get_all(IHTMLElement *iface, IDispatch **p)
1203 {
1204     HTMLElement *This = HTMLELEM_THIS(iface);
1205     elem_vector buf = {NULL, 0, 8};
1206
1207     TRACE("(%p)->(%p)\n", This, p);
1208
1209     buf.buf = heap_alloc(buf.size*sizeof(HTMLElement**));
1210
1211     create_all_list(This->node.doc, &This->node, &buf);
1212     elem_vector_normalize(&buf);
1213
1214     *p = (IDispatch*)HTMLElementCollection_Create((IUnknown*)HTMLELEM(This), buf.buf, buf.len);
1215     return S_OK;
1216 }
1217
1218 #undef HTMLELEM_THIS
1219
1220 static const IHTMLElementVtbl HTMLElementVtbl = {
1221     HTMLElement_QueryInterface,
1222     HTMLElement_AddRef,
1223     HTMLElement_Release,
1224     HTMLElement_GetTypeInfoCount,
1225     HTMLElement_GetTypeInfo,
1226     HTMLElement_GetIDsOfNames,
1227     HTMLElement_Invoke,
1228     HTMLElement_setAttribute,
1229     HTMLElement_getAttribute,
1230     HTMLElement_removeAttribute,
1231     HTMLElement_put_className,
1232     HTMLElement_get_className,
1233     HTMLElement_put_id,
1234     HTMLElement_get_id,
1235     HTMLElement_get_tagName,
1236     HTMLElement_get_parentElement,
1237     HTMLElement_get_style,
1238     HTMLElement_put_onhelp,
1239     HTMLElement_get_onhelp,
1240     HTMLElement_put_onclick,
1241     HTMLElement_get_onclick,
1242     HTMLElement_put_ondblclick,
1243     HTMLElement_get_ondblclick,
1244     HTMLElement_put_onkeydown,
1245     HTMLElement_get_onkeydown,
1246     HTMLElement_put_onkeyup,
1247     HTMLElement_get_onkeyup,
1248     HTMLElement_put_onkeypress,
1249     HTMLElement_get_onkeypress,
1250     HTMLElement_put_onmouseout,
1251     HTMLElement_get_onmouseout,
1252     HTMLElement_put_onmouseover,
1253     HTMLElement_get_onmouseover,
1254     HTMLElement_put_onmousemove,
1255     HTMLElement_get_onmousemove,
1256     HTMLElement_put_onmousedown,
1257     HTMLElement_get_onmousedown,
1258     HTMLElement_put_onmouseup,
1259     HTMLElement_get_onmouseup,
1260     HTMLElement_get_document,
1261     HTMLElement_put_title,
1262     HTMLElement_get_title,
1263     HTMLElement_put_language,
1264     HTMLElement_get_language,
1265     HTMLElement_put_onselectstart,
1266     HTMLElement_get_onselectstart,
1267     HTMLElement_scrollIntoView,
1268     HTMLElement_contains,
1269     HTMLElement_get_sourceIndex,
1270     HTMLElement_get_recordNumber,
1271     HTMLElement_put_lang,
1272     HTMLElement_get_lang,
1273     HTMLElement_get_offsetLeft,
1274     HTMLElement_get_offsetTop,
1275     HTMLElement_get_offsetWidth,
1276     HTMLElement_get_offsetHeight,
1277     HTMLElement_get_offsetParent,
1278     HTMLElement_put_innerHTML,
1279     HTMLElement_get_innerHTML,
1280     HTMLElement_put_innerText,
1281     HTMLElement_get_innerText,
1282     HTMLElement_put_outerHTML,
1283     HTMLElement_get_outerHTML,
1284     HTMLElement_put_outerText,
1285     HTMLElement_get_outerText,
1286     HTMLElement_insertAdjacentHTML,
1287     HTMLElement_insertAdjacentText,
1288     HTMLElement_get_parentTextEdit,
1289     HTMLElement_get_isTextEdit,
1290     HTMLElement_click,
1291     HTMLElement_get_filters,
1292     HTMLElement_put_ondragstart,
1293     HTMLElement_get_ondragstart,
1294     HTMLElement_toString,
1295     HTMLElement_put_onbeforeupdate,
1296     HTMLElement_get_onbeforeupdate,
1297     HTMLElement_put_onafterupdate,
1298     HTMLElement_get_onafterupdate,
1299     HTMLElement_put_onerrorupdate,
1300     HTMLElement_get_onerrorupdate,
1301     HTMLElement_put_onrowexit,
1302     HTMLElement_get_onrowexit,
1303     HTMLElement_put_onrowenter,
1304     HTMLElement_get_onrowenter,
1305     HTMLElement_put_ondatasetchanged,
1306     HTMLElement_get_ondatasetchanged,
1307     HTMLElement_put_ondataavailable,
1308     HTMLElement_get_ondataavailable,
1309     HTMLElement_put_ondatasetcomplete,
1310     HTMLElement_get_ondatasetcomplete,
1311     HTMLElement_put_onfilterchange,
1312     HTMLElement_get_onfilterchange,
1313     HTMLElement_get_children,
1314     HTMLElement_get_all
1315 };
1316
1317 HRESULT HTMLElement_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
1318 {
1319     HTMLElement *This = HTMLELEM_NODE_THIS(iface);
1320
1321     *ppv =  NULL;
1322
1323     if(IsEqualGUID(&IID_IUnknown, riid)) {
1324         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
1325         *ppv = HTMLELEM(This);
1326     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
1327         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
1328         *ppv = HTMLELEM(This);
1329     }else if(IsEqualGUID(&IID_IHTMLElement, riid)) {
1330         TRACE("(%p)->(IID_IHTMLElement %p)\n", This, ppv);
1331         *ppv = HTMLELEM(This);
1332     }else if(IsEqualGUID(&IID_IHTMLElement2, riid)) {
1333         TRACE("(%p)->(IID_IHTMLElement2 %p)\n", This, ppv);
1334         *ppv = HTMLELEM2(This);
1335     }else if(IsEqualGUID(&IID_IConnectionPointContainer, riid)) {
1336         TRACE("(%p)->(IID_IConnectionPointContainer %p)\n", This, ppv);
1337         *ppv = CONPTCONT(&This->cp_container);
1338     }
1339
1340     if(*ppv) {
1341         IHTMLElement_AddRef(HTMLELEM(This));
1342         return S_OK;
1343     }
1344
1345     return HTMLDOMNode_QI(&This->node, riid, ppv);
1346 }
1347
1348 void HTMLElement_destructor(HTMLDOMNode *iface)
1349 {
1350     HTMLElement *This = HTMLELEM_NODE_THIS(iface);
1351
1352     ConnectionPointContainer_Destroy(&This->cp_container);
1353
1354     if(This->nselem)
1355         nsIDOMHTMLElement_Release(This->nselem);
1356
1357     HTMLDOMNode_destructor(&This->node);
1358 }
1359
1360 static const NodeImplVtbl HTMLElementImplVtbl = {
1361     HTMLElement_QI,
1362     HTMLElement_destructor
1363 };
1364
1365 static const tid_t HTMLElement_iface_tids[] = {
1366     IHTMLDOMNode_tid,
1367     IHTMLDOMNode2_tid,
1368     IHTMLElement_tid,
1369     IHTMLElement2_tid,
1370     0
1371 };
1372 static dispex_static_data_t HTMLElement_dispex = {
1373     NULL,
1374     DispHTMLUnknownElement_tid,
1375     NULL,
1376     HTMLElement_iface_tids
1377 };
1378
1379 void HTMLElement_Init(HTMLElement *This)
1380 {
1381     This->lpHTMLElementVtbl = &HTMLElementVtbl;
1382
1383     ConnectionPointContainer_Init(&This->cp_container, (IUnknown*)HTMLELEM(This));
1384
1385     HTMLElement2_Init(This);
1386
1387     if(!This->node.dispex.data)
1388         init_dispex(&This->node.dispex, (IUnknown*)HTMLELEM(This), &HTMLElement_dispex);
1389 }
1390
1391 HTMLElement *HTMLElement_Create(nsIDOMNode *nsnode)
1392 {
1393     nsIDOMHTMLElement *nselem;
1394     HTMLElement *ret = NULL;
1395     nsAString class_name_str;
1396     const PRUnichar *class_name;
1397     nsresult nsres;
1398
1399     static const WCHAR wszA[]        = {'A',0};
1400     static const WCHAR wszBODY[]     = {'B','O','D','Y',0};
1401     static const WCHAR wszIMG[]      = {'I','M','G',0};
1402     static const WCHAR wszINPUT[]    = {'I','N','P','U','T',0};
1403     static const WCHAR wszOPTION[]   = {'O','P','T','I','O','N',0};
1404     static const WCHAR wszSCRIPT[]   = {'S','C','R','I','P','T',0};
1405     static const WCHAR wszSELECT[]   = {'S','E','L','E','C','T',0};
1406     static const WCHAR wszTABLE[]    = {'T','A','B','L','E',0};
1407     static const WCHAR wszTEXTAREA[] = {'T','E','X','T','A','R','E','A',0};
1408
1409     nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMHTMLElement, (void**)&nselem);
1410     if(NS_FAILED(nsres))
1411         return NULL;
1412
1413     nsAString_Init(&class_name_str, NULL);
1414     nsIDOMHTMLElement_GetTagName(nselem, &class_name_str);
1415
1416     nsAString_GetData(&class_name_str, &class_name);
1417
1418     if(!strcmpW(class_name, wszA))
1419         ret = HTMLAnchorElement_Create(nselem);
1420     else if(!strcmpW(class_name, wszBODY))
1421         ret = HTMLBodyElement_Create(nselem);
1422     else if(!strcmpW(class_name, wszIMG))
1423         ret = HTMLImgElement_Create(nselem);
1424     else if(!strcmpW(class_name, wszINPUT))
1425         ret = HTMLInputElement_Create(nselem);
1426     else if(!strcmpW(class_name, wszOPTION))
1427         ret = HTMLOptionElement_Create(nselem);
1428     else if(!strcmpW(class_name, wszSCRIPT))
1429         ret = HTMLScriptElement_Create(nselem);
1430     else if(!strcmpW(class_name, wszSELECT))
1431         ret = HTMLSelectElement_Create(nselem);
1432     else if(!strcmpW(class_name, wszTABLE))
1433         ret = HTMLTable_Create(nselem);
1434     else if(!strcmpW(class_name, wszTEXTAREA))
1435         ret = HTMLTextAreaElement_Create(nselem);
1436
1437     if(!ret) {
1438         ret = heap_alloc_zero(sizeof(HTMLElement));
1439         HTMLElement_Init(ret);
1440         ret->node.vtbl = &HTMLElementImplVtbl;
1441    }
1442
1443     nsAString_Finish(&class_name_str);
1444
1445     ret->nselem = nselem;
1446
1447     return ret;
1448 }
1449
1450 typedef struct {
1451     DispatchEx dispex;
1452     const IHTMLElementCollectionVtbl *lpHTMLElementCollectionVtbl;
1453
1454     IUnknown *ref_unk;
1455     HTMLElement **elems;
1456     DWORD len;
1457
1458     LONG ref;
1459 } HTMLElementCollection;
1460
1461 #define HTMLELEMCOL(x)  ((IHTMLElementCollection*) &(x)->lpHTMLElementCollectionVtbl)
1462
1463 #define ELEMCOL_THIS(iface) DEFINE_THIS(HTMLElementCollection, HTMLElementCollection, iface)
1464
1465 static HRESULT WINAPI HTMLElementCollection_QueryInterface(IHTMLElementCollection *iface,
1466                                                            REFIID riid, void **ppv)
1467 {
1468     HTMLElementCollection *This = ELEMCOL_THIS(iface);
1469
1470     *ppv = NULL;
1471
1472     if(IsEqualGUID(&IID_IUnknown, riid)) {
1473         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
1474         *ppv = HTMLELEMCOL(This);
1475     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
1476         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
1477         *ppv = HTMLELEMCOL(This);
1478     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
1479         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
1480         *ppv = DISPATCHEX(&This->dispex);
1481     }else if(IsEqualGUID(&IID_IHTMLElementCollection, riid)) {
1482         TRACE("(%p)->(IID_IHTMLElementCollection %p)\n", This, ppv);
1483         *ppv = HTMLELEMCOL(This);
1484     }
1485
1486     if(*ppv) {
1487         IHTMLElementCollection_AddRef(HTMLELEMCOL(This));
1488         return S_OK;
1489     }
1490
1491     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
1492     return E_NOINTERFACE;
1493 }
1494
1495 static ULONG WINAPI HTMLElementCollection_AddRef(IHTMLElementCollection *iface)
1496 {
1497     HTMLElementCollection *This = ELEMCOL_THIS(iface);
1498     LONG ref = InterlockedIncrement(&This->ref);
1499
1500     TRACE("(%p) ref=%d\n", This, ref);
1501
1502     return ref;
1503 }
1504
1505 static ULONG WINAPI HTMLElementCollection_Release(IHTMLElementCollection *iface)
1506 {
1507     HTMLElementCollection *This = ELEMCOL_THIS(iface);
1508     LONG ref = InterlockedDecrement(&This->ref);
1509
1510     TRACE("(%p) ref=%d\n", This, ref);
1511
1512     if(!ref) {
1513         IUnknown_Release(This->ref_unk);
1514         heap_free(This->elems);
1515         heap_free(This);
1516     }
1517
1518     return ref;
1519 }
1520
1521 static HRESULT WINAPI HTMLElementCollection_GetTypeInfoCount(IHTMLElementCollection *iface,
1522                                                              UINT *pctinfo)
1523 {
1524     HTMLElementCollection *This = ELEMCOL_THIS(iface);
1525     FIXME("(%p)->(%p)\n", This, pctinfo);
1526     return E_NOTIMPL;
1527 }
1528
1529 static HRESULT WINAPI HTMLElementCollection_GetTypeInfo(IHTMLElementCollection *iface,
1530         UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1531 {
1532     HTMLElementCollection *This = ELEMCOL_THIS(iface);
1533     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1534     return E_NOTIMPL;
1535 }
1536
1537 static HRESULT WINAPI HTMLElementCollection_GetIDsOfNames(IHTMLElementCollection *iface,
1538         REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1539 {
1540     HTMLElementCollection *This = ELEMCOL_THIS(iface);
1541     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1542                                         lcid, rgDispId);
1543     return E_NOTIMPL;
1544 }
1545
1546 static HRESULT WINAPI HTMLElementCollection_Invoke(IHTMLElementCollection *iface,
1547         DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1548         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1549 {
1550     HTMLElementCollection *This = ELEMCOL_THIS(iface);
1551     FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1552             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1553     return E_NOTIMPL;
1554 }
1555
1556 static HRESULT WINAPI HTMLElementCollection_toString(IHTMLElementCollection *iface,
1557                                                      BSTR *String)
1558 {
1559     HTMLElementCollection *This = ELEMCOL_THIS(iface);
1560     FIXME("(%p)->(%p)\n", This, String);
1561     return E_NOTIMPL;
1562 }
1563
1564 static HRESULT WINAPI HTMLElementCollection_put_length(IHTMLElementCollection *iface,
1565                                                        long v)
1566 {
1567     HTMLElementCollection *This = ELEMCOL_THIS(iface);
1568     FIXME("(%p)->(%ld)\n", This, v);
1569     return E_NOTIMPL;
1570 }
1571
1572 static HRESULT WINAPI HTMLElementCollection_get_length(IHTMLElementCollection *iface,
1573                                                        long *p)
1574 {
1575     HTMLElementCollection *This = ELEMCOL_THIS(iface);
1576
1577     TRACE("(%p)->(%p)\n", This, p);
1578
1579     *p = This->len;
1580     return S_OK;
1581 }
1582
1583 static HRESULT WINAPI HTMLElementCollection_get__newEnum(IHTMLElementCollection *iface,
1584                                                          IUnknown **p)
1585 {
1586     HTMLElementCollection *This = ELEMCOL_THIS(iface);
1587     FIXME("(%p)->(%p)\n", This, p);
1588     return E_NOTIMPL;
1589 }
1590
1591 static BOOL is_elem_name(HTMLElement *elem, LPCWSTR name)
1592 {
1593     const PRUnichar *str;
1594     nsAString nsstr, nsname;
1595     BOOL ret = FALSE;
1596     nsresult nsres;
1597
1598     static const PRUnichar nameW[] = {'n','a','m','e',0};
1599
1600     if(!elem->nselem)
1601         return FALSE;
1602
1603     nsAString_Init(&nsstr, NULL);
1604     nsIDOMHTMLElement_GetId(elem->nselem, &nsstr);
1605     nsAString_GetData(&nsstr, &str);
1606     if(!strcmpiW(str, name)) {
1607         nsAString_Finish(&nsstr);
1608         return TRUE;
1609     }
1610
1611     nsAString_Init(&nsname, nameW);
1612     nsres =  nsIDOMHTMLElement_GetAttribute(elem->nselem, &nsname, &nsstr);
1613     nsAString_Finish(&nsname);
1614     if(NS_SUCCEEDED(nsres)) {
1615         nsAString_GetData(&nsstr, &str);
1616         ret = !strcmpiW(str, name);
1617     }
1618
1619     nsAString_Finish(&nsstr);
1620     return ret;
1621 }
1622
1623 static HRESULT WINAPI HTMLElementCollection_item(IHTMLElementCollection *iface,
1624         VARIANT name, VARIANT index, IDispatch **pdisp)
1625 {
1626     HTMLElementCollection *This = ELEMCOL_THIS(iface);
1627
1628     TRACE("(%p)->(v(%d) v(%d) %p)\n", This, V_VT(&name), V_VT(&index), pdisp);
1629
1630     *pdisp = NULL;
1631
1632     if(V_VT(&name) == VT_I4) {
1633         TRACE("name is VT_I4: %d\n", V_I4(&name));
1634
1635         if(V_I4(&name) < 0)
1636             return E_INVALIDARG;
1637         if(V_I4(&name) >= This->len)
1638             return S_OK;
1639
1640         *pdisp = (IDispatch*)This->elems[V_I4(&name)];
1641         IDispatch_AddRef(*pdisp);
1642         TRACE("Returning pdisp=%p\n", pdisp);
1643         return S_OK;
1644     }
1645
1646     if(V_VT(&name) == VT_BSTR) {
1647         DWORD i;
1648
1649         TRACE("name is VT_BSTR: %s\n", debugstr_w(V_BSTR(&name)));
1650
1651         if(V_VT(&index) == VT_I4) {
1652             LONG idx = V_I4(&index);
1653
1654             TRACE("index = %d\n", idx);
1655
1656             if(idx < 0)
1657                 return E_INVALIDARG;
1658
1659             for(i=0; i<This->len; i++) {
1660                 if(is_elem_name(This->elems[i], V_BSTR(&name)) && !idx--)
1661                     break;
1662             }
1663
1664             if(i != This->len) {
1665                 *pdisp = (IDispatch*)HTMLELEM(This->elems[i]);
1666                 IDispatch_AddRef(*pdisp);
1667             }
1668
1669             return S_OK;
1670         }else {
1671             elem_vector buf = {NULL, 0, 8};
1672
1673             buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
1674
1675             for(i=0; i<This->len; i++) {
1676                 if(is_elem_name(This->elems[i], V_BSTR(&name)))
1677                     elem_vector_add(&buf, This->elems[i]);
1678             }
1679
1680             if(buf.len > 1) {
1681                 elem_vector_normalize(&buf);
1682                 *pdisp = (IDispatch*)HTMLElementCollection_Create(This->ref_unk, buf.buf, buf.len);
1683             }else {
1684                 if(buf.len == 1) {
1685                     *pdisp = (IDispatch*)HTMLELEM(buf.buf[0]);
1686                     IDispatch_AddRef(*pdisp);
1687                 }
1688
1689                 heap_free(buf.buf);
1690             }
1691
1692             return S_OK;
1693         }
1694     }
1695
1696     FIXME("unsupported arguments\n");
1697     return E_INVALIDARG;
1698 }
1699
1700 static HRESULT WINAPI HTMLElementCollection_tags(IHTMLElementCollection *iface,
1701                                                  VARIANT tagName, IDispatch **pdisp)
1702 {
1703     HTMLElementCollection *This = ELEMCOL_THIS(iface);
1704     DWORD i;
1705     nsAString tag_str;
1706     const PRUnichar *tag;
1707     elem_vector buf = {NULL, 0, 8};
1708
1709     if(V_VT(&tagName) != VT_BSTR) {
1710         WARN("Invalid arg\n");
1711         return DISP_E_MEMBERNOTFOUND;
1712     }
1713
1714     TRACE("(%p)->(%s %p)\n", This, debugstr_w(V_BSTR(&tagName)), pdisp);
1715
1716     buf.buf = heap_alloc(buf.size*sizeof(HTMLElement*));
1717
1718     nsAString_Init(&tag_str, NULL);
1719
1720     for(i=0; i<This->len; i++) {
1721         if(!This->elems[i]->nselem)
1722             continue;
1723
1724         nsIDOMElement_GetTagName(This->elems[i]->nselem, &tag_str);
1725         nsAString_GetData(&tag_str, &tag);
1726
1727         if(CompareStringW(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE, tag, -1,
1728                           V_BSTR(&tagName), -1) == CSTR_EQUAL)
1729             elem_vector_add(&buf, This->elems[i]);
1730     }
1731
1732     nsAString_Finish(&tag_str);
1733     elem_vector_normalize(&buf);
1734
1735     TRACE("fount %d tags\n", buf.len);
1736
1737     *pdisp = (IDispatch*)HTMLElementCollection_Create(This->ref_unk, buf.buf, buf.len);
1738     return S_OK;
1739 }
1740
1741 #define DISPID_ELEMCOL_0 MSHTML_DISPID_CUSTOM_MIN
1742
1743 static HRESULT HTMLElementCollection_get_dispid(IUnknown *iface, BSTR name, DWORD flags, DISPID *dispid)
1744 {
1745     HTMLElementCollection *This = ELEMCOL_THIS(iface);
1746     WCHAR *ptr;
1747     DWORD idx=0;
1748
1749     for(ptr = name; *ptr && isdigitW(*ptr); ptr++)
1750         idx = idx*10 + (*ptr-'0');
1751
1752     if(*ptr || idx >= This->len)
1753         return DISP_E_UNKNOWNNAME;
1754
1755     *dispid = DISPID_ELEMCOL_0 + idx;
1756     TRACE("ret %x\n", *dispid);
1757     return S_OK;
1758 }
1759
1760 static HRESULT HTMLElementCollection_invoke(IUnknown *iface, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
1761         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
1762 {
1763     HTMLElementCollection *This = ELEMCOL_THIS(iface);
1764     DWORD idx;
1765
1766     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, flags, params, res, ei, caller);
1767
1768     idx = id - DISPID_ELEMCOL_0;
1769     if(idx >= This->len)
1770         return DISP_E_UNKNOWNNAME;
1771
1772     switch(flags) {
1773     case INVOKE_PROPERTYGET:
1774         V_VT(res) = VT_DISPATCH;
1775         V_DISPATCH(res) = (IDispatch*)HTMLELEM(This->elems[idx]);
1776         IHTMLElement_AddRef(HTMLELEM(This->elems[idx]));
1777         break;
1778     default:
1779         FIXME("unimplemented flags %x\n", flags);
1780         return E_NOTIMPL;
1781     }
1782
1783     return S_OK;
1784 }
1785
1786 #undef ELEMCOL_THIS
1787
1788 static const IHTMLElementCollectionVtbl HTMLElementCollectionVtbl = {
1789     HTMLElementCollection_QueryInterface,
1790     HTMLElementCollection_AddRef,
1791     HTMLElementCollection_Release,
1792     HTMLElementCollection_GetTypeInfoCount,
1793     HTMLElementCollection_GetTypeInfo,
1794     HTMLElementCollection_GetIDsOfNames,
1795     HTMLElementCollection_Invoke,
1796     HTMLElementCollection_toString,
1797     HTMLElementCollection_put_length,
1798     HTMLElementCollection_get_length,
1799     HTMLElementCollection_get__newEnum,
1800     HTMLElementCollection_item,
1801     HTMLElementCollection_tags
1802 };
1803
1804 static const dispex_static_data_vtbl_t HTMLElementColection_dispex_vtbl = {
1805     HTMLElementCollection_get_dispid,
1806     HTMLElementCollection_invoke
1807 };
1808
1809 static const tid_t HTMLElementCollection_iface_tids[] = {
1810     IHTMLElementCollection_tid,
1811     0
1812 };
1813 static dispex_static_data_t HTMLElementCollection_dispex = {
1814     &HTMLElementColection_dispex_vtbl,
1815     DispHTMLElementCollection_tid,
1816     NULL,
1817     HTMLElementCollection_iface_tids
1818 };
1819
1820 IHTMLElementCollection *create_all_collection(HTMLDOMNode *node)
1821 {
1822     elem_vector buf = {NULL, 0, 8};
1823
1824     buf.buf = heap_alloc(buf.size*sizeof(HTMLElement**));
1825
1826     elem_vector_add(&buf, HTMLELEM_NODE_THIS(node));
1827     create_all_list(node->doc, node, &buf);
1828     elem_vector_normalize(&buf);
1829
1830     return HTMLElementCollection_Create((IUnknown*)HTMLDOMNODE(node), buf.buf, buf.len);
1831 }
1832
1833 static IHTMLElementCollection *HTMLElementCollection_Create(IUnknown *ref_unk,
1834             HTMLElement **elems, DWORD len)
1835 {
1836     HTMLElementCollection *ret = heap_alloc_zero(sizeof(HTMLElementCollection));
1837
1838     ret->lpHTMLElementCollectionVtbl = &HTMLElementCollectionVtbl;
1839     ret->ref = 1;
1840     ret->elems = elems;
1841     ret->len = len;
1842
1843     init_dispex(&ret->dispex, (IUnknown*)HTMLELEMCOL(ret), &HTMLElementCollection_dispex);
1844
1845     IUnknown_AddRef(ref_unk);
1846     ret->ref_unk = ref_unk;
1847
1848     TRACE("ret=%p len=%d\n", ret, len);
1849
1850     return HTMLELEMCOL(ret);
1851 }