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