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

   1 /*
   2  * Copyright 2006 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "winreg.h"
  28 #include "ole2.h"
  29 #include "shlwapi.h"
  30
  31 #include "wine/debug.h"
  32 #include "wine/unicode.h"
  33
  34 #include "mshtml_private.h"
  35 #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     nsIDOMNSHTMLElement *nselem;
 823     PRInt32 off_left = 0;
 824     nsresult nsres;
 825
 826     TRACE("(%p)->(%p)\n", This, p);
 827
 828     nsres = nsIDOMHTMLElement_QueryInterface(This->nselem, &IID_nsIDOMNSHTMLElement, (void**)&nselem);
 829     if(NS_FAILED(nsres)) {
 830         ERR("Could not get nsIDOMNSHTMLElement: %08x\n", nsres);
 831         return E_FAIL;
 832     }
 833
 834     nsres = nsIDOMNSHTMLElement_GetOffsetLeft(nselem, &off_left);
 835     nsIDOMNSHTMLElement_Release(nselem);
 836     if(NS_FAILED(nsres)) {
 837         ERR("GetOffsetLeft failed: %08x\n", nsres);
 838         return E_FAIL;
 839     }
 840
 841     *p = off_left;
 842     return S_OK;
 843 }
 844
 845 static HRESULT WINAPI HTMLElement_get_offsetTop(IHTMLElement *iface, LONG *p)
 846 {
 847     HTMLElement *This = impl_from_IHTMLElement(iface);
 848     nsIDOMNSHTMLElement *nselem;
 849     PRInt32 top = 0;
 850     nsresult nsres;
 851
 852     TRACE("(%p)->(%p)\n", This, p);
 853
 854     nsres = nsIDOMHTMLElement_QueryInterface(This->nselem, &IID_nsIDOMNSHTMLElement, (void**)&nselem);
 855     if(NS_FAILED(nsres)) {
 856         ERR("Could not get nsIDOMNSHTMLElement: %08x\n", nsres);
 857         return E_FAIL;
 858     }
 859
 860     nsres = nsIDOMNSHTMLElement_GetOffsetTop(nselem, &top);
 861     nsIDOMNSHTMLElement_Release(nselem);
 862     if(NS_FAILED(nsres)) {
 863         ERR("GetOffsetTop failed: %08x\n", nsres);
 864         return E_FAIL;
 865     }
 866
 867     *p = top;
 868     return S_OK;
 869 }
 870
 871 static HRESULT WINAPI HTMLElement_get_offsetWidth(IHTMLElement *iface, LONG *p)
 872 {
 873     HTMLElement *This = impl_from_IHTMLElement(iface);
 874     nsIDOMNSHTMLElement *nselem;
 875     PRInt32 offset = 0;
 876     nsresult nsres;
 877
 878     TRACE("(%p)->(%p)\n", This, p);
 879
 880     nsres = nsIDOMHTMLElement_QueryInterface(This->nselem, &IID_nsIDOMNSHTMLElement, (void**)&nselem);
 881     if(NS_FAILED(nsres)) {
 882         ERR("Could not get nsIDOMNSHTMLElement: %08x\n", nsres);
 883         return E_FAIL;
 884     }
 885
 886     nsres = nsIDOMNSHTMLElement_GetOffsetWidth(nselem, &offset);
 887     nsIDOMNSHTMLElement_Release(nselem);
 888     if(NS_FAILED(nsres)) {
 889         ERR("GetOffsetWidth failed: %08x\n", nsres);
 890         return E_FAIL;
 891     }
 892
 893     *p = offset;
 894     return S_OK;
 895 }
 896
 897 static HRESULT WINAPI HTMLElement_get_offsetHeight(IHTMLElement *iface, LONG *p)
 898 {
 899     HTMLElement *This = impl_from_IHTMLElement(iface);
 900     nsIDOMNSHTMLElement *nselem;
 901     PRInt32 offset = 0;
 902     nsresult nsres;
 903
 904     TRACE("(%p)->(%p)\n", This, p);
 905
 906     nsres = nsIDOMHTMLElement_QueryInterface(This->nselem, &IID_nsIDOMNSHTMLElement, (void**)&nselem);
 907     if(NS_FAILED(nsres)) {
 908         ERR("Could not get nsIDOMNSHTMLElement: %08x\n", nsres);
 909         return E_FAIL;
 910     }
 911
 912     nsres = nsIDOMNSHTMLElement_GetOffsetHeight(nselem, &offset);
 913     nsIDOMNSHTMLElement_Release(nselem);
 914     if(NS_FAILED(nsres)) {
 915         ERR("GetOffsetHeight failed: %08x\n", nsres);
 916         return E_FAIL;
 917     }
 918
 919     *p = offset;
 920     return S_OK;
 921 }
 922
 923 static HRESULT WINAPI HTMLElement_get_offsetParent(IHTMLElement *iface, IHTMLElement **p)
 924 {
 925     HTMLElement *This = impl_from_IHTMLElement(iface);
 926     FIXME("(%p)->(%p)\n", This, p);
 927     return E_NOTIMPL;
 928 }
 929
 930 static HRESULT WINAPI HTMLElement_put_innerHTML(IHTMLElement *iface, BSTR v)
 931 {
 932     HTMLElement *This = impl_from_IHTMLElement(iface);
 933     nsIDOMNSHTMLElement *nselem;
 934     nsAString html_str;
 935     nsresult nsres;
 936
 937     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 938
 939     if(!This->nselem) {
 940         FIXME("NULL nselem\n");
 941         return E_NOTIMPL;
 942     }
 943
 944     nsres = nsIDOMHTMLElement_QueryInterface(This->nselem, &IID_nsIDOMNSHTMLElement, (void**)&nselem);
 945     if(NS_FAILED(nsres)) {
 946         ERR("Could not get nsIDOMNSHTMLElement: %08x\n", nsres);
 947         return E_FAIL;
 948     }
 949
 950     nsAString_InitDepend(&html_str, v);
 951     nsres = nsIDOMNSHTMLElement_SetInnerHTML(nselem, &html_str);
 952     nsAString_Finish(&html_str);
 953
 954     if(NS_FAILED(nsres)) {
 955         FIXME("SetInnerHtml failed %08x\n", nsres);
 956         return E_FAIL;
 957     }
 958
 959     return S_OK;
 960 }
 961
 962 static HRESULT WINAPI HTMLElement_get_innerHTML(IHTMLElement *iface, BSTR *p)
 963 {
 964     HTMLElement *This = impl_from_IHTMLElement(iface);
 965     nsIDOMNSHTMLElement *nselem;
 966     nsAString html_str;
 967     nsresult nsres;
 968
 969     TRACE("(%p)->(%p)\n", This, p);
 970
 971     if(!This->nselem) {
 972         FIXME("NULL nselem\n");
 973         return E_NOTIMPL;
 974     }
 975
 976     nsres = nsIDOMHTMLElement_QueryInterface(This->nselem, &IID_nsIDOMNSHTMLElement, (void**)&nselem);
 977     if(NS_FAILED(nsres)) {
 978         ERR("Could not get nsIDOMNSHTMLElement: %08x\n", nsres);
 979         return E_FAIL;
 980     }
 981
 982     nsAString_Init(&html_str, NULL);
 983     nsres = nsIDOMNSHTMLElement_GetInnerHTML(nselem, &html_str);
 984     if(NS_SUCCEEDED(nsres)) {
 985         const PRUnichar *html;
 986
 987         nsAString_GetData(&html_str, &html);
 988         *p = *html ? SysAllocString(html) : NULL;
 989     }else {
 990         FIXME("SetInnerHtml failed %08x\n", nsres);
 991         *p = NULL;
 992     }
 993
 994     nsAString_Finish(&html_str);
 995     return S_OK;
 996 }
 997
 998 static HRESULT WINAPI HTMLElement_put_innerText(IHTMLElement *iface, BSTR v)
 999 {
1000     HTMLElement *This = impl_from_IHTMLElement(iface);
1001     nsIDOMNode *nschild, *tmp;
1002     nsIDOMText *text_node;
1003     nsAString text_str;
1004     nsresult nsres;
1005
1006     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1007
1008     while(1) {
1009         nsres = nsIDOMHTMLElement_GetLastChild(This->nselem, &nschild);
1010         if(NS_FAILED(nsres)) {
1011             ERR("GetLastChild failed: %08x\n", nsres);
1012             return E_FAIL;
1013         }
1014         if(!nschild)
1015             break;
1016
1017         nsres = nsIDOMHTMLElement_RemoveChild(This->nselem, nschild, &tmp);
1018         nsIDOMNode_Release(nschild);
1019         if(NS_FAILED(nsres)) {
1020             ERR("RemoveChild failed: %08x\n", nsres);
1021             return E_FAIL;
1022         }
1023         nsIDOMNode_Release(tmp);
1024     }
1025
1026     nsAString_InitDepend(&text_str, v);
1027     nsres = nsIDOMHTMLDocument_CreateTextNode(This->node.doc->nsdoc, &text_str, &text_node);
1028     nsAString_Finish(&text_str);
1029     if(NS_FAILED(nsres)) {
1030         ERR("CreateTextNode failed: %08x\n", nsres);
1031         return E_FAIL;
1032     }
1033
1034     nsres = nsIDOMHTMLElement_AppendChild(This->nselem, (nsIDOMNode*)text_node, &tmp);
1035     if(NS_FAILED(nsres)) {
1036         ERR("AppendChild failed: %08x\n", nsres);
1037         return E_FAIL;
1038     }
1039
1040     nsIDOMNode_Release(tmp);
1041     return S_OK;
1042 }
1043
1044 static HRESULT WINAPI HTMLElement_get_innerText(IHTMLElement *iface, BSTR *p)
1045 {
1046     HTMLElement *This = impl_from_IHTMLElement(iface);
1047
1048     TRACE("(%p)->(%p)\n", This, p);
1049
1050     return get_node_text(&This->node, p);
1051 }
1052
1053 static HRESULT WINAPI HTMLElement_put_outerHTML(IHTMLElement *iface, BSTR v)
1054 {
1055     HTMLElement *This = impl_from_IHTMLElement(iface);
1056     nsIDOMDocumentFragment *nsfragment;
1057     nsIDOMDocumentRange *nsdocrange;
1058     nsIDOMNSRange *nsrange;
1059     nsIDOMNode *nsparent;
1060     nsIDOMRange *range;
1061     nsAString html_str;
1062     nsresult nsres;
1063     HRESULT hres = S_OK;
1064
1065     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1066
1067     nsres = nsIDOMHTMLDocument_QueryInterface(This->node.doc->nsdoc, &IID_nsIDOMDocumentRange, (void**)&nsdocrange);
1068     if(NS_FAILED(nsres))
1069         return E_FAIL;
1070
1071     nsres = nsIDOMDocumentRange_CreateRange(nsdocrange, &range);
1072     nsIDOMDocumentRange_Release(nsdocrange);
1073     if(NS_FAILED(nsres)) {
1074         ERR("CreateRange failed: %08x\n", nsres);
1075         return E_FAIL;
1076     }
1077
1078     nsres = nsIDOMRange_QueryInterface(range, &IID_nsIDOMNSRange, (void**)&nsrange);
1079     nsIDOMRange_Release(range);
1080     if(NS_FAILED(nsres)) {
1081         ERR("Could not get nsIDOMNSRange: %08x\n", nsres);
1082         return E_FAIL;
1083     }
1084
1085     nsAString_InitDepend(&html_str, v);
1086     nsIDOMNSRange_CreateContextualFragment(nsrange, &html_str, &nsfragment);
1087     nsIDOMNSRange_Release(nsrange);
1088     nsAString_Finish(&html_str);
1089     if(NS_FAILED(nsres)) {
1090         ERR("CreateContextualFragment failed: %08x\n", nsres);
1091         return E_FAIL;
1092     }
1093
1094     nsres = nsIDOMNode_GetParentNode(This->node.nsnode, &nsparent);
1095     if(NS_SUCCEEDED(nsres) && nsparent) {
1096         nsIDOMNode *nstmp;
1097
1098         nsres = nsIDOMNode_ReplaceChild(nsparent, (nsIDOMNode*)nsfragment, This->node.nsnode, &nstmp);
1099         nsIDOMNode_Release(nsparent);
1100         if(NS_FAILED(nsres)) {
1101             ERR("ReplaceChild failed: %08x\n", nsres);
1102             hres = E_FAIL;
1103         }else if(nstmp) {
1104             nsIDOMNode_Release(nstmp);
1105         }
1106     }else {
1107         ERR("GetParentNode failed: %08x\n", nsres);
1108         hres = E_FAIL;
1109     }
1110
1111     nsIDOMDocumentFragment_Release(nsfragment);
1112     return hres;
1113 }
1114
1115 static HRESULT WINAPI HTMLElement_get_outerHTML(IHTMLElement *iface, BSTR *p)
1116 {
1117     HTMLElement *This = impl_from_IHTMLElement(iface);
1118     nsAString html_str;
1119     HRESULT hres;
1120
1121     WARN("(%p)->(%p) semi-stub\n", This, p);
1122
1123     nsAString_Init(&html_str, NULL);
1124     hres = nsnode_to_nsstring(This->node.nsnode, &html_str);
1125     if(SUCCEEDED(hres)) {
1126         const PRUnichar *html;
1127
1128         nsAString_GetData(&html_str, &html);
1129         *p = SysAllocString(html);
1130         if(!*p)
1131             hres = E_OUTOFMEMORY;
1132     }
1133
1134     nsAString_Finish(&html_str);
1135
1136     TRACE("ret %s\n", debugstr_w(*p));
1137     return S_OK;
1138 }
1139
1140 static HRESULT WINAPI HTMLElement_put_outerText(IHTMLElement *iface, BSTR v)
1141 {
1142     HTMLElement *This = impl_from_IHTMLElement(iface);
1143     FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1144     return E_NOTIMPL;
1145 }
1146
1147 static HRESULT WINAPI HTMLElement_get_outerText(IHTMLElement *iface, BSTR *p)
1148 {
1149     HTMLElement *This = impl_from_IHTMLElement(iface);
1150     FIXME("(%p)->(%p)\n", This, p);
1151     return E_NOTIMPL;
1152 }
1153
1154 static HRESULT HTMLElement_InsertAdjacentNode(HTMLElement *This, BSTR where, nsIDOMNode *nsnode)
1155 {
1156     static const WCHAR wszBeforeBegin[] = {'b','e','f','o','r','e','B','e','g','i','n',0};
1157     static const WCHAR wszAfterBegin[] = {'a','f','t','e','r','B','e','g','i','n',0};
1158     static const WCHAR wszBeforeEnd[] = {'b','e','f','o','r','e','E','n','d',0};
1159     static const WCHAR wszAfterEnd[] = {'a','f','t','e','r','E','n','d',0};
1160     nsresult nsres;
1161
1162     if (!strcmpiW(where, wszBeforeBegin))
1163     {
1164         nsIDOMNode *unused;
1165         nsIDOMNode *parent;
1166         nsres = nsIDOMNode_GetParentNode(This->node.nsnode, &parent);
1167         if (!parent) return E_INVALIDARG;
1168         nsres = nsIDOMNode_InsertBefore(parent, nsnode, This->node.nsnode, &unused);
1169         if (unused) nsIDOMNode_Release(unused);
1170         nsIDOMNode_Release(parent);
1171     }
1172     else if (!strcmpiW(where, wszAfterBegin))
1173     {
1174         nsIDOMNode *unused;
1175         nsIDOMNode *first_child;
1176         nsIDOMNode_GetFirstChild(This->node.nsnode, &first_child);
1177         nsres = nsIDOMNode_InsertBefore(This->node.nsnode, nsnode, first_child, &unused);
1178         if (unused) nsIDOMNode_Release(unused);
1179         if (first_child) nsIDOMNode_Release(first_child);
1180     }
1181     else if (!strcmpiW(where, wszBeforeEnd))
1182     {
1183         nsIDOMNode *unused;
1184         nsres = nsIDOMNode_AppendChild(This->node.nsnode, nsnode, &unused);
1185         if (unused) nsIDOMNode_Release(unused);
1186     }
1187     else if (!strcmpiW(where, wszAfterEnd))
1188     {
1189         nsIDOMNode *unused;
1190         nsIDOMNode *next_sibling;
1191         nsIDOMNode *parent;
1192         nsIDOMNode_GetParentNode(This->node.nsnode, &parent);
1193         if (!parent) return E_INVALIDARG;
1194
1195         nsIDOMNode_GetNextSibling(This->node.nsnode, &next_sibling);
1196         if (next_sibling)
1197         {
1198             nsres = nsIDOMNode_InsertBefore(parent, nsnode, next_sibling, &unused);
1199             nsIDOMNode_Release(next_sibling);
1200         }
1201         else
1202             nsres = nsIDOMNode_AppendChild(parent, nsnode, &unused);
1203         nsIDOMNode_Release(parent);
1204         if (unused) nsIDOMNode_Release(unused);
1205     }
1206     else
1207     {
1208         ERR("invalid where: %s\n", debugstr_w(where));
1209         return E_INVALIDARG;
1210     }
1211
1212     if (NS_FAILED(nsres))
1213         return E_FAIL;
1214     else
1215         return S_OK;
1216 }
1217
1218 static HRESULT WINAPI HTMLElement_insertAdjacentHTML(IHTMLElement *iface, BSTR where,
1219                                                      BSTR html)
1220 {
1221     HTMLElement *This = impl_from_IHTMLElement(iface);
1222     nsIDOMDocumentRange *nsdocrange;
1223     nsIDOMRange *range;
1224     nsIDOMNSRange *nsrange;
1225     nsIDOMNode *nsnode;
1226     nsAString ns_html;
1227     nsresult nsres;
1228     HRESULT hr;
1229
1230     TRACE("(%p)->(%s %s)\n", This, debugstr_w(where), debugstr_w(html));
1231
1232     if(!This->node.doc->nsdoc) {
1233         WARN("NULL nsdoc\n");
1234         return E_UNEXPECTED;
1235     }
1236
1237     nsres = nsIDOMDocument_QueryInterface(This->node.doc->nsdoc, &IID_nsIDOMDocumentRange, (void **)&nsdocrange);
1238     if(NS_FAILED(nsres))
1239     {
1240         ERR("getting nsIDOMDocumentRange failed: %08x\n", nsres);
1241         return E_FAIL;
1242     }
1243     nsres = nsIDOMDocumentRange_CreateRange(nsdocrange, &range);
1244     nsIDOMDocumentRange_Release(nsdocrange);
1245     if(NS_FAILED(nsres))
1246     {
1247         ERR("CreateRange failed: %08x\n", nsres);
1248         return E_FAIL;
1249     }
1250
1251     nsIDOMRange_SetStartBefore(range, This->node.nsnode);
1252
1253     nsIDOMRange_QueryInterface(range, &IID_nsIDOMNSRange, (void **)&nsrange);
1254     nsIDOMRange_Release(range);
1255     if(NS_FAILED(nsres))
1256     {
1257         ERR("getting nsIDOMNSRange failed: %08x\n", nsres);
1258         return E_FAIL;
1259     }
1260
1261     nsAString_InitDepend(&ns_html, html);
1262
1263     nsres = nsIDOMNSRange_CreateContextualFragment(nsrange, &ns_html, (nsIDOMDocumentFragment **)&nsnode);
1264     nsIDOMNSRange_Release(nsrange);
1265     nsAString_Finish(&ns_html);
1266
1267     if(NS_FAILED(nsres) || !nsnode)
1268     {
1269         ERR("CreateTextNode failed: %08x\n", nsres);
1270         return E_FAIL;
1271     }
1272
1273     hr = HTMLElement_InsertAdjacentNode(This, where, nsnode);
1274     nsIDOMNode_Release(nsnode);
1275
1276     return hr;
1277 }
1278
1279 static HRESULT WINAPI HTMLElement_insertAdjacentText(IHTMLElement *iface, BSTR where,
1280                                                      BSTR text)
1281 {
1282     HTMLElement *This = impl_from_IHTMLElement(iface);
1283     nsIDOMNode *nsnode;
1284     nsAString ns_text;
1285     nsresult nsres;
1286     HRESULT hr;
1287
1288     TRACE("(%p)->(%s %s)\n", This, debugstr_w(where), debugstr_w(text));
1289
1290     if(!This->node.doc->nsdoc) {
1291         WARN("NULL nsdoc\n");
1292         return E_UNEXPECTED;
1293     }
1294
1295
1296     nsAString_InitDepend(&ns_text, text);
1297     nsres = nsIDOMDocument_CreateTextNode(This->node.doc->nsdoc, &ns_text, (nsIDOMText **)&nsnode);
1298     nsAString_Finish(&ns_text);
1299
1300     if(NS_FAILED(nsres) || !nsnode)
1301     {
1302         ERR("CreateTextNode failed: %08x\n", nsres);
1303         return E_FAIL;
1304     }
1305
1306     hr = HTMLElement_InsertAdjacentNode(This, where, nsnode);
1307     nsIDOMNode_Release(nsnode);
1308
1309     return hr;
1310 }
1311
1312 static HRESULT WINAPI HTMLElement_get_parentTextEdit(IHTMLElement *iface, IHTMLElement **p)
1313 {
1314     HTMLElement *This = impl_from_IHTMLElement(iface);
1315     FIXME("(%p)->(%p)\n", This, p);
1316     return E_NOTIMPL;
1317 }
1318
1319 static HRESULT WINAPI HTMLElement_get_isTextEdit(IHTMLElement *iface, VARIANT_BOOL *p)
1320 {
1321     HTMLElement *This = impl_from_IHTMLElement(iface);
1322     FIXME("(%p)->(%p)\n", This, p);
1323     return E_NOTIMPL;
1324 }
1325
1326 static HRESULT WINAPI HTMLElement_click(IHTMLElement *iface)
1327 {
1328     HTMLElement *This = impl_from_IHTMLElement(iface);
1329
1330     TRACE("(%p)\n", This);
1331
1332     return call_event(&This->node, EVENTID_CLICK);
1333 }
1334
1335 static HRESULT WINAPI HTMLElement_get_filters(IHTMLElement *iface,
1336                                               IHTMLFiltersCollection **p)
1337 {
1338     HTMLElement *This = impl_from_IHTMLElement(iface);
1339     TRACE("(%p)->(%p)\n", This, p);
1340
1341     if(!p)
1342         return E_POINTER;
1343
1344     *p = HTMLFiltersCollection_Create();
1345
1346     return S_OK;
1347 }
1348
1349 static HRESULT WINAPI HTMLElement_put_ondragstart(IHTMLElement *iface, VARIANT v)
1350 {
1351     HTMLElement *This = impl_from_IHTMLElement(iface);
1352     FIXME("(%p)->()\n", This);
1353     return E_NOTIMPL;
1354 }
1355
1356 static HRESULT WINAPI HTMLElement_get_ondragstart(IHTMLElement *iface, VARIANT *p)
1357 {
1358     HTMLElement *This = impl_from_IHTMLElement(iface);
1359     FIXME("(%p)->(%p)\n", This, p);
1360     return E_NOTIMPL;
1361 }
1362
1363 static HRESULT WINAPI HTMLElement_toString(IHTMLElement *iface, BSTR *String)
1364 {
1365     HTMLElement *This = impl_from_IHTMLElement(iface);
1366     FIXME("(%p)->(%p)\n", This, String);
1367     return E_NOTIMPL;
1368 }
1369
1370 static HRESULT WINAPI HTMLElement_put_onbeforeupdate(IHTMLElement *iface, VARIANT v)
1371 {
1372     HTMLElement *This = impl_from_IHTMLElement(iface);
1373     FIXME("(%p)->()\n", This);
1374     return E_NOTIMPL;
1375 }
1376
1377 static HRESULT WINAPI HTMLElement_get_onbeforeupdate(IHTMLElement *iface, VARIANT *p)
1378 {
1379     HTMLElement *This = impl_from_IHTMLElement(iface);
1380     FIXME("(%p)->(%p)\n", This, p);
1381     return E_NOTIMPL;
1382 }
1383
1384 static HRESULT WINAPI HTMLElement_put_onafterupdate(IHTMLElement *iface, VARIANT v)
1385 {
1386     HTMLElement *This = impl_from_IHTMLElement(iface);
1387     FIXME("(%p)->()\n", This);
1388     return E_NOTIMPL;
1389 }
1390
1391 static HRESULT WINAPI HTMLElement_get_onafterupdate(IHTMLElement *iface, VARIANT *p)
1392 {
1393     HTMLElement *This = impl_from_IHTMLElement(iface);
1394     FIXME("(%p)->(%p)\n", This, p);
1395     return E_NOTIMPL;
1396 }
1397
1398 static HRESULT WINAPI HTMLElement_put_onerrorupdate(IHTMLElement *iface, VARIANT v)
1399 {
1400     HTMLElement *This = impl_from_IHTMLElement(iface);
1401     FIXME("(%p)->()\n", This);
1402     return E_NOTIMPL;
1403 }
1404
1405 static HRESULT WINAPI HTMLElement_get_onerrorupdate(IHTMLElement *iface, VARIANT *p)
1406 {
1407     HTMLElement *This = impl_from_IHTMLElement(iface);
1408     FIXME("(%p)->(%p)\n", This, p);
1409     return E_NOTIMPL;
1410 }
1411
1412 static HRESULT WINAPI HTMLElement_put_onrowexit(IHTMLElement *iface, VARIANT v)
1413 {
1414     HTMLElement *This = impl_from_IHTMLElement(iface);
1415     FIXME("(%p)->()\n", This);
1416     return E_NOTIMPL;
1417 }
1418
1419 static HRESULT WINAPI HTMLElement_get_onrowexit(IHTMLElement *iface, VARIANT *p)
1420 {
1421     HTMLElement *This = impl_from_IHTMLElement(iface);
1422     FIXME("(%p)->(%p)\n", This, p);
1423     return E_NOTIMPL;
1424 }
1425
1426 static HRESULT WINAPI HTMLElement_put_onrowenter(IHTMLElement *iface, VARIANT v)
1427 {
1428     HTMLElement *This = impl_from_IHTMLElement(iface);
1429     FIXME("(%p)->()\n", This);
1430     return E_NOTIMPL;
1431 }
1432
1433 static HRESULT WINAPI HTMLElement_get_onrowenter(IHTMLElement *iface, VARIANT *p)
1434 {
1435     HTMLElement *This = impl_from_IHTMLElement(iface);
1436     FIXME("(%p)->(%p)\n", This, p);
1437     return E_NOTIMPL;
1438 }
1439
1440 static HRESULT WINAPI HTMLElement_put_ondatasetchanged(IHTMLElement *iface, VARIANT v)
1441 {
1442     HTMLElement *This = impl_from_IHTMLElement(iface);
1443     FIXME("(%p)->()\n", This);
1444     return E_NOTIMPL;
1445 }
1446
1447 static HRESULT WINAPI HTMLElement_get_ondatasetchanged(IHTMLElement *iface, VARIANT *p)
1448 {
1449     HTMLElement *This = impl_from_IHTMLElement(iface);
1450     FIXME("(%p)->(%p)\n", This, p);
1451     return E_NOTIMPL;
1452 }
1453
1454 static HRESULT WINAPI HTMLElement_put_ondataavailable(IHTMLElement *iface, VARIANT v)
1455 {
1456     HTMLElement *This = impl_from_IHTMLElement(iface);
1457     FIXME("(%p)->()\n", This);
1458     return E_NOTIMPL;
1459 }
1460
1461 static HRESULT WINAPI HTMLElement_get_ondataavailable(IHTMLElement *iface, VARIANT *p)
1462 {
1463     HTMLElement *This = impl_from_IHTMLElement(iface);
1464     FIXME("(%p)->(%p)\n", This, p);
1465     return E_NOTIMPL;
1466 }
1467
1468 static HRESULT WINAPI HTMLElement_put_ondatasetcomplete(IHTMLElement *iface, VARIANT v)
1469 {
1470     HTMLElement *This = impl_from_IHTMLElement(iface);
1471     FIXME("(%p)->()\n", This);
1472     return E_NOTIMPL;
1473 }
1474
1475 static HRESULT WINAPI HTMLElement_get_ondatasetcomplete(IHTMLElement *iface, VARIANT *p)
1476 {
1477     HTMLElement *This = impl_from_IHTMLElement(iface);
1478     FIXME("(%p)->(%p)\n", This, p);
1479     return E_NOTIMPL;
1480 }
1481
1482 static HRESULT WINAPI HTMLElement_put_onfilterchange(IHTMLElement *iface, VARIANT v)
1483 {
1484     HTMLElement *This = impl_from_IHTMLElement(iface);
1485     FIXME("(%p)->()\n", This);
1486     return E_NOTIMPL;
1487 }
1488
1489 static HRESULT WINAPI HTMLElement_get_onfilterchange(IHTMLElement *iface, VARIANT *p)
1490 {
1491     HTMLElement *This = impl_from_IHTMLElement(iface);
1492     FIXME("(%p)->(%p)\n", This, p);
1493     return E_NOTIMPL;
1494 }
1495
1496 static HRESULT WINAPI HTMLElement_get_children(IHTMLElement *iface, IDispatch **p)
1497 {
1498     HTMLElement *This = impl_from_IHTMLElement(iface);
1499     nsIDOMNodeList *nsnode_list;
1500     nsresult nsres;
1501
1502     TRACE("(%p)->(%p)\n", This, p);
1503
1504     nsres = nsIDOMNode_GetChildNodes(This->node.nsnode, &nsnode_list);
1505     if(NS_FAILED(nsres)) {
1506         ERR("GetChildNodes failed: %08x\n", nsres);
1507         return E_FAIL;
1508     }
1509
1510     *p = (IDispatch*)create_collection_from_nodelist(This->node.doc,
1511             (IUnknown*)&This->IHTMLElement_iface, nsnode_list);
1512
1513     nsIDOMNodeList_Release(nsnode_list);
1514     return S_OK;
1515 }
1516
1517 static HRESULT WINAPI HTMLElement_get_all(IHTMLElement *iface, IDispatch **p)
1518 {
1519     HTMLElement *This = impl_from_IHTMLElement(iface);
1520
1521     TRACE("(%p)->(%p)\n", This, p);
1522
1523     *p = (IDispatch*)create_all_collection(&This->node, FALSE);
1524     return S_OK;
1525 }
1526
1527 static const IHTMLElementVtbl HTMLElementVtbl = {
1528     HTMLElement_QueryInterface,
1529     HTMLElement_AddRef,
1530     HTMLElement_Release,
1531     HTMLElement_GetTypeInfoCount,
1532     HTMLElement_GetTypeInfo,
1533     HTMLElement_GetIDsOfNames,
1534     HTMLElement_Invoke,
1535     HTMLElement_setAttribute,
1536     HTMLElement_getAttribute,
1537     HTMLElement_removeAttribute,
1538     HTMLElement_put_className,
1539     HTMLElement_get_className,
1540     HTMLElement_put_id,
1541     HTMLElement_get_id,
1542     HTMLElement_get_tagName,
1543     HTMLElement_get_parentElement,
1544     HTMLElement_get_style,
1545     HTMLElement_put_onhelp,
1546     HTMLElement_get_onhelp,
1547     HTMLElement_put_onclick,
1548     HTMLElement_get_onclick,
1549     HTMLElement_put_ondblclick,
1550     HTMLElement_get_ondblclick,
1551     HTMLElement_put_onkeydown,
1552     HTMLElement_get_onkeydown,
1553     HTMLElement_put_onkeyup,
1554     HTMLElement_get_onkeyup,
1555     HTMLElement_put_onkeypress,
1556     HTMLElement_get_onkeypress,
1557     HTMLElement_put_onmouseout,
1558     HTMLElement_get_onmouseout,
1559     HTMLElement_put_onmouseover,
1560     HTMLElement_get_onmouseover,
1561     HTMLElement_put_onmousemove,
1562     HTMLElement_get_onmousemove,
1563     HTMLElement_put_onmousedown,
1564     HTMLElement_get_onmousedown,
1565     HTMLElement_put_onmouseup,
1566     HTMLElement_get_onmouseup,
1567     HTMLElement_get_document,
1568     HTMLElement_put_title,
1569     HTMLElement_get_title,
1570     HTMLElement_put_language,
1571     HTMLElement_get_language,
1572     HTMLElement_put_onselectstart,
1573     HTMLElement_get_onselectstart,
1574     HTMLElement_scrollIntoView,
1575     HTMLElement_contains,
1576     HTMLElement_get_sourceIndex,
1577     HTMLElement_get_recordNumber,
1578     HTMLElement_put_lang,
1579     HTMLElement_get_lang,
1580     HTMLElement_get_offsetLeft,
1581     HTMLElement_get_offsetTop,
1582     HTMLElement_get_offsetWidth,
1583     HTMLElement_get_offsetHeight,
1584     HTMLElement_get_offsetParent,
1585     HTMLElement_put_innerHTML,
1586     HTMLElement_get_innerHTML,
1587     HTMLElement_put_innerText,
1588     HTMLElement_get_innerText,
1589     HTMLElement_put_outerHTML,
1590     HTMLElement_get_outerHTML,
1591     HTMLElement_put_outerText,
1592     HTMLElement_get_outerText,
1593     HTMLElement_insertAdjacentHTML,
1594     HTMLElement_insertAdjacentText,
1595     HTMLElement_get_parentTextEdit,
1596     HTMLElement_get_isTextEdit,
1597     HTMLElement_click,
1598     HTMLElement_get_filters,
1599     HTMLElement_put_ondragstart,
1600     HTMLElement_get_ondragstart,
1601     HTMLElement_toString,
1602     HTMLElement_put_onbeforeupdate,
1603     HTMLElement_get_onbeforeupdate,
1604     HTMLElement_put_onafterupdate,
1605     HTMLElement_get_onafterupdate,
1606     HTMLElement_put_onerrorupdate,
1607     HTMLElement_get_onerrorupdate,
1608     HTMLElement_put_onrowexit,
1609     HTMLElement_get_onrowexit,
1610     HTMLElement_put_onrowenter,
1611     HTMLElement_get_onrowenter,
1612     HTMLElement_put_ondatasetchanged,
1613     HTMLElement_get_ondatasetchanged,
1614     HTMLElement_put_ondataavailable,
1615     HTMLElement_get_ondataavailable,
1616     HTMLElement_put_ondatasetcomplete,
1617     HTMLElement_get_ondatasetcomplete,
1618     HTMLElement_put_onfilterchange,
1619     HTMLElement_get_onfilterchange,
1620     HTMLElement_get_children,
1621     HTMLElement_get_all
1622 };
1623
1624 static inline HTMLElement *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
1625 {
1626     return CONTAINING_RECORD(iface, HTMLElement, node);
1627 }
1628
1629 HRESULT HTMLElement_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
1630 {
1631     HTMLElement *This = impl_from_HTMLDOMNode(iface);
1632
1633     *ppv =  NULL;
1634
1635     if(IsEqualGUID(&IID_IUnknown, riid)) {
1636         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
1637         *ppv = &This->IHTMLElement_iface;
1638     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
1639         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
1640         *ppv = &This->IHTMLElement_iface;
1641     }else if(IsEqualGUID(&IID_IHTMLElement, riid)) {
1642         TRACE("(%p)->(IID_IHTMLElement %p)\n", This, ppv);
1643         *ppv = &This->IHTMLElement_iface;
1644     }else if(IsEqualGUID(&IID_IHTMLElement2, riid)) {
1645         TRACE("(%p)->(IID_IHTMLElement2 %p)\n", This, ppv);
1646         *ppv = &This->IHTMLElement2_iface;
1647     }else if(IsEqualGUID(&IID_IHTMLElement3, riid)) {
1648         TRACE("(%p)->(IID_IHTMLElement3 %p)\n", This, ppv);
1649         *ppv = &This->IHTMLElement3_iface;
1650     }else if(IsEqualGUID(&IID_IHTMLElement4, riid)) {
1651         TRACE("(%p)->(IID_IHTMLElement4 %p)\n", This, ppv);
1652         *ppv = &This->IHTMLElement4_iface;
1653     }else if(IsEqualGUID(&IID_IConnectionPointContainer, riid)) {
1654         TRACE("(%p)->(IID_IConnectionPointContainer %p)\n", This, ppv);
1655         *ppv = &This->cp_container.IConnectionPointContainer_iface;
1656     }
1657
1658     if(*ppv) {
1659         IHTMLElement_AddRef(&This->IHTMLElement_iface);
1660         return S_OK;
1661     }
1662
1663     return HTMLDOMNode_QI(&This->node, riid, ppv);
1664 }
1665
1666 void HTMLElement_destructor(HTMLDOMNode *iface)
1667 {
1668     HTMLElement *This = impl_from_HTMLDOMNode(iface);
1669     HTMLDOMAttribute *attr;
1670
1671     while(!list_empty(&This->attrs)) {
1672         attr = LIST_ENTRY(list_head(&This->attrs), HTMLDOMAttribute, entry);
1673
1674         list_remove(&attr->entry);
1675         attr->elem = NULL;
1676         IHTMLDOMAttribute_Release(&attr->IHTMLDOMAttribute_iface);
1677     }
1678
1679     ConnectionPointContainer_Destroy(&This->cp_container);
1680
1681     if(This->nselem)
1682         nsIDOMHTMLElement_Release(This->nselem);
1683     if(This->style)
1684         IHTMLStyle_Release(&This->style->IHTMLStyle_iface);
1685
1686     HTMLDOMNode_destructor(&This->node);
1687 }
1688
1689 HRESULT HTMLElement_clone(HTMLDOMNode *iface, nsIDOMNode *nsnode, HTMLDOMNode **ret)
1690 {
1691     HTMLElement *This = impl_from_HTMLDOMNode(iface);
1692     HTMLElement *new_elem;
1693     HRESULT hres;
1694
1695     hres = HTMLElement_Create(This->node.doc, nsnode, FALSE, &new_elem);
1696     if(FAILED(hres))
1697         return hres;
1698
1699     IHTMLElement_AddRef(&new_elem->IHTMLElement_iface);
1700     *ret = &new_elem->node;
1701     return S_OK;
1702 }
1703
1704 static const NodeImplVtbl HTMLElementImplVtbl = {
1705     HTMLElement_QI,
1706     HTMLElement_destructor,
1707     HTMLElement_clone
1708 };
1709
1710 static inline HTMLElement *impl_from_DispatchEx(DispatchEx *iface)
1711 {
1712     return CONTAINING_RECORD(iface, HTMLElement, node.dispex);
1713 }
1714
1715 static HRESULT HTMLElement_get_dispid(DispatchEx *dispex, BSTR name,
1716         DWORD grfdex, DISPID *pid)
1717 {
1718     HTMLElement *This = impl_from_DispatchEx(dispex);
1719
1720     if(This->node.vtbl->get_dispid)
1721         return This->node.vtbl->get_dispid(&This->node, name, grfdex, pid);
1722
1723     return DISP_E_UNKNOWNNAME;
1724 }
1725
1726 static HRESULT HTMLElement_invoke(DispatchEx *dispex, DISPID id, LCID lcid,
1727         WORD flags, DISPPARAMS *params, VARIANT *res, EXCEPINFO *ei,
1728         IServiceProvider *caller)
1729 {
1730     HTMLElement *This = impl_from_DispatchEx(dispex);
1731
1732     if(This->node.vtbl->invoke)
1733         return This->node.vtbl->invoke(&This->node, id, lcid, flags,
1734                 params, res, ei, caller);
1735
1736     ERR("(%p): element has no invoke method\n", This);
1737     return E_NOTIMPL;
1738 }
1739
1740 static const tid_t HTMLElement_iface_tids[] = {
1741     HTMLELEMENT_TIDS,
1742     0
1743 };
1744
1745 static dispex_static_data_vtbl_t HTMLElement_dispex_vtbl = {
1746     NULL,
1747     HTMLElement_get_dispid,
1748     HTMLElement_invoke
1749 };
1750
1751 static dispex_static_data_t HTMLElement_dispex = {
1752     &HTMLElement_dispex_vtbl,
1753     DispHTMLUnknownElement_tid,
1754     NULL,
1755     HTMLElement_iface_tids
1756 };
1757
1758 void HTMLElement_Init(HTMLElement *This, HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, dispex_static_data_t *dispex_data)
1759 {
1760     This->IHTMLElement_iface.lpVtbl = &HTMLElementVtbl;
1761
1762     HTMLElement2_Init(This);
1763     HTMLElement3_Init(This);
1764
1765     if(dispex_data && !dispex_data->vtbl)
1766         dispex_data->vtbl = &HTMLElement_dispex_vtbl;
1767     init_dispex(&This->node.dispex, (IUnknown*)&This->IHTMLElement_iface,
1768             dispex_data ? dispex_data : &HTMLElement_dispex);
1769
1770     if(nselem)
1771         nsIDOMHTMLElement_AddRef(nselem);
1772     This->nselem = nselem;
1773     list_init(&This->attrs);
1774
1775     HTMLDOMNode_Init(doc, &This->node, (nsIDOMNode*)nselem);
1776
1777     ConnectionPointContainer_Init(&This->cp_container, (IUnknown*)&This->IHTMLElement_iface);
1778 }
1779
1780 HRESULT HTMLElement_Create(HTMLDocumentNode *doc, nsIDOMNode *nsnode, BOOL use_generic, HTMLElement **ret)
1781 {
1782     nsIDOMHTMLElement *nselem;
1783     nsAString class_name_str;
1784     const PRUnichar *class_name;
1785     const tag_desc_t *tag;
1786     HTMLElement *elem;
1787     nsresult nsres;
1788     HRESULT hres;
1789
1790     nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMHTMLElement, (void**)&nselem);
1791     if(NS_FAILED(nsres))
1792         return E_FAIL;
1793
1794     nsAString_Init(&class_name_str, NULL);
1795     nsIDOMHTMLElement_GetTagName(nselem, &class_name_str);
1796
1797     nsAString_GetData(&class_name_str, &class_name);
1798
1799     tag = get_tag_desc(class_name);
1800     if(tag) {
1801         hres = tag->constructor(doc, nselem, &elem);
1802     }else if(use_generic) {
1803         hres = HTMLGenericElement_Create(doc, nselem, &elem);
1804     }else {
1805         elem = heap_alloc_zero(sizeof(HTMLElement));
1806         if(elem) {
1807             HTMLElement_Init(elem, doc, nselem, &HTMLElement_dispex);
1808             elem->node.vtbl = &HTMLElementImplVtbl;
1809             hres = S_OK;
1810         }else {
1811             hres = E_OUTOFMEMORY;
1812         }
1813     }
1814
1815     TRACE("%s ret %p\n", debugstr_w(class_name), elem);
1816
1817     nsIDOMElement_Release(nselem);
1818     nsAString_Finish(&class_name_str);
1819     if(FAILED(hres))
1820         return hres;
1821
1822     *ret = elem;
1823     return S_OK;
1824 }
1825
1826 /* interface IHTMLFiltersCollection */
1827 static HRESULT WINAPI HTMLFiltersCollection_QueryInterface(IHTMLFiltersCollection *iface, REFIID riid, void **ppv)
1828 {
1829     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1830
1831     TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppv );
1832
1833     if(IsEqualGUID(&IID_IUnknown, riid)) {
1834         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
1835         *ppv = &This->IHTMLFiltersCollection_iface;
1836     }else if(IsEqualGUID(&IID_IHTMLFiltersCollection, riid)) {
1837         TRACE("(%p)->(IID_IHTMLFiltersCollection %p)\n", This, ppv);
1838         *ppv = &This->IHTMLFiltersCollection_iface;
1839     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1840         return *ppv ? S_OK : E_NOINTERFACE;
1841     }
1842
1843     if(*ppv) {
1844         IUnknown_AddRef((IUnknown*)*ppv);
1845         return S_OK;
1846     }
1847
1848     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
1849     return E_NOINTERFACE;
1850 }
1851
1852 static ULONG WINAPI HTMLFiltersCollection_AddRef(IHTMLFiltersCollection *iface)
1853 {
1854     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1855     LONG ref = InterlockedIncrement(&This->ref);
1856
1857     TRACE("(%p) ref=%d\n", This, ref);
1858
1859     return ref;
1860 }
1861
1862 static ULONG WINAPI HTMLFiltersCollection_Release(IHTMLFiltersCollection *iface)
1863 {
1864     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1865     LONG ref = InterlockedDecrement(&This->ref);
1866
1867     TRACE("(%p) ref=%d\n", This, ref);
1868
1869     if(!ref)
1870     {
1871         heap_free(This);
1872     }
1873
1874     return ref;
1875 }
1876
1877 static HRESULT WINAPI HTMLFiltersCollection_GetTypeInfoCount(IHTMLFiltersCollection *iface, UINT *pctinfo)
1878 {
1879     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1880     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
1881 }
1882
1883 static HRESULT WINAPI HTMLFiltersCollection_GetTypeInfo(IHTMLFiltersCollection *iface,
1884                                     UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
1885 {
1886     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1887     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1888 }
1889
1890 static HRESULT WINAPI HTMLFiltersCollection_GetIDsOfNames(IHTMLFiltersCollection *iface,
1891                                     REFIID riid, LPOLESTR *rgszNames, UINT cNames,
1892                                     LCID lcid, DISPID *rgDispId)
1893 {
1894     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1895     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1896             lcid, rgDispId);
1897 }
1898
1899 static HRESULT WINAPI HTMLFiltersCollection_Invoke(IHTMLFiltersCollection *iface, DISPID dispIdMember, REFIID riid,
1900                                     LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
1901                                     EXCEPINFO *pExcepInfo, UINT *puArgErr)
1902 {
1903     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1904     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
1905             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1906 }
1907
1908 static HRESULT WINAPI HTMLFiltersCollection_get_length(IHTMLFiltersCollection *iface, LONG *p)
1909 {
1910     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1911
1912     if(!p)
1913         return E_POINTER;
1914
1915     FIXME("(%p)->(%p) Always returning 0\n", This, p);
1916     *p = 0;
1917
1918     return S_OK;
1919 }
1920
1921 static HRESULT WINAPI HTMLFiltersCollection_get__newEnum(IHTMLFiltersCollection *iface, IUnknown **p)
1922 {
1923     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1924     FIXME("(%p)->(%p)\n", This, p);
1925     return E_NOTIMPL;
1926 }
1927
1928 static HRESULT WINAPI HTMLFiltersCollection_item(IHTMLFiltersCollection *iface, VARIANT *pvarIndex, VARIANT *pvarResult)
1929 {
1930     HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
1931     FIXME("(%p)->(%p, %p)\n", This, pvarIndex, pvarResult);
1932     return E_NOTIMPL;
1933 }
1934
1935 static const IHTMLFiltersCollectionVtbl HTMLFiltersCollectionVtbl = {
1936     HTMLFiltersCollection_QueryInterface,
1937     HTMLFiltersCollection_AddRef,
1938     HTMLFiltersCollection_Release,
1939     HTMLFiltersCollection_GetTypeInfoCount,
1940     HTMLFiltersCollection_GetTypeInfo,
1941     HTMLFiltersCollection_GetIDsOfNames,
1942     HTMLFiltersCollection_Invoke,
1943     HTMLFiltersCollection_get_length,
1944     HTMLFiltersCollection_get__newEnum,
1945     HTMLFiltersCollection_item
1946 };
1947
1948 static HRESULT HTMLFiltersCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
1949 {
1950     WCHAR *ptr;
1951     int idx = 0;
1952
1953     for(ptr = name; *ptr && isdigitW(*ptr); ptr++)
1954         idx = idx*10 + (*ptr-'0');
1955     if(*ptr)
1956         return DISP_E_UNKNOWNNAME;
1957
1958     *dispid = MSHTML_DISPID_CUSTOM_MIN + idx;
1959     TRACE("ret %x\n", *dispid);
1960     return S_OK;
1961 }
1962
1963 static HRESULT HTMLFiltersCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
1964         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
1965 {
1966     TRACE("(%p)->(%x %x %x %p %p %p)\n", dispex, id, lcid, flags, params, res, ei);
1967
1968     V_VT(res) = VT_DISPATCH;
1969     V_DISPATCH(res) = NULL;
1970
1971     FIXME("always returning NULL\n");
1972
1973     return S_OK;
1974 }
1975
1976 static const dispex_static_data_vtbl_t HTMLFiltersCollection_dispex_vtbl = {
1977     NULL,
1978     HTMLFiltersCollection_get_dispid,
1979     HTMLFiltersCollection_invoke
1980 };
1981
1982 static const tid_t HTMLFiltersCollection_iface_tids[] = {
1983     IHTMLFiltersCollection_tid,
1984     0
1985 };
1986 static dispex_static_data_t HTMLFiltersCollection_dispex = {
1987     &HTMLFiltersCollection_dispex_vtbl,
1988     IHTMLFiltersCollection_tid,
1989     NULL,
1990     HTMLFiltersCollection_iface_tids
1991 };
1992
1993 static IHTMLFiltersCollection *HTMLFiltersCollection_Create(void)
1994 {
1995     HTMLFiltersCollection *ret = heap_alloc(sizeof(HTMLFiltersCollection));
1996
1997     ret->IHTMLFiltersCollection_iface.lpVtbl = &HTMLFiltersCollectionVtbl;
1998     ret->ref = 1;
1999
2000     init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLFiltersCollection_iface,
2001             &HTMLFiltersCollection_dispex);
2002
2003     return &ret->IHTMLFiltersCollection_iface;
2004 }