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
  33 #include "mshtml_private.h"
  34 #include "htmlevent.h"
  35 #include "htmlstyle.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  38
  39 static const WCHAR aW[]        = {'A',0};
  40 static const WCHAR bodyW[]     = {'B','O','D','Y',0};
  41 static const WCHAR embedW[]    = {'E','M','B','E','D',0};
  42 static const WCHAR formW[]     = {'F','O','R','M',0};
  43 static const WCHAR frameW[]    = {'F','R','A','M','E',0};
  44 static const WCHAR headW[]     = {'H','E','A','D',0};
  45 static const WCHAR iframeW[]   = {'I','F','R','A','M','E',0};
  46 static const WCHAR imgW[]      = {'I','M','G',0};
  47 static const WCHAR inputW[]    = {'I','N','P','U','T',0};
  48 static const WCHAR objectW[]   = {'O','B','J','E','C','T',0};
  49 static const WCHAR optionW[]   = {'O','P','T','I','O','N',0};
  50 static const WCHAR scriptW[]   = {'S','C','R','I','P','T',0};
  51 static const WCHAR selectW[]   = {'S','E','L','E','C','T',0};
  52 static const WCHAR styleW[]    = {'S','T','Y','L','E',0};
  53 static const WCHAR tableW[]    = {'T','A','B','L','E',0};
  54 static const WCHAR textareaW[] = {'T','E','X','T','A','R','E','A',0};
  55 static const WCHAR title_tagW[]= {'T','I','T','L','E',0};
  56 static const WCHAR trW[]       = {'T','R',0};
  57
  58 typedef struct {
  59     const WCHAR *name;
  60     HRESULT (*constructor)(HTMLDocumentNode*,nsIDOMHTMLElement*,HTMLElement**);
  61 } tag_desc_t;
  62
  63 static const tag_desc_t tag_descs[] = {
  64     {aW,         HTMLAnchorElement_Create},
  65     {bodyW,      HTMLBodyElement_Create},
  66     {embedW,     HTMLEmbedElement_Create},
  67     {formW,      HTMLFormElement_Create},
  68     {frameW,     HTMLFrameElement_Create},
  69     {headW,      HTMLHeadElement_Create},
  70     {iframeW,    HTMLIFrame_Create},
  71     {imgW,       HTMLImgElement_Create},
  72     {inputW,     HTMLInputElement_Create},
  73     {objectW,    HTMLObjectElement_Create},
  74     {optionW,    HTMLOptionElement_Create},
  75     {scriptW,    HTMLScriptElement_Create},
  76     {selectW,    HTMLSelectElement_Create},
  77     {styleW,     HTMLStyleElement_Create},
  78     {tableW,     HTMLTable_Create},
  79     {textareaW,  HTMLTextAreaElement_Create},
  80     {title_tagW, HTMLTitleElement_Create},
  81     {trW,        HTMLTableRow_Create}
  82 };
  83
  84 static const tag_desc_t *get_tag_desc(const WCHAR *tag_name)
  85 {
  86     DWORD min=0, max=sizeof(tag_descs)/sizeof(*tag_descs)-1, i;
  87     int r;
  88
  89     while(min <= max) {
  90         i = (min+max)/2;
  91         r = strcmpW(tag_name, tag_descs[i].name);
  92         if(!r)
  93             return tag_descs+i;
  94
  95         if(r < 0)
  96             max = i-1;
  97         else
  98             min = i+1;
  99     }
 100
 101     return NULL;
 102 }
 103
 104 HRESULT replace_node_by_html(nsIDOMHTMLDocument *nsdoc, nsIDOMNode *nsnode, const WCHAR *html)
 105 {
 106     nsIDOMDocumentFragment *nsfragment;
 107     nsIDOMNSRange *nsrange;
 108     nsIDOMNode *nsparent;
 109     nsIDOMRange *range;
 110     nsAString html_str;
 111     nsresult nsres;
 112     HRESULT hres = S_OK;
 113
 114     nsres = nsIDOMHTMLDocument_CreateRange(nsdoc, &range);
 115     if(NS_FAILED(nsres)) {
 116         ERR("CreateRange failed: %08x\n", nsres);
 117         return E_FAIL;
 118     }
 119
 120     nsres = nsIDOMRange_QueryInterface(range, &IID_nsIDOMNSRange, (void**)&nsrange);
 121     nsIDOMRange_Release(range);
 122     if(NS_FAILED(nsres)) {
 123         ERR("Could not get nsIDOMNSRange: %08x\n", nsres);
 124         return E_FAIL;
 125     }
 126
 127     nsAString_InitDepend(&html_str, html);
 128     nsIDOMNSRange_CreateContextualFragment(nsrange, &html_str, &nsfragment);
 129     nsIDOMNSRange_Release(nsrange);
 130     nsAString_Finish(&html_str);
 131     if(NS_FAILED(nsres)) {
 132         ERR("CreateContextualFragment failed: %08x\n", nsres);
 133         return E_FAIL;
 134     }
 135
 136     nsres = nsIDOMNode_GetParentNode(nsnode, &nsparent);
 137     if(NS_SUCCEEDED(nsres) && nsparent) {
 138         nsIDOMNode *nstmp;
 139
 140         nsres = nsIDOMNode_ReplaceChild(nsparent, (nsIDOMNode*)nsfragment, nsnode, &nstmp);
 141         nsIDOMNode_Release(nsparent);
 142         if(NS_FAILED(nsres)) {
 143             ERR("ReplaceChild failed: %08x\n", nsres);
 144             hres = E_FAIL;
 145         }else if(nstmp) {
 146             nsIDOMNode_Release(nstmp);
 147         }
 148     }else {
 149         ERR("GetParentNode failed: %08x\n", nsres);
 150         hres = E_FAIL;
 151     }
 152
 153     nsIDOMDocumentFragment_Release(nsfragment);
 154     return hres;
 155 }
 156
 157 typedef struct
 158 {
 159     DispatchEx dispex;
 160     IHTMLFiltersCollection IHTMLFiltersCollection_iface;
 161
 162     LONG ref;
 163 } HTMLFiltersCollection;
 164
 165 static inline HTMLFiltersCollection *impl_from_IHTMLFiltersCollection(IHTMLFiltersCollection *iface)
 166 {
 167     return CONTAINING_RECORD(iface, HTMLFiltersCollection, IHTMLFiltersCollection_iface);
 168 }
 169
 170 static IHTMLFiltersCollection *HTMLFiltersCollection_Create(void);
 171
 172 static inline HTMLElement *impl_from_IHTMLElement(IHTMLElement *iface)
 173 {
 174     return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement_iface);
 175 }
 176
 177 HRESULT create_nselem(HTMLDocumentNode *doc, const WCHAR *tag, nsIDOMHTMLElement **ret)
 178 {
 179     nsIDOMElement *nselem;
 180     nsAString tag_str;
 181     nsresult nsres;
 182
 183     if(!doc->nsdoc) {
 184         WARN("NULL nsdoc\n");
 185         return E_UNEXPECTED;
 186     }
 187
 188     nsAString_InitDepend(&tag_str, tag);
 189     nsres = nsIDOMDocument_CreateElement(doc->nsdoc, &tag_str, &nselem);
 190     nsAString_Finish(&tag_str);
 191     if(NS_FAILED(nsres)) {
 192         ERR("CreateElement failed: %08x\n", nsres);
 193         return E_FAIL;
 194     }
 195
 196     nsres = nsIDOMElement_QueryInterface(nselem, &IID_nsIDOMHTMLElement, (void**)ret);
 197     nsIDOMElement_Release(nselem);
 198     if(NS_FAILED(nsres)) {
 199         ERR("Could not get nsIDOMHTMLElement iface: %08x\n", nsres);
 200         return E_FAIL;
 201     }
 202
 203     return S_OK;
 204 }
 205
 206 static HRESULT WINAPI HTMLElement_QueryInterface(IHTMLElement *iface,
 207                                                  REFIID riid, void **ppv)
 208 {
 209     HTMLElement *This = impl_from_IHTMLElement(iface);
 210
 211     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
 212 }
 213
 214 static ULONG WINAPI HTMLElement_AddRef(IHTMLElement *iface)
 215 {
 216     HTMLElement *This = impl_from_IHTMLElement(iface);
 217
 218     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
 219 }
 220
 221 static ULONG WINAPI HTMLElement_Release(IHTMLElement *iface)
 222 {
 223     HTMLElement *This = impl_from_IHTMLElement(iface);
 224
 225     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
 226 }
 227
 228 static HRESULT WINAPI HTMLElement_GetTypeInfoCount(IHTMLElement *iface, UINT *pctinfo)
 229 {
 230     HTMLElement *This = impl_from_IHTMLElement(iface);
 231     return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
 232 }
 233
 234 static HRESULT WINAPI HTMLElement_GetTypeInfo(IHTMLElement *iface, UINT iTInfo,
 235                                               LCID lcid, ITypeInfo **ppTInfo)
 236 {
 237     HTMLElement *This = impl_from_IHTMLElement(iface);
 238     return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 239 }
 240
 241 static HRESULT WINAPI HTMLElement_GetIDsOfNames(IHTMLElement *iface, REFIID riid,
 242                                                 LPOLESTR *rgszNames, UINT cNames,
 243                                                 LCID lcid, DISPID *rgDispId)
 244 {
 245     HTMLElement *This = impl_from_IHTMLElement(iface);
 246     return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 247             lcid, rgDispId);
 248 }
 249
 250 static HRESULT WINAPI HTMLElement_Invoke(IHTMLElement *iface, DISPID dispIdMember,
 251                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 252                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 253 {
 254     HTMLElement *This = impl_from_IHTMLElement(iface);
 255     return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 256             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 257 }
 258
 259 static HRESULT WINAPI HTMLElement_setAttribute(IHTMLElement *iface, BSTR strAttributeName,
 260                                                VARIANT AttributeValue, LONG lFlags)
 261 {
 262     HTMLElement *This = impl_from_IHTMLElement(iface);
 263     HRESULT hres;
 264     DISPID dispid, dispidNamed = DISPID_PROPERTYPUT;
 265     DISPPARAMS dispParams;
 266     EXCEPINFO excep;
 267
 268     TRACE("(%p)->(%s . %08x)\n", This, debugstr_w(strAttributeName), lFlags);
 269
 270     hres = IDispatchEx_GetDispID(&This->node.dispex.IDispatchEx_iface, strAttributeName,
 271             fdexNameCaseInsensitive | fdexNameEnsure, &dispid);
 272     if(FAILED(hres))
 273         return hres;
 274
 275     dispParams.cArgs = 1;
 276     dispParams.cNamedArgs = 1;
 277     dispParams.rgdispidNamedArgs = &dispidNamed;
 278     dispParams.rgvarg = &AttributeValue;
 279
 280     hres = IDispatchEx_InvokeEx(&This->node.dispex.IDispatchEx_iface, dispid,
 281             LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYPUT, &dispParams, NULL, &excep, NULL);
 282     return hres;
 283 }
 284
 285 static HRESULT WINAPI HTMLElement_getAttribute(IHTMLElement *iface, BSTR strAttributeName,
 286                                                LONG lFlags, VARIANT *AttributeValue)
 287 {
 288     HTMLElement *This = impl_from_IHTMLElement(iface);
 289     DISPID dispid;
 290     HRESULT hres;
 291     DISPPARAMS dispParams = {NULL, NULL, 0, 0};
 292     EXCEPINFO excep;
 293
 294     TRACE("(%p)->(%s %08x %p)\n", This, debugstr_w(strAttributeName), lFlags, AttributeValue);
 295
 296     hres = IDispatchEx_GetDispID(&This->node.dispex.IDispatchEx_iface, strAttributeName,
 297             fdexNameCaseInsensitive, &dispid);
 298     if(hres == DISP_E_UNKNOWNNAME) {
 299         V_VT(AttributeValue) = VT_NULL;
 300         return S_OK;
 301     }
 302
 303     if(FAILED(hres)) {
 304         V_VT(AttributeValue) = VT_NULL;
 305         return hres;
 306     }
 307
 308     hres = IDispatchEx_InvokeEx(&This->node.dispex.IDispatchEx_iface, dispid, LOCALE_SYSTEM_DEFAULT,
 309             DISPATCH_PROPERTYGET, &dispParams, AttributeValue, &excep, NULL);
 310
 311     return hres;
 312 }
 313
 314 static HRESULT WINAPI HTMLElement_removeAttribute(IHTMLElement *iface, BSTR strAttributeName,
 315                                                   LONG lFlags, VARIANT_BOOL *pfSuccess)
 316 {
 317     HTMLElement *This = impl_from_IHTMLElement(iface);
 318
 319     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(strAttributeName), lFlags, pfSuccess);
 320
 321     return remove_prop(&This->node.dispex, strAttributeName, pfSuccess);
 322 }
 323
 324 static HRESULT WINAPI HTMLElement_put_className(IHTMLElement *iface, BSTR v)
 325 {
 326     HTMLElement *This = impl_from_IHTMLElement(iface);
 327     nsAString classname_str;
 328     nsresult nsres;
 329
 330     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 331
 332     if(!This->nselem) {
 333         FIXME("NULL nselem\n");
 334         return E_NOTIMPL;
 335     }
 336
 337     nsAString_InitDepend(&classname_str, v);
 338     nsres = nsIDOMHTMLElement_SetClassName(This->nselem, &classname_str);
 339     nsAString_Finish(&classname_str);
 340     if(NS_FAILED(nsres))
 341         ERR("SetClassName failed: %08x\n", nsres);
 342
 343     return S_OK;
 344 }
 345
 346 static HRESULT WINAPI HTMLElement_get_className(IHTMLElement *iface, BSTR *p)
 347 {
 348     HTMLElement *This = impl_from_IHTMLElement(iface);
 349     nsAString class_str;
 350     nsresult nsres;
 351     HRESULT hres = S_OK;
 352
 353     TRACE("(%p)->(%p)\n", This, p);
 354
 355     if(!This->nselem) {
 356         FIXME("NULL nselem\n");
 357         return E_NOTIMPL;
 358     }
 359
 360     nsAString_Init(&class_str, NULL);
 361     nsres = nsIDOMHTMLElement_GetClassName(This->nselem, &class_str);
 362
 363     if(NS_SUCCEEDED(nsres)) {
 364         const PRUnichar *class;
 365         nsAString_GetData(&class_str, &class);
 366         *p = *class ? SysAllocString(class) : NULL;
 367     }else {
 368         ERR("GetClassName failed: %08x\n", nsres);
 369         hres = E_FAIL;
 370     }
 371
 372     nsAString_Finish(&class_str);
 373
 374     TRACE("className=%s\n", debugstr_w(*p));
 375     return hres;
 376 }
 377
 378 static HRESULT WINAPI HTMLElement_put_id(IHTMLElement *iface, BSTR v)
 379 {
 380     HTMLElement *This = impl_from_IHTMLElement(iface);
 381     nsAString id_str;
 382     nsresult nsres;
 383
 384     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 385
 386     if(!This->nselem) {
 387         FIXME("nselem == NULL\n");
 388         return S_OK;
 389     }
 390
 391     nsAString_InitDepend(&id_str, v);
 392     nsres = nsIDOMHTMLElement_SetId(This->nselem, &id_str);
 393     nsAString_Finish(&id_str);
 394     if(NS_FAILED(nsres))
 395         ERR("SetId failed: %08x\n", nsres);
 396
 397     return S_OK;
 398 }
 399
 400 static HRESULT WINAPI HTMLElement_get_id(IHTMLElement *iface, BSTR *p)
 401 {
 402     HTMLElement *This = impl_from_IHTMLElement(iface);
 403     const PRUnichar *id;
 404     nsAString id_str;
 405     nsresult nsres;
 406
 407     TRACE("(%p)->(%p)\n", This, p);
 408
 409     *p = NULL;
 410
 411     if(!This->nselem)
 412         return S_OK;
 413
 414     nsAString_Init(&id_str, NULL);
 415     nsres = nsIDOMHTMLElement_GetId(This->nselem, &id_str);
 416     nsAString_GetData(&id_str, &id);
 417
 418     if(NS_FAILED(nsres))
 419         ERR("GetId failed: %08x\n", nsres);
 420     else if(*id)
 421         *p = SysAllocString(id);
 422
 423     nsAString_Finish(&id_str);
 424     return S_OK;
 425 }
 426
 427 static HRESULT WINAPI HTMLElement_get_tagName(IHTMLElement *iface, BSTR *p)
 428 {
 429     HTMLElement *This = impl_from_IHTMLElement(iface);
 430     const PRUnichar *tag;
 431     nsAString tag_str;
 432     nsresult nsres;
 433
 434     TRACE("(%p)->(%p)\n", This, p);
 435
 436     if(!This->nselem) {
 437         static const WCHAR comment_tagW[] = {'!',0};
 438
 439         WARN("NULL nselem, assuming comment\n");
 440
 441         *p = SysAllocString(comment_tagW);
 442         return S_OK;
 443     }
 444
 445     nsAString_Init(&tag_str, NULL);
 446     nsres = nsIDOMHTMLElement_GetTagName(This->nselem, &tag_str);
 447     if(NS_SUCCEEDED(nsres)) {
 448         nsAString_GetData(&tag_str, &tag);
 449         *p = SysAllocString(tag);
 450     }else {
 451         ERR("GetTagName failed: %08x\n", nsres);
 452         *p = NULL;
 453     }
 454     nsAString_Finish(&tag_str);
 455
 456     return S_OK;
 457 }
 458
 459 static HRESULT WINAPI HTMLElement_get_parentElement(IHTMLElement *iface, IHTMLElement **p)
 460 {
 461     HTMLElement *This = impl_from_IHTMLElement(iface);
 462     IHTMLDOMNode *node;
 463     HRESULT hres;
 464
 465     TRACE("(%p)->(%p)\n", This, p);
 466
 467     hres = IHTMLDOMNode_get_parentNode(&This->node.IHTMLDOMNode_iface, &node);
 468     if(FAILED(hres))
 469         return hres;
 470
 471     hres = IHTMLDOMNode_QueryInterface(node, &IID_IHTMLElement, (void**)p);
 472     IHTMLDOMNode_Release(node);
 473     if(FAILED(hres))
 474         *p = NULL;
 475
 476     return S_OK;
 477 }
 478
 479 static HRESULT WINAPI HTMLElement_get_style(IHTMLElement *iface, IHTMLStyle **p)
 480 {
 481     HTMLElement *This = impl_from_IHTMLElement(iface);
 482
 483     TRACE("(%p)->(%p)\n", This, p);
 484
 485     if(!This->style) {
 486         nsIDOMElementCSSInlineStyle *nselemstyle;
 487         nsIDOMCSSStyleDeclaration *nsstyle;
 488         nsresult nsres;
 489         HRESULT hres;
 490
 491         if(!This->nselem) {
 492             FIXME("NULL nselem\n");
 493             return E_NOTIMPL;
 494         }
 495
 496         nsres = nsIDOMHTMLElement_QueryInterface(This->nselem, &IID_nsIDOMElementCSSInlineStyle,
 497                 (void**)&nselemstyle);
 498         if(NS_FAILED(nsres)) {
 499             ERR("Could not get nsIDOMCSSStyleDeclaration interface: %08x\n", nsres);
 500             return E_FAIL;
 501         }
 502
 503         nsres = nsIDOMElementCSSInlineStyle_GetStyle(nselemstyle, &nsstyle);
 504         nsIDOMElementCSSInlineStyle_Release(nselemstyle);
 505         if(NS_FAILED(nsres)) {
 506             ERR("GetStyle failed: %08x\n", nsres);
 507             return E_FAIL;
 508         }
 509
 510         hres = HTMLStyle_Create(nsstyle, &This->style);
 511         nsIDOMCSSStyleDeclaration_Release(nsstyle);
 512         if(FAILED(hres))
 513             return hres;
 514     }
 515
 516     *p = &This->style->IHTMLStyle_iface;
 517     IHTMLStyle_AddRef(*p);
 518     return S_OK;
 519 }
 520
 521 static HRESULT WINAPI HTMLElement_put_onhelp(IHTMLElement *iface, VARIANT v)
 522 {
 523     HTMLElement *This = impl_from_IHTMLElement(iface);
 524     FIXME("(%p)->()\n", This);
 525     return E_NOTIMPL;
 526 }
 527
 528 static HRESULT WINAPI HTMLElement_get_onhelp(IHTMLElement *iface, VARIANT *p)
 529 {
 530     HTMLElement *This = impl_from_IHTMLElement(iface);
 531     FIXME("(%p)->(%p)\n", This, p);
 532     return E_NOTIMPL;
 533 }
 534
 535 static HRESULT WINAPI HTMLElement_put_onclick(IHTMLElement *iface, VARIANT v)
 536 {
 537     HTMLElement *This = impl_from_IHTMLElement(iface);
 538
 539     TRACE("(%p)->()\n", This);
 540
 541     return set_node_event(&This->node, EVENTID_CLICK, &v);
 542 }
 543
 544 static HRESULT WINAPI HTMLElement_get_onclick(IHTMLElement *iface, VARIANT *p)
 545 {
 546     HTMLElement *This = impl_from_IHTMLElement(iface);
 547
 548     TRACE("(%p)->(%p)\n", This, p);
 549
 550     return get_node_event(&This->node, EVENTID_CLICK, p);
 551 }
 552
 553 static HRESULT WINAPI HTMLElement_put_ondblclick(IHTMLElement *iface, VARIANT v)
 554 {
 555     HTMLElement *This = impl_from_IHTMLElement(iface);
 556
 557     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 558
 559     return set_node_event(&This->node, EVENTID_DBLCLICK, &v);
 560 }
 561
 562 static HRESULT WINAPI HTMLElement_get_ondblclick(IHTMLElement *iface, VARIANT *p)
 563 {
 564     HTMLElement *This = impl_from_IHTMLElement(iface);
 565
 566     TRACE("(%p)->(%p)\n", This, p);
 567
 568     return get_node_event(&This->node, EVENTID_DBLCLICK, p);
 569 }
 570
 571 static HRESULT WINAPI HTMLElement_put_onkeydown(IHTMLElement *iface, VARIANT v)
 572 {
 573     HTMLElement *This = impl_from_IHTMLElement(iface);
 574
 575     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 576
 577     return set_node_event(&This->node, EVENTID_KEYDOWN, &v);
 578 }
 579
 580 static HRESULT WINAPI HTMLElement_get_onkeydown(IHTMLElement *iface, VARIANT *p)
 581 {
 582     HTMLElement *This = impl_from_IHTMLElement(iface);
 583
 584     TRACE("(%p)->(%p)\n", This, p);
 585
 586     return get_node_event(&This->node, EVENTID_KEYDOWN, p);
 587 }
 588
 589 static HRESULT WINAPI HTMLElement_put_onkeyup(IHTMLElement *iface, VARIANT v)
 590 {
 591     HTMLElement *This = impl_from_IHTMLElement(iface);
 592
 593     TRACE("(%p)->()\n", This);
 594
 595     return set_node_event(&This->node, EVENTID_KEYUP, &v);
 596 }
 597
 598 static HRESULT WINAPI HTMLElement_get_onkeyup(IHTMLElement *iface, VARIANT *p)
 599 {
 600     HTMLElement *This = impl_from_IHTMLElement(iface);
 601     FIXME("(%p)->(%p)\n", This, p);
 602     return E_NOTIMPL;
 603 }
 604
 605 static HRESULT WINAPI HTMLElement_put_onkeypress(IHTMLElement *iface, VARIANT v)
 606 {
 607     HTMLElement *This = impl_from_IHTMLElement(iface);
 608     FIXME("(%p)->()\n", This);
 609     return E_NOTIMPL;
 610 }
 611
 612 static HRESULT WINAPI HTMLElement_get_onkeypress(IHTMLElement *iface, VARIANT *p)
 613 {
 614     HTMLElement *This = impl_from_IHTMLElement(iface);
 615     FIXME("(%p)->(%p)\n", This, p);
 616     return E_NOTIMPL;
 617 }
 618
 619 static HRESULT WINAPI HTMLElement_put_onmouseout(IHTMLElement *iface, VARIANT v)
 620 {
 621     HTMLElement *This = impl_from_IHTMLElement(iface);
 622
 623     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 624
 625     return set_node_event(&This->node, EVENTID_MOUSEOUT, &v);
 626 }
 627
 628 static HRESULT WINAPI HTMLElement_get_onmouseout(IHTMLElement *iface, VARIANT *p)
 629 {
 630     HTMLElement *This = impl_from_IHTMLElement(iface);
 631
 632     TRACE("(%p)->(%p)\n", This, p);
 633
 634     return get_node_event(&This->node, EVENTID_MOUSEOUT, p);
 635 }
 636
 637 static HRESULT WINAPI HTMLElement_put_onmouseover(IHTMLElement *iface, VARIANT v)
 638 {
 639     HTMLElement *This = impl_from_IHTMLElement(iface);
 640
 641     TRACE("(%p)->()\n", This);
 642
 643     return set_node_event(&This->node, EVENTID_MOUSEOVER, &v);
 644 }
 645
 646 static HRESULT WINAPI HTMLElement_get_onmouseover(IHTMLElement *iface, VARIANT *p)
 647 {
 648     HTMLElement *This = impl_from_IHTMLElement(iface);
 649
 650     TRACE("(%p)->(%p)\n", This, p);
 651
 652     return get_node_event(&This->node, EVENTID_MOUSEOVER, p);
 653 }
 654
 655 static HRESULT WINAPI HTMLElement_put_onmousemove(IHTMLElement *iface, VARIANT v)
 656 {
 657     HTMLElement *This = impl_from_IHTMLElement(iface);
 658
 659     TRACE("(%p)->()\n", This);
 660
 661     return set_node_event(&This->node, EVENTID_MOUSEMOVE, &v);
 662 }
 663
 664 static HRESULT WINAPI HTMLElement_get_onmousemove(IHTMLElement *iface, VARIANT *p)
 665 {
 666     HTMLElement *This = impl_from_IHTMLElement(iface);
 667
 668     TRACE("(%p)->(%p)\n", This, p);
 669
 670     return get_node_event(&This->node, EVENTID_MOUSEMOVE, p);
 671 }
 672
 673 static HRESULT WINAPI HTMLElement_put_onmousedown(IHTMLElement *iface, VARIANT v)
 674 {
 675     HTMLElement *This = impl_from_IHTMLElement(iface);
 676
 677     TRACE("(%p)->()\n", This);
 678
 679     return set_node_event(&This->node, EVENTID_MOUSEDOWN, &v);
 680 }
 681
 682 static HRESULT WINAPI HTMLElement_get_onmousedown(IHTMLElement *iface, VARIANT *p)
 683 {
 684     HTMLElement *This = impl_from_IHTMLElement(iface);
 685
 686     TRACE("(%p)->(%p)\n", This, p);
 687
 688     return get_node_event(&This->node, EVENTID_MOUSEDOWN, p);
 689 }
 690
 691 static HRESULT WINAPI HTMLElement_put_onmouseup(IHTMLElement *iface, VARIANT v)
 692 {
 693     HTMLElement *This = impl_from_IHTMLElement(iface);
 694
 695     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 696
 697     return set_node_event(&This->node, EVENTID_MOUSEUP, &v);
 698 }
 699
 700 static HRESULT WINAPI HTMLElement_get_onmouseup(IHTMLElement *iface, VARIANT *p)
 701 {
 702     HTMLElement *This = impl_from_IHTMLElement(iface);
 703
 704     TRACE("(%p)->(%p)\n", This, p);
 705
 706     return get_node_event(&This->node, EVENTID_MOUSEUP, p);
 707 }
 708
 709 static HRESULT WINAPI HTMLElement_get_document(IHTMLElement *iface, IDispatch **p)
 710 {
 711     HTMLElement *This = impl_from_IHTMLElement(iface);
 712
 713     TRACE("(%p)->(%p)\n", This, p);
 714
 715     if(!p)
 716         return E_POINTER;
 717
 718     if(This->node.vtbl->get_document)
 719         return This->node.vtbl->get_document(&This->node, p);
 720
 721     *p = (IDispatch*)&This->node.doc->basedoc.IHTMLDocument2_iface;
 722     IDispatch_AddRef(*p);
 723     return S_OK;
 724 }
 725
 726 static const WCHAR titleW[] = {'t','i','t','l','e',0};
 727
 728 static HRESULT WINAPI HTMLElement_put_title(IHTMLElement *iface, BSTR v)
 729 {
 730     HTMLElement *This = impl_from_IHTMLElement(iface);
 731     nsAString title_str;
 732     nsresult nsres;
 733
 734     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 735
 736     if(!This->nselem) {
 737         VARIANT *var;
 738         HRESULT hres;
 739
 740         hres = dispex_get_dprop_ref(&This->node.dispex, titleW, TRUE, &var);
 741         if(FAILED(hres))
 742             return hres;
 743
 744         VariantClear(var);
 745         V_VT(var) = VT_BSTR;
 746         V_BSTR(var) = v ? SysAllocString(v) : NULL;
 747         return S_OK;
 748     }
 749
 750     nsAString_InitDepend(&title_str, v);
 751     nsres = nsIDOMHTMLElement_SetTitle(This->nselem, &title_str);
 752     nsAString_Finish(&title_str);
 753     if(NS_FAILED(nsres))
 754         ERR("SetTitle failed: %08x\n", nsres);
 755
 756     return S_OK;
 757 }
 758
 759 static HRESULT WINAPI HTMLElement_get_title(IHTMLElement *iface, BSTR *p)
 760 {
 761     HTMLElement *This = impl_from_IHTMLElement(iface);
 762     nsAString title_str;
 763     nsresult nsres;
 764
 765     TRACE("(%p)->(%p)\n", This, p);
 766
 767     if(!This->nselem) {
 768         VARIANT *var;
 769         HRESULT hres;
 770
 771         hres = dispex_get_dprop_ref(&This->node.dispex, titleW, FALSE, &var);
 772         if(hres == DISP_E_UNKNOWNNAME) {
 773             *p = NULL;
 774         }else if(V_VT(var) != VT_BSTR) {
 775             FIXME("title = %s\n", debugstr_variant(var));
 776             return E_FAIL;
 777         }else {
 778             *p = V_BSTR(var) ? SysAllocString(V_BSTR(var)) : NULL;
 779         }
 780
 781         return S_OK;
 782     }
 783
 784     nsAString_Init(&title_str, NULL);
 785     nsres = nsIDOMHTMLElement_GetTitle(This->nselem, &title_str);
 786     if(NS_SUCCEEDED(nsres)) {
 787         const PRUnichar *title;
 788
 789         nsAString_GetData(&title_str, &title);
 790         *p = *title ? SysAllocString(title) : NULL;
 791     }else {
 792         ERR("GetTitle failed: %08x\n", nsres);
 793         return E_FAIL;
 794     }
 795
 796     return S_OK;
 797 }
 798
 799 static HRESULT WINAPI HTMLElement_put_language(IHTMLElement *iface, BSTR v)
 800 {
 801     HTMLElement *This = impl_from_IHTMLElement(iface);
 802     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 803     return E_NOTIMPL;
 804 }
 805
 806 static HRESULT WINAPI HTMLElement_get_language(IHTMLElement *iface, BSTR *p)
 807 {
 808     HTMLElement *This = impl_from_IHTMLElement(iface);
 809     FIXME("(%p)->(%p)\n", This, p);
 810     return E_NOTIMPL;
 811 }
 812
 813 static HRESULT WINAPI HTMLElement_put_onselectstart(IHTMLElement *iface, VARIANT v)
 814 {
 815     HTMLElement *This = impl_from_IHTMLElement(iface);
 816
 817     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 818
 819     return set_node_event(&This->node, EVENTID_SELECTSTART, &v);
 820 }
 821
 822 static HRESULT WINAPI HTMLElement_get_onselectstart(IHTMLElement *iface, VARIANT *p)
 823 {
 824     HTMLElement *This = impl_from_IHTMLElement(iface);
 825
 826     TRACE("(%p)->(%p)\n", This, p);
 827
 828     return get_node_event(&This->node, EVENTID_SELECTSTART, p);
 829 }
 830
 831 static HRESULT WINAPI HTMLElement_scrollIntoView(IHTMLElement *iface, VARIANT varargStart)
 832 {
 833     HTMLElement *This = impl_from_IHTMLElement(iface);
 834     FIXME("(%p)->()\n", This);
 835     return E_NOTIMPL;
 836 }
 837
 838 static HRESULT WINAPI HTMLElement_contains(IHTMLElement *iface, IHTMLElement *pChild,
 839                                            VARIANT_BOOL *pfResult)
 840 {
 841     HTMLElement *This = impl_from_IHTMLElement(iface);
 842     FIXME("(%p)->(%p %p)\n", This, pChild, pfResult);
 843     return E_NOTIMPL;
 844 }
 845
 846 static HRESULT WINAPI HTMLElement_get_sourceIndex(IHTMLElement *iface, LONG *p)
 847 {
 848     HTMLElement *This = impl_from_IHTMLElement(iface);
 849     FIXME("(%p)->(%p)\n", This, p);
 850     return E_NOTIMPL;
 851 }
 852
 853 static HRESULT WINAPI HTMLElement_get_recordNumber(IHTMLElement *iface, VARIANT *p)
 854 {
 855     HTMLElement *This = impl_from_IHTMLElement(iface);
 856     FIXME("(%p)->(%p)\n", This, p);
 857     return E_NOTIMPL;
 858 }
 859
 860 static HRESULT WINAPI HTMLElement_put_lang(IHTMLElement *iface, BSTR v)
 861 {
 862     HTMLElement *This = impl_from_IHTMLElement(iface);
 863     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 864     return E_NOTIMPL;
 865 }
 866
 867 static HRESULT WINAPI HTMLElement_get_lang(IHTMLElement *iface, BSTR *p)
 868 {
 869     HTMLElement *This = impl_from_IHTMLElement(iface);
 870     FIXME("(%p)->(%p)\n", This, p);
 871     return E_NOTIMPL;
 872 }
 873
 874 static HRESULT WINAPI HTMLElement_get_offsetLeft(IHTMLElement *iface, LONG *p)
 875 {
 876     HTMLElement *This = impl_from_IHTMLElement(iface);
 877     PRInt32 off_left = 0;
 878     nsresult nsres;
 879
 880     TRACE("(%p)->(%p)\n", This, p);
 881
 882     nsres = nsIDOMHTMLElement_GetOffsetLeft(This->nselem, &off_left);
 883     if(NS_FAILED(nsres)) {
 884         ERR("GetOffsetLeft failed: %08x\n", nsres);
 885         return E_FAIL;
 886     }
 887
 888     *p = off_left;
 889     return S_OK;
 890 }
 891
 892 static HRESULT WINAPI HTMLElement_get_offsetTop(IHTMLElement *iface, LONG *p)
 893 {
 894     HTMLElement *This = impl_from_IHTMLElement(iface);
 895     PRInt32 top = 0;
 896     nsresult nsres;
 897
 898     TRACE("(%p)->(%p)\n", This, p);
 899
 900     nsres = nsIDOMHTMLElement_GetOffsetTop(This->nselem, &top);
 901     if(NS_FAILED(nsres)) {
 902         ERR("GetOffsetTop failed: %08x\n", nsres);
 903         return E_FAIL;
 904     }
 905
 906     *p = top;
 907     return S_OK;
 908 }
 909
 910 static HRESULT WINAPI HTMLElement_get_offsetWidth(IHTMLElement *iface, LONG *p)
 911 {
 912     HTMLElement *This = impl_from_IHTMLElement(iface);
 913     PRInt32 offset = 0;
 914     nsresult nsres;
 915
 916     TRACE("(%p)->(%p)\n", This, p);
 917
 918     nsres = nsIDOMHTMLElement_GetOffsetWidth(This->nselem, &offset);
 919     if(NS_FAILED(nsres)) {
 920         ERR("GetOffsetWidth failed: %08x\n", nsres);
 921         return E_FAIL;
 922     }
 923
 924     *p = offset;
 925     return S_OK;
 926 }
 927
 928 static HRESULT WINAPI HTMLElement_get_offsetHeight(IHTMLElement *iface, LONG *p)
 929 {
 930     HTMLElement *This = impl_from_IHTMLElement(iface);
 931     PRInt32 offset = 0;
 932     nsresult nsres;
 933
 934     TRACE("(%p)->(%p)\n", This, p);
 935
 936     nsres = nsIDOMHTMLElement_GetOffsetHeight(This->nselem, &offset);
 937     if(NS_FAILED(nsres)) {
 938         ERR("GetOffsetHeight failed: %08x\n", nsres);
 939         return E_FAIL;
 940     }
 941
 942     *p = offset;
 943     return S_OK;
 944 }
 945
 946 static HRESULT WINAPI HTMLElement_get_offsetParent(IHTMLElement *iface, IHTMLElement **p)
 947 {
 948     HTMLElement *This = impl_from_IHTMLElement(iface);
 949     nsIDOMElement *nsparent;
 950     nsresult nsres;
 951     HRESULT hres;
 952
 953     TRACE("(%p)->(%p)\n", This, p);
 954
 955     nsres = nsIDOMHTMLElement_GetOffsetParent(This->nselem, &nsparent);
 956     if(NS_FAILED(nsres)) {
 957         ERR("GetOffsetParent failed: %08x\n", nsres);
 958         return E_FAIL;
 959     }
 960
 961     if(nsparent) {
 962         HTMLDOMNode *node;
 963
 964         hres = get_node(This->node.doc, (nsIDOMNode*)nsparent, TRUE, &node);
 965         nsIDOMElement_Release(nsparent);
 966         if(FAILED(hres))
 967             return hres;
 968
 969         hres = IHTMLDOMNode_QueryInterface(&node->IHTMLDOMNode_iface, &IID_IHTMLElement, (void**)p);
 970     }else {
 971         *p = NULL;
 972         hres = S_OK;
 973     }
 974
 975     return hres;
 976 }
 977
 978 static HRESULT WINAPI HTMLElement_put_innerHTML(IHTMLElement *iface, BSTR v)
 979 {
 980     HTMLElement *This = impl_from_IHTMLElement(iface);
 981     nsAString html_str;
 982     nsresult nsres;
 983
 984     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 985
 986     if(!This->nselem) {
 987         FIXME("NULL nselem\n");
 988         return E_NOTIMPL;
 989     }
 990
 991     nsAString_InitDepend(&html_str, v);
 992     nsres = nsIDOMHTMLElement_SetInnerHTML(This->nselem, &html_str);
 993     nsAString_Finish(&html_str);
 994     if(NS_FAILED(nsres)) {
 995         FIXME("SetInnerHtml failed %08x\n", nsres);
 996         return E_FAIL;
 997     }
 998
 999     return S_OK;
1000 }
1001
1002 static HRESULT WINAPI HTMLElement_get_innerHTML(IHTMLElement *iface, BSTR *p)
1003 {
1004     HTMLElement *This = impl_from_IHTMLElement(iface);
1005     nsAString html_str;
1006     nsresult nsres;
1007
1008     TRACE("(%p)->(%p)\n", This, p);
1009
1010     if(!This->nselem) {
1011         FIXME("NULL nselem\n");
1012         return E_NOTIMPL;
1013     }
1014
1015     nsAString_Init(&html_str, NULL);
1016     nsres = nsIDOMHTMLElement_GetInnerHTML(This->nselem, &html_str);
1017     if(NS_SUCCEEDED(nsres)) {
1018         const PRUnichar *html;
1019
1020         nsAString_GetData(&html_str, &html);
1021         *p = *html ? SysAllocString(html) : NULL;
1022     }else {
1023         FIXME("SetInnerHtml failed %08x\n", nsres);
1024         *p = NULL;
1025     }
1026
1027     nsAString_Finish(&html_str);
1028     return S_OK;
1029 }
1030
1031 static HRESULT WINAPI HTMLElement_put_innerText(IHTMLElement *iface, BSTR v)
1032 {
1033     HTMLElement *This = impl_from_IHTMLElement(iface);
1034     nsIDOMNode *nschild, *tmp;
1035     nsIDOMText *text_node;
1036     nsAString text_str;
1037     nsresult nsres;
1038
1039     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1040
1041     while(1) {
1042         nsres = nsIDOMHTMLElement_GetLastChild(This->nselem, &nschild);
1043         if(NS_FAILED(nsres)) {
1044             ERR("GetLastChild failed: %08x\n", nsres);
1045             return E_FAIL;
1046         }
1047         if(!nschild)
1048             break;
1049
1050         nsres = nsIDOMHTMLElement_RemoveChild(This->nselem, nschild, &tmp);
1051         nsIDOMNode_Release(nschild);
1052         if(NS_FAILED(nsres)) {
1053             ERR("RemoveChild failed: %08x\n", nsres);
1054             return E_FAIL;
1055         }
1056         nsIDOMNode_Release(tmp);
1057     }
1058
1059     nsAString_InitDepend(&text_str, v);
1060     nsres = nsIDOMHTMLDocument_CreateTextNode(This->node.doc->nsdoc, &text_str, &text_node);
1061     nsAString_Finish(&text_str);
1062     if(NS_FAILED(nsres)) {
1063         ERR("CreateTextNode failed: %08x\n", nsres);
1064         return E_FAIL;
1065     }
1066
1067     nsres = nsIDOMHTMLElement_AppendChild(This->nselem, (nsIDOMNode*)text_node, &tmp);
1068     if(NS_FAILED(nsres)) {
1069         ERR("AppendChild failed: %08x\n", nsres);
1070         return E_FAIL;
1071     }
1072
1073     nsIDOMNode_Release(tmp);
1074     return S_OK;
1075 }
1076
1077 static HRESULT WINAPI HTMLElement_get_innerText(IHTMLElement *iface, BSTR *p)
1078 {
1079     HTMLElement *This = impl_from_IHTMLElement(iface);
1080
1081     TRACE("(%p)->(%p)\n", This, p);
1082
1083     return get_node_text(&This->node, p);
1084 }
1085
1086 static HRESULT WINAPI HTMLElement_put_outerHTML(IHTMLElement *iface, BSTR v)
1087 {
1088     HTMLElement *This = impl_from_IHTMLElement(iface);
1089
1090     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1091
1092     return replace_node_by_html(This->node.doc->nsdoc, This->node.nsnode, v);
1093 }
1094
1095 static HRESULT WINAPI HTMLElement_get_outerHTML(IHTMLElement *iface, BSTR *p)
1096 {
1097     HTMLElement *This = impl_from_IHTMLElement(iface);
1098     nsAString html_str;
1099     HRESULT hres;
1100
1101     WARN("(%p)->(%p) semi-stub\n", This, p);
1102
1103     nsAString_Init(&html_str, NULL);
1104     hres = nsnode_to_nsstring(This->node.nsnode, &html_str);
1105     if(SUCCEEDED(hres)) {
1106         const PRUnichar *html;
1107
1108         nsAString_GetData(&html_str, &html);
1109         *p = SysAllocString(html);
1110         if(!*p)
1111             hres = E_OUTOFMEMORY;
1112     }
1113
1114     nsAString_Finish(&html_str);
1115
1116     TRACE("ret %s\n", debugstr_w(*p));
1117     return hres;
1118 }
1119
1120 static HRESULT WINAPI HTMLElement_put_outerText(IHTMLElement *iface, BSTR v)
1121 {
1122     HTMLElement *This = impl_from_IHTMLElement(iface);
1123     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1124     return E_NOTIMPL;
1125 }
1126
1127 static HRESULT WINAPI HTMLElement_get_outerText(IHTMLElement *iface, BSTR *p)
1128 {
1129     HTMLElement *This = impl_from_IHTMLElement(iface);
1130     FIXME("(%p)->(%p)\n", This, p);
1131     return E_NOTIMPL;
1132 }
1133
1134 static HRESULT HTMLElement_InsertAdjacentNode(HTMLElement *This, BSTR where, nsIDOMNode *nsnode)
1135 {
1136     static const WCHAR wszBeforeBegin[] = {'b','e','f','o','r','e','B','e','g','i','n',0};
1137     static const WCHAR wszAfterBegin[] = {'a','f','t','e','r','B','e','g','i','n',0};
1138     static const WCHAR wszBeforeEnd[] = {'b','e','f','o','r','e','E','n','d',0};
1139     static const WCHAR wszAfterEnd[] = {'a','f','t','e','r','E','n','d',0};
1140     nsresult nsres;
1141
1142     if (!strcmpiW(where, wszBeforeBegin))
1143     {
1144         nsIDOMNode *unused;
1145         nsIDOMNode *parent;
1146         nsres = nsIDOMNode_GetParentNode(This->node.nsnode, &parent);
1147         if (!parent) return E_INVALIDARG;
1148         nsres = nsIDOMNode_InsertBefore(parent, nsnode, This->node.nsnode, &unused);
1149         if (unused) nsIDOMNode_Release(unused);
1150         nsIDOMNode_Release(parent);
1151     }
1152     else if (!strcmpiW(where, wszAfterBegin))
1153     {
1154         nsIDOMNode *unused;
1155         nsIDOMNode *first_child;
1156         nsIDOMNode_GetFirstChild(This->node.nsnode, &first_child);
1157         nsres = nsIDOMNode_InsertBefore(This->node.nsnode, nsnode, first_child, &unused);
1158         if (unused) nsIDOMNode_Release(unused);
1159         if (first_child) nsIDOMNode_Release(first_child);
1160     }
1161     else if (!strcmpiW(where, wszBeforeEnd))
1162     {
1163         nsIDOMNode *unused;
1164         nsres = nsIDOMNode_AppendChild(This->node.nsnode, nsnode, &unused);
1165         if (unused) nsIDOMNode_Release(unused);
1166     }
1167     else if (!strcmpiW(where, wszAfterEnd))
1168     {
1169         nsIDOMNode *unused;
1170         nsIDOMNode *next_sibling;
1171         nsIDOMNode *parent;
1172         nsIDOMNode_GetParentNode(This->node.nsnode, &parent);
1173         if (!parent) return E_INVALIDARG;
1174
1175         nsIDOMNode_GetNextSibling(This->node.nsnode, &next_sibling);
1176         if (next_sibling)
1177         {
1178             nsres = nsIDOMNode_InsertBefore(parent, nsnode, next_sibling, &unused);
1179             nsIDOMNode_Release(next_sibling);
1180         }
1181         else
1182             nsres = nsIDOMNode_AppendChild(parent, nsnode, &unused);
1183         nsIDOMNode_Release(parent);
1184         if (unused) nsIDOMNode_Release(unused);
1185     }
1186     else
1187     {
1188         ERR("invalid where: %s\n", debugstr_w(where));
1189         return E_INVALIDARG;
1190     }
1191
1192     if (NS_FAILED(nsres))
1193         return E_FAIL;
1194     else
1195         return S_OK;
1196 }
1197
1198 static HRESULT WINAPI HTMLElement_insertAdjacentHTML(IHTMLElement *iface, BSTR where,
1199                                                      BSTR html)
1200 {
1201     HTMLElement *This = impl_from_IHTMLElement(iface);
1202     nsIDOMRange *range;
1203     nsIDOMNSRange *nsrange;
1204     nsIDOMNode *nsnode;
1205     nsAString ns_html;
1206     nsresult nsres;
1207     HRESULT hr;
1208
1209     TRACE("(%p)->(%s %s)\n", This, debugstr_w(where), debugstr_w(html));
1210
1211     if(!This->node.doc->nsdoc) {
1212         WARN("NULL nsdoc\n");
1213         return E_UNEXPECTED;
1214     }
1215
1216     nsres = nsIDOMHTMLDocument_CreateRange(This->node.doc->nsdoc, &range);
1217     if(NS_FAILED(nsres))
1218     {
1219         ERR("CreateRange failed: %08x\n", nsres);
1220         return E_FAIL;
1221     }
1222
1223     nsIDOMRange_SetStartBefore(range, This->node.nsnode);
1224
1225     nsIDOMRange_QueryInterface(range, &IID_nsIDOMNSRange, (void **)&nsrange);
1226     nsIDOMRange_Release(range);
1227     if(NS_FAILED(nsres))
1228     {
1229         ERR("getting nsIDOMNSRange failed: %08x\n", nsres);
1230         return E_FAIL;
1231     }
1232
1233     nsAString_InitDepend(&ns_html, html);
1234
1235     nsres = nsIDOMNSRange_CreateContextualFragment(nsrange, &ns_html, (nsIDOMDocumentFragment **)&nsnode);
1236     nsIDOMNSRange_Release(nsrange);
1237     nsAString_Finish(&ns_html);
1238
1239     if(NS_FAILED(nsres) || !nsnode)
1240     {
1241         ERR("CreateTextNode failed: %08x\n", nsres);
1242         return E_FAIL;
1243     }
1244
1245     hr = HTMLElement_InsertAdjacentNode(This, where, nsnode);
1246     nsIDOMNode_Release(nsnode);
1247
1248     return hr;
1249 }
1250
1251 static HRESULT WINAPI HTMLElement_insertAdjacentText(IHTMLElement *iface, BSTR where,
1252                                                      BSTR text)
1253 {
1254     HTMLElement *This = impl_from_IHTMLElement(iface);
1255     nsIDOMNode *nsnode;
1256     nsAString ns_text;
1257     nsresult nsres;
1258     HRESULT hr;
1259
1260     TRACE("(%p)->(%s %s)\n", This, debugstr_w(where), debugstr_w(text));
1261
1262     if(!This->node.doc->nsdoc) {
1263         WARN("NULL nsdoc\n");
1264         return E_UNEXPECTED;
1265     }
1266
1267
1268     nsAString_InitDepend(&ns_text, text);
1269     nsres = nsIDOMDocument_CreateTextNode(This->node.doc->nsdoc, &ns_text, (nsIDOMText **)&nsnode);
1270     nsAString_Finish(&ns_text);
1271
1272     if(NS_FAILED(nsres) || !nsnode)
1273     {
1274         ERR("CreateTextNode failed: %08x\n", nsres);
1275         return E_FAIL;
1276     }
1277
1278     hr = HTMLElement_InsertAdjacentNode(This, where, nsnode);
1279     nsIDOMNode_Release(nsnode);
1280
1281     return hr;
1282 }
1283
1284 static HRESULT WINAPI HTMLElement_get_parentTextEdit(IHTMLElement *iface, IHTMLElement **p)
1285 {
1286     HTMLElement *This = impl_from_IHTMLElement(iface);
1287     FIXME("(%p)->(%p)\n", This, p);
1288     return E_NOTIMPL;
1289 }
1290
1291 static HRESULT WINAPI HTMLElement_get_isTextEdit(IHTMLElement *iface, VARIANT_BOOL *p)
1292 {
1293     HTMLElement *This = impl_from_IHTMLElement(iface);
1294     FIXME("(%p)->(%p)\n", This, p);
1295     return E_NOTIMPL;
1296 }
1297
1298 static HRESULT WINAPI HTMLElement_click(IHTMLElement *iface)
1299 {
1300     HTMLElement *This = impl_from_IHTMLElement(iface);
1301
1302     TRACE("(%p)\n", This);
1303
1304     return call_fire_event(&This->node, EVENTID_CLICK);
1305 }
1306
1307 static HRESULT WINAPI HTMLElement_get_filters(IHTMLElement *iface,
1308                                               IHTMLFiltersCollection **p)
1309 {
1310     HTMLElement *This = impl_from_IHTMLElement(iface);
1311     TRACE("(%p)->(%p)\n", This, p);
1312
1313     if(!p)
1314         return E_POINTER;
1315
1316     *p = HTMLFiltersCollection_Create();
1317
1318     return S_OK;
1319 }
1320
1321 static HRESULT WINAPI HTMLElement_put_ondragstart(IHTMLElement *iface, VARIANT v)
1322 {
1323     HTMLElement *This = impl_from_IHTMLElement(iface);
1324     FIXME("(%p)->()\n", This);
1325     return E_NOTIMPL;
1326 }
1327
1328 static HRESULT WINAPI HTMLElement_get_ondragstart(IHTMLElement *iface, VARIANT *p)
1329 {
1330     HTMLElement *This = impl_from_IHTMLElement(iface);
1331     FIXME("(%p)->(%p)\n", This, p);
1332     return E_NOTIMPL;
1333 }
1334
1335 static HRESULT WINAPI HTMLElement_toString(IHTMLElement *iface, BSTR *String)
1336 {
1337     HTMLElement *This = impl_from_IHTMLElement(iface);
1338     FIXME("(%p)->(%p)\n", This, String);
1339     return E_NOTIMPL;
1340 }
1341
1342 static HRESULT WINAPI HTMLElement_put_onbeforeupdate(IHTMLElement *iface, VARIANT v)
1343 {
1344     HTMLElement *This = impl_from_IHTMLElement(iface);
1345     FIXME("(%p)->()\n", This);
1346     return E_NOTIMPL;
1347 }
1348
1349 static HRESULT WINAPI HTMLElement_get_onbeforeupdate(IHTMLElement *iface, VARIANT *p)
1350 {
1351     HTMLElement *This = impl_from_IHTMLElement(iface);
1352     FIXME("(%p)->(%p)\n", This, p);
1353     return E_NOTIMPL;
1354 }
1355
1356 static HRESULT WINAPI HTMLElement_put_onafterupdate(IHTMLElement *iface, VARIANT v)
1357 {
1358     HTMLElement *This = impl_from_IHTMLElement(iface);
1359     FIXME("(%p)->()\n", This);
1360     return E_NOTIMPL;
1361 }
1362
1363 static HRESULT WINAPI HTMLElement_get_onafterupdate(IHTMLElement *iface, VARIANT *p)
1364 {
1365     HTMLElement *This = impl_from_IHTMLElement(iface);
1366     FIXME("(%p)->(%p)\n", This, p);
1367     return E_NOTIMPL;
1368 }
1369
1370 static HRESULT WINAPI HTMLElement_put_onerrorupdate(IHTMLElement *iface, VARIANT v)
1371 {
1372     HTMLElement *This = impl_from_IHTMLElement(iface);
1373     FIXME("(%p)->()\n", This);
1374     return E_NOTIMPL;
1375 }
1376
1377 static HRESULT WINAPI HTMLElement_get_onerrorupdate(IHTMLElement *iface, VARIANT *p)
1378 {
1379     HTMLElement *This = impl_from_IHTMLElement(iface);
1380     FIXME("(%p)->(%p)\n", This, p);
1381     return E_NOTIMPL;
1382 }
1383
1384 static HRESULT WINAPI HTMLElement_put_onrowexit(IHTMLElement *iface, VARIANT v)
1385 {
1386     HTMLElement *This = impl_from_IHTMLElement(iface);
1387     FIXME("(%p)->()\n", This);
1388     return E_NOTIMPL;
1389 }
1390
1391 static HRESULT WINAPI HTMLElement_get_onrowexit(IHTMLElement *iface, VARIANT *p)
1392 {
1393     HTMLElement *This = impl_from_IHTMLElement(iface);
1394     FIXME("(%p)->(%p)\n", This, p);
1395     return E_NOTIMPL;
1396 }
1397
1398 static HRESULT WINAPI HTMLElement_put_onrowenter(IHTMLElement *iface, VARIANT v)
1399 {
1400     HTMLElement *This = impl_from_IHTMLElement(iface);
1401     FIXME("(%p)->()\n", This);
1402     return E_NOTIMPL;
1403 }
1404
1405 static HRESULT WINAPI HTMLElement_get_onrowenter(IHTMLElement *iface, VARIANT *p)
1406 {
1407     HTMLElement *This = impl_from_IHTMLElement(iface);
1408     FIXME("(%p)->(%p)\n", This, p);
1409     return E_NOTIMPL;
1410 }
1411
1412 static HRESULT WINAPI HTMLElement_put_ondatasetchanged(IHTMLElement *iface, VARIANT v)
1413 {
1414     HTMLElement *This = impl_from_IHTMLElement(iface);
1415     FIXME("(%p)->()\n", This);
1416     return E_NOTIMPL;
1417 }
1418
1419 static HRESULT WINAPI HTMLElement_get_ondatasetchanged(IHTMLElement *iface, VARIANT *p)
1420 {
1421     HTMLElement *This = impl_from_IHTMLElement(iface);
1422     FIXME("(%p)->(%p)\n", This, p);
1423     return E_NOTIMPL;
1424 }
1425
1426 static HRESULT WINAPI HTMLElement_put_ondataavailable(IHTMLElement *iface, VARIANT v)
1427 {
1428     HTMLElement *This = impl_from_IHTMLElement(iface);
1429     FIXME("(%p)->()\n", This);
1430     return E_NOTIMPL;
1431 }
1432
1433 static HRESULT WINAPI HTMLElement_get_ondataavailable(IHTMLElement *iface, VARIANT *p)
1434 {
1435     HTMLElement *This = impl_from_IHTMLElement(iface);
1436     FIXME("(%p)->(%p)\n", This, p);
1437     return E_NOTIMPL;
1438 }
1439
1440 static HRESULT WINAPI HTMLElement_put_ondatasetcomplete(IHTMLElement *iface, VARIANT v)
1441 {
1442     HTMLElement *This = impl_from_IHTMLElement(iface);
1443     FIXME("(%p)->()\n", This);
1444     return E_NOTIMPL;
1445 }
1446
1447 static HRESULT WINAPI HTMLElement_get_ondatasetcomplete(IHTMLElement *iface, VARIANT *p)
1448 {
1449     HTMLElement *This = impl_from_IHTMLElement(iface);
1450     FIXME("(%p)->(%p)\n", This, p);
1451     return E_NOTIMPL;
1452 }
1453
1454 static HRESULT WINAPI HTMLElement_put_onfilterchange(IHTMLElement *iface, VARIANT v)
1455 {
1456     HTMLElement *This = impl_from_IHTMLElement(iface);
1457     FIXME("(%p)->()\n", This);
1458     return E_NOTIMPL;
1459 }
1460
1461 static HRESULT WINAPI HTMLElement_get_onfilterchange(IHTMLElement *iface, VARIANT *p)
1462 {
1463     HTMLElement *This = impl_from_IHTMLElement(iface);
1464     FIXME("(%p)->(%p)\n", This, p);
1465     return E_NOTIMPL;
1466 }
1467
1468 static HRESULT WINAPI HTMLElement_get_children(IHTMLElement *iface, IDispatch **p)
1469 {
1470     HTMLElement *This = impl_from_IHTMLElement(iface);
1471     nsIDOMNodeList *nsnode_list;
1472     nsresult nsres;
1473
1474     TRACE("(%p)->(%p)\n", This, p);
1475
1476     nsres = nsIDOMNode_GetChildNodes(This->node.nsnode, &nsnode_list);
1477     if(NS_FAILED(nsres)) {
1478         ERR("GetChildNodes failed: %08x\n", nsres);
1479         return E_FAIL;
1480     }
1481
1482     *p = (IDispatch*)create_collection_from_nodelist(This->node.doc,
1483             (IUnknown*)&This->IHTMLElement_iface, nsnode_list);
1484
1485     nsIDOMNodeList_Release(nsnode_list);
1486     return S_OK;
1487 }
1488
1489 static HRESULT WINAPI HTMLElement_get_all(IHTMLElement *iface, IDispatch **p)
1490 {
1491     HTMLElement *This = impl_from_IHTMLElement(iface);
1492
1493     TRACE("(%p)->(%p)\n", This, p);
1494
1495     *p = (IDispatch*)create_all_collection(&This->node, FALSE);
1496     return S_OK;
1497 }
1498
1499 static const IHTMLElementVtbl HTMLElementVtbl = {
1500     HTMLElement_QueryInterface,
1501     HTMLElement_AddRef,
1502     HTMLElement_Release,
1503     HTMLElement_GetTypeInfoCount,
1504     HTMLElement_GetTypeInfo,
1505     HTMLElement_GetIDsOfNames,
1506     HTMLElement_Invoke,
1507     HTMLElement_setAttribute,
1508     HTMLElement_getAttribute,
1509     HTMLElement_removeAttribute,
1510     HTMLElement_put_className,
1511     HTMLElement_get_className,
1512     HTMLElement_put_id,
1513     HTMLElement_get_id,
1514     HTMLElement_get_tagName,
1515     HTMLElement_get_parentElement,
1516     HTMLElement_get_style,
1517     HTMLElement_put_onhelp,
1518     HTMLElement_get_onhelp,
1519     HTMLElement_put_onclick,
1520     HTMLElement_get_onclick,
1521     HTMLElement_put_ondblclick,
1522     HTMLElement_get_ondblclick,
1523     HTMLElement_put_onkeydown,
1524     HTMLElement_get_onkeydown,
1525     HTMLElement_put_onkeyup,
1526     HTMLElement_get_onkeyup,
1527     HTMLElement_put_onkeypress,
1528     HTMLElement_get_onkeypress,
1529     HTMLElement_put_onmouseout,
1530     HTMLElement_get_onmouseout,
1531     HTMLElement_put_onmouseover,
1532     HTMLElement_get_onmouseover,
1533     HTMLElement_put_onmousemove,
1534     HTMLElement_get_onmousemove,
1535     HTMLElement_put_onmousedown,
1536     HTMLElement_get_onmousedown,
1537     HTMLElement_put_onmouseup,
1538     HTMLElement_get_onmouseup,
1539     HTMLElement_get_document,
1540     HTMLElement_put_title,
1541     HTMLElement_get_title,
1542     HTMLElement_put_language,
1543     HTMLElement_get_language,
1544     HTMLElement_put_onselectstart,
1545     HTMLElement_get_onselectstart,
1546     HTMLElement_scrollIntoView,
1547     HTMLElement_contains,
1548     HTMLElement_get_sourceIndex,
1549     HTMLElement_get_recordNumber,
1550     HTMLElement_put_lang,
1551     HTMLElement_get_lang,
1552     HTMLElement_get_offsetLeft,
1553     HTMLElement_get_offsetTop,
1554     HTMLElement_get_offsetWidth,
1555     HTMLElement_get_offsetHeight,
1556     HTMLElement_get_offsetParent,
1557     HTMLElement_put_innerHTML,
1558     HTMLElement_get_innerHTML,
1559     HTMLElement_put_innerText,
1560     HTMLElement_get_innerText,
1561     HTMLElement_put_outerHTML,
1562     HTMLElement_get_outerHTML,
1563     HTMLElement_put_outerText,
1564     HTMLElement_get_outerText,
1565     HTMLElement_insertAdjacentHTML,
1566     HTMLElement_insertAdjacentText,
1567     HTMLElement_get_parentTextEdit,
1568     HTMLElement_get_isTextEdit,
1569     HTMLElement_click,
1570     HTMLElement_get_filters,
1571     HTMLElement_put_ondragstart,
1572     HTMLElement_get_ondragstart,
1573     HTMLElement_toString,
1574     HTMLElement_put_onbeforeupdate,
1575     HTMLElement_get_onbeforeupdate,
1576     HTMLElement_put_onafterupdate,
1577     HTMLElement_get_onafterupdate,
1578     HTMLElement_put_onerrorupdate,
1579     HTMLElement_get_onerrorupdate,
1580     HTMLElement_put_onrowexit,
1581     HTMLElement_get_onrowexit,
1582     HTMLElement_put_onrowenter,
1583     HTMLElement_get_onrowenter,
1584     HTMLElement_put_ondatasetchanged,
1585     HTMLElement_get_ondatasetchanged,
1586     HTMLElement_put_ondataavailable,
1587     HTMLElement_get_ondataavailable,
1588     HTMLElement_put_ondatasetcomplete,
1589     HTMLElement_get_ondatasetcomplete,
1590     HTMLElement_put_onfilterchange,
1591     HTMLElement_get_onfilterchange,
1592     HTMLElement_get_children,
1593     HTMLElement_get_all
1594 };
1595
1596 HTMLElement *unsafe_impl_from_IHTMLElement(IHTMLElement *iface)
1597 {
1598     return iface->lpVtbl == &HTMLElementVtbl ? impl_from_IHTMLElement(iface) : NULL;
1599 }
1600
1601 static inline HTMLElement *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
1602 {
1603     return CONTAINING_RECORD(iface, HTMLElement, node);
1604 }
1605
1606 HRESULT HTMLElement_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
1607 {
1608     HTMLElement *This = impl_from_HTMLDOMNode(iface);
1609
1610     *ppv =  NULL;
1611
1612     if(IsEqualGUID(&IID_IUnknown, riid)) {
1613         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
1614         *ppv = &This->IHTMLElement_iface;
1615     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
1616         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
1617         *ppv = &This->IHTMLElement_iface;
1618     }else if(IsEqualGUID(&IID_IHTMLElement, riid)) {
1619         TRACE("(%p)->(IID_IHTMLElement %p)\n", This, ppv);
1620         *ppv = &This->IHTMLElement_iface;
1621     }else if(IsEqualGUID(&IID_IHTMLElement2, riid)) {
1622         TRACE("(%p)->(IID_IHTMLElement2 %p)\n", This, ppv);
1623         *ppv = &This->IHTMLElement2_iface;
1624     }else if(IsEqualGUID(&IID_IHTMLElement3, riid)) {
1625         TRACE("(%p)->(IID_IHTMLElement3 %p)\n", This, ppv);
1626         *ppv = &This->IHTMLElement3_iface;
1627     }else if(IsEqualGUID(&IID_IHTMLElement4, riid)) {
1628         TRACE("(%p)->(IID_IHTMLElement4 %p)\n", This, ppv);
1629         *ppv = &This->IHTMLElement4_iface;
1630     }else if(IsEqualGUID(&IID_IConnectionPointContainer, riid)) {
1631         TRACE("(%p)->(IID_IConnectionPointContainer %p)\n", This, ppv);
1632         *ppv = &This->cp_container.IConnectionPointContainer_iface;
1633     }
1634
1635     if(*ppv) {
1636         IHTMLElement_AddRef(&This->IHTMLElement_iface);
1637         return S_OK;
1638     }
1639
1640     return HTMLDOMNode_QI(&This->node, riid, ppv);
1641 }
1642
1643 void HTMLElement_destructor(HTMLDOMNode *iface)
1644 {
1645     HTMLElement *This = impl_from_HTMLDOMNode(iface);
1646
1647     ConnectionPointContainer_Destroy(&This->cp_container);
1648
1649     if(This->nselem)
1650         nsIDOMHTMLElement_Release(This->nselem);
1651     if(This->style)
1652         IHTMLStyle_Release(&This->style->IHTMLStyle_iface);
1653     if(This->attrs) {
1654         HTMLDOMAttribute *attr;
1655
1656         LIST_FOR_EACH_ENTRY(attr, &This->attrs->attrs, HTMLDOMAttribute, entry)
1657             attr->elem = NULL;
1658
1659         This->attrs->elem = NULL;
1660         IHTMLAttributeCollection_Release(&This->attrs->IHTMLAttributeCollection_iface);
1661     }
1662
1663     HTMLDOMNode_destructor(&This->node);
1664 }
1665
1666 HRESULT HTMLElement_clone(HTMLDOMNode *iface, nsIDOMNode *nsnode, HTMLDOMNode **ret)
1667 {
1668     HTMLElement *This = impl_from_HTMLDOMNode(iface);
1669     HTMLElement *new_elem;
1670     HRESULT hres;
1671
1672     hres = HTMLElement_Create(This->node.doc, nsnode, FALSE, &new_elem);
1673     if(FAILED(hres))
1674         return hres;
1675
1676     IHTMLElement_AddRef(&new_elem->IHTMLElement_iface);
1677     *ret = &new_elem->node;
1678     return S_OK;
1679 }
1680
1681 static const NodeImplVtbl HTMLElementImplVtbl = {
1682     HTMLElement_QI,
1683     HTMLElement_destructor,
1684     HTMLElement_clone,
1685     HTMLElement_get_attr_col
1686 };
1687
1688 static inline HTMLElement *impl_from_DispatchEx(DispatchEx *iface)
1689 {
1690     return CONTAINING_RECORD(iface, HTMLElement, node.dispex);
1691 }
1692
1693 static HRESULT HTMLElement_get_dispid(DispatchEx *dispex, BSTR name,
1694         DWORD grfdex, DISPID *pid)
1695 {
1696     HTMLElement *This = impl_from_DispatchEx(dispex);
1697
1698     if(This->node.vtbl->get_dispid)
1699         return This->node.vtbl->get_dispid(&This->node, name, grfdex, pid);
1700
1701     return DISP_E_UNKNOWNNAME;
1702 }
1703
1704 static HRESULT HTMLElement_invoke(DispatchEx *dispex, DISPID id, LCID lcid,
1705         WORD flags, DISPPARAMS *params, VARIANT *res, EXCEPINFO *ei,
1706         IServiceProvider *caller)
1707 {
1708     HTMLElement *This = impl_from_DispatchEx(dispex);
1709
1710     if(This->node.vtbl->invoke)
1711         return This->node.vtbl->invoke(&This->node, id, lcid, flags,
1712                 params, res, ei, caller);
1713
1714     ERR("(%p): element has no invoke method\n", This);
1715     return E_NOTIMPL;
1716 }
1717
1718 static HRESULT HTMLElement_populate_props(DispatchEx *dispex)
1719 {
1720     HTMLElement *This = impl_from_DispatchEx(dispex);
1721     nsIDOMNamedNodeMap *attrs;
1722     nsIDOMNode *node;
1723     nsAString nsstr;
1724     const PRUnichar *str;
1725     BSTR name;
1726     VARIANT value;
1727     unsigned i;
1728     PRUint32 len;
1729     DISPID id;
1730     nsresult nsres;
1731     HRESULT hres;
1732
1733     if(!This->nselem)
1734         return S_FALSE;
1735
1736     nsres = nsIDOMHTMLElement_GetAttributes(This->nselem, &attrs);
1737     if(NS_FAILED(nsres))
1738         return E_FAIL;
1739
1740     nsres = nsIDOMNamedNodeMap_GetLength(attrs, &len);
1741     if(NS_FAILED(nsres)) {
1742         nsIDOMNamedNodeMap_Release(attrs);
1743         return E_FAIL;
1744     }
1745
1746     nsAString_Init(&nsstr, NULL);
1747     for(i=0; i<len; i++) {
1748         nsres = nsIDOMNamedNodeMap_Item(attrs, i, &node);
1749         if(NS_FAILED(nsres))
1750             continue;
1751
1752         nsres = nsIDOMNode_GetNodeName(node, &nsstr);
1753         if(NS_FAILED(nsres)) {
1754             nsIDOMNode_Release(node);
1755             continue;
1756         }
1757
1758         nsAString_GetData(&nsstr, &str);
1759         name = SysAllocString(str);
1760         if(!name) {
1761             nsIDOMNode_Release(node);
1762             continue;
1763         }
1764
1765         hres = IDispatchEx_GetDispID(&dispex->IDispatchEx_iface, name, fdexNameCaseInsensitive, &id);
1766         if(hres != DISP_E_UNKNOWNNAME) {
1767             nsIDOMNode_Release(node);
1768             SysFreeString(name);
1769             continue;
1770         }
1771
1772         nsres = nsIDOMNode_GetNodeValue(node, &nsstr);
1773         nsIDOMNode_Release(node);
1774         if(NS_FAILED(nsres)) {
1775             SysFreeString(name);
1776             continue;
1777         }
1778
1779         nsAString_GetData(&nsstr, &str);
1780         V_VT(&value) = VT_BSTR;
1781         if(*str) {
1782             V_BSTR(&value) = SysAllocString(str);
1783             if(!V_BSTR(&value)) {
1784                 SysFreeString(name);
1785                 continue;
1786             }
1787         } else
1788             V_BSTR(&value) = NULL;
1789
1790         IHTMLElement_setAttribute(&This->IHTMLElement_iface, name, value, 0);
1791         SysFreeString(name);
1792         VariantClear(&value);
1793     }
1794     nsAString_Finish(&nsstr);
1795
1796     nsIDOMNamedNodeMap_Release(attrs);
1797     return S_OK;
1798 }
1799
1800 static const tid_t HTMLElement_iface_tids[] = {
1801     HTMLELEMENT_TIDS,
1802     0
1803 };
1804
1805 static dispex_static_data_vtbl_t HTMLElement_dispex_vtbl = {
1806     NULL,
1807     HTMLElement_get_dispid,
1808     HTMLElement_invoke,
1809     HTMLElement_populate_props
1810 };
1811
1812 static dispex_static_data_t HTMLElement_dispex = {
1813     &HTMLElement_dispex_vtbl,
1814     DispHTMLUnknownElement_tid,
1815     NULL,
1816     HTMLElement_iface_tids
1817 };
1818
1819 void HTMLElement_Init(HTMLElement *This, HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, dispex_static_data_t *dispex_data)
1820 {
1821     This->IHTMLElement_iface.lpVtbl = &HTMLElementVtbl;
1822
1823     HTMLElement2_Init(This);
1824     HTMLElement3_Init(This);
1825
1826     if(dispex_data && !dispex_data->vtbl)
1827         dispex_data->vtbl = &HTMLElement_dispex_vtbl;
1828     init_dispex(&This->node.dispex, (IUnknown*)&This->IHTMLElement_iface,
1829             dispex_data ? dispex_data : &HTMLElement_dispex);
1830
1831     if(nselem)
1832         nsIDOMHTMLElement_AddRef(nselem);
1833     This->nselem = nselem;
1834
1835     HTMLDOMNode_Init(doc, &This->node, (nsIDOMNode*)nselem);
1836
1837     ConnectionPointContainer_Init(&This->cp_container, (IUnknown*)&This->IHTMLElement_iface);
1838 }
1839
1840 HRESULT HTMLElement_Create(HTMLDocumentNode *doc, nsIDOMNode *nsnode, BOOL use_generic, HTMLElement **ret)
1841 {
1842     nsIDOMHTMLElement *nselem;
1843     nsAString class_name_str;
1844     const PRUnichar *class_name;
1845     const tag_desc_t *tag;
1846     HTMLElement *elem;
1847     nsresult nsres;
1848     HRESULT hres;
1849
1850     nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMHTMLElement, (void**)&nselem);
1851     if(NS_FAILED(nsres))
1852         return E_FAIL;
1853
1854     nsAString_Init(&class_name_str, NULL);
1855     nsIDOMHTMLElement_GetTagName(nselem, &class_name_str);
1856
1857     nsAString_GetData(&class_name_str, &class_name);
1858
1859     tag = get_tag_desc(class_name);
1860     if(tag) {
1861         hres = tag->constructor(doc, nselem, &elem);
1862     }else if(use_generic) {
1863         hres = HTMLGenericElement_Create(doc, nselem, &elem);
1864     }else {
1865         elem = heap_alloc_zero(sizeof(HTMLElement));
1866         if(elem) {
1867             HTMLElement_Init(elem, doc, nselem, &HTMLElement_dispex);
1868             elem->node.vtbl = &HTMLElementImplVtbl;
1869             hres = S_OK;
1870         }else {
1871             hres = E_OUTOFMEMORY;
1872         }
1873     }
1874
1875     TRACE("%s ret %p\n", debugstr_w(class_name), elem);
1876
1877     nsIDOMElement_Release(nselem);
1878     nsAString_Finish(&class_name_str);
1879     if(FAILED(hres))
1880         return hres;
1881
1882     *ret = elem;
1883     return S_OK;
1884 }
1885
1886 /* interface IHTMLFiltersCollection */
1887 static HRESULT WINAPI HTMLFiltersCollection_QueryInterface(IHTMLFiltersCollection *iface, REFIID riid, void **ppv)
1888 {
1889     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1890
1891     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppv );
1892
1893     if(IsEqualGUID(&IID_IUnknown, riid)) {
1894         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
1895         *ppv = &This->IHTMLFiltersCollection_iface;
1896     }else if(IsEqualGUID(&IID_IHTMLFiltersCollection, riid)) {
1897         TRACE("(%p)->(IID_IHTMLFiltersCollection %p)\n", This, ppv);
1898         *ppv = &This->IHTMLFiltersCollection_iface;
1899     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1900         return *ppv ? S_OK : E_NOINTERFACE;
1901     }
1902
1903     if(*ppv) {
1904         IUnknown_AddRef((IUnknown*)*ppv);
1905         return S_OK;
1906     }
1907
1908     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
1909     return E_NOINTERFACE;
1910 }
1911
1912 static ULONG WINAPI HTMLFiltersCollection_AddRef(IHTMLFiltersCollection *iface)
1913 {
1914     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1915     LONG ref = InterlockedIncrement(&This->ref);
1916
1917     TRACE("(%p) ref=%d\n", This, ref);
1918
1919     return ref;
1920 }
1921
1922 static ULONG WINAPI HTMLFiltersCollection_Release(IHTMLFiltersCollection *iface)
1923 {
1924     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1925     LONG ref = InterlockedDecrement(&This->ref);
1926
1927     TRACE("(%p) ref=%d\n", This, ref);
1928
1929     if(!ref)
1930     {
1931         heap_free(This);
1932     }
1933
1934     return ref;
1935 }
1936
1937 static HRESULT WINAPI HTMLFiltersCollection_GetTypeInfoCount(IHTMLFiltersCollection *iface, UINT *pctinfo)
1938 {
1939     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1940     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
1941 }
1942
1943 static HRESULT WINAPI HTMLFiltersCollection_GetTypeInfo(IHTMLFiltersCollection *iface,
1944                                     UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1945 {
1946     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1947     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1948 }
1949
1950 static HRESULT WINAPI HTMLFiltersCollection_GetIDsOfNames(IHTMLFiltersCollection *iface,
1951                                     REFIID riid, LPOLESTR *rgszNames, UINT cNames,
1952                                     LCID lcid, DISPID *rgDispId)
1953 {
1954     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1955     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1956             lcid, rgDispId);
1957 }
1958
1959 static HRESULT WINAPI HTMLFiltersCollection_Invoke(IHTMLFiltersCollection *iface, DISPID dispIdMember, REFIID riid,
1960                                     LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1961                                     EXCEPINFO *pExcepInfo, UINT *puArgErr)
1962 {
1963     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1964     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
1965             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1966 }
1967
1968 static HRESULT WINAPI HTMLFiltersCollection_get_length(IHTMLFiltersCollection *iface, LONG *p)
1969 {
1970     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1971
1972     if(!p)
1973         return E_POINTER;
1974
1975     FIXME("(%p)->(%p) Always returning 0\n", This, p);
1976     *p = 0;
1977
1978     return S_OK;
1979 }
1980
1981 static HRESULT WINAPI HTMLFiltersCollection_get__newEnum(IHTMLFiltersCollection *iface, IUnknown **p)
1982 {
1983     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1984     FIXME("(%p)->(%p)\n", This, p);
1985     return E_NOTIMPL;
1986 }
1987
1988 static HRESULT WINAPI HTMLFiltersCollection_item(IHTMLFiltersCollection *iface, VARIANT *pvarIndex, VARIANT *pvarResult)
1989 {
1990     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1991     FIXME("(%p)->(%p, %p)\n", This, pvarIndex, pvarResult);
1992     return E_NOTIMPL;
1993 }
1994
1995 static const IHTMLFiltersCollectionVtbl HTMLFiltersCollectionVtbl = {
1996     HTMLFiltersCollection_QueryInterface,
1997     HTMLFiltersCollection_AddRef,
1998     HTMLFiltersCollection_Release,
1999     HTMLFiltersCollection_GetTypeInfoCount,
2000     HTMLFiltersCollection_GetTypeInfo,
2001     HTMLFiltersCollection_GetIDsOfNames,
2002     HTMLFiltersCollection_Invoke,
2003     HTMLFiltersCollection_get_length,
2004     HTMLFiltersCollection_get__newEnum,
2005     HTMLFiltersCollection_item
2006 };
2007
2008 static HRESULT HTMLFiltersCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
2009 {
2010     WCHAR *ptr;
2011     int idx = 0;
2012
2013     for(ptr = name; *ptr && isdigitW(*ptr); ptr++)
2014         idx = idx*10 + (*ptr-'0');
2015     if(*ptr)
2016         return DISP_E_UNKNOWNNAME;
2017
2018     *dispid = MSHTML_DISPID_CUSTOM_MIN + idx;
2019     TRACE("ret %x\n", *dispid);
2020     return S_OK;
2021 }
2022
2023 static HRESULT HTMLFiltersCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
2024         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
2025 {
2026     TRACE("(%p)->(%x %x %x %p %p %p)\n", dispex, id, lcid, flags, params, res, ei);
2027
2028     V_VT(res) = VT_DISPATCH;
2029     V_DISPATCH(res) = NULL;
2030
2031     FIXME("always returning NULL\n");
2032
2033     return S_OK;
2034 }
2035
2036 static const dispex_static_data_vtbl_t HTMLFiltersCollection_dispex_vtbl = {
2037     NULL,
2038     HTMLFiltersCollection_get_dispid,
2039     HTMLFiltersCollection_invoke,
2040     NULL
2041 };
2042
2043 static const tid_t HTMLFiltersCollection_iface_tids[] = {
2044     IHTMLFiltersCollection_tid,
2045     0
2046 };
2047 static dispex_static_data_t HTMLFiltersCollection_dispex = {
2048     &HTMLFiltersCollection_dispex_vtbl,
2049     IHTMLFiltersCollection_tid,
2050     NULL,
2051     HTMLFiltersCollection_iface_tids
2052 };
2053
2054 static IHTMLFiltersCollection *HTMLFiltersCollection_Create(void)
2055 {
2056     HTMLFiltersCollection *ret = heap_alloc(sizeof(HTMLFiltersCollection));
2057
2058     ret->IHTMLFiltersCollection_iface.lpVtbl = &HTMLFiltersCollectionVtbl;
2059     ret->ref = 1;
2060
2061     init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLFiltersCollection_iface,
2062             &HTMLFiltersCollection_dispex);
2063
2064     return &ret->IHTMLFiltersCollection_iface;
2065 }
2066
2067 /* interface IHTMLAttributeCollection */
2068 static inline HTMLAttributeCollection *impl_from_IHTMLAttributeCollection(IHTMLAttributeCollection *iface)
2069 {
2070     return CONTAINING_RECORD(iface, HTMLAttributeCollection, IHTMLAttributeCollection_iface);
2071 }
2072
2073 static HRESULT WINAPI HTMLAttributeCollection_QueryInterface(IHTMLAttributeCollection *iface, REFIID riid, void **ppv)
2074 {
2075     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
2076
2077     *ppv = NULL;
2078
2079     if(IsEqualGUID(&IID_IUnknown, riid)) {
2080         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
2081         *ppv = &This->IHTMLAttributeCollection_iface;
2082     }else if(IsEqualGUID(&IID_IHTMLAttributeCollection, riid)) {
2083         TRACE("(%p)->(IID_IHTMLAttributeCollection %p)\n", This, ppv);
2084         *ppv = &This->IHTMLAttributeCollection_iface;
2085     }else if(IsEqualGUID(&IID_IHTMLAttributeCollection2, riid)) {
2086         TRACE("(%p)->(IID_IHTMLAttributeCollection2 %p)\n", This, ppv);
2087         *ppv = &This->IHTMLAttributeCollection2_iface;
2088     }else if(IsEqualGUID(&IID_IHTMLAttributeCollection3, riid)) {
2089         TRACE("(%p)->(IID_IHTMLAttributeCollection3 %p)\n", This, ppv);
2090         *ppv = &This->IHTMLAttributeCollection3_iface;
2091     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
2092         return *ppv ? S_OK : E_NOINTERFACE;
2093     }
2094
2095     if(*ppv) {
2096         IUnknown_AddRef((IUnknown*)*ppv);
2097         return S_OK;
2098     }
2099
2100     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
2101     return E_NOINTERFACE;
2102 }
2103
2104 static ULONG WINAPI HTMLAttributeCollection_AddRef(IHTMLAttributeCollection *iface)
2105 {
2106     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
2107     LONG ref = InterlockedIncrement(&This->ref);
2108
2109     TRACE("(%p) ref=%d\n", This, ref);
2110
2111     return ref;
2112 }
2113
2114 static ULONG WINAPI HTMLAttributeCollection_Release(IHTMLAttributeCollection *iface)
2115 {
2116     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
2117     LONG ref = InterlockedDecrement(&This->ref);
2118
2119     TRACE("(%p) ref=%d\n", This, ref);
2120
2121     if(!ref) {
2122         while(!list_empty(&This->attrs)) {
2123             HTMLDOMAttribute *attr = LIST_ENTRY(list_head(&This->attrs), HTMLDOMAttribute, entry);
2124
2125             list_remove(&attr->entry);
2126             attr->elem = NULL;
2127             IHTMLDOMAttribute_Release(&attr->IHTMLDOMAttribute_iface);
2128         }
2129
2130         heap_free(This);
2131     }
2132
2133     return ref;
2134 }
2135
2136 static HRESULT WINAPI HTMLAttributeCollection_GetTypeInfoCount(IHTMLAttributeCollection *iface, UINT *pctinfo)
2137 {
2138     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
2139     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
2140 }
2141
2142 static HRESULT WINAPI HTMLAttributeCollection_GetTypeInfo(IHTMLAttributeCollection *iface, UINT iTInfo,
2143         LCID lcid, ITypeInfo **ppTInfo)
2144 {
2145     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
2146     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2147 }
2148
2149 static HRESULT WINAPI HTMLAttributeCollection_GetIDsOfNames(IHTMLAttributeCollection *iface, REFIID riid,
2150         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2151 {
2152     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
2153     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2154             lcid, rgDispId);
2155 }
2156
2157 static HRESULT WINAPI HTMLAttributeCollection_Invoke(IHTMLAttributeCollection *iface, DISPID dispIdMember,
2158         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2159         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2160 {
2161     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
2162     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
2163             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2164 }
2165
2166 static HRESULT get_attr_dispid_by_idx(HTMLAttributeCollection *This, LONG *idx, DISPID *dispid)
2167 {
2168     IDispatchEx *dispex = &This->elem->node.dispex.IDispatchEx_iface;
2169     DISPID id = DISPID_STARTENUM;
2170     LONG len = -1;
2171     HRESULT hres;
2172
2173     FIXME("filter non-enumerable attributes out\n");
2174
2175     while(1) {
2176         hres = IDispatchEx_GetNextDispID(dispex, fdexEnumAll, id, &id);
2177         if(FAILED(hres))
2178             return hres;
2179         else if(hres == S_FALSE)
2180             break;
2181
2182         len++;
2183         if(len == *idx)
2184             break;
2185     }
2186
2187     if(dispid) {
2188         *dispid = id;
2189         return *idx==len ? S_OK : DISP_E_UNKNOWNNAME;
2190     }
2191
2192     *idx = len+1;
2193     return S_OK;
2194 }
2195
2196 static inline HRESULT get_attr_dispid_by_name(HTMLAttributeCollection *This, BSTR name, DISPID *id)
2197 {
2198     HRESULT hres;
2199
2200     if(name[0]>='0' && name[0]<='9') {
2201         WCHAR *end_ptr;
2202         LONG idx;
2203
2204         idx = strtoulW(name, &end_ptr, 10);
2205         if(!*end_ptr) {
2206             hres = get_attr_dispid_by_idx(This, &idx, id);
2207             if(SUCCEEDED(hres))
2208                 return hres;
2209         }
2210     }
2211
2212     if(!This->elem) {
2213         WARN("NULL elem\n");
2214         return E_UNEXPECTED;
2215     }
2216
2217     hres = IDispatchEx_GetDispID(&This->elem->node.dispex.IDispatchEx_iface,
2218             name, fdexNameCaseInsensitive, id);
2219     return hres;
2220 }
2221
2222 static inline HRESULT get_domattr(HTMLAttributeCollection *This, DISPID id, LONG *list_pos, HTMLDOMAttribute **attr)
2223 {
2224     HTMLDOMAttribute *iter;
2225     LONG pos = 0;
2226     HRESULT hres;
2227
2228     *attr = NULL;
2229     LIST_FOR_EACH_ENTRY(iter, &This->attrs, HTMLDOMAttribute, entry) {
2230         if(iter->dispid == id) {
2231             *attr = iter;
2232             break;
2233         }
2234         pos++;
2235     }
2236
2237     if(!*attr) {
2238         if(!This->elem) {
2239             WARN("NULL elem\n");
2240             return E_UNEXPECTED;
2241         }
2242
2243         pos++;
2244         hres = HTMLDOMAttribute_Create(This->elem, id, attr);
2245         if(FAILED(hres))
2246             return hres;
2247     }
2248
2249     IHTMLDOMAttribute_AddRef(&(*attr)->IHTMLDOMAttribute_iface);
2250     if(list_pos)
2251         *list_pos = pos;
2252     return S_OK;
2253 }
2254
2255 static HRESULT WINAPI HTMLAttributeCollection_get_length(IHTMLAttributeCollection *iface, LONG *p)
2256 {
2257     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
2258     HRESULT hres;
2259
2260     TRACE("(%p)->(%p)\n", This, p);
2261
2262     *p = -1;
2263     hres = get_attr_dispid_by_idx(This, p, NULL);
2264     return hres;
2265 }
2266
2267 static HRESULT WINAPI HTMLAttributeCollection__newEnum(IHTMLAttributeCollection *iface, IUnknown **p)
2268 {
2269     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
2270     FIXME("(%p)->(%p)\n", This, p);
2271     return E_NOTIMPL;
2272 }
2273
2274 static HRESULT WINAPI HTMLAttributeCollection_item(IHTMLAttributeCollection *iface, VARIANT *name, IDispatch **ppItem)
2275 {
2276     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
2277     HTMLDOMAttribute *attr;
2278     DISPID id;
2279     HRESULT hres;
2280
2281     TRACE("(%p)->(%s %p)\n", This, debugstr_variant(name), ppItem);
2282
2283     switch(V_VT(name)) {
2284     case VT_I4:
2285         hres = get_attr_dispid_by_idx(This, &V_I4(name), &id);
2286         break;
2287     case VT_BSTR:
2288         hres = get_attr_dispid_by_name(This, V_BSTR(name), &id);
2289         break;
2290     default:
2291         FIXME("unsupported vt %x\n", V_VT(name));
2292         hres = E_NOTIMPL;
2293     }
2294     if(hres == DISP_E_UNKNOWNNAME)
2295         return E_INVALIDARG;
2296     if(FAILED(hres))
2297         return hres;
2298
2299     hres = get_domattr(This, id, NULL, &attr);
2300     if(FAILED(hres))
2301         return hres;
2302
2303     *ppItem = (IDispatch*)&attr->IHTMLDOMAttribute_iface;
2304     return S_OK;
2305 }
2306
2307 static const IHTMLAttributeCollectionVtbl HTMLAttributeCollectionVtbl = {
2308     HTMLAttributeCollection_QueryInterface,
2309     HTMLAttributeCollection_AddRef,
2310     HTMLAttributeCollection_Release,
2311     HTMLAttributeCollection_GetTypeInfoCount,
2312     HTMLAttributeCollection_GetTypeInfo,
2313     HTMLAttributeCollection_GetIDsOfNames,
2314     HTMLAttributeCollection_Invoke,
2315     HTMLAttributeCollection_get_length,
2316     HTMLAttributeCollection__newEnum,
2317     HTMLAttributeCollection_item
2318 };
2319
2320 static inline HTMLAttributeCollection *impl_from_IHTMLAttributeCollection2(IHTMLAttributeCollection2 *iface)
2321 {
2322     return CONTAINING_RECORD(iface, HTMLAttributeCollection, IHTMLAttributeCollection2_iface);
2323 }
2324
2325 static HRESULT WINAPI HTMLAttributeCollection2_QueryInterface(IHTMLAttributeCollection2 *iface, REFIID riid, void **ppv)
2326 {
2327     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
2328     return IHTMLAttributeCollection_QueryInterface(&This->IHTMLAttributeCollection_iface, riid, ppv);
2329 }
2330
2331 static ULONG WINAPI HTMLAttributeCollection2_AddRef(IHTMLAttributeCollection2 *iface)
2332 {
2333     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
2334     return IHTMLAttributeCollection_AddRef(&This->IHTMLAttributeCollection_iface);
2335 }
2336
2337 static ULONG WINAPI HTMLAttributeCollection2_Release(IHTMLAttributeCollection2 *iface)
2338 {
2339     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
2340     return IHTMLAttributeCollection_Release(&This->IHTMLAttributeCollection_iface);
2341 }
2342
2343 static HRESULT WINAPI HTMLAttributeCollection2_GetTypeInfoCount(IHTMLAttributeCollection2 *iface, UINT *pctinfo)
2344 {
2345     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
2346     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
2347 }
2348
2349 static HRESULT WINAPI HTMLAttributeCollection2_GetTypeInfo(IHTMLAttributeCollection2 *iface, UINT iTInfo,
2350         LCID lcid, ITypeInfo **ppTInfo)
2351 {
2352     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
2353     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2354 }
2355
2356 static HRESULT WINAPI HTMLAttributeCollection2_GetIDsOfNames(IHTMLAttributeCollection2 *iface, REFIID riid,
2357         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2358 {
2359     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
2360     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2361             lcid, rgDispId);
2362 }
2363
2364 static HRESULT WINAPI HTMLAttributeCollection2_Invoke(IHTMLAttributeCollection2 *iface, DISPID dispIdMember,
2365         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2366         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2367 {
2368     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
2369     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
2370             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2371 }
2372
2373 static HRESULT WINAPI HTMLAttributeCollection2_getNamedItem(IHTMLAttributeCollection2 *iface, BSTR bstrName,
2374         IHTMLDOMAttribute **newretNode)
2375 {
2376     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
2377     HTMLDOMAttribute *attr;
2378     DISPID id;
2379     HRESULT hres;
2380
2381     TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrName), newretNode);
2382
2383     hres = get_attr_dispid_by_name(This, bstrName, &id);
2384     if(hres == DISP_E_UNKNOWNNAME) {
2385         *newretNode = NULL;
2386         return S_OK;
2387     } else if(FAILED(hres)) {
2388         return hres;
2389     }
2390
2391     hres = get_domattr(This, id, NULL, &attr);
2392     if(FAILED(hres))
2393         return hres;
2394
2395     *newretNode = &attr->IHTMLDOMAttribute_iface;
2396     return S_OK;
2397 }
2398
2399 static HRESULT WINAPI HTMLAttributeCollection2_setNamedItem(IHTMLAttributeCollection2 *iface,
2400         IHTMLDOMAttribute *ppNode, IHTMLDOMAttribute **newretNode)
2401 {
2402     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
2403     FIXME("(%p)->(%p %p)\n", This, ppNode, newretNode);
2404     return E_NOTIMPL;
2405 }
2406
2407 static HRESULT WINAPI HTMLAttributeCollection2_removeNamedItem(IHTMLAttributeCollection2 *iface,
2408         BSTR bstrName, IHTMLDOMAttribute **newretNode)
2409 {
2410     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
2411     FIXME("(%p)->(%s %p)\n", This, debugstr_w(bstrName), newretNode);
2412     return E_NOTIMPL;
2413 }
2414
2415 static const IHTMLAttributeCollection2Vtbl HTMLAttributeCollection2Vtbl = {
2416     HTMLAttributeCollection2_QueryInterface,
2417     HTMLAttributeCollection2_AddRef,
2418     HTMLAttributeCollection2_Release,
2419     HTMLAttributeCollection2_GetTypeInfoCount,
2420     HTMLAttributeCollection2_GetTypeInfo,
2421     HTMLAttributeCollection2_GetIDsOfNames,
2422     HTMLAttributeCollection2_Invoke,
2423     HTMLAttributeCollection2_getNamedItem,
2424     HTMLAttributeCollection2_setNamedItem,
2425     HTMLAttributeCollection2_removeNamedItem
2426 };
2427
2428 static inline HTMLAttributeCollection *impl_from_IHTMLAttributeCollection3(IHTMLAttributeCollection3 *iface)
2429 {
2430     return CONTAINING_RECORD(iface, HTMLAttributeCollection, IHTMLAttributeCollection3_iface);
2431 }
2432
2433 static HRESULT WINAPI HTMLAttributeCollection3_QueryInterface(IHTMLAttributeCollection3 *iface, REFIID riid, void **ppv)
2434 {
2435     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
2436     return IHTMLAttributeCollection_QueryInterface(&This->IHTMLAttributeCollection_iface, riid, ppv);
2437 }
2438
2439 static ULONG WINAPI HTMLAttributeCollection3_AddRef(IHTMLAttributeCollection3 *iface)
2440 {
2441     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
2442     return IHTMLAttributeCollection_AddRef(&This->IHTMLAttributeCollection_iface);
2443 }
2444
2445 static ULONG WINAPI HTMLAttributeCollection3_Release(IHTMLAttributeCollection3 *iface)
2446 {
2447     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
2448     return IHTMLAttributeCollection_Release(&This->IHTMLAttributeCollection_iface);
2449 }
2450
2451 static HRESULT WINAPI HTMLAttributeCollection3_GetTypeInfoCount(IHTMLAttributeCollection3 *iface, UINT *pctinfo)
2452 {
2453     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
2454     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
2455 }
2456
2457 static HRESULT WINAPI HTMLAttributeCollection3_GetTypeInfo(IHTMLAttributeCollection3 *iface, UINT iTInfo,
2458         LCID lcid, ITypeInfo **ppTInfo)
2459 {
2460     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
2461     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2462 }
2463
2464 static HRESULT WINAPI HTMLAttributeCollection3_GetIDsOfNames(IHTMLAttributeCollection3 *iface, REFIID riid,
2465         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2466 {
2467     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
2468     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2469             lcid, rgDispId);
2470 }
2471
2472 static HRESULT WINAPI HTMLAttributeCollection3_Invoke(IHTMLAttributeCollection3 *iface, DISPID dispIdMember,
2473         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2474         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2475 {
2476     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
2477     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
2478             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2479 }
2480
2481 static HRESULT WINAPI HTMLAttributeCollection3_getNamedItem(IHTMLAttributeCollection3 *iface, BSTR bstrName,
2482         IHTMLDOMAttribute **ppNodeOut)
2483 {
2484     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
2485     return IHTMLAttributeCollection2_getNamedItem(&This->IHTMLAttributeCollection2_iface, bstrName, ppNodeOut);
2486 }
2487
2488 static HRESULT WINAPI HTMLAttributeCollection3_setNamedItem(IHTMLAttributeCollection3 *iface,
2489         IHTMLDOMAttribute *pNodeIn, IHTMLDOMAttribute **ppNodeOut)
2490 {
2491     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
2492     FIXME("(%p)->(%p %p)\n", This, pNodeIn, ppNodeOut);
2493     return E_NOTIMPL;
2494 }
2495
2496 static HRESULT WINAPI HTMLAttributeCollection3_removeNamedItem(IHTMLAttributeCollection3 *iface,
2497         BSTR bstrName, IHTMLDOMAttribute **ppNodeOut)
2498 {
2499     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
2500     FIXME("(%p)->(%s %p)\n", This, debugstr_w(bstrName), ppNodeOut);
2501     return E_NOTIMPL;
2502 }
2503
2504 static HRESULT WINAPI HTMLAttributeCollection3_item(IHTMLAttributeCollection3 *iface, LONG index, IHTMLDOMAttribute **ppNodeOut)
2505 {
2506     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
2507     HTMLDOMAttribute *attr;
2508     DISPID id;
2509     HRESULT hres;
2510
2511     TRACE("(%p)->(%d %p)\n", This, index, ppNodeOut);
2512
2513     hres = get_attr_dispid_by_idx(This, &index, &id);
2514     if(hres == DISP_E_UNKNOWNNAME)
2515         return E_INVALIDARG;
2516     if(FAILED(hres))
2517         return hres;
2518
2519     hres = get_domattr(This, id, NULL, &attr);
2520     if(FAILED(hres))
2521         return hres;
2522
2523     *ppNodeOut = &attr->IHTMLDOMAttribute_iface;
2524     return S_OK;
2525 }
2526
2527 static HRESULT WINAPI HTMLAttributeCollection3_get_length(IHTMLAttributeCollection3 *iface, LONG *p)
2528 {
2529     HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
2530     return IHTMLAttributeCollection_get_length(&This->IHTMLAttributeCollection_iface, p);
2531 }
2532
2533 static const IHTMLAttributeCollection3Vtbl HTMLAttributeCollection3Vtbl = {
2534     HTMLAttributeCollection3_QueryInterface,
2535     HTMLAttributeCollection3_AddRef,
2536     HTMLAttributeCollection3_Release,
2537     HTMLAttributeCollection3_GetTypeInfoCount,
2538     HTMLAttributeCollection3_GetTypeInfo,
2539     HTMLAttributeCollection3_GetIDsOfNames,
2540     HTMLAttributeCollection3_Invoke,
2541     HTMLAttributeCollection3_getNamedItem,
2542     HTMLAttributeCollection3_setNamedItem,
2543     HTMLAttributeCollection3_removeNamedItem,
2544     HTMLAttributeCollection3_item,
2545     HTMLAttributeCollection3_get_length
2546 };
2547
2548 static inline HTMLAttributeCollection *HTMLAttributeCollection_from_DispatchEx(DispatchEx *iface)
2549 {
2550     return CONTAINING_RECORD(iface, HTMLAttributeCollection, dispex);
2551 }
2552
2553 static HRESULT HTMLAttributeCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
2554 {
2555     HTMLAttributeCollection *This = HTMLAttributeCollection_from_DispatchEx(dispex);
2556     HTMLDOMAttribute *attr;
2557     LONG pos;
2558     HRESULT hres;
2559
2560     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(name), flags, dispid);
2561
2562     hres = get_attr_dispid_by_name(This, name, dispid);
2563     if(FAILED(hres))
2564         return hres;
2565
2566     hres = get_domattr(This, *dispid, &pos, &attr);
2567     if(FAILED(hres))
2568         return hres;
2569     IHTMLDOMAttribute_Release(&attr->IHTMLDOMAttribute_iface);
2570
2571     *dispid = MSHTML_DISPID_CUSTOM_MIN+pos;
2572     return S_OK;
2573 }
2574
2575 static HRESULT HTMLAttributeCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid,
2576         WORD flags, DISPPARAMS *params, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
2577 {
2578     HTMLAttributeCollection *This = HTMLAttributeCollection_from_DispatchEx(dispex);
2579
2580     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, flags, params, res, ei, caller);
2581
2582     switch(flags) {
2583     case DISPATCH_PROPERTYGET: {
2584         HTMLDOMAttribute *iter;
2585
2586         id = id-MSHTML_DISPID_CUSTOM_MIN+1;
2587
2588         LIST_FOR_EACH_ENTRY(iter, &This->attrs, HTMLDOMAttribute, entry) {
2589             if(!(--id))
2590                 break;
2591         }
2592         if(id)
2593             return E_INVALIDARG;
2594
2595         IHTMLDOMAttribute_AddRef(&iter->IHTMLDOMAttribute_iface);
2596         V_VT(res) = VT_DISPATCH;
2597         V_DISPATCH(res) = (IDispatch*)&iter->IHTMLDOMAttribute_iface;
2598         return S_OK;
2599     }
2600
2601     default:
2602         FIXME("unimplemented flags %x\n", flags);
2603         return E_NOTIMPL;
2604     }
2605 }
2606
2607 static const dispex_static_data_vtbl_t HTMLAttributeCollection_dispex_vtbl = {
2608     NULL,
2609     HTMLAttributeCollection_get_dispid,
2610     HTMLAttributeCollection_invoke,
2611     NULL
2612 };
2613
2614 static const tid_t HTMLAttributeCollection_iface_tids[] = {
2615     IHTMLAttributeCollection_tid,
2616     IHTMLAttributeCollection2_tid,
2617     IHTMLAttributeCollection3_tid,
2618     0
2619 };
2620
2621 static dispex_static_data_t HTMLAttributeCollection_dispex = {
2622     &HTMLAttributeCollection_dispex_vtbl,
2623     DispHTMLAttributeCollection_tid,
2624     NULL,
2625     HTMLAttributeCollection_iface_tids
2626 };
2627
2628 HRESULT HTMLElement_get_attr_col(HTMLDOMNode *iface, HTMLAttributeCollection **ac)
2629 {
2630     HTMLElement *This = impl_from_HTMLDOMNode(iface);
2631
2632     if(This->attrs) {
2633         IHTMLAttributeCollection_AddRef(&This->attrs->IHTMLAttributeCollection_iface);
2634         *ac = This->attrs;
2635         return S_OK;
2636     }
2637
2638     This->attrs = heap_alloc_zero(sizeof(HTMLAttributeCollection));
2639     if(!This->attrs)
2640         return E_OUTOFMEMORY;
2641
2642     This->attrs->IHTMLAttributeCollection_iface.lpVtbl = &HTMLAttributeCollectionVtbl;
2643     This->attrs->IHTMLAttributeCollection2_iface.lpVtbl = &HTMLAttributeCollection2Vtbl;
2644     This->attrs->IHTMLAttributeCollection3_iface.lpVtbl = &HTMLAttributeCollection3Vtbl;
2645     This->attrs->ref = 2;
2646
2647     This->attrs->elem = This;
2648     list_init(&This->attrs->attrs);
2649     init_dispex(&This->attrs->dispex, (IUnknown*)&This->attrs->IHTMLAttributeCollection_iface,
2650             &HTMLAttributeCollection_dispex);
2651
2652     *ac = This->attrs;
2653     return S_OK;
2654 }