dlls/mshtml/htmlelem.c

   1 /*
   2  * Copyright 2006 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "winreg.h"
  28 #include "ole2.h"
  29 #include "shlwapi.h"
  30
  31 #include "wine/debug.h"
  32 #include "wine/unicode.h"
  33
  34 #include "mshtml_private.h"
  35 #include "htmlevent.h"
  36 #include "htmlstyle.h"
  37
  38 static const WCHAR aW[]        = {'A',0};
  39 static const WCHAR bodyW[]     = {'B','O','D','Y',0};
  40 static const WCHAR embedW[]    = {'E','M','B','E','D',0};
  41 static const WCHAR formW[]     = {'F','O','R','M',0};
  42 static const WCHAR frameW[]    = {'F','R','A','M','E',0};
  43 static const WCHAR iframeW[]   = {'I','F','R','A','M','E',0};
  44 static const WCHAR imgW[]      = {'I','M','G',0};
  45 static const WCHAR inputW[]    = {'I','N','P','U','T',0};
  46 static const WCHAR objectW[]   = {'O','B','J','E','C','T',0};
  47 static const WCHAR optionW[]   = {'O','P','T','I','O','N',0};
  48 static const WCHAR scriptW[]   = {'S','C','R','I','P','T',0};
  49 static const WCHAR selectW[]   = {'S','E','L','E','C','T',0};
  50 static const WCHAR styleW[]    = {'S','T','Y','L','E',0};
  51 static const WCHAR tableW[]    = {'T','A','B','L','E',0};
  52 static const WCHAR textareaW[] = {'T','E','X','T','A','R','E','A',0};
  53 static const WCHAR trW[]       = {'T','R',0};
  54
  55 typedef struct {
  56     const WCHAR *name;
  57     HRESULT (*constructor)(HTMLDocumentNode*,nsIDOMHTMLElement*,HTMLElement**);
  58 } tag_desc_t;
  59
  60 static const tag_desc_t tag_descs[] = {
  61     {aW,         HTMLAnchorElement_Create},
  62     {bodyW,      HTMLBodyElement_Create},
  63     {embedW,     HTMLEmbedElement_Create},
  64     {formW,      HTMLFormElement_Create},
  65     {frameW,     HTMLFrameElement_Create},
  66     {iframeW,    HTMLIFrame_Create},
  67     {imgW,       HTMLImgElement_Create},
  68     {inputW,     HTMLInputElement_Create},
  69     {objectW,    HTMLObjectElement_Create},
  70     {optionW,    HTMLOptionElement_Create},
  71     {scriptW,    HTMLScriptElement_Create},
  72     {selectW,    HTMLSelectElement_Create},
  73     {styleW,     HTMLStyleElement_Create},
  74     {tableW,     HTMLTable_Create},
  75     {textareaW,  HTMLTextAreaElement_Create},
  76     {trW,        HTMLTableRow_Create}
  77 };
  78
  79 static const tag_desc_t *get_tag_desc(const WCHAR *tag_name)
  80 {
  81     DWORD min=0, max=sizeof(tag_descs)/sizeof(*tag_descs)-1, i;
  82     int r;
  83
  84     while(min <= max) {
  85         i = (min+max)/2;
  86         r = strcmpW(tag_name, tag_descs[i].name);
  87         if(!r)
  88             return tag_descs+i;
  89
  90         if(r < 0)
  91             max = i-1;
  92         else
  93             min = i+1;
  94     }
  95
  96     return NULL;
  97 }
  98
  99 typedef struct
 100 {
 101     DispatchEx dispex;
 102     IHTMLFiltersCollection IHTMLFiltersCollection_iface;
 103
 104     LONG ref;
 105 } HTMLFiltersCollection;
 106
 107 static inline HTMLFiltersCollection *impl_from_IHTMLFiltersCollection(IHTMLFiltersCollection *iface)
 108 {
 109     return CONTAINING_RECORD(iface, HTMLFiltersCollection, IHTMLFiltersCollection_iface);
 110 }
 111
 112 static IHTMLFiltersCollection *HTMLFiltersCollection_Create(void);
 113
 114
 115 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
 116
 117 static inline HTMLElement *impl_from_IHTMLElement(IHTMLElement *iface)
 118 {
 119     return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement_iface);
 120 }
 121
 122 HRESULT create_nselem(HTMLDocumentNode *doc, const WCHAR *tag, nsIDOMHTMLElement **ret)
 123 {
 124     nsIDOMElement *nselem;
 125     nsAString tag_str;
 126     nsresult nsres;
 127
 128     if(!doc->nsdoc) {
 129         WARN("NULL nsdoc\n");
 130         return E_UNEXPECTED;
 131     }
 132
 133     nsAString_InitDepend(&tag_str, tag);
 134     nsres = nsIDOMDocument_CreateElement(doc->nsdoc, &tag_str, &nselem);
 135     nsAString_Finish(&tag_str);
 136     if(NS_FAILED(nsres)) {
 137         ERR("CreateElement failed: %08x\n", nsres);
 138         return E_FAIL;
 139     }
 140
 141     nsres = nsIDOMElement_QueryInterface(nselem, &IID_nsIDOMHTMLElement, (void**)ret);
 142     nsIDOMElement_Release(nselem);
 143     if(NS_FAILED(nsres)) {
 144         ERR("Could not get nsIDOMHTMLElement iface: %08x\n", nsres);
 145         return E_FAIL;
 146     }
 147
 148     return S_OK;
 149 }
 150
 151 static HRESULT WINAPI HTMLElement_QueryInterface(IHTMLElement *iface,
 152                                                  REFIID riid, void **ppv)
 153 {
 154     HTMLElement *This = impl_from_IHTMLElement(iface);
 155
 156     return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
 157 }
 158
 159 static ULONG WINAPI HTMLElement_AddRef(IHTMLElement *iface)
 160 {
 161     HTMLElement *This = impl_from_IHTMLElement(iface);
 162
 163     return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
 164 }
 165
 166 static ULONG WINAPI HTMLElement_Release(IHTMLElement *iface)
 167 {
 168     HTMLElement *This = impl_from_IHTMLElement(iface);
 169
 170     return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
 171 }
 172
 173 static HRESULT WINAPI HTMLElement_GetTypeInfoCount(IHTMLElement *iface, UINT *pctinfo)
 174 {
 175     HTMLElement *This = impl_from_IHTMLElement(iface);
 176     return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
 177 }
 178
 179 static HRESULT WINAPI HTMLElement_GetTypeInfo(IHTMLElement *iface, UINT iTInfo,
 180                                               LCID lcid, ITypeInfo **ppTInfo)
 181 {
 182     HTMLElement *This = impl_from_IHTMLElement(iface);
 183     return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 184 }
 185
 186 static HRESULT WINAPI HTMLElement_GetIDsOfNames(IHTMLElement *iface, REFIID riid,
 187                                                 LPOLESTR *rgszNames, UINT cNames,
 188                                                 LCID lcid, DISPID *rgDispId)
 189 {
 190     HTMLElement *This = impl_from_IHTMLElement(iface);
 191     return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 192             lcid, rgDispId);
 193 }
 194
 195 static HRESULT WINAPI HTMLElement_Invoke(IHTMLElement *iface, DISPID dispIdMember,
 196                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 197                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 198 {
 199     HTMLElement *This = impl_from_IHTMLElement(iface);
 200     return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 201             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 202 }
 203
 204 static HRESULT WINAPI HTMLElement_setAttribute(IHTMLElement *iface, BSTR strAttributeName,
 205                                                VARIANT AttributeValue, LONG lFlags)
 206 {
 207     HTMLElement *This = impl_from_IHTMLElement(iface);
 208     HRESULT hres;
 209     DISPID dispid, dispidNamed = DISPID_PROPERTYPUT;
 210     DISPPARAMS dispParams;
 211     EXCEPINFO excep;
 212
 213     TRACE("(%p)->(%s . %08x)\n", This, debugstr_w(strAttributeName), lFlags);
 214
 215     hres = IDispatchEx_GetDispID(&This->node.dispex.IDispatchEx_iface, strAttributeName,
 216             fdexNameCaseInsensitive | fdexNameEnsure, &dispid);
 217     if(FAILED(hres))
 218         return hres;
 219
 220     dispParams.cArgs = 1;
 221     dispParams.cNamedArgs = 1;
 222     dispParams.rgdispidNamedArgs = &dispidNamed;
 223     dispParams.rgvarg = &AttributeValue;
 224
 225     hres = IDispatchEx_InvokeEx(&This->node.dispex.IDispatchEx_iface, dispid,
 226             LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYPUT, &dispParams, NULL, &excep, NULL);
 227     return hres;
 228 }
 229
 230 static HRESULT WINAPI HTMLElement_getAttribute(IHTMLElement *iface, BSTR strAttributeName,
 231                                                LONG lFlags, VARIANT *AttributeValue)
 232 {
 233     HTMLElement *This = impl_from_IHTMLElement(iface);
 234     DISPID dispid;
 235     HRESULT hres;
 236     DISPPARAMS dispParams = {NULL, NULL, 0, 0};
 237     EXCEPINFO excep;
 238
 239     TRACE("(%p)->(%s %08x %p)\n", This, debugstr_w(strAttributeName), lFlags, AttributeValue);
 240
 241     hres = IDispatchEx_GetDispID(&This->node.dispex.IDispatchEx_iface, strAttributeName,
 242             fdexNameCaseInsensitive, &dispid);
 243     if(hres == DISP_E_UNKNOWNNAME) {
 244         V_VT(AttributeValue) = VT_NULL;
 245         return S_OK;
 246     }
 247
 248     if(FAILED(hres)) {
 249         V_VT(AttributeValue) = VT_NULL;
 250         return hres;
 251     }
 252
 253     hres = IDispatchEx_InvokeEx(&This->node.dispex.IDispatchEx_iface, dispid, LOCALE_SYSTEM_DEFAULT,
 254             DISPATCH_PROPERTYGET, &dispParams, AttributeValue, &excep, NULL);
 255
 256     return hres;
 257 }
 258
 259 static HRESULT WINAPI HTMLElement_removeAttribute(IHTMLElement *iface, BSTR strAttributeName,
 260                                                   LONG lFlags, VARIANT_BOOL *pfSuccess)
 261 {
 262     HTMLElement *This = impl_from_IHTMLElement(iface);
 263
 264     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(strAttributeName), lFlags, pfSuccess);
 265
 266     return remove_prop(&This->node.dispex, strAttributeName, pfSuccess);
 267 }
 268
 269 static HRESULT WINAPI HTMLElement_put_className(IHTMLElement *iface, BSTR v)
 270 {
 271     HTMLElement *This = impl_from_IHTMLElement(iface);
 272     nsAString classname_str;
 273     nsresult nsres;
 274
 275     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 276
 277     if(!This->nselem) {
 278         FIXME("NULL nselem\n");
 279         return E_NOTIMPL;
 280     }
 281
 282     nsAString_InitDepend(&classname_str, v);
 283     nsres = nsIDOMHTMLElement_SetClassName(This->nselem, &classname_str);
 284     nsAString_Finish(&classname_str);
 285     if(NS_FAILED(nsres))
 286         ERR("SetClassName failed: %08x\n", nsres);
 287
 288     return S_OK;
 289 }
 290
 291 static HRESULT WINAPI HTMLElement_get_className(IHTMLElement *iface, BSTR *p)
 292 {
 293     HTMLElement *This = impl_from_IHTMLElement(iface);
 294     nsAString class_str;
 295     nsresult nsres;
 296     HRESULT hres = S_OK;
 297
 298     TRACE("(%p)->(%p)\n", This, p);
 299
 300     if(!This->nselem) {
 301         FIXME("NULL nselem\n");
 302         return E_NOTIMPL;
 303     }
 304
 305     nsAString_Init(&class_str, NULL);
 306     nsres = nsIDOMHTMLElement_GetClassName(This->nselem, &class_str);
 307
 308     if(NS_SUCCEEDED(nsres)) {
 309         const PRUnichar *class;
 310         nsAString_GetData(&class_str, &class);
 311         *p = *class ? SysAllocString(class) : NULL;
 312     }else {
 313         ERR("GetClassName failed: %08x\n", nsres);
 314         hres = E_FAIL;
 315     }
 316
 317     nsAString_Finish(&class_str);
 318
 319     TRACE("className=%s\n", debugstr_w(*p));
 320     return hres;
 321 }
 322
 323 static HRESULT WINAPI HTMLElement_put_id(IHTMLElement *iface, BSTR v)
 324 {
 325     HTMLElement *This = impl_from_IHTMLElement(iface);
 326     nsAString id_str;
 327     nsresult nsres;
 328
 329     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 330
 331     if(!This->nselem) {
 332         FIXME("nselem == NULL\n");
 333         return S_OK;
 334     }
 335
 336     nsAString_InitDepend(&id_str, v);
 337     nsres = nsIDOMHTMLElement_SetId(This->nselem, &id_str);
 338     nsAString_Finish(&id_str);
 339     if(NS_FAILED(nsres))
 340         ERR("SetId failed: %08x\n", nsres);
 341
 342     return S_OK;
 343 }
 344
 345 static HRESULT WINAPI HTMLElement_get_id(IHTMLElement *iface, BSTR *p)
 346 {
 347     HTMLElement *This = impl_from_IHTMLElement(iface);
 348     const PRUnichar *id;
 349     nsAString id_str;
 350     nsresult nsres;
 351
 352     TRACE("(%p)->(%p)\n", This, p);
 353
 354     *p = NULL;
 355
 356     if(!This->nselem)
 357         return S_OK;
 358
 359     nsAString_Init(&id_str, NULL);
 360     nsres = nsIDOMHTMLElement_GetId(This->nselem, &id_str);
 361     nsAString_GetData(&id_str, &id);
 362
 363     if(NS_FAILED(nsres))
 364         ERR("GetId failed: %08x\n", nsres);
 365     else if(*id)
 366         *p = SysAllocString(id);
 367
 368     nsAString_Finish(&id_str);
 369     return S_OK;
 370 }
 371
 372 static HRESULT WINAPI HTMLElement_get_tagName(IHTMLElement *iface, BSTR *p)
 373 {
 374     HTMLElement *This = impl_from_IHTMLElement(iface);
 375     const PRUnichar *tag;
 376     nsAString tag_str;
 377     nsresult nsres;
 378
 379     TRACE("(%p)->(%p)\n", This, p);
 380
 381     if(!This->nselem) {
 382         static const WCHAR comment_tagW[] = {'!',0};
 383
 384         WARN("NULL nselem, assuming comment\n");
 385
 386         *p = SysAllocString(comment_tagW);
 387         return S_OK;
 388     }
 389
 390     nsAString_Init(&tag_str, NULL);
 391     nsres = nsIDOMHTMLElement_GetTagName(This->nselem, &tag_str);
 392     if(NS_SUCCEEDED(nsres)) {
 393         nsAString_GetData(&tag_str, &tag);
 394         *p = SysAllocString(tag);
 395     }else {
 396         ERR("GetTagName failed: %08x\n", nsres);
 397         *p = NULL;
 398     }
 399     nsAString_Finish(&tag_str);
 400
 401     return S_OK;
 402 }
 403
 404 static HRESULT WINAPI HTMLElement_get_parentElement(IHTMLElement *iface, IHTMLElement **p)
 405 {
 406     HTMLElement *This = impl_from_IHTMLElement(iface);
 407     IHTMLDOMNode *node;
 408     HRESULT hres;
 409
 410     TRACE("(%p)->(%p)\n", This, p);
 411
 412     hres = IHTMLDOMNode_get_parentNode(&This->node.IHTMLDOMNode_iface, &node);
 413     if(FAILED(hres))
 414         return hres;
 415
 416     hres = IHTMLDOMNode_QueryInterface(node, &IID_IHTMLElement, (void**)p);
 417     IHTMLDOMNode_Release(node);
 418     if(FAILED(hres))
 419         *p = NULL;
 420
 421     return S_OK;
 422 }
 423
 424 static HRESULT WINAPI HTMLElement_get_style(IHTMLElement *iface, IHTMLStyle **p)
 425 {
 426     HTMLElement *This = impl_from_IHTMLElement(iface);
 427
 428     TRACE("(%p)->(%p)\n", This, p);
 429
 430     if(!This->style) {
 431         nsIDOMElementCSSInlineStyle *nselemstyle;
 432         nsIDOMCSSStyleDeclaration *nsstyle;
 433         nsresult nsres;
 434         HRESULT hres;
 435
 436         if(!This->nselem) {
 437             FIXME("NULL nselem\n");
 438             return E_NOTIMPL;
 439         }
 440
 441         nsres = nsIDOMHTMLElement_QueryInterface(This->nselem, &IID_nsIDOMElementCSSInlineStyle,
 442                 (void**)&nselemstyle);
 443         if(NS_FAILED(nsres)) {
 444             ERR("Coud not get nsIDOMCSSStyleDeclaration interface: %08x\n", nsres);
 445             return E_FAIL;
 446         }
 447
 448         nsres = nsIDOMElementCSSInlineStyle_GetStyle(nselemstyle, &nsstyle);
 449         nsIDOMElementCSSInlineStyle_Release(nselemstyle);
 450         if(NS_FAILED(nsres)) {
 451             ERR("GetStyle failed: %08x\n", nsres);
 452             return E_FAIL;
 453         }
 454
 455         hres = HTMLStyle_Create(nsstyle, &This->style);
 456         nsIDOMCSSStyleDeclaration_Release(nsstyle);
 457         if(FAILED(hres))
 458             return hres;
 459     }
 460
 461     *p = &This->style->IHTMLStyle_iface;
 462     IHTMLStyle_AddRef(*p);
 463     return S_OK;
 464 }
 465
 466 static HRESULT WINAPI HTMLElement_put_onhelp(IHTMLElement *iface, VARIANT v)
 467 {
 468     HTMLElement *This = impl_from_IHTMLElement(iface);
 469     FIXME("(%p)->()\n", This);
 470     return E_NOTIMPL;
 471 }
 472
 473 static HRESULT WINAPI HTMLElement_get_onhelp(IHTMLElement *iface, VARIANT *p)
 474 {
 475     HTMLElement *This = impl_from_IHTMLElement(iface);
 476     FIXME("(%p)->(%p)\n", This, p);
 477     return E_NOTIMPL;
 478 }
 479
 480 static HRESULT WINAPI HTMLElement_put_onclick(IHTMLElement *iface, VARIANT v)
 481 {
 482     HTMLElement *This = impl_from_IHTMLElement(iface);
 483
 484     TRACE("(%p)->()\n", This);
 485
 486     return set_node_event(&This->node, EVENTID_CLICK, &v);
 487 }
 488
 489 static HRESULT WINAPI HTMLElement_get_onclick(IHTMLElement *iface, VARIANT *p)
 490 {
 491     HTMLElement *This = impl_from_IHTMLElement(iface);
 492
 493     TRACE("(%p)->(%p)\n", This, p);
 494
 495     return get_node_event(&This->node, EVENTID_CLICK, p);
 496 }
 497
 498 static HRESULT WINAPI HTMLElement_put_ondblclick(IHTMLElement *iface, VARIANT v)
 499 {
 500     HTMLElement *This = impl_from_IHTMLElement(iface);
 501
 502     FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
 503
 504     return set_node_event(&This->node, EVENTID_DBLCLICK, &v);
 505 }
 506
 507 static HRESULT WINAPI HTMLElement_get_ondblclick(IHTMLElement *iface, VARIANT *p)
 508 {
 509     HTMLElement *This = impl_from_IHTMLElement(iface);
 510
 511     TRACE("(%p)->(%p)\n", This, p);
 512
 513     return get_node_event(&This->node, EVENTID_DBLCLICK, p);
 514 }
 515
 516 static HRESULT WINAPI HTMLElement_put_onkeydown(IHTMLElement *iface, VARIANT v)
 517 {
 518     HTMLElement *This = impl_from_IHTMLElement(iface);
 519
 520     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 521
 522     return set_node_event(&This->node, EVENTID_KEYDOWN, &v);
 523 }
 524
 525 static HRESULT WINAPI HTMLElement_get_onkeydown(IHTMLElement *iface, VARIANT *p)
 526 {
 527     HTMLElement *This = impl_from_IHTMLElement(iface);
 528
 529     TRACE("(%p)->(%p)\n", This, p);
 530
 531     return get_node_event(&This->node, EVENTID_KEYDOWN, p);
 532 }
 533
 534 static HRESULT WINAPI HTMLElement_put_onkeyup(IHTMLElement *iface, VARIANT v)
 535 {
 536     HTMLElement *This = impl_from_IHTMLElement(iface);
 537
 538     TRACE("(%p)->()\n", This);
 539
 540     return set_node_event(&This->node, EVENTID_KEYUP, &v);
 541 }
 542
 543 static HRESULT WINAPI HTMLElement_get_onkeyup(IHTMLElement *iface, VARIANT *p)
 544 {
 545     HTMLElement *This = impl_from_IHTMLElement(iface);
 546     FIXME("(%p)->(%p)\n", This, p);
 547     return E_NOTIMPL;
 548 }
 549
 550 static HRESULT WINAPI HTMLElement_put_onkeypress(IHTMLElement *iface, VARIANT v)
 551 {
 552     HTMLElement *This = impl_from_IHTMLElement(iface);
 553     FIXME("(%p)->()\n", This);
 554     return E_NOTIMPL;
 555 }
 556
 557 static HRESULT WINAPI HTMLElement_get_onkeypress(IHTMLElement *iface, VARIANT *p)
 558 {
 559     HTMLElement *This = impl_from_IHTMLElement(iface);
 560     FIXME("(%p)->(%p)\n", This, p);
 561     return E_NOTIMPL;
 562 }
 563
 564 static HRESULT WINAPI HTMLElement_put_onmouseout(IHTMLElement *iface, VARIANT v)
 565 {
 566     HTMLElement *This = impl_from_IHTMLElement(iface);
 567
 568     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 569
 570     return set_node_event(&This->node, EVENTID_MOUSEOUT, &v);
 571 }
 572
 573 static HRESULT WINAPI HTMLElement_get_onmouseout(IHTMLElement *iface, VARIANT *p)
 574 {
 575     HTMLElement *This = impl_from_IHTMLElement(iface);
 576
 577     TRACE("(%p)->(%p)\n", This, p);
 578
 579     return get_node_event(&This->node, EVENTID_MOUSEOUT, p);
 580 }
 581
 582 static HRESULT WINAPI HTMLElement_put_onmouseover(IHTMLElement *iface, VARIANT v)
 583 {
 584     HTMLElement *This = impl_from_IHTMLElement(iface);
 585
 586     TRACE("(%p)->()\n", This);
 587
 588     return set_node_event(&This->node, EVENTID_MOUSEOVER, &v);
 589 }
 590
 591 static HRESULT WINAPI HTMLElement_get_onmouseover(IHTMLElement *iface, VARIANT *p)
 592 {
 593     HTMLElement *This = impl_from_IHTMLElement(iface);
 594
 595     TRACE("(%p)->(%p)\n", This, p);
 596
 597     return get_node_event(&This->node, EVENTID_MOUSEOVER, p);
 598 }
 599
 600 static HRESULT WINAPI HTMLElement_put_onmousemove(IHTMLElement *iface, VARIANT v)
 601 {
 602     HTMLElement *This = impl_from_IHTMLElement(iface);
 603
 604     TRACE("(%p)->()\n", This);
 605
 606     return set_node_event(&This->node, EVENTID_MOUSEMOVE, &v);
 607 }
 608
 609 static HRESULT WINAPI HTMLElement_get_onmousemove(IHTMLElement *iface, VARIANT *p)
 610 {
 611     HTMLElement *This = impl_from_IHTMLElement(iface);
 612
 613     TRACE("(%p)->(%p)\n", This, p);
 614
 615     return get_node_event(&This->node, EVENTID_MOUSEMOVE, p);
 616 }
 617
 618 static HRESULT WINAPI HTMLElement_put_onmousedown(IHTMLElement *iface, VARIANT v)
 619 {
 620     HTMLElement *This = impl_from_IHTMLElement(iface);
 621
 622     TRACE("(%p)->()\n", This);
 623
 624     return set_node_event(&This->node, EVENTID_MOUSEDOWN, &v);
 625 }
 626
 627 static HRESULT WINAPI HTMLElement_get_onmousedown(IHTMLElement *iface, VARIANT *p)
 628 {
 629     HTMLElement *This = impl_from_IHTMLElement(iface);
 630
 631     TRACE("(%p)->(%p)\n", This, p);
 632
 633     return get_node_event(&This->node, EVENTID_MOUSEDOWN, p);
 634 }
 635
 636 static HRESULT WINAPI HTMLElement_put_onmouseup(IHTMLElement *iface, VARIANT v)
 637 {
 638     HTMLElement *This = impl_from_IHTMLElement(iface);
 639
 640     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 641
 642     return set_node_event(&This->node, EVENTID_MOUSEUP, &v);
 643 }
 644
 645 static HRESULT WINAPI HTMLElement_get_onmouseup(IHTMLElement *iface, VARIANT *p)
 646 {
 647     HTMLElement *This = impl_from_IHTMLElement(iface);
 648
 649     TRACE("(%p)->(%p)\n", This, p);
 650
 651     return get_node_event(&This->node, EVENTID_MOUSEUP, p);
 652 }
 653
 654 static HRESULT WINAPI HTMLElement_get_document(IHTMLElement *iface, IDispatch **p)
 655 {
 656     HTMLElement *This = impl_from_IHTMLElement(iface);
 657
 658     TRACE("(%p)->(%p)\n", This, p);
 659
 660     if(!p)
 661         return E_POINTER;
 662
 663     if(This->node.vtbl->get_document)
 664         return This->node.vtbl->get_document(&This->node, p);
 665
 666     *p = (IDispatch*)&This->node.doc->basedoc.IHTMLDocument2_iface;
 667     IDispatch_AddRef(*p);
 668     return S_OK;
 669 }
 670
 671 static const WCHAR titleW[] = {'t','i','t','l','e',0};
 672
 673 static HRESULT WINAPI HTMLElement_put_title(IHTMLElement *iface, BSTR v)
 674 {
 675     HTMLElement *This = impl_from_IHTMLElement(iface);
 676     nsAString title_str;
 677     nsresult nsres;
 678
 679     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 680
 681     if(!This->nselem) {
 682         VARIANT *var;
 683         HRESULT hres;
 684
 685         hres = dispex_get_dprop_ref(&This->node.dispex, titleW, TRUE, &var);
 686         if(FAILED(hres))
 687             return hres;
 688
 689         VariantClear(var);
 690         V_VT(var) = VT_BSTR;
 691         V_BSTR(var) = v ? SysAllocString(v) : NULL;
 692         return S_OK;
 693     }
 694
 695     nsAString_InitDepend(&title_str, v);
 696     nsres = nsIDOMHTMLElement_SetTitle(This->nselem, &title_str);
 697     nsAString_Finish(&title_str);
 698     if(NS_FAILED(nsres))
 699         ERR("SetTitle failed: %08x\n", nsres);
 700
 701     return S_OK;
 702 }
 703
 704 static HRESULT WINAPI HTMLElement_get_title(IHTMLElement *iface, BSTR *p)
 705 {
 706     HTMLElement *This = impl_from_IHTMLElement(iface);
 707     nsAString title_str;
 708     nsresult nsres;
 709
 710     TRACE("(%p)->(%p)\n", This, p);
 711
 712     if(!This->nselem) {
 713         VARIANT *var;
 714         HRESULT hres;
 715
 716         hres = dispex_get_dprop_ref(&This->node.dispex, titleW, FALSE, &var);
 717         if(hres == DISP_E_UNKNOWNNAME) {
 718             *p = NULL;
 719         }else if(V_VT(var) != VT_BSTR) {
 720             FIXME("title = %s\n", debugstr_variant(var));
 721             return E_FAIL;
 722         }else {
 723             *p = V_BSTR(var) ? SysAllocString(V_BSTR(var)) : NULL;
 724         }
 725
 726         return S_OK;
 727     }
 728
 729     nsAString_Init(&title_str, NULL);
 730     nsres = nsIDOMHTMLElement_GetTitle(This->nselem, &title_str);
 731     if(NS_SUCCEEDED(nsres)) {
 732         const PRUnichar *title;
 733
 734         nsAString_GetData(&title_str, &title);
 735         *p = *title ? SysAllocString(title) : NULL;
 736     }else {
 737         ERR("GetTitle failed: %08x\n", nsres);
 738         return E_FAIL;
 739     }
 740
 741     return S_OK;
 742 }
 743
 744 static HRESULT WINAPI HTMLElement_put_language(IHTMLElement *iface, BSTR v)
 745 {
 746     HTMLElement *This = impl_from_IHTMLElement(iface);
 747     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 748     return E_NOTIMPL;
 749 }
 750
 751 static HRESULT WINAPI HTMLElement_get_language(IHTMLElement *iface, BSTR *p)
 752 {
 753     HTMLElement *This = impl_from_IHTMLElement(iface);
 754     FIXME("(%p)->(%p)\n", This, p);
 755     return E_NOTIMPL;
 756 }
 757
 758 static HRESULT WINAPI HTMLElement_put_onselectstart(IHTMLElement *iface, VARIANT v)
 759 {
 760     HTMLElement *This = impl_from_IHTMLElement(iface);
 761
 762     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 763
 764     return set_node_event(&This->node, EVENTID_SELECTSTART, &v);
 765 }
 766
 767 static HRESULT WINAPI HTMLElement_get_onselectstart(IHTMLElement *iface, VARIANT *p)
 768 {
 769     HTMLElement *This = impl_from_IHTMLElement(iface);
 770
 771     TRACE("(%p)->(%p)\n", This, p);
 772
 773     return get_node_event(&This->node, EVENTID_SELECTSTART, p);
 774 }
 775
 776 static HRESULT WINAPI HTMLElement_scrollIntoView(IHTMLElement *iface, VARIANT varargStart)
 777 {
 778     HTMLElement *This = impl_from_IHTMLElement(iface);
 779     FIXME("(%p)->()\n", This);
 780     return E_NOTIMPL;
 781 }
 782
 783 static HRESULT WINAPI HTMLElement_contains(IHTMLElement *iface, IHTMLElement *pChild,
 784                                            VARIANT_BOOL *pfResult)
 785 {
 786     HTMLElement *This = impl_from_IHTMLElement(iface);
 787     FIXME("(%p)->(%p %p)\n", This, pChild, pfResult);
 788     return E_NOTIMPL;
 789 }
 790
 791 static HRESULT WINAPI HTMLElement_get_sourceIndex(IHTMLElement *iface, LONG *p)
 792 {
 793     HTMLElement *This = impl_from_IHTMLElement(iface);
 794     FIXME("(%p)->(%p)\n", This, p);
 795     return E_NOTIMPL;
 796 }
 797
 798 static HRESULT WINAPI HTMLElement_get_recordNumber(IHTMLElement *iface, VARIANT *p)
 799 {
 800     HTMLElement *This = impl_from_IHTMLElement(iface);
 801     FIXME("(%p)->(%p)\n", This, p);
 802     return E_NOTIMPL;
 803 }
 804
 805 static HRESULT WINAPI HTMLElement_put_lang(IHTMLElement *iface, BSTR v)
 806 {
 807     HTMLElement *This = impl_from_IHTMLElement(iface);
 808     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
 809     return E_NOTIMPL;
 810 }
 811
 812 static HRESULT WINAPI HTMLElement_get_lang(IHTMLElement *iface, BSTR *p)
 813 {
 814     HTMLElement *This = impl_from_IHTMLElement(iface);
 815     FIXME("(%p)->(%p)\n", This, p);
 816     return E_NOTIMPL;
 817 }
 818
 819 static HRESULT WINAPI HTMLElement_get_offsetLeft(IHTMLElement *iface, LONG *p)
 820 {
 821     HTMLElement *This = impl_from_IHTMLElement(iface);
 822     FIXME("(%p)->(%p)\n", This, p);
 823     return E_NOTIMPL;
 824 }
 825
 826 static HRESULT WINAPI HTMLElement_get_offsetTop(IHTMLElement *iface, LONG *p)
 827 {
 828     HTMLElement *This = impl_from_IHTMLElement(iface);
 829     nsIDOMNSHTMLElement *nselem;
 830     PRInt32 top = 0;
 831     nsresult nsres;
 832
 833     TRACE("(%p)->(%p)\n", This, p);
 834
 835     nsres = nsIDOMHTMLElement_QueryInterface(This->nselem, &IID_nsIDOMNSHTMLElement, (void**)&nselem);
 836     if(NS_FAILED(nsres)) {
 837         ERR("Could not get nsIDOMNSHTMLElement: %08x\n", nsres);
 838         return E_FAIL;
 839     }
 840
 841     nsres = nsIDOMNSHTMLElement_GetOffsetTop(nselem, &top);
 842     nsIDOMNSHTMLElement_Release(nselem);
 843     if(NS_FAILED(nsres)) {
 844         ERR("GetOffsetTop failed: %08x\n", nsres);
 845         return E_FAIL;
 846     }
 847
 848     *p = top;
 849     return S_OK;
 850 }
 851
 852 static HRESULT WINAPI HTMLElement_get_offsetWidth(IHTMLElement *iface, LONG *p)
 853 {
 854     HTMLElement *This = impl_from_IHTMLElement(iface);
 855     nsIDOMNSHTMLElement *nselem;
 856     PRInt32 offset = 0;
 857     nsresult nsres;
 858
 859     TRACE("(%p)->(%p)\n", This, p);
 860
 861     nsres = nsIDOMHTMLElement_QueryInterface(This->nselem, &IID_nsIDOMNSHTMLElement, (void**)&nselem);
 862     if(NS_FAILED(nsres)) {
 863         ERR("Could not get nsIDOMNSHTMLElement: %08x\n", nsres);
 864         return E_FAIL;
 865     }
 866
 867     nsres = nsIDOMNSHTMLElement_GetOffsetWidth(nselem, &offset);
 868     nsIDOMNSHTMLElement_Release(nselem);
 869     if(NS_FAILED(nsres)) {
 870         ERR("GetOffsetWidth failed: %08x\n", nsres);
 871         return E_FAIL;
 872     }
 873
 874     *p = offset;
 875     return S_OK;
 876 }
 877
 878 static HRESULT WINAPI HTMLElement_get_offsetHeight(IHTMLElement *iface, LONG *p)
 879 {
 880     HTMLElement *This = impl_from_IHTMLElement(iface);
 881     nsIDOMNSHTMLElement *nselem;
 882     PRInt32 offset = 0;
 883     nsresult nsres;
 884
 885     TRACE("(%p)->(%p)\n", This, p);
 886
 887     nsres = nsIDOMHTMLElement_QueryInterface(This->nselem, &IID_nsIDOMNSHTMLElement, (void**)&nselem);
 888     if(NS_FAILED(nsres)) {
 889         ERR("Could not get nsIDOMNSHTMLElement: %08x\n", nsres);
 890         return E_FAIL;
 891     }
 892
 893     nsres = nsIDOMNSHTMLElement_GetOffsetHeight(nselem, &offset);
 894     nsIDOMNSHTMLElement_Release(nselem);
 895     if(NS_FAILED(nsres)) {
 896         ERR("GetOffsetHeight failed: %08x\n", nsres);
 897         return E_FAIL;
 898     }
 899
 900     *p = offset;
 901     return S_OK;
 902 }
 903
 904 static HRESULT WINAPI HTMLElement_get_offsetParent(IHTMLElement *iface, IHTMLElement **p)
 905 {
 906     HTMLElement *This = impl_from_IHTMLElement(iface);
 907     FIXME("(%p)->(%p)\n", This, p);
 908     return E_NOTIMPL;
 909 }
 910
 911 static HRESULT WINAPI HTMLElement_put_innerHTML(IHTMLElement *iface, BSTR v)
 912 {
 913     HTMLElement *This = impl_from_IHTMLElement(iface);
 914     nsIDOMNSHTMLElement *nselem;
 915     nsAString html_str;
 916     nsresult nsres;
 917
 918     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 919
 920     if(!This->nselem) {
 921         FIXME("NULL nselem\n");
 922         return E_NOTIMPL;
 923     }
 924
 925     nsres = nsIDOMHTMLElement_QueryInterface(This->nselem, &IID_nsIDOMNSHTMLElement, (void**)&nselem);
 926     if(NS_FAILED(nsres)) {
 927         ERR("Could not get nsIDOMNSHTMLElement: %08x\n", nsres);
 928         return E_FAIL;
 929     }
 930
 931     nsAString_InitDepend(&html_str, v);
 932     nsres = nsIDOMNSHTMLElement_SetInnerHTML(nselem, &html_str);
 933     nsAString_Finish(&html_str);
 934
 935     if(NS_FAILED(nsres)) {
 936         FIXME("SetInnerHtml failed %08x\n", nsres);
 937         return E_FAIL;
 938     }
 939
 940     return S_OK;
 941 }
 942
 943 static HRESULT WINAPI HTMLElement_get_innerHTML(IHTMLElement *iface, BSTR *p)
 944 {
 945     HTMLElement *This = impl_from_IHTMLElement(iface);
 946     nsIDOMNSHTMLElement *nselem;
 947     nsAString html_str;
 948     nsresult nsres;
 949
 950     TRACE("(%p)->(%p)\n", This, p);
 951
 952     if(!This->nselem) {
 953         FIXME("NULL nselem\n");
 954         return E_NOTIMPL;
 955     }
 956
 957     nsres = nsIDOMHTMLElement_QueryInterface(This->nselem, &IID_nsIDOMNSHTMLElement, (void**)&nselem);
 958     if(NS_FAILED(nsres)) {
 959         ERR("Could not get nsIDOMNSHTMLElement: %08x\n", nsres);
 960         return E_FAIL;
 961     }
 962
 963     nsAString_Init(&html_str, NULL);
 964     nsres = nsIDOMNSHTMLElement_GetInnerHTML(nselem, &html_str);
 965     if(NS_SUCCEEDED(nsres)) {
 966         const PRUnichar *html;
 967
 968         nsAString_GetData(&html_str, &html);
 969         *p = *html ? SysAllocString(html) : NULL;
 970     }else {
 971         FIXME("SetInnerHtml failed %08x\n", nsres);
 972         *p = NULL;
 973     }
 974
 975     nsAString_Finish(&html_str);
 976     return S_OK;
 977 }
 978
 979 static HRESULT WINAPI HTMLElement_put_innerText(IHTMLElement *iface, BSTR v)
 980 {
 981     HTMLElement *This = impl_from_IHTMLElement(iface);
 982     nsIDOMNode *nschild, *tmp;
 983     nsIDOMText *text_node;
 984     nsAString text_str;
 985     nsresult nsres;
 986
 987     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 988
 989     while(1) {
 990         nsres = nsIDOMHTMLElement_GetLastChild(This->nselem, &nschild);
 991         if(NS_FAILED(nsres)) {
 992             ERR("GetLastChild failed: %08x\n", nsres);
 993             return E_FAIL;
 994         }
 995         if(!nschild)
 996             break;
 997
 998         nsres = nsIDOMHTMLElement_RemoveChild(This->nselem, nschild, &tmp);
 999         nsIDOMNode_Release(nschild);
1000         if(NS_FAILED(nsres)) {
1001             ERR("RemoveChild failed: %08x\n", nsres);
1002             return E_FAIL;
1003         }
1004         nsIDOMNode_Release(tmp);
1005     }
1006
1007     nsAString_InitDepend(&text_str, v);
1008     nsres = nsIDOMHTMLDocument_CreateTextNode(This->node.doc->nsdoc, &text_str, &text_node);
1009     nsAString_Finish(&text_str);
1010     if(NS_FAILED(nsres)) {
1011         ERR("CreateTextNode failed: %08x\n", nsres);
1012         return E_FAIL;
1013     }
1014
1015     nsres = nsIDOMHTMLElement_AppendChild(This->nselem, (nsIDOMNode*)text_node, &tmp);
1016     if(NS_FAILED(nsres)) {
1017         ERR("AppendChild failed: %08x\n", nsres);
1018         return E_FAIL;
1019     }
1020
1021     nsIDOMNode_Release(tmp);
1022     return S_OK;
1023 }
1024
1025 static HRESULT WINAPI HTMLElement_get_innerText(IHTMLElement *iface, BSTR *p)
1026 {
1027     HTMLElement *This = impl_from_IHTMLElement(iface);
1028
1029     TRACE("(%p)->(%p)\n", This, p);
1030
1031     return get_node_text(&This->node, p);
1032 }
1033
1034 static HRESULT WINAPI HTMLElement_put_outerHTML(IHTMLElement *iface, BSTR v)
1035 {
1036     HTMLElement *This = impl_from_IHTMLElement(iface);
1037     nsIDOMDocumentFragment *nsfragment;
1038     nsIDOMDocumentRange *nsdocrange;
1039     nsIDOMNSRange *nsrange;
1040     nsIDOMNode *nsparent;
1041     nsIDOMRange *range;
1042     nsAString html_str;
1043     nsresult nsres;
1044     HRESULT hres = S_OK;
1045
1046     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1047
1048     nsres = nsIDOMHTMLDocument_QueryInterface(This->node.doc->nsdoc, &IID_nsIDOMDocumentRange, (void**)&nsdocrange);
1049     if(NS_FAILED(nsres))
1050         return E_FAIL;
1051
1052     nsres = nsIDOMDocumentRange_CreateRange(nsdocrange, &range);
1053     nsIDOMDocumentRange_Release(nsdocrange);
1054     if(NS_FAILED(nsres)) {
1055         ERR("CreateRange failed: %08x\n", nsres);
1056         return E_FAIL;
1057     }
1058
1059     nsres = nsIDOMRange_QueryInterface(range, &IID_nsIDOMNSRange, (void**)&nsrange);
1060     nsIDOMRange_Release(range);
1061     if(NS_FAILED(nsres)) {
1062         ERR("Could not get nsIDOMNSRange: %08x\n", nsres);
1063         return E_FAIL;
1064     }
1065
1066     nsAString_InitDepend(&html_str, v);
1067     nsIDOMNSRange_CreateContextualFragment(nsrange, &html_str, &nsfragment);
1068     nsIDOMNSRange_Release(nsrange);
1069     nsAString_Finish(&html_str);
1070     if(NS_FAILED(nsres)) {
1071         ERR("CreateContextualFragment failed: %08x\n", nsres);
1072         return E_FAIL;
1073     }
1074
1075     nsres = nsIDOMNode_GetParentNode(This->node.nsnode, &nsparent);
1076     if(NS_SUCCEEDED(nsres) && nsparent) {
1077         nsIDOMNode *nstmp;
1078
1079         nsres = nsIDOMNode_ReplaceChild(nsparent, (nsIDOMNode*)nsfragment, This->node.nsnode, &nstmp);
1080         nsIDOMNode_Release(nsparent);
1081         if(NS_FAILED(nsres)) {
1082             ERR("ReplaceChild failed: %08x\n", nsres);
1083             hres = E_FAIL;
1084         }else if(nstmp) {
1085             nsIDOMNode_Release(nstmp);
1086         }
1087     }else {
1088         ERR("GetParentNode failed: %08x\n", nsres);
1089         hres = E_FAIL;
1090     }
1091
1092     nsIDOMDocumentFragment_Release(nsfragment);
1093     return hres;
1094 }
1095
1096 static HRESULT WINAPI HTMLElement_get_outerHTML(IHTMLElement *iface, BSTR *p)
1097 {
1098     HTMLElement *This = impl_from_IHTMLElement(iface);
1099     nsAString html_str;
1100     HRESULT hres;
1101
1102     WARN("(%p)->(%p) semi-stub\n", This, p);
1103
1104     nsAString_Init(&html_str, NULL);
1105     hres = nsnode_to_nsstring(This->node.nsnode, &html_str);
1106     if(SUCCEEDED(hres)) {
1107         const PRUnichar *html;
1108
1109         nsAString_GetData(&html_str, &html);
1110         *p = SysAllocString(html);
1111         if(!*p)
1112             hres = E_OUTOFMEMORY;
1113     }
1114
1115     nsAString_Finish(&html_str);
1116
1117     TRACE("ret %s\n", debugstr_w(*p));
1118     return S_OK;
1119 }
1120
1121 static HRESULT WINAPI HTMLElement_put_outerText(IHTMLElement *iface, BSTR v)
1122 {
1123     HTMLElement *This = impl_from_IHTMLElement(iface);
1124     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1125     return E_NOTIMPL;
1126 }
1127
1128 static HRESULT WINAPI HTMLElement_get_outerText(IHTMLElement *iface, BSTR *p)
1129 {
1130     HTMLElement *This = impl_from_IHTMLElement(iface);
1131     FIXME("(%p)->(%p)\n", This, p);
1132     return E_NOTIMPL;
1133 }
1134
1135 static HRESULT HTMLElement_InsertAdjacentNode(HTMLElement *This, BSTR where, nsIDOMNode *nsnode)
1136 {
1137     static const WCHAR wszBeforeBegin[] = {'b','e','f','o','r','e','B','e','g','i','n',0};
1138     static const WCHAR wszAfterBegin[] = {'a','f','t','e','r','B','e','g','i','n',0};
1139     static const WCHAR wszBeforeEnd[] = {'b','e','f','o','r','e','E','n','d',0};
1140     static const WCHAR wszAfterEnd[] = {'a','f','t','e','r','E','n','d',0};
1141     nsresult nsres;
1142
1143     if (!strcmpiW(where, wszBeforeBegin))
1144     {
1145         nsIDOMNode *unused;
1146         nsIDOMNode *parent;
1147         nsres = nsIDOMNode_GetParentNode(This->node.nsnode, &parent);
1148         if (!parent) return E_INVALIDARG;
1149         nsres = nsIDOMNode_InsertBefore(parent, nsnode, This->node.nsnode, &unused);
1150         if (unused) nsIDOMNode_Release(unused);
1151         nsIDOMNode_Release(parent);
1152     }
1153     else if (!strcmpiW(where, wszAfterBegin))
1154     {
1155         nsIDOMNode *unused;
1156         nsIDOMNode *first_child;
1157         nsIDOMNode_GetFirstChild(This->node.nsnode, &first_child);
1158         nsres = nsIDOMNode_InsertBefore(This->node.nsnode, nsnode, first_child, &unused);
1159         if (unused) nsIDOMNode_Release(unused);
1160         if (first_child) nsIDOMNode_Release(first_child);
1161     }
1162     else if (!strcmpiW(where, wszBeforeEnd))
1163     {
1164         nsIDOMNode *unused;
1165         nsres = nsIDOMNode_AppendChild(This->node.nsnode, nsnode, &unused);
1166         if (unused) nsIDOMNode_Release(unused);
1167     }
1168     else if (!strcmpiW(where, wszAfterEnd))
1169     {
1170         nsIDOMNode *unused;
1171         nsIDOMNode *next_sibling;
1172         nsIDOMNode *parent;
1173         nsIDOMNode_GetParentNode(This->node.nsnode, &parent);
1174         if (!parent) return E_INVALIDARG;
1175
1176         nsIDOMNode_GetNextSibling(This->node.nsnode, &next_sibling);
1177         if (next_sibling)
1178         {
1179             nsres = nsIDOMNode_InsertBefore(parent, nsnode, next_sibling, &unused);
1180             nsIDOMNode_Release(next_sibling);
1181         }
1182         else
1183             nsres = nsIDOMNode_AppendChild(parent, nsnode, &unused);
1184         nsIDOMNode_Release(parent);
1185         if (unused) nsIDOMNode_Release(unused);
1186     }
1187     else
1188     {
1189         ERR("invalid where: %s\n", debugstr_w(where));
1190         return E_INVALIDARG;
1191     }
1192
1193     if (NS_FAILED(nsres))
1194         return E_FAIL;
1195     else
1196         return S_OK;
1197 }
1198
1199 static HRESULT WINAPI HTMLElement_insertAdjacentHTML(IHTMLElement *iface, BSTR where,
1200                                                      BSTR html)
1201 {
1202     HTMLElement *This = impl_from_IHTMLElement(iface);
1203     nsIDOMDocumentRange *nsdocrange;
1204     nsIDOMRange *range;
1205     nsIDOMNSRange *nsrange;
1206     nsIDOMNode *nsnode;
1207     nsAString ns_html;
1208     nsresult nsres;
1209     HRESULT hr;
1210
1211     TRACE("(%p)->(%s %s)\n", This, debugstr_w(where), debugstr_w(html));
1212
1213     if(!This->node.doc->nsdoc) {
1214         WARN("NULL nsdoc\n");
1215         return E_UNEXPECTED;
1216     }
1217
1218     nsres = nsIDOMDocument_QueryInterface(This->node.doc->nsdoc, &IID_nsIDOMDocumentRange, (void **)&nsdocrange);
1219     if(NS_FAILED(nsres))
1220     {
1221         ERR("getting nsIDOMDocumentRange failed: %08x\n", nsres);
1222         return E_FAIL;
1223     }
1224     nsres = nsIDOMDocumentRange_CreateRange(nsdocrange, &range);
1225     nsIDOMDocumentRange_Release(nsdocrange);
1226     if(NS_FAILED(nsres))
1227     {
1228         ERR("CreateRange failed: %08x\n", nsres);
1229         return E_FAIL;
1230     }
1231
1232     nsIDOMRange_SetStartBefore(range, This->node.nsnode);
1233
1234     nsIDOMRange_QueryInterface(range, &IID_nsIDOMNSRange, (void **)&nsrange);
1235     nsIDOMRange_Release(range);
1236     if(NS_FAILED(nsres))
1237     {
1238         ERR("getting nsIDOMNSRange failed: %08x\n", nsres);
1239         return E_FAIL;
1240     }
1241
1242     nsAString_InitDepend(&ns_html, html);
1243
1244     nsres = nsIDOMNSRange_CreateContextualFragment(nsrange, &ns_html, (nsIDOMDocumentFragment **)&nsnode);
1245     nsIDOMNSRange_Release(nsrange);
1246     nsAString_Finish(&ns_html);
1247
1248     if(NS_FAILED(nsres) || !nsnode)
1249     {
1250         ERR("CreateTextNode failed: %08x\n", nsres);
1251         return E_FAIL;
1252     }
1253
1254     hr = HTMLElement_InsertAdjacentNode(This, where, nsnode);
1255     nsIDOMNode_Release(nsnode);
1256
1257     return hr;
1258 }
1259
1260 static HRESULT WINAPI HTMLElement_insertAdjacentText(IHTMLElement *iface, BSTR where,
1261                                                      BSTR text)
1262 {
1263     HTMLElement *This = impl_from_IHTMLElement(iface);
1264     nsIDOMNode *nsnode;
1265     nsAString ns_text;
1266     nsresult nsres;
1267     HRESULT hr;
1268
1269     TRACE("(%p)->(%s %s)\n", This, debugstr_w(where), debugstr_w(text));
1270
1271     if(!This->node.doc->nsdoc) {
1272         WARN("NULL nsdoc\n");
1273         return E_UNEXPECTED;
1274     }
1275
1276
1277     nsAString_InitDepend(&ns_text, text);
1278     nsres = nsIDOMDocument_CreateTextNode(This->node.doc->nsdoc, &ns_text, (nsIDOMText **)&nsnode);
1279     nsAString_Finish(&ns_text);
1280
1281     if(NS_FAILED(nsres) || !nsnode)
1282     {
1283         ERR("CreateTextNode failed: %08x\n", nsres);
1284         return E_FAIL;
1285     }
1286
1287     hr = HTMLElement_InsertAdjacentNode(This, where, nsnode);
1288     nsIDOMNode_Release(nsnode);
1289
1290     return hr;
1291 }
1292
1293 static HRESULT WINAPI HTMLElement_get_parentTextEdit(IHTMLElement *iface, IHTMLElement **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_get_isTextEdit(IHTMLElement *iface, VARIANT_BOOL *p)
1301 {
1302     HTMLElement *This = impl_from_IHTMLElement(iface);
1303     FIXME("(%p)->(%p)\n", This, p);
1304     return E_NOTIMPL;
1305 }
1306
1307 static HRESULT WINAPI HTMLElement_click(IHTMLElement *iface)
1308 {
1309     HTMLElement *This = impl_from_IHTMLElement(iface);
1310
1311     TRACE("(%p)\n", This);
1312
1313     return call_event(&This->node, EVENTID_CLICK);
1314 }
1315
1316 static HRESULT WINAPI HTMLElement_get_filters(IHTMLElement *iface,
1317                                               IHTMLFiltersCollection **p)
1318 {
1319     HTMLElement *This = impl_from_IHTMLElement(iface);
1320     TRACE("(%p)->(%p)\n", This, p);
1321
1322     if(!p)
1323         return E_POINTER;
1324
1325     *p = HTMLFiltersCollection_Create();
1326
1327     return S_OK;
1328 }
1329
1330 static HRESULT WINAPI HTMLElement_put_ondragstart(IHTMLElement *iface, VARIANT v)
1331 {
1332     HTMLElement *This = impl_from_IHTMLElement(iface);
1333     FIXME("(%p)->()\n", This);
1334     return E_NOTIMPL;
1335 }
1336
1337 static HRESULT WINAPI HTMLElement_get_ondragstart(IHTMLElement *iface, VARIANT *p)
1338 {
1339     HTMLElement *This = impl_from_IHTMLElement(iface);
1340     FIXME("(%p)->(%p)\n", This, p);
1341     return E_NOTIMPL;
1342 }
1343
1344 static HRESULT WINAPI HTMLElement_toString(IHTMLElement *iface, BSTR *String)
1345 {
1346     HTMLElement *This = impl_from_IHTMLElement(iface);
1347     FIXME("(%p)->(%p)\n", This, String);
1348     return E_NOTIMPL;
1349 }
1350
1351 static HRESULT WINAPI HTMLElement_put_onbeforeupdate(IHTMLElement *iface, VARIANT v)
1352 {
1353     HTMLElement *This = impl_from_IHTMLElement(iface);
1354     FIXME("(%p)->()\n", This);
1355     return E_NOTIMPL;
1356 }
1357
1358 static HRESULT WINAPI HTMLElement_get_onbeforeupdate(IHTMLElement *iface, VARIANT *p)
1359 {
1360     HTMLElement *This = impl_from_IHTMLElement(iface);
1361     FIXME("(%p)->(%p)\n", This, p);
1362     return E_NOTIMPL;
1363 }
1364
1365 static HRESULT WINAPI HTMLElement_put_onafterupdate(IHTMLElement *iface, VARIANT v)
1366 {
1367     HTMLElement *This = impl_from_IHTMLElement(iface);
1368     FIXME("(%p)->()\n", This);
1369     return E_NOTIMPL;
1370 }
1371
1372 static HRESULT WINAPI HTMLElement_get_onafterupdate(IHTMLElement *iface, VARIANT *p)
1373 {
1374     HTMLElement *This = impl_from_IHTMLElement(iface);
1375     FIXME("(%p)->(%p)\n", This, p);
1376     return E_NOTIMPL;
1377 }
1378
1379 static HRESULT WINAPI HTMLElement_put_onerrorupdate(IHTMLElement *iface, VARIANT v)
1380 {
1381     HTMLElement *This = impl_from_IHTMLElement(iface);
1382     FIXME("(%p)->()\n", This);
1383     return E_NOTIMPL;
1384 }
1385
1386 static HRESULT WINAPI HTMLElement_get_onerrorupdate(IHTMLElement *iface, VARIANT *p)
1387 {
1388     HTMLElement *This = impl_from_IHTMLElement(iface);
1389     FIXME("(%p)->(%p)\n", This, p);
1390     return E_NOTIMPL;
1391 }
1392
1393 static HRESULT WINAPI HTMLElement_put_onrowexit(IHTMLElement *iface, VARIANT v)
1394 {
1395     HTMLElement *This = impl_from_IHTMLElement(iface);
1396     FIXME("(%p)->()\n", This);
1397     return E_NOTIMPL;
1398 }
1399
1400 static HRESULT WINAPI HTMLElement_get_onrowexit(IHTMLElement *iface, VARIANT *p)
1401 {
1402     HTMLElement *This = impl_from_IHTMLElement(iface);
1403     FIXME("(%p)->(%p)\n", This, p);
1404     return E_NOTIMPL;
1405 }
1406
1407 static HRESULT WINAPI HTMLElement_put_onrowenter(IHTMLElement *iface, VARIANT v)
1408 {
1409     HTMLElement *This = impl_from_IHTMLElement(iface);
1410     FIXME("(%p)->()\n", This);
1411     return E_NOTIMPL;
1412 }
1413
1414 static HRESULT WINAPI HTMLElement_get_onrowenter(IHTMLElement *iface, VARIANT *p)
1415 {
1416     HTMLElement *This = impl_from_IHTMLElement(iface);
1417     FIXME("(%p)->(%p)\n", This, p);
1418     return E_NOTIMPL;
1419 }
1420
1421 static HRESULT WINAPI HTMLElement_put_ondatasetchanged(IHTMLElement *iface, VARIANT v)
1422 {
1423     HTMLElement *This = impl_from_IHTMLElement(iface);
1424     FIXME("(%p)->()\n", This);
1425     return E_NOTIMPL;
1426 }
1427
1428 static HRESULT WINAPI HTMLElement_get_ondatasetchanged(IHTMLElement *iface, VARIANT *p)
1429 {
1430     HTMLElement *This = impl_from_IHTMLElement(iface);
1431     FIXME("(%p)->(%p)\n", This, p);
1432     return E_NOTIMPL;
1433 }
1434
1435 static HRESULT WINAPI HTMLElement_put_ondataavailable(IHTMLElement *iface, VARIANT v)
1436 {
1437     HTMLElement *This = impl_from_IHTMLElement(iface);
1438     FIXME("(%p)->()\n", This);
1439     return E_NOTIMPL;
1440 }
1441
1442 static HRESULT WINAPI HTMLElement_get_ondataavailable(IHTMLElement *iface, VARIANT *p)
1443 {
1444     HTMLElement *This = impl_from_IHTMLElement(iface);
1445     FIXME("(%p)->(%p)\n", This, p);
1446     return E_NOTIMPL;
1447 }
1448
1449 static HRESULT WINAPI HTMLElement_put_ondatasetcomplete(IHTMLElement *iface, VARIANT v)
1450 {
1451     HTMLElement *This = impl_from_IHTMLElement(iface);
1452     FIXME("(%p)->()\n", This);
1453     return E_NOTIMPL;
1454 }
1455
1456 static HRESULT WINAPI HTMLElement_get_ondatasetcomplete(IHTMLElement *iface, VARIANT *p)
1457 {
1458     HTMLElement *This = impl_from_IHTMLElement(iface);
1459     FIXME("(%p)->(%p)\n", This, p);
1460     return E_NOTIMPL;
1461 }
1462
1463 static HRESULT WINAPI HTMLElement_put_onfilterchange(IHTMLElement *iface, VARIANT v)
1464 {
1465     HTMLElement *This = impl_from_IHTMLElement(iface);
1466     FIXME("(%p)->()\n", This);
1467     return E_NOTIMPL;
1468 }
1469
1470 static HRESULT WINAPI HTMLElement_get_onfilterchange(IHTMLElement *iface, VARIANT *p)
1471 {
1472     HTMLElement *This = impl_from_IHTMLElement(iface);
1473     FIXME("(%p)->(%p)\n", This, p);
1474     return E_NOTIMPL;
1475 }
1476
1477 static HRESULT WINAPI HTMLElement_get_children(IHTMLElement *iface, IDispatch **p)
1478 {
1479     HTMLElement *This = impl_from_IHTMLElement(iface);
1480     nsIDOMNodeList *nsnode_list;
1481     nsresult nsres;
1482
1483     TRACE("(%p)->(%p)\n", This, p);
1484
1485     nsres = nsIDOMNode_GetChildNodes(This->node.nsnode, &nsnode_list);
1486     if(NS_FAILED(nsres)) {
1487         ERR("GetChildNodes failed: %08x\n", nsres);
1488         return E_FAIL;
1489     }
1490
1491     *p = (IDispatch*)create_collection_from_nodelist(This->node.doc,
1492             (IUnknown*)&This->IHTMLElement_iface, nsnode_list);
1493
1494     nsIDOMNodeList_Release(nsnode_list);
1495     return S_OK;
1496 }
1497
1498 static HRESULT WINAPI HTMLElement_get_all(IHTMLElement *iface, IDispatch **p)
1499 {
1500     HTMLElement *This = impl_from_IHTMLElement(iface);
1501
1502     TRACE("(%p)->(%p)\n", This, p);
1503
1504     *p = (IDispatch*)create_all_collection(&This->node, FALSE);
1505     return S_OK;
1506 }
1507
1508 static const IHTMLElementVtbl HTMLElementVtbl = {
1509     HTMLElement_QueryInterface,
1510     HTMLElement_AddRef,
1511     HTMLElement_Release,
1512     HTMLElement_GetTypeInfoCount,
1513     HTMLElement_GetTypeInfo,
1514     HTMLElement_GetIDsOfNames,
1515     HTMLElement_Invoke,
1516     HTMLElement_setAttribute,
1517     HTMLElement_getAttribute,
1518     HTMLElement_removeAttribute,
1519     HTMLElement_put_className,
1520     HTMLElement_get_className,
1521     HTMLElement_put_id,
1522     HTMLElement_get_id,
1523     HTMLElement_get_tagName,
1524     HTMLElement_get_parentElement,
1525     HTMLElement_get_style,
1526     HTMLElement_put_onhelp,
1527     HTMLElement_get_onhelp,
1528     HTMLElement_put_onclick,
1529     HTMLElement_get_onclick,
1530     HTMLElement_put_ondblclick,
1531     HTMLElement_get_ondblclick,
1532     HTMLElement_put_onkeydown,
1533     HTMLElement_get_onkeydown,
1534     HTMLElement_put_onkeyup,
1535     HTMLElement_get_onkeyup,
1536     HTMLElement_put_onkeypress,
1537     HTMLElement_get_onkeypress,
1538     HTMLElement_put_onmouseout,
1539     HTMLElement_get_onmouseout,
1540     HTMLElement_put_onmouseover,
1541     HTMLElement_get_onmouseover,
1542     HTMLElement_put_onmousemove,
1543     HTMLElement_get_onmousemove,
1544     HTMLElement_put_onmousedown,
1545     HTMLElement_get_onmousedown,
1546     HTMLElement_put_onmouseup,
1547     HTMLElement_get_onmouseup,
1548     HTMLElement_get_document,
1549     HTMLElement_put_title,
1550     HTMLElement_get_title,
1551     HTMLElement_put_language,
1552     HTMLElement_get_language,
1553     HTMLElement_put_onselectstart,
1554     HTMLElement_get_onselectstart,
1555     HTMLElement_scrollIntoView,
1556     HTMLElement_contains,
1557     HTMLElement_get_sourceIndex,
1558     HTMLElement_get_recordNumber,
1559     HTMLElement_put_lang,
1560     HTMLElement_get_lang,
1561     HTMLElement_get_offsetLeft,
1562     HTMLElement_get_offsetTop,
1563     HTMLElement_get_offsetWidth,
1564     HTMLElement_get_offsetHeight,
1565     HTMLElement_get_offsetParent,
1566     HTMLElement_put_innerHTML,
1567     HTMLElement_get_innerHTML,
1568     HTMLElement_put_innerText,
1569     HTMLElement_get_innerText,
1570     HTMLElement_put_outerHTML,
1571     HTMLElement_get_outerHTML,
1572     HTMLElement_put_outerText,
1573     HTMLElement_get_outerText,
1574     HTMLElement_insertAdjacentHTML,
1575     HTMLElement_insertAdjacentText,
1576     HTMLElement_get_parentTextEdit,
1577     HTMLElement_get_isTextEdit,
1578     HTMLElement_click,
1579     HTMLElement_get_filters,
1580     HTMLElement_put_ondragstart,
1581     HTMLElement_get_ondragstart,
1582     HTMLElement_toString,
1583     HTMLElement_put_onbeforeupdate,
1584     HTMLElement_get_onbeforeupdate,
1585     HTMLElement_put_onafterupdate,
1586     HTMLElement_get_onafterupdate,
1587     HTMLElement_put_onerrorupdate,
1588     HTMLElement_get_onerrorupdate,
1589     HTMLElement_put_onrowexit,
1590     HTMLElement_get_onrowexit,
1591     HTMLElement_put_onrowenter,
1592     HTMLElement_get_onrowenter,
1593     HTMLElement_put_ondatasetchanged,
1594     HTMLElement_get_ondatasetchanged,
1595     HTMLElement_put_ondataavailable,
1596     HTMLElement_get_ondataavailable,
1597     HTMLElement_put_ondatasetcomplete,
1598     HTMLElement_get_ondatasetcomplete,
1599     HTMLElement_put_onfilterchange,
1600     HTMLElement_get_onfilterchange,
1601     HTMLElement_get_children,
1602     HTMLElement_get_all
1603 };
1604
1605 static inline HTMLElement *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
1606 {
1607     return CONTAINING_RECORD(iface, HTMLElement, node);
1608 }
1609
1610 HRESULT HTMLElement_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
1611 {
1612     HTMLElement *This = impl_from_HTMLDOMNode(iface);
1613
1614     *ppv =  NULL;
1615
1616     if(IsEqualGUID(&IID_IUnknown, riid)) {
1617         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
1618         *ppv = &This->IHTMLElement_iface;
1619     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
1620         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
1621         *ppv = &This->IHTMLElement_iface;
1622     }else if(IsEqualGUID(&IID_IHTMLElement, riid)) {
1623         TRACE("(%p)->(IID_IHTMLElement %p)\n", This, ppv);
1624         *ppv = &This->IHTMLElement_iface;
1625     }else if(IsEqualGUID(&IID_IHTMLElement2, riid)) {
1626         TRACE("(%p)->(IID_IHTMLElement2 %p)\n", This, ppv);
1627         *ppv = &This->IHTMLElement2_iface;
1628     }else if(IsEqualGUID(&IID_IHTMLElement3, riid)) {
1629         TRACE("(%p)->(IID_IHTMLElement3 %p)\n", This, ppv);
1630         *ppv = &This->IHTMLElement3_iface;
1631     }else if(IsEqualGUID(&IID_IHTMLElement4, riid)) {
1632         TRACE("(%p)->(IID_IHTMLElement4 %p)\n", This, ppv);
1633         *ppv = &This->IHTMLElement4_iface;
1634     }else if(IsEqualGUID(&IID_IConnectionPointContainer, riid)) {
1635         TRACE("(%p)->(IID_IConnectionPointContainer %p)\n", This, ppv);
1636         *ppv = &This->cp_container.IConnectionPointContainer_iface;
1637     }
1638
1639     if(*ppv) {
1640         IHTMLElement_AddRef(&This->IHTMLElement_iface);
1641         return S_OK;
1642     }
1643
1644     return HTMLDOMNode_QI(&This->node, riid, ppv);
1645 }
1646
1647 void HTMLElement_destructor(HTMLDOMNode *iface)
1648 {
1649     HTMLElement *This = impl_from_HTMLDOMNode(iface);
1650     HTMLDOMAttribute *attr;
1651
1652     while(!list_empty(&This->attrs)) {
1653         attr = LIST_ENTRY(list_head(&This->attrs), HTMLDOMAttribute, entry);
1654
1655         list_remove(&attr->entry);
1656         attr->elem = NULL;
1657         IHTMLDOMAttribute_Release(&attr->IHTMLDOMAttribute_iface);
1658     }
1659
1660     ConnectionPointContainer_Destroy(&This->cp_container);
1661
1662     if(This->nselem)
1663         nsIDOMHTMLElement_Release(This->nselem);
1664     if(This->style)
1665         IHTMLStyle_Release(&This->style->IHTMLStyle_iface);
1666
1667     HTMLDOMNode_destructor(&This->node);
1668 }
1669
1670 HRESULT HTMLElement_clone(HTMLDOMNode *iface, nsIDOMNode *nsnode, HTMLDOMNode **ret)
1671 {
1672     HTMLElement *This = impl_from_HTMLDOMNode(iface);
1673     HTMLElement *new_elem;
1674     HRESULT hres;
1675
1676     hres = HTMLElement_Create(This->node.doc, nsnode, FALSE, &new_elem);
1677     if(FAILED(hres))
1678         return hres;
1679
1680     IHTMLElement_AddRef(&new_elem->IHTMLElement_iface);
1681     *ret = &new_elem->node;
1682     return S_OK;
1683 }
1684
1685 static const NodeImplVtbl HTMLElementImplVtbl = {
1686     HTMLElement_QI,
1687     HTMLElement_destructor,
1688     HTMLElement_clone
1689 };
1690
1691 static inline HTMLElement *impl_from_DispatchEx(DispatchEx *iface)
1692 {
1693     return CONTAINING_RECORD(iface, HTMLElement, node.dispex);
1694 }
1695
1696 static HRESULT HTMLElement_get_dispid(DispatchEx *dispex, BSTR name,
1697         DWORD grfdex, DISPID *pid)
1698 {
1699     HTMLElement *This = impl_from_DispatchEx(dispex);
1700
1701     if(This->node.vtbl->get_dispid)
1702         return This->node.vtbl->get_dispid(&This->node, name, grfdex, pid);
1703
1704     return DISP_E_UNKNOWNNAME;
1705 }
1706
1707 static HRESULT HTMLElement_invoke(DispatchEx *dispex, DISPID id, LCID lcid,
1708         WORD flags, DISPPARAMS *params, VARIANT *res, EXCEPINFO *ei,
1709         IServiceProvider *caller)
1710 {
1711     HTMLElement *This = impl_from_DispatchEx(dispex);
1712
1713     if(This->node.vtbl->invoke)
1714         return This->node.vtbl->invoke(&This->node, id, lcid, flags,
1715                 params, res, ei, caller);
1716
1717     ERR("(%p): element has no invoke method\n", This);
1718     return E_NOTIMPL;
1719 }
1720
1721 static const tid_t HTMLElement_iface_tids[] = {
1722     HTMLELEMENT_TIDS,
1723     0
1724 };
1725
1726 static dispex_static_data_vtbl_t HTMLElement_dispex_vtbl = {
1727     NULL,
1728     HTMLElement_get_dispid,
1729     HTMLElement_invoke
1730 };
1731
1732 static dispex_static_data_t HTMLElement_dispex = {
1733     &HTMLElement_dispex_vtbl,
1734     DispHTMLUnknownElement_tid,
1735     NULL,
1736     HTMLElement_iface_tids
1737 };
1738
1739 void HTMLElement_Init(HTMLElement *This, HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, dispex_static_data_t *dispex_data)
1740 {
1741     This->IHTMLElement_iface.lpVtbl = &HTMLElementVtbl;
1742
1743     HTMLElement2_Init(This);
1744     HTMLElement3_Init(This);
1745
1746     if(dispex_data && !dispex_data->vtbl)
1747         dispex_data->vtbl = &HTMLElement_dispex_vtbl;
1748     init_dispex(&This->node.dispex, (IUnknown*)&This->IHTMLElement_iface,
1749             dispex_data ? dispex_data : &HTMLElement_dispex);
1750
1751     if(nselem)
1752         nsIDOMHTMLElement_AddRef(nselem);
1753     This->nselem = nselem;
1754     list_init(&This->attrs);
1755
1756     HTMLDOMNode_Init(doc, &This->node, (nsIDOMNode*)nselem);
1757
1758     ConnectionPointContainer_Init(&This->cp_container, (IUnknown*)&This->IHTMLElement_iface);
1759 }
1760
1761 HRESULT HTMLElement_Create(HTMLDocumentNode *doc, nsIDOMNode *nsnode, BOOL use_generic, HTMLElement **ret)
1762 {
1763     nsIDOMHTMLElement *nselem;
1764     nsAString class_name_str;
1765     const PRUnichar *class_name;
1766     const tag_desc_t *tag;
1767     HTMLElement *elem;
1768     nsresult nsres;
1769     HRESULT hres;
1770
1771     nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMHTMLElement, (void**)&nselem);
1772     if(NS_FAILED(nsres))
1773         return E_FAIL;
1774
1775     nsAString_Init(&class_name_str, NULL);
1776     nsIDOMHTMLElement_GetTagName(nselem, &class_name_str);
1777
1778     nsAString_GetData(&class_name_str, &class_name);
1779
1780     tag = get_tag_desc(class_name);
1781     if(tag) {
1782         hres = tag->constructor(doc, nselem, &elem);
1783     }else if(use_generic) {
1784         hres = HTMLGenericElement_Create(doc, nselem, &elem);
1785     }else {
1786         elem = heap_alloc_zero(sizeof(HTMLElement));
1787         if(elem) {
1788             HTMLElement_Init(elem, doc, nselem, &HTMLElement_dispex);
1789             elem->node.vtbl = &HTMLElementImplVtbl;
1790             hres = S_OK;
1791         }else {
1792             hres = E_OUTOFMEMORY;
1793         }
1794     }
1795
1796     TRACE("%s ret %p\n", debugstr_w(class_name), elem);
1797
1798     nsIDOMElement_Release(nselem);
1799     nsAString_Finish(&class_name_str);
1800     if(FAILED(hres))
1801         return hres;
1802
1803     *ret = elem;
1804     return S_OK;
1805 }
1806
1807 /* interface IHTMLFiltersCollection */
1808 static HRESULT WINAPI HTMLFiltersCollection_QueryInterface(IHTMLFiltersCollection *iface, REFIID riid, void **ppv)
1809 {
1810     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1811
1812     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppv );
1813
1814     if(IsEqualGUID(&IID_IUnknown, riid)) {
1815         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
1816         *ppv = &This->IHTMLFiltersCollection_iface;
1817     }else if(IsEqualGUID(&IID_IHTMLFiltersCollection, riid)) {
1818         TRACE("(%p)->(IID_IHTMLFiltersCollection %p)\n", This, ppv);
1819         *ppv = &This->IHTMLFiltersCollection_iface;
1820     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1821         return *ppv ? S_OK : E_NOINTERFACE;
1822     }
1823
1824     if(*ppv) {
1825         IUnknown_AddRef((IUnknown*)*ppv);
1826         return S_OK;
1827     }
1828
1829     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
1830     return E_NOINTERFACE;
1831 }
1832
1833 static ULONG WINAPI HTMLFiltersCollection_AddRef(IHTMLFiltersCollection *iface)
1834 {
1835     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1836     LONG ref = InterlockedIncrement(&This->ref);
1837
1838     TRACE("(%p) ref=%d\n", This, ref);
1839
1840     return ref;
1841 }
1842
1843 static ULONG WINAPI HTMLFiltersCollection_Release(IHTMLFiltersCollection *iface)
1844 {
1845     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1846     LONG ref = InterlockedDecrement(&This->ref);
1847
1848     TRACE("(%p) ref=%d\n", This, ref);
1849
1850     if(!ref)
1851     {
1852         heap_free(This);
1853     }
1854
1855     return ref;
1856 }
1857
1858 static HRESULT WINAPI HTMLFiltersCollection_GetTypeInfoCount(IHTMLFiltersCollection *iface, UINT *pctinfo)
1859 {
1860     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1861     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
1862 }
1863
1864 static HRESULT WINAPI HTMLFiltersCollection_GetTypeInfo(IHTMLFiltersCollection *iface,
1865                                     UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1866 {
1867     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1868     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1869 }
1870
1871 static HRESULT WINAPI HTMLFiltersCollection_GetIDsOfNames(IHTMLFiltersCollection *iface,
1872                                     REFIID riid, LPOLESTR *rgszNames, UINT cNames,
1873                                     LCID lcid, DISPID *rgDispId)
1874 {
1875     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1876     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1877             lcid, rgDispId);
1878 }
1879
1880 static HRESULT WINAPI HTMLFiltersCollection_Invoke(IHTMLFiltersCollection *iface, DISPID dispIdMember, REFIID riid,
1881                                     LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1882                                     EXCEPINFO *pExcepInfo, UINT *puArgErr)
1883 {
1884     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1885     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
1886             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1887 }
1888
1889 static HRESULT WINAPI HTMLFiltersCollection_get_length(IHTMLFiltersCollection *iface, LONG *p)
1890 {
1891     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1892
1893     if(!p)
1894         return E_POINTER;
1895
1896     FIXME("(%p)->(%p) Always returning 0\n", This, p);
1897     *p = 0;
1898
1899     return S_OK;
1900 }
1901
1902 static HRESULT WINAPI HTMLFiltersCollection_get__newEnum(IHTMLFiltersCollection *iface, IUnknown **p)
1903 {
1904     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1905     FIXME("(%p)->(%p)\n", This, p);
1906     return E_NOTIMPL;
1907 }
1908
1909 static HRESULT WINAPI HTMLFiltersCollection_item(IHTMLFiltersCollection *iface, VARIANT *pvarIndex, VARIANT *pvarResult)
1910 {
1911     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1912     FIXME("(%p)->(%p, %p)\n", This, pvarIndex, pvarResult);
1913     return E_NOTIMPL;
1914 }
1915
1916 static const IHTMLFiltersCollectionVtbl HTMLFiltersCollectionVtbl = {
1917     HTMLFiltersCollection_QueryInterface,
1918     HTMLFiltersCollection_AddRef,
1919     HTMLFiltersCollection_Release,
1920     HTMLFiltersCollection_GetTypeInfoCount,
1921     HTMLFiltersCollection_GetTypeInfo,
1922     HTMLFiltersCollection_GetIDsOfNames,
1923     HTMLFiltersCollection_Invoke,
1924     HTMLFiltersCollection_get_length,
1925     HTMLFiltersCollection_get__newEnum,
1926     HTMLFiltersCollection_item
1927 };
1928
1929 static HRESULT HTMLFiltersCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
1930 {
1931     WCHAR *ptr;
1932     int idx = 0;
1933
1934     for(ptr = name; *ptr && isdigitW(*ptr); ptr++)
1935         idx = idx*10 + (*ptr-'0');
1936     if(*ptr)
1937         return DISP_E_UNKNOWNNAME;
1938
1939     *dispid = MSHTML_DISPID_CUSTOM_MIN + idx;
1940     TRACE("ret %x\n", *dispid);
1941     return S_OK;
1942 }
1943
1944 static HRESULT HTMLFiltersCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
1945         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
1946 {
1947     TRACE("(%p)->(%x %x %x %p %p %p)\n", dispex, id, lcid, flags, params, res, ei);
1948
1949     V_VT(res) = VT_DISPATCH;
1950     V_DISPATCH(res) = NULL;
1951
1952     FIXME("always returning NULL\n");
1953
1954     return S_OK;
1955 }
1956
1957 static const dispex_static_data_vtbl_t HTMLFiltersCollection_dispex_vtbl = {
1958     NULL,
1959     HTMLFiltersCollection_get_dispid,
1960     HTMLFiltersCollection_invoke
1961 };
1962
1963 static const tid_t HTMLFiltersCollection_iface_tids[] = {
1964     IHTMLFiltersCollection_tid,
1965     0
1966 };
1967 static dispex_static_data_t HTMLFiltersCollection_dispex = {
1968     &HTMLFiltersCollection_dispex_vtbl,
1969     IHTMLFiltersCollection_tid,
1970     NULL,
1971     HTMLFiltersCollection_iface_tids
1972 };
1973
1974 static IHTMLFiltersCollection *HTMLFiltersCollection_Create(void)
1975 {
1976     HTMLFiltersCollection *ret = heap_alloc(sizeof(HTMLFiltersCollection));
1977
1978     ret->IHTMLFiltersCollection_iface.lpVtbl = &HTMLFiltersCollectionVtbl;
1979     ret->ref = 1;
1980
1981     init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLFiltersCollection_iface,
1982             &HTMLFiltersCollection_dispex);
1983
1984     return &ret->IHTMLFiltersCollection_iface;
1985 }