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