?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mshtml: Initialize HTMLAttributeCollection object with compat mode.
[wine/zf.git] / dlls / mshtml / htmlelem.c
blob04e59eafdae91cec892ed88619010827fbdb6a7d
1 /*
2 * Copyright 2006-2010 Jacek Caban for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <stdarg.h>
20 #include <assert.h>
21 #include <math.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "winreg.h"
29 #include "ole2.h"
30 #include "shlwapi.h"
31 #include "mshtmdid.h"
32
33 #include "wine/debug.h"
34
35 #include "mshtml_private.h"
36 #include "htmlevent.h"
37 #include "htmlstyle.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
40
41 #define ATTRFLAG_CASESENSITIVE 0x0001
42 #define ATTRFLAG_ASSTRING 0x0002
43 #define ATTRFLAG_EXPANDURL 0x0004
44
45 typedef struct {
46 const WCHAR *name;
47 HRESULT (*constructor)(HTMLDocumentNode*,nsIDOMElement*,HTMLElement**);
48 } tag_desc_t;
49
50 static const tag_desc_t tag_descs[] = {
51 {L"A", HTMLAnchorElement_Create},
52 {L"AREA", HTMLAreaElement_Create},
53 {L"BODY", HTMLBodyElement_Create},
54 {L"BUTTON", HTMLButtonElement_Create},
55 {L"EMBED", HTMLEmbedElement_Create},
56 {L"FORM", HTMLFormElement_Create},
57 {L"FRAME", HTMLFrameElement_Create},
58 {L"HEAD", HTMLHeadElement_Create},
59 {L"HTML", HTMLHtmlElement_Create},
60 {L"IFRAME", HTMLIFrame_Create},
61 {L"IMG", HTMLImgElement_Create},
62 {L"INPUT", HTMLInputElement_Create},
63 {L"LABEL", HTMLLabelElement_Create},
64 {L"LINK", HTMLLinkElement_Create},
65 {L"META", HTMLMetaElement_Create},
66 {L"OBJECT", HTMLObjectElement_Create},
67 {L"OPTION", HTMLOptionElement_Create},
68 {L"SCRIPT", HTMLScriptElement_Create},
69 {L"SELECT", HTMLSelectElement_Create},
70 {L"STYLE", HTMLStyleElement_Create},
71 {L"TABLE", HTMLTable_Create},
72 {L"TD", HTMLTableCell_Create},
73 {L"TEXTAREA", HTMLTextAreaElement_Create},
74 {L"TITLE", HTMLTitleElement_Create},
75 {L"TR", HTMLTableRow_Create}
76 };
77
78 static const tag_desc_t *get_tag_desc(const WCHAR *tag_name)
79 {
80 DWORD min=0, max=ARRAY_SIZE(tag_descs)-1, i;
81 int r;
82
83 while(min <= max) {
84 i = (min+max)/2;
85 r = wcscmp(tag_name, tag_descs[i].name);
86 if(!r)
87 return tag_descs+i;
88
89 if(r < 0)
90 max = i-1;
91 else
92 min = i+1;
93 }
94
95 return NULL;
96 }
97
98 HRESULT replace_node_by_html(nsIDOMHTMLDocument *nsdoc, nsIDOMNode *nsnode, const WCHAR *html)
99 {
100 nsIDOMDocumentFragment *nsfragment;
101 nsIDOMNode *nsparent;
102 nsIDOMRange *range;
103 nsAString html_str;
104 nsresult nsres;
105 HRESULT hres = S_OK;
106
107 nsres = nsIDOMHTMLDocument_CreateRange(nsdoc, &range);
108 if(NS_FAILED(nsres)) {
109 ERR("CreateRange failed: %08x\n", nsres);
110 return E_FAIL;
111 }
112
113 nsAString_InitDepend(&html_str, html);
114 nsIDOMRange_CreateContextualFragment(range, &html_str, &nsfragment);
115 nsIDOMRange_Release(range);
116 nsAString_Finish(&html_str);
117 if(NS_FAILED(nsres)) {
118 ERR("CreateContextualFragment failed: %08x\n", nsres);
119 return E_FAIL;
120 }
121
122 nsres = nsIDOMNode_GetParentNode(nsnode, &nsparent);
123 if(NS_SUCCEEDED(nsres) && nsparent) {
124 nsIDOMNode *nstmp;
125
126 nsres = nsIDOMNode_ReplaceChild(nsparent, (nsIDOMNode*)nsfragment, nsnode, &nstmp);
127 nsIDOMNode_Release(nsparent);
128 if(NS_FAILED(nsres)) {
129 ERR("ReplaceChild failed: %08x\n", nsres);
130 hres = E_FAIL;
131 }else if(nstmp) {
132 nsIDOMNode_Release(nstmp);
133 }
134 }else {
135 ERR("GetParentNode failed: %08x\n", nsres);
136 hres = E_FAIL;
137 }
138
139 nsIDOMDocumentFragment_Release(nsfragment);
140 return hres;
141 }
142
143 nsresult get_elem_attr_value(nsIDOMElement *nselem, const WCHAR *name, nsAString *val_str, const PRUnichar **val)
144 {
145 nsAString name_str;
146 nsresult nsres;
147
148 nsAString_InitDepend(&name_str, name);
149 nsAString_Init(val_str, NULL);
150 nsres = nsIDOMElement_GetAttribute(nselem, &name_str, val_str);
151 nsAString_Finish(&name_str);
152 if(NS_FAILED(nsres)) {
153 ERR("GetAttribute(%s) failed: %08x\n", debugstr_w(name), nsres);
154 nsAString_Finish(val_str);
155 return nsres;
156 }
157
158 nsAString_GetData(val_str, val);
159 return NS_OK;
160 }
161
162 HRESULT elem_string_attr_getter(HTMLElement *elem, const WCHAR *name, BOOL use_null, BSTR *p)
163 {
164 const PRUnichar *val;
165 nsAString val_str;
166 nsresult nsres;
167 HRESULT hres = S_OK;
168
169 nsres = get_elem_attr_value(elem->dom_element, name, &val_str, &val);
170 if(NS_FAILED(nsres))
171 return E_FAIL;
172
173 TRACE("%s: returning %s\n", debugstr_w(name), debugstr_w(val));
174
175 if(*val || !use_null) {
176 *p = SysAllocString(val);
177 if(!*p)
178 hres = E_OUTOFMEMORY;
179 }else {
180 *p = NULL;
181 }
182 nsAString_Finish(&val_str);
183 return hres;
184 }
185
186 HRESULT elem_string_attr_setter(HTMLElement *elem, const WCHAR *name, const WCHAR *value)
187 {
188 nsAString name_str, val_str;
189 nsresult nsres;
190
191 nsAString_InitDepend(&name_str, name);
192 nsAString_InitDepend(&val_str, value);
193 nsres = nsIDOMElement_SetAttribute(elem->dom_element, &name_str, &val_str);
194 nsAString_Finish(&name_str);
195 nsAString_Finish(&val_str);
196
197 if(NS_FAILED(nsres)) {
198 WARN("SetAttribute failed: %08x\n", nsres);
199 return E_FAIL;
200 }
201
202 return S_OK;
203 }
204
205 HRESULT get_readystate_string(READYSTATE readystate, BSTR *p)
206 {
207 static const LPCWSTR readystate_strs[] = {
208 L"uninitialized",
209 L"loading",
210 L"loaded",
211 L"interactive",
212 L"complete"
213 };
214
215 assert(readystate <= READYSTATE_COMPLETE);
216 *p = SysAllocString(readystate_strs[readystate]);
217 return *p ? S_OK : E_OUTOFMEMORY;
218 }
219
220 typedef struct
221 {
222 DispatchEx dispex;
223 IHTMLFiltersCollection IHTMLFiltersCollection_iface;
224
225 LONG ref;
226 } HTMLFiltersCollection;
227
228 static inline HTMLFiltersCollection *impl_from_IHTMLFiltersCollection(IHTMLFiltersCollection *iface)
229 {
230 return CONTAINING_RECORD(iface, HTMLFiltersCollection, IHTMLFiltersCollection_iface);
231 }
232
233 static IHTMLFiltersCollection *HTMLFiltersCollection_Create(void);
234
235 static inline HTMLElement *impl_from_IHTMLElement(IHTMLElement *iface)
236 {
237 return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement_iface);
238 }
239
240 HRESULT create_nselem(HTMLDocumentNode *doc, const WCHAR *tag, nsIDOMElement **ret)
241 {
242 nsAString tag_str;
243 nsresult nsres;
244
245 if(!doc->nsdoc) {
246 WARN("NULL nsdoc\n");
247 return E_UNEXPECTED;
248 }
249
250 nsAString_InitDepend(&tag_str, tag);
251 nsres = nsIDOMHTMLDocument_CreateElement(doc->nsdoc, &tag_str, ret);
252 nsAString_Finish(&tag_str);
253 if(NS_FAILED(nsres)) {
254 ERR("CreateElement failed: %08x\n", nsres);
255 return E_FAIL;
256 }
257
258 return S_OK;
259 }
260
261 HRESULT create_element(HTMLDocumentNode *doc, const WCHAR *tag, HTMLElement **ret)
262 {
263 nsIDOMElement *nselem;
264 HRESULT hres;
265
266 /* Use owner doc if called on document fragment */
267 if(!doc->nsdoc)
268 doc = doc->node.doc;
269
270 hres = create_nselem(doc, tag, &nselem);
271 if(FAILED(hres))
272 return hres;
273
274 hres = HTMLElement_Create(doc, (nsIDOMNode*)nselem, TRUE, ret);
275 nsIDOMElement_Release(nselem);
276 return hres;
277 }
278
279 typedef struct {
280 DispatchEx dispex;
281 IHTMLRect IHTMLRect_iface;
282
283 LONG ref;
284
285 nsIDOMClientRect *nsrect;
286 } HTMLRect;
287
288 static inline HTMLRect *impl_from_IHTMLRect(IHTMLRect *iface)
289 {
290 return CONTAINING_RECORD(iface, HTMLRect, IHTMLRect_iface);
291 }
292
293 static HRESULT WINAPI HTMLRect_QueryInterface(IHTMLRect *iface, REFIID riid, void **ppv)
294 {
295 HTMLRect *This = impl_from_IHTMLRect(iface);
296
297 TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
298
299 if(IsEqualGUID(&IID_IUnknown, riid)) {
300 *ppv = &This->IHTMLRect_iface;
301 }else if(IsEqualGUID(&IID_IHTMLRect, riid)) {
302 *ppv = &This->IHTMLRect_iface;
303 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
304 return *ppv ? S_OK : E_NOINTERFACE;
305 }else {
306 FIXME("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
307 *ppv = NULL;
308 return E_NOINTERFACE;
309 }
310
311 IUnknown_AddRef((IUnknown*)*ppv);
312 return S_OK;
313 }
314
315 static ULONG WINAPI HTMLRect_AddRef(IHTMLRect *iface)
316 {
317 HTMLRect *This = impl_from_IHTMLRect(iface);
318 LONG ref = InterlockedIncrement(&This->ref);
319
320 TRACE("(%p) ref=%d\n", This, ref);
321
322 return ref;
323 }
324
325 static ULONG WINAPI HTMLRect_Release(IHTMLRect *iface)
326 {
327 HTMLRect *This = impl_from_IHTMLRect(iface);
328 LONG ref = InterlockedDecrement(&This->ref);
329
330 TRACE("(%p) ref=%d\n", This, ref);
331
332 if(!ref) {
333 if(This->nsrect)
334 nsIDOMClientRect_Release(This->nsrect);
335 release_dispex(&This->dispex);
336 heap_free(This);
337 }
338
339 return ref;
340 }
341
342 static HRESULT WINAPI HTMLRect_GetTypeInfoCount(IHTMLRect *iface, UINT *pctinfo)
343 {
344 HTMLRect *This = impl_from_IHTMLRect(iface);
345 FIXME("(%p)->(%p)\n", This, pctinfo);
346 return E_NOTIMPL;
347 }
348
349 static HRESULT WINAPI HTMLRect_GetTypeInfo(IHTMLRect *iface, UINT iTInfo,
350 LCID lcid, ITypeInfo **ppTInfo)
351 {
352 HTMLRect *This = impl_from_IHTMLRect(iface);
353
354 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
355 }
356
357 static HRESULT WINAPI HTMLRect_GetIDsOfNames(IHTMLRect *iface, REFIID riid,
358 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
359 {
360 HTMLRect *This = impl_from_IHTMLRect(iface);
361
362 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
363 lcid, rgDispId);
364 }
365
366 static HRESULT WINAPI HTMLRect_Invoke(IHTMLRect *iface, DISPID dispIdMember,
367 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
368 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
369 {
370 HTMLRect *This = impl_from_IHTMLRect(iface);
371
372 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
373 pDispParams, pVarResult, pExcepInfo, puArgErr);
374 }
375
376 static HRESULT WINAPI HTMLRect_put_left(IHTMLRect *iface, LONG v)
377 {
378 HTMLRect *This = impl_from_IHTMLRect(iface);
379 FIXME("(%p)->(%d)\n", This, v);
380 return E_NOTIMPL;
381 }
382
383 static HRESULT WINAPI HTMLRect_get_left(IHTMLRect *iface, LONG *p)
384 {
385 HTMLRect *This = impl_from_IHTMLRect(iface);
386 float left;
387 nsresult nsres;
388
389 TRACE("(%p)->(%p)\n", This, p);
390
391 nsres = nsIDOMClientRect_GetLeft(This->nsrect, &left);
392 if(NS_FAILED(nsres)) {
393 ERR("GetLeft failed: %08x\n", nsres);
394 return E_FAIL;
395 }
396
397 *p = floor(left+0.5);
398 return S_OK;
399 }
400
401 static HRESULT WINAPI HTMLRect_put_top(IHTMLRect *iface, LONG v)
402 {
403 HTMLRect *This = impl_from_IHTMLRect(iface);
404 FIXME("(%p)->(%d)\n", This, v);
405 return E_NOTIMPL;
406 }
407
408 static HRESULT WINAPI HTMLRect_get_top(IHTMLRect *iface, LONG *p)
409 {
410 HTMLRect *This = impl_from_IHTMLRect(iface);
411 float top;
412 nsresult nsres;
413
414 TRACE("(%p)->(%p)\n", This, p);
415
416 nsres = nsIDOMClientRect_GetTop(This->nsrect, &top);
417 if(NS_FAILED(nsres)) {
418 ERR("GetTop failed: %08x\n", nsres);
419 return E_FAIL;
420 }
421
422 *p = floor(top+0.5);
423 return S_OK;
424 }
425
426 static HRESULT WINAPI HTMLRect_put_right(IHTMLRect *iface, LONG v)
427 {
428 HTMLRect *This = impl_from_IHTMLRect(iface);
429 FIXME("(%p)->(%d)\n", This, v);
430 return E_NOTIMPL;
431 }
432
433 static HRESULT WINAPI HTMLRect_get_right(IHTMLRect *iface, LONG *p)
434 {
435 HTMLRect *This = impl_from_IHTMLRect(iface);
436 float right;
437 nsresult nsres;
438
439 TRACE("(%p)->(%p)\n", This, p);
440
441 nsres = nsIDOMClientRect_GetRight(This->nsrect, &right);
442 if(NS_FAILED(nsres)) {
443 ERR("GetRight failed: %08x\n", nsres);
444 return E_FAIL;
445 }
446
447 *p = floor(right+0.5);
448 return S_OK;
449 }
450
451 static HRESULT WINAPI HTMLRect_put_bottom(IHTMLRect *iface, LONG v)
452 {
453 HTMLRect *This = impl_from_IHTMLRect(iface);
454 FIXME("(%p)->(%d)\n", This, v);
455 return E_NOTIMPL;
456 }
457
458 static HRESULT WINAPI HTMLRect_get_bottom(IHTMLRect *iface, LONG *p)
459 {
460 HTMLRect *This = impl_from_IHTMLRect(iface);
461 float bottom;
462 nsresult nsres;
463
464 TRACE("(%p)->(%p)\n", This, p);
465
466 nsres = nsIDOMClientRect_GetBottom(This->nsrect, &bottom);
467 if(NS_FAILED(nsres)) {
468 ERR("GetBottom failed: %08x\n", nsres);
469 return E_FAIL;
470 }
471
472 *p = floor(bottom+0.5);
473 return S_OK;
474 }
475
476 static const IHTMLRectVtbl HTMLRectVtbl = {
477 HTMLRect_QueryInterface,
478 HTMLRect_AddRef,
479 HTMLRect_Release,
480 HTMLRect_GetTypeInfoCount,
481 HTMLRect_GetTypeInfo,
482 HTMLRect_GetIDsOfNames,
483 HTMLRect_Invoke,
484 HTMLRect_put_left,
485 HTMLRect_get_left,
486 HTMLRect_put_top,
487 HTMLRect_get_top,
488 HTMLRect_put_right,
489 HTMLRect_get_right,
490 HTMLRect_put_bottom,
491 HTMLRect_get_bottom
492 };
493
494 static const tid_t HTMLRect_iface_tids[] = {
495 IHTMLRect_tid,
496 0
497 };
498 static dispex_static_data_t HTMLRect_dispex = {
499 NULL,
500 IHTMLRect_tid,
501 HTMLRect_iface_tids
502 };
503
504 static HRESULT create_html_rect(nsIDOMClientRect *nsrect, compat_mode_t compat_mode, IHTMLRect **ret)
505 {
506 HTMLRect *rect;
507
508 rect = heap_alloc_zero(sizeof(HTMLRect));
509 if(!rect)
510 return E_OUTOFMEMORY;
511
512 rect->IHTMLRect_iface.lpVtbl = &HTMLRectVtbl;
513 rect->ref = 1;
514
515 init_dispex_with_compat_mode(&rect->dispex, (IUnknown*)&rect->IHTMLRect_iface, &HTMLRect_dispex, compat_mode);
516
517 nsIDOMClientRect_AddRef(nsrect);
518 rect->nsrect = nsrect;
519
520 *ret = &rect->IHTMLRect_iface;
521 return S_OK;
522 }
523
524 typedef struct {
525 DispatchEx dispex;
526 IHTMLRectCollection IHTMLRectCollection_iface;
527
528 LONG ref;
529
530 nsIDOMClientRectList *rect_list;
531 } HTMLRectCollection;
532
533 static inline HTMLRectCollection *impl_from_IHTMLRectCollection(IHTMLRectCollection *iface)
534 {
535 return CONTAINING_RECORD(iface, HTMLRectCollection, IHTMLRectCollection_iface);
536 }
537
538 static HRESULT WINAPI HTMLRectCollection_QueryInterface(IHTMLRectCollection *iface, REFIID riid, void **ppv)
539 {
540 HTMLRectCollection *This = impl_from_IHTMLRectCollection(iface);
541
542 TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
543
544 if(IsEqualGUID(&IID_IUnknown, riid)) {
545 *ppv = &This->IHTMLRectCollection_iface;
546 }else if(IsEqualGUID(&IID_IHTMLRectCollection, riid)) {
547 *ppv = &This->IHTMLRectCollection_iface;
548 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
549 return *ppv ? S_OK : E_NOINTERFACE;
550 }else {
551 FIXME("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
552 *ppv = NULL;
553 return E_NOINTERFACE;
554 }
555
556 IUnknown_AddRef((IUnknown*)*ppv);
557 return S_OK;
558 }
559
560 static ULONG WINAPI HTMLRectCollection_AddRef(IHTMLRectCollection *iface)
561 {
562 HTMLRectCollection *This = impl_from_IHTMLRectCollection(iface);
563 LONG ref = InterlockedIncrement(&This->ref);
564
565 TRACE("(%p) ref=%d\n", This, ref);
566
567 return ref;
568 }
569
570 static ULONG WINAPI HTMLRectCollection_Release(IHTMLRectCollection *iface)
571 {
572 HTMLRectCollection *This = impl_from_IHTMLRectCollection(iface);
573 LONG ref = InterlockedDecrement(&This->ref);
574
575 TRACE("(%p) ref=%d\n", This, ref);
576
577 if(!ref) {
578 if(This->rect_list)
579 nsIDOMClientRectList_Release(This->rect_list);
580 release_dispex(&This->dispex);
581 heap_free(This);
582 }
583
584 return ref;
585 }
586
587 static HRESULT WINAPI HTMLRectCollection_GetTypeInfoCount(IHTMLRectCollection *iface, UINT *pctinfo)
588 {
589 HTMLRectCollection *This = impl_from_IHTMLRectCollection(iface);
590 FIXME("(%p)->(%p)\n", This, pctinfo);
591 return E_NOTIMPL;
592 }
593
594 static HRESULT WINAPI HTMLRectCollection_GetTypeInfo(IHTMLRectCollection *iface, UINT iTInfo,
595 LCID lcid, ITypeInfo **ppTInfo)
596 {
597 HTMLRectCollection *This = impl_from_IHTMLRectCollection(iface);
598 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
599 }
600
601 static HRESULT WINAPI HTMLRectCollection_GetIDsOfNames(IHTMLRectCollection *iface, REFIID riid,
602 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
603 {
604 HTMLRectCollection *This = impl_from_IHTMLRectCollection(iface);
605 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
606 lcid, rgDispId);
607 }
608
609 static HRESULT WINAPI HTMLRectCollection_Invoke(IHTMLRectCollection *iface, DISPID dispIdMember,
610 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
611 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
612 {
613 HTMLRectCollection *This = impl_from_IHTMLRectCollection(iface);
614 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
615 pDispParams, pVarResult, pExcepInfo, puArgErr);
616 }
617
618 static HRESULT WINAPI HTMLRectCollection_get_length(IHTMLRectCollection *iface, LONG *p)
619 {
620 HTMLRectCollection *This = impl_from_IHTMLRectCollection(iface);
621 UINT32 length;
622 nsresult nsres;
623
624 TRACE("(%p)->(%p)\n", This, p);
625
626 nsres = nsIDOMClientRectList_GetLength(This->rect_list, &length);
627 assert(nsres == NS_OK);
628 *p = length;
629 return S_OK;
630 }
631
632 static HRESULT WINAPI HTMLRectCollection_get__newEnum(IHTMLRectCollection *iface, IUnknown **p)
633 {
634 HTMLRectCollection *This = impl_from_IHTMLRectCollection(iface);
635 FIXME("(%p)->(%p)\n", This, p);
636 return E_NOTIMPL;
637 }
638
639 static HRESULT WINAPI HTMLRectCollection_item(IHTMLRectCollection *iface, VARIANT *index, VARIANT *result)
640 {
641 HTMLRectCollection *This = impl_from_IHTMLRectCollection(iface);
642 nsIDOMClientRect *nsrect;
643 IHTMLRect *rect;
644 nsresult nsres;
645 HRESULT hres;
646
647 TRACE("(%p)->(%s %p)\n", This, debugstr_variant(index), result);
648
649 if(V_VT(index) != VT_I4 || V_I4(index) < 0) {
650 FIXME("Unsupported for %s index\n", debugstr_variant(index));
651 return E_NOTIMPL;
652 }
653
654 nsres = nsIDOMClientRectList_Item(This->rect_list, V_I4(index), &nsrect);
655 if(NS_FAILED(nsres))
656 return map_nsresult(nsres);
657 if(!nsrect) {
658 V_VT(result) = VT_NULL;
659 return S_OK;
660 }
661
662 hres = create_html_rect(nsrect, dispex_compat_mode(&This->dispex), &rect);
663 nsIDOMClientRect_Release(nsrect);
664 if(FAILED(hres))
665 return hres;
666
667 V_VT(result) = VT_DISPATCH;
668 V_DISPATCH(result) = (IDispatch *)rect;
669 return S_OK;
670 }
671
672 static const IHTMLRectCollectionVtbl HTMLRectCollectionVtbl = {
673 HTMLRectCollection_QueryInterface,
674 HTMLRectCollection_AddRef,
675 HTMLRectCollection_Release,
676 HTMLRectCollection_GetTypeInfoCount,
677 HTMLRectCollection_GetTypeInfo,
678 HTMLRectCollection_GetIDsOfNames,
679 HTMLRectCollection_Invoke,
680 HTMLRectCollection_get_length,
681 HTMLRectCollection_get__newEnum,
682 HTMLRectCollection_item
683 };
684
685 static inline HTMLRectCollection *HTMLRectCollection_from_DispatchEx(DispatchEx *iface)
686 {
687 return CONTAINING_RECORD(iface, HTMLRectCollection, dispex);
688 }
689
690 static HRESULT HTMLRectCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
691 {
692 HTMLRectCollection *This = HTMLRectCollection_from_DispatchEx(dispex);
693 UINT32 len = 0;
694 DWORD idx = 0;
695 WCHAR *ptr;
696
697 for(ptr = name; *ptr && is_digit(*ptr); ptr++)
698 idx = idx*10 + (*ptr-'0');
699 if(*ptr)
700 return DISP_E_UNKNOWNNAME;
701
702 nsIDOMClientRectList_GetLength(This->rect_list, &len);
703 if(idx >= len)
704 return DISP_E_UNKNOWNNAME;
705
706 *dispid = MSHTML_DISPID_CUSTOM_MIN + idx;
707 TRACE("ret %x\n", *dispid);
708 return S_OK;
709 }
710
711 static HRESULT HTMLRectCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
712 VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
713 {
714 HTMLRectCollection *This = HTMLRectCollection_from_DispatchEx(dispex);
715
716 TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, flags, params, res, ei, caller);
717
718 switch(flags) {
719 case DISPATCH_PROPERTYGET: {
720 nsIDOMClientRect *rect;
721 IHTMLRect *html_rect;
722 nsresult nsres;
723 HRESULT hres;
724
725 nsres = nsIDOMClientRectList_Item(This->rect_list, id - MSHTML_DISPID_CUSTOM_MIN, &rect);
726 if(NS_FAILED(nsres) || !rect) {
727 WARN("Unknown item\n");
728 return DISP_E_UNKNOWNNAME;
729 }
730
731 hres = create_html_rect(rect, dispex_compat_mode(&This->dispex), &html_rect);
732 nsIDOMClientRect_Release(rect);
733 if(FAILED(hres))
734 return hres;
735
736 V_VT(res) = VT_DISPATCH;
737 V_DISPATCH(res) = (IDispatch*)html_rect;
738 break;
739 }
740
741 default:
742 FIXME("unimplemented flags %x\n", flags);
743 return E_NOTIMPL;
744 }
745
746 return S_OK;
747 }
748
749 static const dispex_static_data_vtbl_t HTMLRectCollection_dispex_vtbl = {
750 NULL,
751 HTMLRectCollection_get_dispid,
752 HTMLRectCollection_invoke,
753 NULL
754 };
755 static const tid_t HTMLRectCollection_iface_tids[] = {
756 IHTMLRectCollection_tid,
757 0
758 };
759 static dispex_static_data_t HTMLRectCollection_dispex = {
760 &HTMLRectCollection_dispex_vtbl,
761 IHTMLRectCollection_tid,
762 HTMLRectCollection_iface_tids
763 };
764
765 static HRESULT WINAPI HTMLElement_QueryInterface(IHTMLElement *iface,
766 REFIID riid, void **ppv)
767 {
768 HTMLElement *This = impl_from_IHTMLElement(iface);
769
770 return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
771 }
772
773 static ULONG WINAPI HTMLElement_AddRef(IHTMLElement *iface)
774 {
775 HTMLElement *This = impl_from_IHTMLElement(iface);
776
777 return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
778 }
779
780 static ULONG WINAPI HTMLElement_Release(IHTMLElement *iface)
781 {
782 HTMLElement *This = impl_from_IHTMLElement(iface);
783
784 return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
785 }
786
787 static HRESULT WINAPI HTMLElement_GetTypeInfoCount(IHTMLElement *iface, UINT *pctinfo)
788 {
789 HTMLElement *This = impl_from_IHTMLElement(iface);
790 return IDispatchEx_GetTypeInfoCount(&This->node.event_target.dispex.IDispatchEx_iface, pctinfo);
791 }
792
793 static HRESULT WINAPI HTMLElement_GetTypeInfo(IHTMLElement *iface, UINT iTInfo,
794 LCID lcid, ITypeInfo **ppTInfo)
795 {
796 HTMLElement *This = impl_from_IHTMLElement(iface);
797 return IDispatchEx_GetTypeInfo(&This->node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
798 }
799
800 static HRESULT WINAPI HTMLElement_GetIDsOfNames(IHTMLElement *iface, REFIID riid,
801 LPOLESTR *rgszNames, UINT cNames,
802 LCID lcid, DISPID *rgDispId)
803 {
804 HTMLElement *This = impl_from_IHTMLElement(iface);
805 return IDispatchEx_GetIDsOfNames(&This->node.event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
806 lcid, rgDispId);
807 }
808
809 static HRESULT WINAPI HTMLElement_Invoke(IHTMLElement *iface, DISPID dispIdMember,
810 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
811 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
812 {
813 HTMLElement *This = impl_from_IHTMLElement(iface);
814 return IDispatchEx_Invoke(&This->node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
815 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
816 }
817
818 static HRESULT set_elem_attr_value_by_dispid(HTMLElement *elem, DISPID dispid, VARIANT *v)
819 {
820 DISPID propput_dispid = DISPID_PROPERTYPUT;
821 DISPPARAMS dp = {v, &propput_dispid, 1, 1};
822 EXCEPINFO ei;
823
824 if(dispid == DISPID_IHTMLELEMENT_STYLE) {
825 TRACE("Ignoring call on style attribute\n");
826 return S_OK;
827 }
828
829 return IDispatchEx_InvokeEx(&elem->node.event_target.dispex.IDispatchEx_iface, dispid,
830 LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYPUT, &dp, NULL, &ei, NULL);
831 }
832
833 static HRESULT WINAPI HTMLElement_setAttribute(IHTMLElement *iface, BSTR strAttributeName,
834 VARIANT AttributeValue, LONG lFlags)
835 {
836 HTMLElement *This = impl_from_IHTMLElement(iface);
837 DISPID dispid;
838 HRESULT hres;
839
840 TRACE("(%p)->(%s %s %08x)\n", This, debugstr_w(strAttributeName), debugstr_variant(&AttributeValue), lFlags);
841
842 hres = IDispatchEx_GetDispID(&This->node.event_target.dispex.IDispatchEx_iface, strAttributeName,
843 (lFlags&ATTRFLAG_CASESENSITIVE ? fdexNameCaseSensitive : fdexNameCaseInsensitive) | fdexNameEnsure, &dispid);
844 if(FAILED(hres))
845 return hres;
846
847 return set_elem_attr_value_by_dispid(This, dispid, &AttributeValue);
848 }
849
850 HRESULT get_elem_attr_value_by_dispid(HTMLElement *elem, DISPID dispid, VARIANT *ret)
851 {
852 DISPPARAMS dispParams = {NULL, NULL, 0, 0};
853 EXCEPINFO excep;
854
855 return IDispatchEx_InvokeEx(&elem->node.event_target.dispex.IDispatchEx_iface, dispid, LOCALE_SYSTEM_DEFAULT,
856 DISPATCH_PROPERTYGET, &dispParams, ret, &excep, NULL);
857 }
858
859 HRESULT attr_value_to_string(VARIANT *v)
860 {
861 HRESULT hres;
862
863 switch(V_VT(v)) {
864 case VT_BSTR:
865 break;
866 case VT_NULL:
867 V_BSTR(v) = SysAllocString(L"null");
868 if(!V_BSTR(v))
869 return E_OUTOFMEMORY;
870 V_VT(v) = VT_BSTR;
871 break;
872 case VT_DISPATCH:
873 IDispatch_Release(V_DISPATCH(v));
874 V_VT(v) = VT_BSTR;
875 V_BSTR(v) = SysAllocString(NULL);
876 break;
877 default:
878 hres = VariantChangeType(v, v, 0, VT_BSTR);
879 if(FAILED(hres))
880 return hres;
881 }
882
883 return S_OK;
884 }
885
886 static HRESULT WINAPI HTMLElement_getAttribute(IHTMLElement *iface, BSTR strAttributeName,
887 LONG lFlags, VARIANT *AttributeValue)
888 {
889 HTMLElement *This = impl_from_IHTMLElement(iface);
890 DISPID dispid;
891 HRESULT hres;
892
893 TRACE("(%p)->(%s %08x %p)\n", This, debugstr_w(strAttributeName), lFlags, AttributeValue);
894
895 if(lFlags & ~(ATTRFLAG_CASESENSITIVE|ATTRFLAG_ASSTRING))
896 FIXME("Unsupported flags %x\n", lFlags);
897
898 hres = IDispatchEx_GetDispID(&This->node.event_target.dispex.IDispatchEx_iface, strAttributeName,
899 lFlags&ATTRFLAG_CASESENSITIVE ? fdexNameCaseSensitive : fdexNameCaseInsensitive, &dispid);
900 if(hres == DISP_E_UNKNOWNNAME) {
901 V_VT(AttributeValue) = VT_NULL;
902 return S_OK;
903 }
904
905 if(FAILED(hres)) {
906 V_VT(AttributeValue) = VT_NULL;
907 return hres;
908 }
909
910 hres = get_elem_attr_value_by_dispid(This, dispid, AttributeValue);
911 if(SUCCEEDED(hres) && (lFlags & ATTRFLAG_ASSTRING))
912 hres = attr_value_to_string(AttributeValue);
913 return hres;
914 }
915
916 static HRESULT WINAPI HTMLElement_removeAttribute(IHTMLElement *iface, BSTR strAttributeName,
917 LONG lFlags, VARIANT_BOOL *pfSuccess)
918 {
919 HTMLElement *This = impl_from_IHTMLElement(iface);
920 DISPID id;
921 HRESULT hres;
922
923 TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(strAttributeName), lFlags, pfSuccess);
924
925 hres = IDispatchEx_GetDispID(&This->node.event_target.dispex.IDispatchEx_iface, strAttributeName,
926 lFlags&ATTRFLAG_CASESENSITIVE ? fdexNameCaseSensitive : fdexNameCaseInsensitive, &id);
927 if(hres == DISP_E_UNKNOWNNAME) {
928 *pfSuccess = VARIANT_FALSE;
929 return S_OK;
930 }
931 if(FAILED(hres))
932 return hres;
933
934 if(id == DISPID_IHTMLELEMENT_STYLE) {
935 IHTMLStyle *style;
936
937 TRACE("Special case: style\n");
938
939 hres = IHTMLElement_get_style(&This->IHTMLElement_iface, &style);
940 if(FAILED(hres))
941 return hres;
942
943 hres = IHTMLStyle_put_cssText(style, NULL);
944 IHTMLStyle_Release(style);
945 if(FAILED(hres))
946 return hres;
947
948 *pfSuccess = VARIANT_TRUE;
949 return S_OK;
950 }
951
952 return remove_attribute(&This->node.event_target.dispex, id, pfSuccess);
953 }
954
955 static HRESULT WINAPI HTMLElement_put_className(IHTMLElement *iface, BSTR v)
956 {
957 HTMLElement *This = impl_from_IHTMLElement(iface);
958 nsAString classname_str;
959 nsresult nsres;
960
961 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
962
963 if(!This->dom_element) {
964 FIXME("comment element\n");
965 return E_NOTIMPL;
966 }
967
968 nsAString_InitDepend(&classname_str, v);
969 nsres = nsIDOMElement_SetClassName(This->dom_element, &classname_str);
970 nsAString_Finish(&classname_str);
971 if(NS_FAILED(nsres))
972 ERR("SetClassName failed: %08x\n", nsres);
973
974 return S_OK;
975 }
976
977 static HRESULT WINAPI HTMLElement_get_className(IHTMLElement *iface, BSTR *p)
978 {
979 HTMLElement *This = impl_from_IHTMLElement(iface);
980 nsAString class_str;
981 nsresult nsres;
982
983 TRACE("(%p)->(%p)\n", This, p);
984
985 if(!This->dom_element) {
986 FIXME("comment element\n");
987 return E_NOTIMPL;
988 }
989
990 nsAString_Init(&class_str, NULL);
991 nsres = nsIDOMElement_GetClassName(This->dom_element, &class_str);
992 return return_nsstr(nsres, &class_str, p);
993 }
994
995 static HRESULT WINAPI HTMLElement_put_id(IHTMLElement *iface, BSTR v)
996 {
997 HTMLElement *This = impl_from_IHTMLElement(iface);
998 nsAString id_str;
999 nsresult nsres;
1000
1001 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1002
1003 if(!This->dom_element) {
1004 FIXME("comment element\n");
1005 return S_OK;
1006 }
1007
1008 nsAString_InitDepend(&id_str, v);
1009 nsres = nsIDOMElement_SetId(This->dom_element, &id_str);
1010 nsAString_Finish(&id_str);
1011 if(NS_FAILED(nsres))
1012 ERR("SetId failed: %08x\n", nsres);
1013
1014 return S_OK;
1015 }
1016
1017 static HRESULT WINAPI HTMLElement_get_id(IHTMLElement *iface, BSTR *p)
1018 {
1019 HTMLElement *This = impl_from_IHTMLElement(iface);
1020 nsAString id_str;
1021 nsresult nsres;
1022
1023 TRACE("(%p)->(%p)\n", This, p);
1024
1025 if(!This->dom_element) {
1026 *p = NULL;
1027 return S_OK;
1028 }
1029
1030 nsAString_Init(&id_str, NULL);
1031 nsres = nsIDOMElement_GetId(This->dom_element, &id_str);
1032 return return_nsstr(nsres, &id_str, p);
1033 }
1034
1035 static HRESULT WINAPI HTMLElement_get_tagName(IHTMLElement *iface, BSTR *p)
1036 {
1037 HTMLElement *This = impl_from_IHTMLElement(iface);
1038 nsAString tag_str;
1039 nsresult nsres;
1040
1041 TRACE("(%p)->(%p)\n", This, p);
1042
1043 if(!This->dom_element) {
1044 TRACE("comment element\n");
1045 *p = SysAllocString(L"!");
1046 return *p ? S_OK : E_OUTOFMEMORY;
1047 }
1048
1049 nsAString_Init(&tag_str, NULL);
1050 nsres = nsIDOMElement_GetTagName(This->dom_element, &tag_str);
1051 return return_nsstr(nsres, &tag_str, p);
1052 }
1053
1054 static HRESULT WINAPI HTMLElement_get_parentElement(IHTMLElement *iface, IHTMLElement **p)
1055 {
1056 HTMLElement *This = impl_from_IHTMLElement(iface);
1057 IHTMLDOMNode *node;
1058 HRESULT hres;
1059
1060 TRACE("(%p)->(%p)\n", This, p);
1061
1062 hres = IHTMLDOMNode_get_parentNode(&This->node.IHTMLDOMNode_iface, &node);
1063 if(FAILED(hres))
1064 return hres;
1065
1066 if(!node) {
1067 *p = NULL;
1068 return S_OK;
1069 }
1070
1071 hres = IHTMLDOMNode_QueryInterface(node, &IID_IHTMLElement, (void**)p);
1072 IHTMLDOMNode_Release(node);
1073 if(FAILED(hres))
1074 *p = NULL;
1075
1076 return S_OK;
1077 }
1078
1079 static HRESULT WINAPI HTMLElement_get_style(IHTMLElement *iface, IHTMLStyle **p)
1080 {
1081 HTMLElement *This = impl_from_IHTMLElement(iface);
1082
1083 TRACE("(%p)->(%p)\n", This, p);
1084
1085 if(!This->style) {
1086 HRESULT hres;
1087
1088 hres = HTMLStyle_Create(This, &This->style);
1089 if(FAILED(hres))
1090 return hres;
1091 }
1092
1093 *p = &This->style->IHTMLStyle_iface;
1094 IHTMLStyle_AddRef(*p);
1095 return S_OK;
1096 }
1097
1098 static HRESULT WINAPI HTMLElement_put_onhelp(IHTMLElement *iface, VARIANT v)
1099 {
1100 HTMLElement *This = impl_from_IHTMLElement(iface);
1101
1102 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1103
1104 return set_node_event(&This->node, EVENTID_HELP, &v);
1105 }
1106
1107 static HRESULT WINAPI HTMLElement_get_onhelp(IHTMLElement *iface, VARIANT *p)
1108 {
1109 HTMLElement *This = impl_from_IHTMLElement(iface);
1110
1111 TRACE("(%p)->(%p)\n", This, p);
1112
1113 return get_node_event(&This->node, EVENTID_HELP, p);
1114 }
1115
1116 static HRESULT WINAPI HTMLElement_put_onclick(IHTMLElement *iface, VARIANT v)
1117 {
1118 HTMLElement *This = impl_from_IHTMLElement(iface);
1119
1120 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1121
1122 return set_node_event(&This->node, EVENTID_CLICK, &v);
1123 }
1124
1125 static HRESULT WINAPI HTMLElement_get_onclick(IHTMLElement *iface, VARIANT *p)
1126 {
1127 HTMLElement *This = impl_from_IHTMLElement(iface);
1128
1129 TRACE("(%p)->(%p)\n", This, p);
1130
1131 return get_node_event(&This->node, EVENTID_CLICK, p);
1132 }
1133
1134 static HRESULT WINAPI HTMLElement_put_ondblclick(IHTMLElement *iface, VARIANT v)
1135 {
1136 HTMLElement *This = impl_from_IHTMLElement(iface);
1137
1138 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1139
1140 return set_node_event(&This->node, EVENTID_DBLCLICK, &v);
1141 }
1142
1143 static HRESULT WINAPI HTMLElement_get_ondblclick(IHTMLElement *iface, VARIANT *p)
1144 {
1145 HTMLElement *This = impl_from_IHTMLElement(iface);
1146
1147 TRACE("(%p)->(%p)\n", This, p);
1148
1149 return get_node_event(&This->node, EVENTID_DBLCLICK, p);
1150 }
1151
1152 static HRESULT WINAPI HTMLElement_put_onkeydown(IHTMLElement *iface, VARIANT v)
1153 {
1154 HTMLElement *This = impl_from_IHTMLElement(iface);
1155
1156 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1157
1158 return set_node_event(&This->node, EVENTID_KEYDOWN, &v);
1159 }
1160
1161 static HRESULT WINAPI HTMLElement_get_onkeydown(IHTMLElement *iface, VARIANT *p)
1162 {
1163 HTMLElement *This = impl_from_IHTMLElement(iface);
1164
1165 TRACE("(%p)->(%p)\n", This, p);
1166
1167 return get_node_event(&This->node, EVENTID_KEYDOWN, p);
1168 }
1169
1170 static HRESULT WINAPI HTMLElement_put_onkeyup(IHTMLElement *iface, VARIANT v)
1171 {
1172 HTMLElement *This = impl_from_IHTMLElement(iface);
1173
1174 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1175
1176 return set_node_event(&This->node, EVENTID_KEYUP, &v);
1177 }
1178
1179 static HRESULT WINAPI HTMLElement_get_onkeyup(IHTMLElement *iface, VARIANT *p)
1180 {
1181 HTMLElement *This = impl_from_IHTMLElement(iface);
1182
1183 TRACE("(%p)->(%p)\n", This, p);
1184
1185 return get_node_event(&This->node, EVENTID_KEYUP, p);
1186 }
1187
1188 static HRESULT WINAPI HTMLElement_put_onkeypress(IHTMLElement *iface, VARIANT v)
1189 {
1190 HTMLElement *This = impl_from_IHTMLElement(iface);
1191
1192 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1193
1194 return set_node_event(&This->node, EVENTID_KEYPRESS, &v);
1195 }
1196
1197 static HRESULT WINAPI HTMLElement_get_onkeypress(IHTMLElement *iface, VARIANT *p)
1198 {
1199 HTMLElement *This = impl_from_IHTMLElement(iface);
1200
1201 TRACE("(%p)->(%p)\n", This, p);
1202
1203 return get_node_event(&This->node, EVENTID_KEYPRESS, p);
1204 }
1205
1206 static HRESULT WINAPI HTMLElement_put_onmouseout(IHTMLElement *iface, VARIANT v)
1207 {
1208 HTMLElement *This = impl_from_IHTMLElement(iface);
1209
1210 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1211
1212 return set_node_event(&This->node, EVENTID_MOUSEOUT, &v);
1213 }
1214
1215 static HRESULT WINAPI HTMLElement_get_onmouseout(IHTMLElement *iface, VARIANT *p)
1216 {
1217 HTMLElement *This = impl_from_IHTMLElement(iface);
1218
1219 TRACE("(%p)->(%p)\n", This, p);
1220
1221 return get_node_event(&This->node, EVENTID_MOUSEOUT, p);
1222 }
1223
1224 static HRESULT WINAPI HTMLElement_put_onmouseover(IHTMLElement *iface, VARIANT v)
1225 {
1226 HTMLElement *This = impl_from_IHTMLElement(iface);
1227
1228 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1229
1230 return set_node_event(&This->node, EVENTID_MOUSEOVER, &v);
1231 }
1232
1233 static HRESULT WINAPI HTMLElement_get_onmouseover(IHTMLElement *iface, VARIANT *p)
1234 {
1235 HTMLElement *This = impl_from_IHTMLElement(iface);
1236
1237 TRACE("(%p)->(%p)\n", This, p);
1238
1239 return get_node_event(&This->node, EVENTID_MOUSEOVER, p);
1240 }
1241
1242 static HRESULT WINAPI HTMLElement_put_onmousemove(IHTMLElement *iface, VARIANT v)
1243 {
1244 HTMLElement *This = impl_from_IHTMLElement(iface);
1245
1246 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1247
1248 return set_node_event(&This->node, EVENTID_MOUSEMOVE, &v);
1249 }
1250
1251 static HRESULT WINAPI HTMLElement_get_onmousemove(IHTMLElement *iface, VARIANT *p)
1252 {
1253 HTMLElement *This = impl_from_IHTMLElement(iface);
1254
1255 TRACE("(%p)->(%p)\n", This, p);
1256
1257 return get_node_event(&This->node, EVENTID_MOUSEMOVE, p);
1258 }
1259
1260 static HRESULT WINAPI HTMLElement_put_onmousedown(IHTMLElement *iface, VARIANT v)
1261 {
1262 HTMLElement *This = impl_from_IHTMLElement(iface);
1263
1264 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1265
1266 return set_node_event(&This->node, EVENTID_MOUSEDOWN, &v);
1267 }
1268
1269 static HRESULT WINAPI HTMLElement_get_onmousedown(IHTMLElement *iface, VARIANT *p)
1270 {
1271 HTMLElement *This = impl_from_IHTMLElement(iface);
1272
1273 TRACE("(%p)->(%p)\n", This, p);
1274
1275 return get_node_event(&This->node, EVENTID_MOUSEDOWN, p);
1276 }
1277
1278 static HRESULT WINAPI HTMLElement_put_onmouseup(IHTMLElement *iface, VARIANT v)
1279 {
1280 HTMLElement *This = impl_from_IHTMLElement(iface);
1281
1282 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1283
1284 return set_node_event(&This->node, EVENTID_MOUSEUP, &v);
1285 }
1286
1287 static HRESULT WINAPI HTMLElement_get_onmouseup(IHTMLElement *iface, VARIANT *p)
1288 {
1289 HTMLElement *This = impl_from_IHTMLElement(iface);
1290
1291 TRACE("(%p)->(%p)\n", This, p);
1292
1293 return get_node_event(&This->node, EVENTID_MOUSEUP, p);
1294 }
1295
1296 static HRESULT WINAPI HTMLElement_get_document(IHTMLElement *iface, IDispatch **p)
1297 {
1298 HTMLElement *This = impl_from_IHTMLElement(iface);
1299
1300 TRACE("(%p)->(%p)\n", This, p);
1301
1302 if(!p)
1303 return E_POINTER;
1304
1305 if(This->node.vtbl->get_document)
1306 return This->node.vtbl->get_document(&This->node, p);
1307
1308 *p = (IDispatch*)&This->node.doc->basedoc.IHTMLDocument2_iface;
1309 IDispatch_AddRef(*p);
1310 return S_OK;
1311 }
1312
1313 static HRESULT WINAPI HTMLElement_put_title(IHTMLElement *iface, BSTR v)
1314 {
1315 HTMLElement *This = impl_from_IHTMLElement(iface);
1316 nsAString title_str;
1317 nsresult nsres;
1318
1319 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1320
1321 if(!This->html_element) {
1322 VARIANT *var;
1323 HRESULT hres;
1324
1325 hres = dispex_get_dprop_ref(&This->node.event_target.dispex, L"title", TRUE, &var);
1326 if(FAILED(hres))
1327 return hres;
1328
1329 VariantClear(var);
1330 V_VT(var) = VT_BSTR;
1331 V_BSTR(var) = v ? SysAllocString(v) : NULL;
1332 return S_OK;
1333 }
1334
1335 nsAString_InitDepend(&title_str, v);
1336 nsres = nsIDOMHTMLElement_SetTitle(This->html_element, &title_str);
1337 nsAString_Finish(&title_str);
1338 if(NS_FAILED(nsres))
1339 ERR("SetTitle failed: %08x\n", nsres);
1340
1341 return S_OK;
1342 }
1343
1344 static HRESULT WINAPI HTMLElement_get_title(IHTMLElement *iface, BSTR *p)
1345 {
1346 HTMLElement *This = impl_from_IHTMLElement(iface);
1347 nsAString title_str;
1348 nsresult nsres;
1349
1350 TRACE("(%p)->(%p)\n", This, p);
1351
1352 if(!This->html_element) {
1353 VARIANT *var;
1354 HRESULT hres;
1355
1356 hres = dispex_get_dprop_ref(&This->node.event_target.dispex, L"title", FALSE, &var);
1357 if(hres == DISP_E_UNKNOWNNAME) {
1358 *p = NULL;
1359 }else if(V_VT(var) != VT_BSTR) {
1360 FIXME("title = %s\n", debugstr_variant(var));
1361 return E_FAIL;
1362 }else {
1363 *p = V_BSTR(var) ? SysAllocString(V_BSTR(var)) : NULL;
1364 }
1365
1366 return S_OK;
1367 }
1368
1369 nsAString_Init(&title_str, NULL);
1370 nsres = nsIDOMHTMLElement_GetTitle(This->html_element, &title_str);
1371 return return_nsstr(nsres, &title_str, p);
1372 }
1373
1374 static HRESULT WINAPI HTMLElement_put_language(IHTMLElement *iface, BSTR v)
1375 {
1376 HTMLElement *This = impl_from_IHTMLElement(iface);
1377
1378 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1379
1380 return elem_string_attr_setter(This, L"language", v);
1381 }
1382
1383 static HRESULT WINAPI HTMLElement_get_language(IHTMLElement *iface, BSTR *p)
1384 {
1385 HTMLElement *This = impl_from_IHTMLElement(iface);
1386
1387 TRACE("(%p)->(%p)\n", This, p);
1388
1389 return elem_string_attr_getter(This, L"language", TRUE, p);
1390 }
1391
1392 static HRESULT WINAPI HTMLElement_put_onselectstart(IHTMLElement *iface, VARIANT v)
1393 {
1394 HTMLElement *This = impl_from_IHTMLElement(iface);
1395
1396 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1397
1398 return set_node_event(&This->node, EVENTID_SELECTSTART, &v);
1399 }
1400
1401 static HRESULT WINAPI HTMLElement_get_onselectstart(IHTMLElement *iface, VARIANT *p)
1402 {
1403 HTMLElement *This = impl_from_IHTMLElement(iface);
1404
1405 TRACE("(%p)->(%p)\n", This, p);
1406
1407 return get_node_event(&This->node, EVENTID_SELECTSTART, p);
1408 }
1409
1410 static HRESULT WINAPI HTMLElement_scrollIntoView(IHTMLElement *iface, VARIANT varargStart)
1411 {
1412 HTMLElement *This = impl_from_IHTMLElement(iface);
1413 cpp_bool start = TRUE;
1414 nsresult nsres;
1415
1416 TRACE("(%p)->(%s)\n", This, debugstr_variant(&varargStart));
1417
1418 switch(V_VT(&varargStart)) {
1419 case VT_EMPTY:
1420 case VT_ERROR:
1421 break;
1422 case VT_BOOL:
1423 start = V_BOOL(&varargStart) != VARIANT_FALSE;
1424 break;
1425 default:
1426 FIXME("Unsupported argument %s\n", debugstr_variant(&varargStart));
1427 }
1428
1429 if(!This->html_element) {
1430 FIXME("non-HTML elements\n");
1431 return E_NOTIMPL;
1432 }
1433
1434 nsres = nsIDOMHTMLElement_ScrollIntoView(This->html_element, start, 1);
1435 assert(nsres == NS_OK);
1436
1437 return S_OK;
1438 }
1439
1440 static HRESULT WINAPI HTMLElement_contains(IHTMLElement *iface, IHTMLElement *pChild,
1441 VARIANT_BOOL *pfResult)
1442 {
1443 HTMLElement *This = impl_from_IHTMLElement(iface);
1444 cpp_bool result = FALSE;
1445
1446 TRACE("(%p)->(%p %p)\n", This, pChild, pfResult);
1447
1448 if(pChild) {
1449 HTMLElement *child;
1450 nsresult nsres;
1451
1452 child = unsafe_impl_from_IHTMLElement(pChild);
1453 if(!child) {
1454 ERR("not our element\n");
1455 return E_FAIL;
1456 }
1457
1458 nsres = nsIDOMNode_Contains(This->node.nsnode, child->node.nsnode, &result);
1459 assert(nsres == NS_OK);
1460 }
1461
1462 *pfResult = variant_bool(result);
1463 return S_OK;
1464 }
1465
1466 static HRESULT WINAPI HTMLElement_get_sourceIndex(IHTMLElement *iface, LONG *p)
1467 {
1468 HTMLElement *This = impl_from_IHTMLElement(iface);
1469
1470 TRACE("(%p)->(%p)\n", This, p);
1471
1472 return get_elem_source_index(This, p);
1473 }
1474
1475 static HRESULT WINAPI HTMLElement_get_recordNumber(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_lang(IHTMLElement *iface, BSTR v)
1483 {
1484 HTMLElement *This = impl_from_IHTMLElement(iface);
1485 nsAString nsstr;
1486 nsresult nsres;
1487
1488 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1489
1490 if(!This->html_element) {
1491 FIXME("non-HTML element\n");
1492 return E_NOTIMPL;
1493 }
1494
1495 nsAString_InitDepend(&nsstr, v);
1496 nsres = nsIDOMHTMLElement_SetLang(This->html_element, &nsstr);
1497 nsAString_Finish(&nsstr);
1498 if(NS_FAILED(nsres)) {
1499 ERR("SetLang failed: %08x\n", nsres);
1500 return E_FAIL;
1501 }
1502
1503 return S_OK;
1504 }
1505
1506 static HRESULT WINAPI HTMLElement_get_lang(IHTMLElement *iface, BSTR *p)
1507 {
1508 HTMLElement *This = impl_from_IHTMLElement(iface);
1509 nsAString nsstr;
1510 nsresult nsres;
1511
1512 TRACE("(%p)->(%p)\n", This, p);
1513
1514 if(!This->html_element) {
1515 FIXME("non-HTML element\n");
1516 return E_NOTIMPL;
1517 }
1518
1519 nsAString_Init(&nsstr, NULL);
1520 nsres = nsIDOMHTMLElement_GetLang(This->html_element, &nsstr);
1521 return return_nsstr(nsres, &nsstr, p);
1522 }
1523
1524 static HRESULT WINAPI HTMLElement_get_offsetLeft(IHTMLElement *iface, LONG *p)
1525 {
1526 HTMLElement *This = impl_from_IHTMLElement(iface);
1527 nsresult nsres;
1528
1529 TRACE("(%p)->(%p)\n", This, p);
1530
1531 if(!This->html_element) {
1532 FIXME("non-HTML element\n");
1533 return E_NOTIMPL;
1534 }
1535
1536 nsres = nsIDOMHTMLElement_GetOffsetLeft(This->html_element, p);
1537 if(NS_FAILED(nsres)) {
1538 ERR("GetOffsetLeft failed: %08x\n", nsres);
1539 return E_FAIL;
1540 }
1541
1542 return S_OK;
1543 }
1544
1545 static HRESULT WINAPI HTMLElement_get_offsetTop(IHTMLElement *iface, LONG *p)
1546 {
1547 HTMLElement *This = impl_from_IHTMLElement(iface);
1548 nsresult nsres;
1549
1550 TRACE("(%p)->(%p)\n", This, p);
1551
1552 if(!This->html_element) {
1553 FIXME("non-HTML element\n");
1554 return E_NOTIMPL;
1555 }
1556
1557 nsres = nsIDOMHTMLElement_GetOffsetTop(This->html_element, p);
1558 if(NS_FAILED(nsres)) {
1559 ERR("GetOffsetTop failed: %08x\n", nsres);
1560 return E_FAIL;
1561 }
1562
1563 return S_OK;
1564 }
1565
1566 static HRESULT WINAPI HTMLElement_get_offsetWidth(IHTMLElement *iface, LONG *p)
1567 {
1568 HTMLElement *This = impl_from_IHTMLElement(iface);
1569 nsresult nsres;
1570
1571 TRACE("(%p)->(%p)\n", This, p);
1572
1573 if(!This->html_element) {
1574 FIXME("non-HTML element\n");
1575 return E_NOTIMPL;
1576 }
1577
1578 nsres = nsIDOMHTMLElement_GetOffsetWidth(This->html_element, p);
1579 if(NS_FAILED(nsres)) {
1580 ERR("GetOffsetWidth failed: %08x\n", nsres);
1581 return E_FAIL;
1582 }
1583
1584 return S_OK;
1585 }
1586
1587 static HRESULT WINAPI HTMLElement_get_offsetHeight(IHTMLElement *iface, LONG *p)
1588 {
1589 HTMLElement *This = impl_from_IHTMLElement(iface);
1590 nsresult nsres;
1591
1592 TRACE("(%p)->(%p)\n", This, p);
1593
1594 if(!This->html_element) {
1595 FIXME("non-HTML element\n");
1596 return E_NOTIMPL;
1597 }
1598
1599 nsres = nsIDOMHTMLElement_GetOffsetHeight(This->html_element, p);
1600 if(NS_FAILED(nsres)) {
1601 ERR("GetOffsetHeight failed: %08x\n", nsres);
1602 return E_FAIL;
1603 }
1604
1605 return S_OK;
1606 }
1607
1608 static HRESULT WINAPI HTMLElement_get_offsetParent(IHTMLElement *iface, IHTMLElement **p)
1609 {
1610 HTMLElement *This = impl_from_IHTMLElement(iface);
1611 nsIDOMElement *nsparent;
1612 HTMLElement *parent;
1613 nsresult nsres;
1614 HRESULT hres;
1615
1616 TRACE("(%p)->(%p)\n", This, p);
1617
1618 if(!This->html_element) {
1619 FIXME("non-HTML element\n");
1620 return E_NOTIMPL;
1621 }
1622
1623 nsres = nsIDOMHTMLElement_GetOffsetParent(This->html_element, &nsparent);
1624 if(NS_FAILED(nsres)) {
1625 ERR("GetOffsetParent failed: %08x\n", nsres);
1626 return E_FAIL;
1627 }
1628
1629 if(!nsparent) {
1630 *p = NULL;
1631 hres = S_OK;
1632 }
1633
1634 hres = get_element(nsparent, &parent);
1635 nsIDOMElement_Release(nsparent);
1636 if(FAILED(hres))
1637 return hres;
1638
1639 *p = &parent->IHTMLElement_iface;
1640 return S_OK;
1641 }
1642
1643 static HRESULT WINAPI HTMLElement_put_innerHTML(IHTMLElement *iface, BSTR v)
1644 {
1645 HTMLElement *This = impl_from_IHTMLElement(iface);
1646 nsAString html_str;
1647 nsresult nsres;
1648
1649 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1650
1651 if(!This->html_element) {
1652 FIXME("non-HTML element\n");
1653 return E_NOTIMPL;
1654 }
1655
1656 nsAString_InitDepend(&html_str, v);
1657 nsres = nsIDOMHTMLElement_SetInnerHTML(This->html_element, &html_str);
1658 nsAString_Finish(&html_str);
1659 if(NS_FAILED(nsres)) {
1660 FIXME("SetInnerHtml failed %08x\n", nsres);
1661 return E_FAIL;
1662 }
1663
1664 return S_OK;
1665 }
1666
1667 static HRESULT WINAPI HTMLElement_get_innerHTML(IHTMLElement *iface, BSTR *p)
1668 {
1669 HTMLElement *This = impl_from_IHTMLElement(iface);
1670 nsAString html_str;
1671 nsresult nsres;
1672
1673 TRACE("(%p)->(%p)\n", This, p);
1674
1675 if(!This->html_element) {
1676 FIXME("non-HTML element\n");
1677 return E_NOTIMPL;
1678 }
1679
1680 nsAString_Init(&html_str, NULL);
1681 nsres = nsIDOMHTMLElement_GetInnerHTML(This->html_element, &html_str);
1682 return return_nsstr(nsres, &html_str, p);
1683 }
1684
1685 static HRESULT WINAPI HTMLElement_put_innerText(IHTMLElement *iface, BSTR v)
1686 {
1687 HTMLElement *This = impl_from_IHTMLElement(iface);
1688 nsIDOMNode *nschild, *tmp;
1689 nsIDOMText *text_node;
1690 nsAString text_str;
1691 nsresult nsres;
1692
1693 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1694
1695 while(1) {
1696 nsres = nsIDOMElement_GetLastChild(This->dom_element, &nschild);
1697 if(NS_FAILED(nsres)) {
1698 ERR("GetLastChild failed: %08x\n", nsres);
1699 return E_FAIL;
1700 }
1701 if(!nschild)
1702 break;
1703
1704 nsres = nsIDOMElement_RemoveChild(This->dom_element, nschild, &tmp);
1705 nsIDOMNode_Release(nschild);
1706 if(NS_FAILED(nsres)) {
1707 ERR("RemoveChild failed: %08x\n", nsres);
1708 return E_FAIL;
1709 }
1710 nsIDOMNode_Release(tmp);
1711 }
1712
1713 nsAString_InitDepend(&text_str, v);
1714 nsres = nsIDOMHTMLDocument_CreateTextNode(This->node.doc->nsdoc, &text_str, &text_node);
1715 nsAString_Finish(&text_str);
1716 if(NS_FAILED(nsres)) {
1717 ERR("CreateTextNode failed: %08x\n", nsres);
1718 return E_FAIL;
1719 }
1720
1721 nsres = nsIDOMElement_AppendChild(This->dom_element, (nsIDOMNode*)text_node, &tmp);
1722 if(NS_FAILED(nsres)) {
1723 ERR("AppendChild failed: %08x\n", nsres);
1724 return E_FAIL;
1725 }
1726
1727 nsIDOMNode_Release(tmp);
1728 return S_OK;
1729 }
1730
1731 static HRESULT WINAPI HTMLElement_get_innerText(IHTMLElement *iface, BSTR *p)
1732 {
1733 HTMLElement *This = impl_from_IHTMLElement(iface);
1734
1735 TRACE("(%p)->(%p)\n", This, p);
1736
1737 return get_node_text(&This->node, p);
1738 }
1739
1740 static HRESULT WINAPI HTMLElement_put_outerHTML(IHTMLElement *iface, BSTR v)
1741 {
1742 HTMLElement *This = impl_from_IHTMLElement(iface);
1743
1744 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1745
1746 return replace_node_by_html(This->node.doc->nsdoc, This->node.nsnode, v);
1747 }
1748
1749 static HRESULT WINAPI HTMLElement_get_outerHTML(IHTMLElement *iface, BSTR *p)
1750 {
1751 HTMLElement *This = impl_from_IHTMLElement(iface);
1752 nsAString html_str;
1753 HRESULT hres;
1754
1755 WARN("(%p)->(%p) semi-stub\n", This, p);
1756
1757 nsAString_Init(&html_str, NULL);
1758 hres = nsnode_to_nsstring(This->node.nsnode, &html_str);
1759 if(SUCCEEDED(hres)) {
1760 const PRUnichar *html;
1761
1762 nsAString_GetData(&html_str, &html);
1763 *p = SysAllocString(html);
1764 if(!*p)
1765 hres = E_OUTOFMEMORY;
1766 }
1767
1768 nsAString_Finish(&html_str);
1769
1770 TRACE("ret %s\n", debugstr_w(*p));
1771 return hres;
1772 }
1773
1774 static HRESULT WINAPI HTMLElement_put_outerText(IHTMLElement *iface, BSTR v)
1775 {
1776 HTMLElement *This = impl_from_IHTMLElement(iface);
1777 nsIDOMText *text_node;
1778 nsIDOMRange *range;
1779 nsAString nsstr;
1780 nsresult nsres;
1781
1782 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1783
1784 if(This->node.vtbl->is_settable && !This->node.vtbl->is_settable(&This->node, DISPID_IHTMLELEMENT_OUTERTEXT)) {
1785 WARN("Called on element that does not support setting the property.\n");
1786 return 0x800a0258; /* undocumented error code */
1787 }
1788
1789 if(!This->node.doc->nsdoc) {
1790 FIXME("NULL nsdoc\n");
1791 return E_FAIL;
1792 }
1793
1794 nsAString_InitDepend(&nsstr, v);
1795 nsres = nsIDOMHTMLDocument_CreateTextNode(This->node.doc->nsdoc, &nsstr, &text_node);
1796 nsAString_Finish(&nsstr);
1797 if(NS_FAILED(nsres)) {
1798 ERR("CreateTextNode failed\n");
1799 return E_FAIL;
1800 }
1801
1802 nsres = nsIDOMHTMLDocument_CreateRange(This->node.doc->nsdoc, &range);
1803 if(NS_SUCCEEDED(nsres)) {
1804 nsres = nsIDOMRange_SelectNode(range, This->node.nsnode);
1805 if(NS_SUCCEEDED(nsres))
1806 nsres = nsIDOMRange_DeleteContents(range);
1807 if(NS_SUCCEEDED(nsres))
1808 nsres = nsIDOMRange_InsertNode(range, (nsIDOMNode*)text_node);
1809 if(NS_SUCCEEDED(nsres))
1810 nsres = nsIDOMRange_SelectNodeContents(range, This->node.nsnode);
1811 if(NS_SUCCEEDED(nsres))
1812 nsres = nsIDOMRange_DeleteContents(range);
1813 nsIDOMRange_Release(range);
1814 }
1815 nsIDOMText_Release(text_node);
1816 if(NS_FAILED(nsres)) {
1817 ERR("failed to set text: %08x\n", nsres);
1818 return E_FAIL;
1819 }
1820
1821 return S_OK;
1822 }
1823
1824 static HRESULT WINAPI HTMLElement_get_outerText(IHTMLElement *iface, BSTR *p)
1825 {
1826 HTMLElement *This = impl_from_IHTMLElement(iface);
1827
1828 TRACE("(%p)->(%p)\n", This, p);
1829
1830 /* getter is the same as innerText */
1831 return IHTMLElement_get_innerText(&This->IHTMLElement_iface, p);
1832 }
1833
1834 static HRESULT insert_adjacent_node(HTMLElement *This, const WCHAR *where, nsIDOMNode *nsnode, HTMLDOMNode **ret_node)
1835 {
1836 nsIDOMNode *ret_nsnode;
1837 nsresult nsres;
1838 HRESULT hres = S_OK;
1839
1840 if (!wcsicmp(where, L"beforebegin")) {
1841 nsIDOMNode *parent;
1842
1843 nsres = nsIDOMNode_GetParentNode(This->node.nsnode, &parent);
1844 if(NS_FAILED(nsres))
1845 return E_FAIL;
1846
1847 if(!parent)
1848 return E_INVALIDARG;
1849
1850 nsres = nsIDOMNode_InsertBefore(parent, nsnode, This->node.nsnode, &ret_nsnode);
1851 nsIDOMNode_Release(parent);
1852 }else if(!wcsicmp(where, L"afterbegin")) {
1853 nsIDOMNode *first_child;
1854
1855 nsres = nsIDOMNode_GetFirstChild(This->node.nsnode, &first_child);
1856 if(NS_FAILED(nsres))
1857 return E_FAIL;
1858
1859 nsres = nsIDOMNode_InsertBefore(This->node.nsnode, nsnode, first_child, &ret_nsnode);
1860 if(NS_FAILED(nsres))
1861 return E_FAIL;
1862
1863 if (first_child)
1864 nsIDOMNode_Release(first_child);
1865 }else if (!wcsicmp(where, L"beforeend")) {
1866 nsres = nsIDOMNode_AppendChild(This->node.nsnode, nsnode, &ret_nsnode);
1867 }else if (!wcsicmp(where, L"afterend")) {
1868 nsIDOMNode *next_sibling, *parent;
1869
1870 nsres = nsIDOMNode_GetParentNode(This->node.nsnode, &parent);
1871 if(NS_FAILED(nsres))
1872 return E_FAIL;
1873 if(!parent)
1874 return E_INVALIDARG;
1875
1876 nsres = nsIDOMNode_GetNextSibling(This->node.nsnode, &next_sibling);
1877 if(NS_SUCCEEDED(nsres)) {
1878 if(next_sibling) {
1879 nsres = nsIDOMNode_InsertBefore(parent, nsnode, next_sibling, &ret_nsnode);
1880 nsIDOMNode_Release(next_sibling);
1881 }else {
1882 nsres = nsIDOMNode_AppendChild(parent, nsnode, &ret_nsnode);
1883 }
1884 }
1885
1886 nsIDOMNode_Release(parent);
1887 }else {
1888 ERR("invalid where: %s\n", debugstr_w(where));
1889 return E_INVALIDARG;
1890 }
1891
1892 if (NS_FAILED(nsres))
1893 return E_FAIL;
1894
1895 if(ret_node)
1896 hres = get_node(ret_nsnode, TRUE, ret_node);
1897 nsIDOMNode_Release(ret_nsnode);
1898 return hres;
1899 }
1900
1901 static HRESULT WINAPI HTMLElement_insertAdjacentHTML(IHTMLElement *iface, BSTR where,
1902 BSTR html)
1903 {
1904 HTMLElement *This = impl_from_IHTMLElement(iface);
1905 nsIDOMRange *range;
1906 nsIDOMNode *nsnode;
1907 nsAString ns_html;
1908 nsresult nsres;
1909 HRESULT hr;
1910
1911 TRACE("(%p)->(%s %s)\n", This, debugstr_w(where), debugstr_w(html));
1912
1913 if(!This->node.doc->nsdoc) {
1914 WARN("NULL nsdoc\n");
1915 return E_UNEXPECTED;
1916 }
1917
1918 nsres = nsIDOMHTMLDocument_CreateRange(This->node.doc->nsdoc, &range);
1919 if(NS_FAILED(nsres))
1920 {
1921 ERR("CreateRange failed: %08x\n", nsres);
1922 return E_FAIL;
1923 }
1924
1925 nsIDOMRange_SetStartBefore(range, This->node.nsnode);
1926
1927 nsAString_InitDepend(&ns_html, html);
1928 nsres = nsIDOMRange_CreateContextualFragment(range, &ns_html, (nsIDOMDocumentFragment **)&nsnode);
1929 nsAString_Finish(&ns_html);
1930 nsIDOMRange_Release(range);
1931
1932 if(NS_FAILED(nsres) || !nsnode)
1933 {
1934 ERR("CreateTextNode failed: %08x\n", nsres);
1935 return E_FAIL;
1936 }
1937
1938 hr = insert_adjacent_node(This, where, nsnode, NULL);
1939 nsIDOMNode_Release(nsnode);
1940 return hr;
1941 }
1942
1943 static HRESULT WINAPI HTMLElement_insertAdjacentText(IHTMLElement *iface, BSTR where,
1944 BSTR text)
1945 {
1946 HTMLElement *This = impl_from_IHTMLElement(iface);
1947 nsIDOMNode *nsnode;
1948 nsAString ns_text;
1949 nsresult nsres;
1950 HRESULT hr;
1951
1952 TRACE("(%p)->(%s %s)\n", This, debugstr_w(where), debugstr_w(text));
1953
1954 if(!This->node.doc->nsdoc) {
1955 WARN("NULL nsdoc\n");
1956 return E_UNEXPECTED;
1957 }
1958
1959
1960 nsAString_InitDepend(&ns_text, text);
1961 nsres = nsIDOMHTMLDocument_CreateTextNode(This->node.doc->nsdoc, &ns_text, (nsIDOMText **)&nsnode);
1962 nsAString_Finish(&ns_text);
1963
1964 if(NS_FAILED(nsres) || !nsnode)
1965 {
1966 ERR("CreateTextNode failed: %08x\n", nsres);
1967 return E_FAIL;
1968 }
1969
1970 hr = insert_adjacent_node(This, where, nsnode, NULL);
1971 nsIDOMNode_Release(nsnode);
1972
1973 return hr;
1974 }
1975
1976 static HRESULT WINAPI HTMLElement_get_parentTextEdit(IHTMLElement *iface, IHTMLElement **p)
1977 {
1978 HTMLElement *This = impl_from_IHTMLElement(iface);
1979 FIXME("(%p)->(%p)\n", This, p);
1980 return E_NOTIMPL;
1981 }
1982
1983 static HRESULT WINAPI HTMLElement_get_isTextEdit(IHTMLElement *iface, VARIANT_BOOL *p)
1984 {
1985 HTMLElement *This = impl_from_IHTMLElement(iface);
1986
1987 TRACE("(%p)->(%p)\n", This, p);
1988
1989 *p = variant_bool(This->node.vtbl->is_text_edit && This->node.vtbl->is_text_edit(&This->node));
1990 return S_OK;
1991 }
1992
1993 static HRESULT WINAPI HTMLElement_click(IHTMLElement *iface)
1994 {
1995 HTMLElement *This = impl_from_IHTMLElement(iface);
1996 nsresult nsres;
1997
1998 TRACE("(%p)\n", This);
1999
2000 if(!This->html_element) {
2001 FIXME("non-HTML element\n");
2002 return E_NOTIMPL;
2003 }
2004
2005 nsres = nsIDOMHTMLElement_Click(This->html_element);
2006 if(NS_FAILED(nsres)) {
2007 ERR("Click failed: %08x\n", nsres);
2008 return E_FAIL;
2009 }
2010
2011 return S_OK;
2012 }
2013
2014 static HRESULT WINAPI HTMLElement_get_filters(IHTMLElement *iface,
2015 IHTMLFiltersCollection **p)
2016 {
2017 HTMLElement *This = impl_from_IHTMLElement(iface);
2018 TRACE("(%p)->(%p)\n", This, p);
2019
2020 if(!p)
2021 return E_POINTER;
2022
2023 *p = HTMLFiltersCollection_Create();
2024
2025 return S_OK;
2026 }
2027
2028 static HRESULT WINAPI HTMLElement_put_ondragstart(IHTMLElement *iface, VARIANT v)
2029 {
2030 HTMLElement *This = impl_from_IHTMLElement(iface);
2031
2032 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2033
2034 return set_node_event(&This->node, EVENTID_DRAGSTART, &v);
2035 }
2036
2037 static HRESULT WINAPI HTMLElement_get_ondragstart(IHTMLElement *iface, VARIANT *p)
2038 {
2039 HTMLElement *This = impl_from_IHTMLElement(iface);
2040
2041 TRACE("(%p)->(%p)\n", This, p);
2042
2043 return get_node_event(&This->node, EVENTID_DRAGSTART, p);
2044 }
2045
2046 static HRESULT WINAPI HTMLElement_toString(IHTMLElement *iface, BSTR *String)
2047 {
2048 HTMLElement *This = impl_from_IHTMLElement(iface);
2049 FIXME("(%p)->(%p)\n", This, String);
2050 return E_NOTIMPL;
2051 }
2052
2053 static HRESULT WINAPI HTMLElement_put_onbeforeupdate(IHTMLElement *iface, VARIANT v)
2054 {
2055 HTMLElement *This = impl_from_IHTMLElement(iface);
2056 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2057 return E_NOTIMPL;
2058 }
2059
2060 static HRESULT WINAPI HTMLElement_get_onbeforeupdate(IHTMLElement *iface, VARIANT *p)
2061 {
2062 HTMLElement *This = impl_from_IHTMLElement(iface);
2063 FIXME("(%p)->(%p)\n", This, p);
2064 return E_NOTIMPL;
2065 }
2066
2067 static HRESULT WINAPI HTMLElement_put_onafterupdate(IHTMLElement *iface, VARIANT v)
2068 {
2069 HTMLElement *This = impl_from_IHTMLElement(iface);
2070 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2071 return E_NOTIMPL;
2072 }
2073
2074 static HRESULT WINAPI HTMLElement_get_onafterupdate(IHTMLElement *iface, VARIANT *p)
2075 {
2076 HTMLElement *This = impl_from_IHTMLElement(iface);
2077 FIXME("(%p)->(%p)\n", This, p);
2078 return E_NOTIMPL;
2079 }
2080
2081 static HRESULT WINAPI HTMLElement_put_onerrorupdate(IHTMLElement *iface, VARIANT v)
2082 {
2083 HTMLElement *This = impl_from_IHTMLElement(iface);
2084 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2085 return E_NOTIMPL;
2086 }
2087
2088 static HRESULT WINAPI HTMLElement_get_onerrorupdate(IHTMLElement *iface, VARIANT *p)
2089 {
2090 HTMLElement *This = impl_from_IHTMLElement(iface);
2091 FIXME("(%p)->(%p)\n", This, p);
2092 return E_NOTIMPL;
2093 }
2094
2095 static HRESULT WINAPI HTMLElement_put_onrowexit(IHTMLElement *iface, VARIANT v)
2096 {
2097 HTMLElement *This = impl_from_IHTMLElement(iface);
2098 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2099 return E_NOTIMPL;
2100 }
2101
2102 static HRESULT WINAPI HTMLElement_get_onrowexit(IHTMLElement *iface, VARIANT *p)
2103 {
2104 HTMLElement *This = impl_from_IHTMLElement(iface);
2105 FIXME("(%p)->(%p)\n", This, p);
2106 return E_NOTIMPL;
2107 }
2108
2109 static HRESULT WINAPI HTMLElement_put_onrowenter(IHTMLElement *iface, VARIANT v)
2110 {
2111 HTMLElement *This = impl_from_IHTMLElement(iface);
2112 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2113 return E_NOTIMPL;
2114 }
2115
2116 static HRESULT WINAPI HTMLElement_get_onrowenter(IHTMLElement *iface, VARIANT *p)
2117 {
2118 HTMLElement *This = impl_from_IHTMLElement(iface);
2119 FIXME("(%p)->(%p)\n", This, p);
2120 return E_NOTIMPL;
2121 }
2122
2123 static HRESULT WINAPI HTMLElement_put_ondatasetchanged(IHTMLElement *iface, VARIANT v)
2124 {
2125 HTMLElement *This = impl_from_IHTMLElement(iface);
2126 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2127 return E_NOTIMPL;
2128 }
2129
2130 static HRESULT WINAPI HTMLElement_get_ondatasetchanged(IHTMLElement *iface, VARIANT *p)
2131 {
2132 HTMLElement *This = impl_from_IHTMLElement(iface);
2133 FIXME("(%p)->(%p)\n", This, p);
2134 return E_NOTIMPL;
2135 }
2136
2137 static HRESULT WINAPI HTMLElement_put_ondataavailable(IHTMLElement *iface, VARIANT v)
2138 {
2139 HTMLElement *This = impl_from_IHTMLElement(iface);
2140
2141 FIXME("(%p)->(%s) semi-stub\n", This, debugstr_variant(&v));
2142
2143 return set_node_event(&This->node, EVENTID_DATAAVAILABLE, &v);
2144 }
2145
2146 static HRESULT WINAPI HTMLElement_get_ondataavailable(IHTMLElement *iface, VARIANT *p)
2147 {
2148 HTMLElement *This = impl_from_IHTMLElement(iface);
2149
2150 TRACE("(%p)->(%p)\n", This, p);
2151
2152 return get_node_event(&This->node, EVENTID_DATAAVAILABLE, p);
2153 }
2154
2155 static HRESULT WINAPI HTMLElement_put_ondatasetcomplete(IHTMLElement *iface, VARIANT v)
2156 {
2157 HTMLElement *This = impl_from_IHTMLElement(iface);
2158 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2159 return E_NOTIMPL;
2160 }
2161
2162 static HRESULT WINAPI HTMLElement_get_ondatasetcomplete(IHTMLElement *iface, VARIANT *p)
2163 {
2164 HTMLElement *This = impl_from_IHTMLElement(iface);
2165 FIXME("(%p)->(%p)\n", This, p);
2166 return E_NOTIMPL;
2167 }
2168
2169 static HRESULT WINAPI HTMLElement_put_onfilterchange(IHTMLElement *iface, VARIANT v)
2170 {
2171 HTMLElement *This = impl_from_IHTMLElement(iface);
2172 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
2173 return E_NOTIMPL;
2174 }
2175
2176 static HRESULT WINAPI HTMLElement_get_onfilterchange(IHTMLElement *iface, VARIANT *p)
2177 {
2178 HTMLElement *This = impl_from_IHTMLElement(iface);
2179 FIXME("(%p)->(%p)\n", This, p);
2180 return E_NOTIMPL;
2181 }
2182
2183 static HRESULT WINAPI HTMLElement_get_children(IHTMLElement *iface, IDispatch **p)
2184 {
2185 HTMLElement *This = impl_from_IHTMLElement(iface);
2186 nsIDOMNodeList *nsnode_list;
2187 nsresult nsres;
2188
2189 TRACE("(%p)->(%p)\n", This, p);
2190
2191 nsres = nsIDOMNode_GetChildNodes(This->node.nsnode, &nsnode_list);
2192 if(NS_FAILED(nsres)) {
2193 ERR("GetChildNodes failed: %08x\n", nsres);
2194 return E_FAIL;
2195 }
2196
2197 *p = (IDispatch*)create_collection_from_nodelist(nsnode_list, This->node.doc->document_mode);
2198
2199 nsIDOMNodeList_Release(nsnode_list);
2200 return S_OK;
2201 }
2202
2203 static HRESULT WINAPI HTMLElement_get_all(IHTMLElement *iface, IDispatch **p)
2204 {
2205 HTMLElement *This = impl_from_IHTMLElement(iface);
2206
2207 TRACE("(%p)->(%p)\n", This, p);
2208
2209 *p = (IDispatch*)create_all_collection(&This->node, FALSE);
2210 return S_OK;
2211 }
2212
2213 static const IHTMLElementVtbl HTMLElementVtbl = {
2214 HTMLElement_QueryInterface,
2215 HTMLElement_AddRef,
2216 HTMLElement_Release,
2217 HTMLElement_GetTypeInfoCount,
2218 HTMLElement_GetTypeInfo,
2219 HTMLElement_GetIDsOfNames,
2220 HTMLElement_Invoke,
2221 HTMLElement_setAttribute,
2222 HTMLElement_getAttribute,
2223 HTMLElement_removeAttribute,
2224 HTMLElement_put_className,
2225 HTMLElement_get_className,
2226 HTMLElement_put_id,
2227 HTMLElement_get_id,
2228 HTMLElement_get_tagName,
2229 HTMLElement_get_parentElement,
2230 HTMLElement_get_style,
2231 HTMLElement_put_onhelp,
2232 HTMLElement_get_onhelp,
2233 HTMLElement_put_onclick,
2234 HTMLElement_get_onclick,
2235 HTMLElement_put_ondblclick,
2236 HTMLElement_get_ondblclick,
2237 HTMLElement_put_onkeydown,
2238 HTMLElement_get_onkeydown,
2239 HTMLElement_put_onkeyup,
2240 HTMLElement_get_onkeyup,
2241 HTMLElement_put_onkeypress,
2242 HTMLElement_get_onkeypress,
2243 HTMLElement_put_onmouseout,
2244 HTMLElement_get_onmouseout,
2245 HTMLElement_put_onmouseover,
2246 HTMLElement_get_onmouseover,
2247 HTMLElement_put_onmousemove,
2248 HTMLElement_get_onmousemove,
2249 HTMLElement_put_onmousedown,
2250 HTMLElement_get_onmousedown,
2251 HTMLElement_put_onmouseup,
2252 HTMLElement_get_onmouseup,
2253 HTMLElement_get_document,
2254 HTMLElement_put_title,
2255 HTMLElement_get_title,
2256 HTMLElement_put_language,
2257 HTMLElement_get_language,
2258 HTMLElement_put_onselectstart,
2259 HTMLElement_get_onselectstart,
2260 HTMLElement_scrollIntoView,
2261 HTMLElement_contains,
2262 HTMLElement_get_sourceIndex,
2263 HTMLElement_get_recordNumber,
2264 HTMLElement_put_lang,
2265 HTMLElement_get_lang,
2266 HTMLElement_get_offsetLeft,
2267 HTMLElement_get_offsetTop,
2268 HTMLElement_get_offsetWidth,
2269 HTMLElement_get_offsetHeight,
2270 HTMLElement_get_offsetParent,
2271 HTMLElement_put_innerHTML,
2272 HTMLElement_get_innerHTML,
2273 HTMLElement_put_innerText,
2274 HTMLElement_get_innerText,
2275 HTMLElement_put_outerHTML,
2276 HTMLElement_get_outerHTML,
2277 HTMLElement_put_outerText,
2278 HTMLElement_get_outerText,
2279 HTMLElement_insertAdjacentHTML,
2280 HTMLElement_insertAdjacentText,
2281 HTMLElement_get_parentTextEdit,
2282 HTMLElement_get_isTextEdit,
2283 HTMLElement_click,
2284 HTMLElement_get_filters,
2285 HTMLElement_put_ondragstart,
2286 HTMLElement_get_ondragstart,
2287 HTMLElement_toString,
2288 HTMLElement_put_onbeforeupdate,
2289 HTMLElement_get_onbeforeupdate,
2290 HTMLElement_put_onafterupdate,
2291 HTMLElement_get_onafterupdate,
2292 HTMLElement_put_onerrorupdate,
2293 HTMLElement_get_onerrorupdate,
2294 HTMLElement_put_onrowexit,
2295 HTMLElement_get_onrowexit,
2296 HTMLElement_put_onrowenter,
2297 HTMLElement_get_onrowenter,
2298 HTMLElement_put_ondatasetchanged,
2299 HTMLElement_get_ondatasetchanged,
2300 HTMLElement_put_ondataavailable,
2301 HTMLElement_get_ondataavailable,
2302 HTMLElement_put_ondatasetcomplete,
2303 HTMLElement_get_ondatasetcomplete,
2304 HTMLElement_put_onfilterchange,
2305 HTMLElement_get_onfilterchange,
2306 HTMLElement_get_children,
2307 HTMLElement_get_all
2308 };
2309
2310 HTMLElement *unsafe_impl_from_IHTMLElement(IHTMLElement *iface)
2311 {
2312 return iface->lpVtbl == &HTMLElementVtbl ? impl_from_IHTMLElement(iface) : NULL;
2313 }
2314
2315 static inline HTMLElement *impl_from_IHTMLElement2(IHTMLElement2 *iface)
2316 {
2317 return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement2_iface);
2318 }
2319
2320 static HRESULT WINAPI HTMLElement2_QueryInterface(IHTMLElement2 *iface,
2321 REFIID riid, void **ppv)
2322 {
2323 HTMLElement *This = impl_from_IHTMLElement2(iface);
2324 return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
2325 }
2326
2327 static ULONG WINAPI HTMLElement2_AddRef(IHTMLElement2 *iface)
2328 {
2329 HTMLElement *This = impl_from_IHTMLElement2(iface);
2330 return IHTMLElement_AddRef(&This->IHTMLElement_iface);
2331 }
2332
2333 static ULONG WINAPI HTMLElement2_Release(IHTMLElement2 *iface)
2334 {
2335 HTMLElement *This = impl_from_IHTMLElement2(iface);
2336 return IHTMLElement_Release(&This->IHTMLElement_iface);
2337 }
2338
2339 static HRESULT WINAPI HTMLElement2_GetTypeInfoCount(IHTMLElement2 *iface, UINT *pctinfo)
2340 {
2341 HTMLElement *This = impl_from_IHTMLElement2(iface);
2342 return IDispatchEx_GetTypeInfoCount(&This->node.event_target.dispex.IDispatchEx_iface, pctinfo);
2343 }
2344
2345 static HRESULT WINAPI HTMLElement2_GetTypeInfo(IHTMLElement2 *iface, UINT iTInfo,
2346 LCID lcid, ITypeInfo **ppTInfo)
2347 {
2348 HTMLElement *This = impl_from_IHTMLElement2(iface);
2349 return IDispatchEx_GetTypeInfo(&This->node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2350 }
2351
2352 static HRESULT WINAPI HTMLElement2_GetIDsOfNames(IHTMLElement2 *iface, REFIID riid,
2353 LPOLESTR *rgszNames, UINT cNames,
2354 LCID lcid, DISPID *rgDispId)
2355 {
2356 HTMLElement *This = impl_from_IHTMLElement2(iface);
2357 return IDispatchEx_GetIDsOfNames(&This->node.event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2358 lcid, rgDispId);
2359 }
2360
2361 static HRESULT WINAPI HTMLElement2_Invoke(IHTMLElement2 *iface, DISPID dispIdMember,
2362 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2363 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2364 {
2365 HTMLElement *This = impl_from_IHTMLElement2(iface);
2366 return IDispatchEx_Invoke(&This->node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
2367 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2368 }
2369
2370 static HRESULT WINAPI HTMLElement2_get_scopeName(IHTMLElement2 *iface, BSTR *p)
2371 {
2372 HTMLElement *This = impl_from_IHTMLElement2(iface);
2373 FIXME("(%p)->(%p)\n", This, p);
2374 return E_NOTIMPL;
2375 }
2376
2377 static HRESULT WINAPI HTMLElement2_setCapture(IHTMLElement2 *iface, VARIANT_BOOL containerCapture)
2378 {
2379 HTMLElement *This = impl_from_IHTMLElement2(iface);
2380 FIXME("(%p)->(%x)\n", This, containerCapture);
2381 return E_NOTIMPL;
2382 }
2383
2384 static HRESULT WINAPI HTMLElement2_releaseCapture(IHTMLElement2 *iface)
2385 {
2386 HTMLElement *This = impl_from_IHTMLElement2(iface);
2387 FIXME("(%p)\n", This);
2388 return E_NOTIMPL;
2389 }
2390
2391 static HRESULT WINAPI HTMLElement2_put_onlosecapture(IHTMLElement2 *iface, VARIANT v)
2392 {
2393 HTMLElement *This = impl_from_IHTMLElement2(iface);
2394 FIXME("(%p)->()\n", This);
2395 return E_NOTIMPL;
2396 }
2397
2398 static HRESULT WINAPI HTMLElement2_get_onlosecapture(IHTMLElement2 *iface, VARIANT *p)
2399 {
2400 HTMLElement *This = impl_from_IHTMLElement2(iface);
2401 FIXME("(%p)->(%p)\n", This, p);
2402 return E_NOTIMPL;
2403 }
2404
2405 static HRESULT WINAPI HTMLElement2_componentFromPoint(IHTMLElement2 *iface,
2406 LONG x, LONG y, BSTR *component)
2407 {
2408 HTMLElement *This = impl_from_IHTMLElement2(iface);
2409 FIXME("(%p)->(%d %d %p)\n", This, x, y, component);
2410 return E_NOTIMPL;
2411 }
2412
2413 static HRESULT WINAPI HTMLElement2_doScroll(IHTMLElement2 *iface, VARIANT component)
2414 {
2415 HTMLElement *This = impl_from_IHTMLElement2(iface);
2416
2417 TRACE("(%p)->(%s)\n", This, debugstr_variant(&component));
2418
2419 if(!This->node.doc->content_ready
2420 || !This->node.doc->basedoc.doc_obj->in_place_active)
2421 return E_PENDING;
2422
2423 WARN("stub\n");
2424 return S_OK;
2425 }
2426
2427 static HRESULT WINAPI HTMLElement2_put_onscroll(IHTMLElement2 *iface, VARIANT v)
2428 {
2429 HTMLElement *This = impl_from_IHTMLElement2(iface);
2430
2431 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2432
2433 return set_node_event(&This->node, EVENTID_SCROLL, &v);
2434 }
2435
2436 static HRESULT WINAPI HTMLElement2_get_onscroll(IHTMLElement2 *iface, VARIANT *p)
2437 {
2438 HTMLElement *This = impl_from_IHTMLElement2(iface);
2439
2440 TRACE("(%p)->(%p)\n", This, p);
2441
2442 return get_node_event(&This->node, EVENTID_SCROLL, p);
2443 }
2444
2445 static HRESULT WINAPI HTMLElement2_put_ondrag(IHTMLElement2 *iface, VARIANT v)
2446 {
2447 HTMLElement *This = impl_from_IHTMLElement2(iface);
2448
2449 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2450
2451 return set_node_event(&This->node, EVENTID_DRAG, &v);
2452 }
2453
2454 static HRESULT WINAPI HTMLElement2_get_ondrag(IHTMLElement2 *iface, VARIANT *p)
2455 {
2456 HTMLElement *This = impl_from_IHTMLElement2(iface);
2457
2458 TRACE("(%p)->(%p)\n", This, p);
2459
2460 return get_node_event(&This->node, EVENTID_DRAG, p);
2461 }
2462
2463 static HRESULT WINAPI HTMLElement2_put_ondragend(IHTMLElement2 *iface, VARIANT v)
2464 {
2465 HTMLElement *This = impl_from_IHTMLElement2(iface);
2466 FIXME("(%p)->()\n", This);
2467 return E_NOTIMPL;
2468 }
2469
2470 static HRESULT WINAPI HTMLElement2_get_ondragend(IHTMLElement2 *iface, VARIANT *p)
2471 {
2472 HTMLElement *This = impl_from_IHTMLElement2(iface);
2473 FIXME("(%p)->(%p)\n", This, p);
2474 return E_NOTIMPL;
2475 }
2476
2477 static HRESULT WINAPI HTMLElement2_put_ondragenter(IHTMLElement2 *iface, VARIANT v)
2478 {
2479 HTMLElement *This = impl_from_IHTMLElement2(iface);
2480 FIXME("(%p)->()\n", This);
2481 return E_NOTIMPL;
2482 }
2483
2484 static HRESULT WINAPI HTMLElement2_get_ondragenter(IHTMLElement2 *iface, VARIANT *p)
2485 {
2486 HTMLElement *This = impl_from_IHTMLElement2(iface);
2487 FIXME("(%p)->(%p)\n", This, p);
2488 return E_NOTIMPL;
2489 }
2490
2491 static HRESULT WINAPI HTMLElement2_put_ondragover(IHTMLElement2 *iface, VARIANT v)
2492 {
2493 HTMLElement *This = impl_from_IHTMLElement2(iface);
2494 FIXME("(%p)->()\n", This);
2495 return E_NOTIMPL;
2496 }
2497
2498 static HRESULT WINAPI HTMLElement2_get_ondragover(IHTMLElement2 *iface, VARIANT *p)
2499 {
2500 HTMLElement *This = impl_from_IHTMLElement2(iface);
2501 FIXME("(%p)->(%p)\n", This, p);
2502 return E_NOTIMPL;
2503 }
2504
2505 static HRESULT WINAPI HTMLElement2_put_ondragleave(IHTMLElement2 *iface, VARIANT v)
2506 {
2507 HTMLElement *This = impl_from_IHTMLElement2(iface);
2508 FIXME("(%p)->()\n", This);
2509 return E_NOTIMPL;
2510 }
2511
2512 static HRESULT WINAPI HTMLElement2_get_ondragleave(IHTMLElement2 *iface, VARIANT *p)
2513 {
2514 HTMLElement *This = impl_from_IHTMLElement2(iface);
2515 FIXME("(%p)->(%p)\n", This, p);
2516 return E_NOTIMPL;
2517 }
2518
2519 static HRESULT WINAPI HTMLElement2_put_ondrop(IHTMLElement2 *iface, VARIANT v)
2520 {
2521 HTMLElement *This = impl_from_IHTMLElement2(iface);
2522 FIXME("(%p)->()\n", This);
2523 return E_NOTIMPL;
2524 }
2525
2526 static HRESULT WINAPI HTMLElement2_get_ondrop(IHTMLElement2 *iface, VARIANT *p)
2527 {
2528 HTMLElement *This = impl_from_IHTMLElement2(iface);
2529 FIXME("(%p)->(%p)\n", This, p);
2530 return E_NOTIMPL;
2531 }
2532
2533 static HRESULT WINAPI HTMLElement2_put_onbeforecut(IHTMLElement2 *iface, VARIANT v)
2534 {
2535 HTMLElement *This = impl_from_IHTMLElement2(iface);
2536 FIXME("(%p)->()\n", This);
2537 return E_NOTIMPL;
2538 }
2539
2540 static HRESULT WINAPI HTMLElement2_get_onbeforecut(IHTMLElement2 *iface, VARIANT *p)
2541 {
2542 HTMLElement *This = impl_from_IHTMLElement2(iface);
2543 FIXME("(%p)->(%p)\n", This, p);
2544 return E_NOTIMPL;
2545 }
2546
2547 static HRESULT WINAPI HTMLElement2_put_oncut(IHTMLElement2 *iface, VARIANT v)
2548 {
2549 HTMLElement *This = impl_from_IHTMLElement2(iface);
2550 FIXME("(%p)->()\n", This);
2551 return E_NOTIMPL;
2552 }
2553
2554 static HRESULT WINAPI HTMLElement2_get_oncut(IHTMLElement2 *iface, VARIANT *p)
2555 {
2556 HTMLElement *This = impl_from_IHTMLElement2(iface);
2557 FIXME("(%p)->(%p)\n", This, p);
2558 return E_NOTIMPL;
2559 }
2560
2561 static HRESULT WINAPI HTMLElement2_put_onbeforecopy(IHTMLElement2 *iface, VARIANT v)
2562 {
2563 HTMLElement *This = impl_from_IHTMLElement2(iface);
2564 FIXME("(%p)->()\n", This);
2565 return E_NOTIMPL;
2566 }
2567
2568 static HRESULT WINAPI HTMLElement2_get_onbeforecopy(IHTMLElement2 *iface, VARIANT *p)
2569 {
2570 HTMLElement *This = impl_from_IHTMLElement2(iface);
2571 FIXME("(%p)->(%p)\n", This, p);
2572 return E_NOTIMPL;
2573 }
2574
2575 static HRESULT WINAPI HTMLElement2_put_oncopy(IHTMLElement2 *iface, VARIANT v)
2576 {
2577 HTMLElement *This = impl_from_IHTMLElement2(iface);
2578 FIXME("(%p)->()\n", This);
2579 return E_NOTIMPL;
2580 }
2581
2582 static HRESULT WINAPI HTMLElement2_get_oncopy(IHTMLElement2 *iface, VARIANT *p)
2583 {
2584 HTMLElement *This = impl_from_IHTMLElement2(iface);
2585 FIXME("(%p)->(%p)\n", This, p);
2586 return E_NOTIMPL;
2587 }
2588
2589 static HRESULT WINAPI HTMLElement2_put_onbeforepaste(IHTMLElement2 *iface, VARIANT v)
2590 {
2591 HTMLElement *This = impl_from_IHTMLElement2(iface);
2592 FIXME("(%p)->()\n", This);
2593 return E_NOTIMPL;
2594 }
2595
2596 static HRESULT WINAPI HTMLElement2_get_onbeforepaste(IHTMLElement2 *iface, VARIANT *p)
2597 {
2598 HTMLElement *This = impl_from_IHTMLElement2(iface);
2599 FIXME("(%p)->(%p)\n", This, p);
2600 return E_NOTIMPL;
2601 }
2602
2603 static HRESULT WINAPI HTMLElement2_put_onpaste(IHTMLElement2 *iface, VARIANT v)
2604 {
2605 HTMLElement *This = impl_from_IHTMLElement2(iface);
2606
2607 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2608
2609 return set_node_event(&This->node, EVENTID_PASTE, &v);
2610 }
2611
2612 static HRESULT WINAPI HTMLElement2_get_onpaste(IHTMLElement2 *iface, VARIANT *p)
2613 {
2614 HTMLElement *This = impl_from_IHTMLElement2(iface);
2615
2616 TRACE("(%p)->(%p)\n", This, p);
2617
2618 return get_node_event(&This->node, EVENTID_PASTE, p);
2619 }
2620
2621 static HRESULT WINAPI HTMLElement2_get_currentStyle(IHTMLElement2 *iface, IHTMLCurrentStyle **p)
2622 {
2623 HTMLElement *This = impl_from_IHTMLElement2(iface);
2624
2625 TRACE("(%p)->(%p)\n", This, p);
2626
2627 return HTMLCurrentStyle_Create(This, p);
2628 }
2629
2630 static HRESULT WINAPI HTMLElement2_put_onpropertychange(IHTMLElement2 *iface, VARIANT v)
2631 {
2632 HTMLElement *This = impl_from_IHTMLElement2(iface);
2633 FIXME("(%p)->()\n", This);
2634 return E_NOTIMPL;
2635 }
2636
2637 static HRESULT WINAPI HTMLElement2_get_onpropertychange(IHTMLElement2 *iface, VARIANT *p)
2638 {
2639 HTMLElement *This = impl_from_IHTMLElement2(iface);
2640 FIXME("(%p)->(%p)\n", This, p);
2641 return E_NOTIMPL;
2642 }
2643
2644 static HRESULT WINAPI HTMLElement2_getClientRects(IHTMLElement2 *iface, IHTMLRectCollection **pRectCol)
2645 {
2646 HTMLElement *This = impl_from_IHTMLElement2(iface);
2647 nsIDOMClientRectList *rect_list;
2648 HTMLRectCollection *rects;
2649 nsresult nsres;
2650
2651 TRACE("(%p)->(%p)\n", This, pRectCol);
2652
2653 if(!This->dom_element) {
2654 FIXME("comment element\n");
2655 return E_NOTIMPL;
2656 }
2657
2658 nsres = nsIDOMElement_GetClientRects(This->dom_element, &rect_list);
2659 if(NS_FAILED(nsres)) {
2660 WARN("GetClientRects failed: %08x\n", nsres);
2661 return map_nsresult(nsres);
2662 }
2663
2664 rects = heap_alloc_zero(sizeof(*rects));
2665 if(!rects) {
2666 nsIDOMClientRectList_Release(rect_list);
2667 return E_OUTOFMEMORY;
2668 }
2669
2670 rects->IHTMLRectCollection_iface.lpVtbl = &HTMLRectCollectionVtbl;
2671 rects->ref = 1;
2672 rects->rect_list = rect_list;
2673 init_dispex_with_compat_mode(&rects->dispex, (IUnknown*)&rects->IHTMLRectCollection_iface,
2674 &HTMLRectCollection_dispex, dispex_compat_mode(&This->node.event_target.dispex));
2675
2676 *pRectCol = &rects->IHTMLRectCollection_iface;
2677 return S_OK;
2678 }
2679
2680 static HRESULT WINAPI HTMLElement2_getBoundingClientRect(IHTMLElement2 *iface, IHTMLRect **pRect)
2681 {
2682 HTMLElement *This = impl_from_IHTMLElement2(iface);
2683 nsIDOMClientRect *nsrect;
2684 nsresult nsres;
2685 HRESULT hres;
2686
2687 TRACE("(%p)->(%p)\n", This, pRect);
2688
2689 if(!This->dom_element) {
2690 FIXME("comment element\n");
2691 return E_NOTIMPL;
2692 }
2693
2694 nsres = nsIDOMElement_GetBoundingClientRect(This->dom_element, &nsrect);
2695 if(NS_FAILED(nsres) || !nsrect) {
2696 ERR("GetBoindingClientRect failed: %08x\n", nsres);
2697 return E_FAIL;
2698 }
2699
2700 hres = create_html_rect(nsrect, dispex_compat_mode(&This->node.event_target.dispex), pRect);
2701
2702 nsIDOMClientRect_Release(nsrect);
2703 return hres;
2704 }
2705
2706 static HRESULT WINAPI HTMLElement2_setExpression(IHTMLElement2 *iface, BSTR propname,
2707 BSTR expression, BSTR language)
2708 {
2709 HTMLElement *This = impl_from_IHTMLElement2(iface);
2710 FIXME("(%p)->(%s %s %s)\n", This, debugstr_w(propname), debugstr_w(expression),
2711 debugstr_w(language));
2712 return E_NOTIMPL;
2713 }
2714
2715 static HRESULT WINAPI HTMLElement2_getExpression(IHTMLElement2 *iface, BSTR propname,
2716 VARIANT *expression)
2717 {
2718 HTMLElement *This = impl_from_IHTMLElement2(iface);
2719 FIXME("(%p)->(%s %p)\n", This, debugstr_w(propname), expression);
2720 return E_NOTIMPL;
2721 }
2722
2723 static HRESULT WINAPI HTMLElement2_removeExpression(IHTMLElement2 *iface, BSTR propname,
2724 VARIANT_BOOL *pfSuccess)
2725 {
2726 HTMLElement *This = impl_from_IHTMLElement2(iface);
2727 FIXME("(%p)->(%s %p)\n", This, debugstr_w(propname), pfSuccess);
2728 return E_NOTIMPL;
2729 }
2730
2731 static HRESULT WINAPI HTMLElement2_put_tabIndex(IHTMLElement2 *iface, short v)
2732 {
2733 HTMLElement *This = impl_from_IHTMLElement2(iface);
2734 nsresult nsres;
2735
2736 TRACE("(%p)->(%d)\n", This, v);
2737
2738 if(!This->html_element) {
2739 FIXME("non-HTML element\n");
2740 return E_NOTIMPL;
2741 }
2742
2743 nsres = nsIDOMHTMLElement_SetTabIndex(This->html_element, v);
2744 if(NS_FAILED(nsres))
2745 ERR("GetTabIndex failed: %08x\n", nsres);
2746
2747 return S_OK;
2748 }
2749
2750 static HRESULT WINAPI HTMLElement2_get_tabIndex(IHTMLElement2 *iface, short *p)
2751 {
2752 HTMLElement *This = impl_from_IHTMLElement2(iface);
2753 LONG index;
2754 nsresult nsres;
2755
2756 TRACE("(%p)->(%p)\n", This, p);
2757
2758 if(!This->html_element) {
2759 FIXME("non-HTML element\n");
2760 return E_NOTIMPL;
2761 }
2762
2763 nsres = nsIDOMHTMLElement_GetTabIndex(This->html_element, &index);
2764 if(NS_FAILED(nsres)) {
2765 ERR("GetTabIndex failed: %08x\n", nsres);
2766 return E_FAIL;
2767 }
2768
2769 *p = index;
2770 return S_OK;
2771 }
2772
2773 static HRESULT WINAPI HTMLElement2_focus(IHTMLElement2 *iface)
2774 {
2775 HTMLElement *This = impl_from_IHTMLElement2(iface);
2776 nsresult nsres;
2777
2778 TRACE("(%p)\n", This);
2779
2780 if(!This->html_element) {
2781 FIXME("non-HTML element\n");
2782 return E_NOTIMPL;
2783 }
2784
2785 nsres = nsIDOMHTMLElement_Focus(This->html_element);
2786 if(NS_FAILED(nsres))
2787 ERR("Focus failed: %08x\n", nsres);
2788
2789 return S_OK;
2790 }
2791
2792 static HRESULT WINAPI HTMLElement2_put_accessKey(IHTMLElement2 *iface, BSTR v)
2793 {
2794 HTMLElement *This = impl_from_IHTMLElement2(iface);
2795 VARIANT var;
2796
2797 static WCHAR accessKeyW[] = L"accessKey";
2798
2799 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2800
2801 V_VT(&var) = VT_BSTR;
2802 V_BSTR(&var) = v;
2803 return IHTMLElement_setAttribute(&This->IHTMLElement_iface, accessKeyW, var, 0);
2804 }
2805
2806 static HRESULT WINAPI HTMLElement2_get_accessKey(IHTMLElement2 *iface, BSTR *p)
2807 {
2808 HTMLElement *This = impl_from_IHTMLElement2(iface);
2809 FIXME("(%p)->(%p)\n", This, p);
2810 return E_NOTIMPL;
2811 }
2812
2813 static HRESULT WINAPI HTMLElement2_put_onblur(IHTMLElement2 *iface, VARIANT v)
2814 {
2815 HTMLElement *This = impl_from_IHTMLElement2(iface);
2816
2817 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2818
2819 return set_node_event(&This->node, EVENTID_BLUR, &v);
2820 }
2821
2822 static HRESULT WINAPI HTMLElement2_get_onblur(IHTMLElement2 *iface, VARIANT *p)
2823 {
2824 HTMLElement *This = impl_from_IHTMLElement2(iface);
2825
2826 TRACE("(%p)->(%p)\n", This, p);
2827
2828 return get_node_event(&This->node, EVENTID_BLUR, p);
2829 }
2830
2831 static HRESULT WINAPI HTMLElement2_put_onfocus(IHTMLElement2 *iface, VARIANT v)
2832 {
2833 HTMLElement *This = impl_from_IHTMLElement2(iface);
2834
2835 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2836
2837 return set_node_event(&This->node, EVENTID_FOCUS, &v);
2838 }
2839
2840 static HRESULT WINAPI HTMLElement2_get_onfocus(IHTMLElement2 *iface, VARIANT *p)
2841 {
2842 HTMLElement *This = impl_from_IHTMLElement2(iface);
2843
2844 TRACE("(%p)->(%p)\n", This, p);
2845
2846 return get_node_event(&This->node, EVENTID_FOCUS, p);
2847 }
2848
2849 static HRESULT WINAPI HTMLElement2_put_onresize(IHTMLElement2 *iface, VARIANT v)
2850 {
2851 HTMLElement *This = impl_from_IHTMLElement2(iface);
2852
2853 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2854
2855 return set_node_event(&This->node, EVENTID_RESIZE, &v);
2856 }
2857
2858 static HRESULT WINAPI HTMLElement2_get_onresize(IHTMLElement2 *iface, VARIANT *p)
2859 {
2860 HTMLElement *This = impl_from_IHTMLElement2(iface);
2861
2862 TRACE("(%p)->(%p)\n", This, p);
2863
2864 return get_node_event(&This->node, EVENTID_RESIZE, p);
2865 }
2866
2867 static HRESULT WINAPI HTMLElement2_blur(IHTMLElement2 *iface)
2868 {
2869 HTMLElement *This = impl_from_IHTMLElement2(iface);
2870 nsresult nsres;
2871
2872 TRACE("(%p)\n", This);
2873
2874 if(!This->html_element) {
2875 FIXME("non-HTML element\n");
2876 return E_NOTIMPL;
2877 }
2878
2879 nsres = nsIDOMHTMLElement_Blur(This->html_element);
2880 if(NS_FAILED(nsres)) {
2881 ERR("Blur failed: %08x\n", nsres);
2882 return E_FAIL;
2883 }
2884
2885 return S_OK;
2886 }
2887
2888 static HRESULT WINAPI HTMLElement2_addFilter(IHTMLElement2 *iface, IUnknown *pUnk)
2889 {
2890 HTMLElement *This = impl_from_IHTMLElement2(iface);
2891 FIXME("(%p)->(%p)\n", This, pUnk);
2892 return E_NOTIMPL;
2893 }
2894
2895 static HRESULT WINAPI HTMLElement2_removeFilter(IHTMLElement2 *iface, IUnknown *pUnk)
2896 {
2897 HTMLElement *This = impl_from_IHTMLElement2(iface);
2898 FIXME("(%p)->(%p)\n", This, pUnk);
2899 return E_NOTIMPL;
2900 }
2901
2902 static HRESULT WINAPI HTMLElement2_get_clientHeight(IHTMLElement2 *iface, LONG *p)
2903 {
2904 HTMLElement *This = impl_from_IHTMLElement2(iface);
2905 nsresult nsres;
2906
2907 TRACE("(%p)->(%p)\n", This, p);
2908
2909 if(!This->dom_element) {
2910 FIXME("Unimplemented for comment element\n");
2911 return E_NOTIMPL;
2912 }
2913
2914 nsres = nsIDOMElement_GetClientHeight(This->dom_element, p);
2915 assert(nsres == NS_OK);
2916 return S_OK;
2917 }
2918
2919 static HRESULT WINAPI HTMLElement2_get_clientWidth(IHTMLElement2 *iface, LONG *p)
2920 {
2921 HTMLElement *This = impl_from_IHTMLElement2(iface);
2922 nsresult nsres;
2923
2924 TRACE("(%p)->(%p)\n", This, p);
2925
2926 if(!This->dom_element) {
2927 FIXME("comment element\n");
2928 return E_NOTIMPL;
2929 }
2930
2931 nsres = nsIDOMElement_GetClientWidth(This->dom_element, p);
2932 assert(nsres == NS_OK);
2933 return S_OK;
2934 }
2935
2936 static HRESULT WINAPI HTMLElement2_get_clientTop(IHTMLElement2 *iface, LONG *p)
2937 {
2938 HTMLElement *This = impl_from_IHTMLElement2(iface);
2939 nsresult nsres;
2940
2941 TRACE("(%p)->(%p)\n", This, p);
2942
2943 if(!This->dom_element) {
2944 FIXME("comment element\n");
2945 return E_NOTIMPL;
2946 }
2947
2948 nsres = nsIDOMElement_GetClientTop(This->dom_element, p);
2949 assert(nsres == NS_OK);
2950
2951 TRACE("*p = %d\n", *p);
2952 return S_OK;
2953 }
2954
2955 static HRESULT WINAPI HTMLElement2_get_clientLeft(IHTMLElement2 *iface, LONG *p)
2956 {
2957 HTMLElement *This = impl_from_IHTMLElement2(iface);
2958 nsresult nsres;
2959
2960 TRACE("(%p)->(%p)\n", This, p);
2961
2962 if(!This->dom_element) {
2963 FIXME("comment element\n");
2964 return E_NOTIMPL;
2965 }
2966
2967 nsres = nsIDOMElement_GetClientLeft(This->dom_element, p);
2968 assert(nsres == NS_OK);
2969
2970 TRACE("*p = %d\n", *p);
2971 return S_OK;
2972 }
2973
2974 static HRESULT WINAPI HTMLElement2_attachEvent(IHTMLElement2 *iface, BSTR event,
2975 IDispatch *pDisp, VARIANT_BOOL *pfResult)
2976 {
2977 HTMLElement *This = impl_from_IHTMLElement2(iface);
2978
2979 TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(event), pDisp, pfResult);
2980
2981 return attach_event(&This->node.event_target, event, pDisp, pfResult);
2982 }
2983
2984 static HRESULT WINAPI HTMLElement2_detachEvent(IHTMLElement2 *iface, BSTR event, IDispatch *pDisp)
2985 {
2986 HTMLElement *This = impl_from_IHTMLElement2(iface);
2987
2988 TRACE("(%p)->(%s %p)\n", This, debugstr_w(event), pDisp);
2989
2990 return detach_event(&This->node.event_target, event, pDisp);
2991 }
2992
2993 static HRESULT WINAPI HTMLElement2_get_readyState(IHTMLElement2 *iface, VARIANT *p)
2994 {
2995 HTMLElement *This = impl_from_IHTMLElement2(iface);
2996 BSTR str;
2997
2998 TRACE("(%p)->(%p)\n", This, p);
2999
3000 if(This->node.vtbl->get_readystate) {
3001 HRESULT hres;
3002
3003 hres = This->node.vtbl->get_readystate(&This->node, &str);
3004 if(FAILED(hres))
3005 return hres;
3006 }else {
3007 str = SysAllocString(L"complete");
3008 if(!str)
3009 return E_OUTOFMEMORY;
3010 }
3011
3012 V_VT(p) = VT_BSTR;
3013 V_BSTR(p) = str;
3014 return S_OK;
3015 }
3016
3017 static HRESULT WINAPI HTMLElement2_put_onreadystatechange(IHTMLElement2 *iface, VARIANT v)
3018 {
3019 HTMLElement *This = impl_from_IHTMLElement2(iface);
3020
3021 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
3022
3023 return set_node_event(&This->node, EVENTID_READYSTATECHANGE, &v);
3024 }
3025
3026 static HRESULT WINAPI HTMLElement2_get_onreadystatechange(IHTMLElement2 *iface, VARIANT *p)
3027 {
3028 HTMLElement *This = impl_from_IHTMLElement2(iface);
3029
3030 TRACE("(%p)->(%p)\n", This, p);
3031
3032 return get_node_event(&This->node, EVENTID_READYSTATECHANGE, p);
3033 }
3034
3035 static HRESULT WINAPI HTMLElement2_put_onrowsdelete(IHTMLElement2 *iface, VARIANT v)
3036 {
3037 HTMLElement *This = impl_from_IHTMLElement2(iface);
3038 FIXME("(%p)->()\n", This);
3039 return E_NOTIMPL;
3040 }
3041
3042 static HRESULT WINAPI HTMLElement2_get_onrowsdelete(IHTMLElement2 *iface, VARIANT *p)
3043 {
3044 HTMLElement *This = impl_from_IHTMLElement2(iface);
3045 FIXME("(%p)->(%p)\n", This, p);
3046 return E_NOTIMPL;
3047 }
3048
3049 static HRESULT WINAPI HTMLElement2_put_onrowsinserted(IHTMLElement2 *iface, VARIANT v)
3050 {
3051 HTMLElement *This = impl_from_IHTMLElement2(iface);
3052 FIXME("(%p)->()\n", This);
3053 return E_NOTIMPL;
3054 }
3055
3056 static HRESULT WINAPI HTMLElement2_get_onrowsinserted(IHTMLElement2 *iface, VARIANT *p)
3057 {
3058 HTMLElement *This = impl_from_IHTMLElement2(iface);
3059 FIXME("(%p)->(%p)\n", This, p);
3060 return E_NOTIMPL;
3061 }
3062
3063 static HRESULT WINAPI HTMLElement2_put_oncellchange(IHTMLElement2 *iface, VARIANT v)
3064 {
3065 HTMLElement *This = impl_from_IHTMLElement2(iface);
3066 FIXME("(%p)->()\n", This);
3067 return E_NOTIMPL;
3068 }
3069
3070 static HRESULT WINAPI HTMLElement2_get_oncellchange(IHTMLElement2 *iface, VARIANT *p)
3071 {
3072 HTMLElement *This = impl_from_IHTMLElement2(iface);
3073 FIXME("(%p)->(%p)\n", This, p);
3074 return E_NOTIMPL;
3075 }
3076
3077 static HRESULT WINAPI HTMLElement2_put_dir(IHTMLElement2 *iface, BSTR v)
3078 {
3079 HTMLElement *This = impl_from_IHTMLElement2(iface);
3080 nsAString nsstr;
3081 nsresult nsres;
3082
3083 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
3084
3085 if(!This->html_element) {
3086 FIXME("non-HTML element\n");
3087 return S_OK;
3088 }
3089
3090 nsAString_InitDepend(&nsstr, v);
3091 nsres = nsIDOMHTMLElement_SetDir(This->html_element, &nsstr);
3092 nsAString_Finish(&nsstr);
3093 if(NS_FAILED(nsres)) {
3094 ERR("SetDir failed: %08x\n", nsres);
3095 return E_FAIL;
3096 }
3097
3098 return S_OK;
3099 }
3100
3101 static HRESULT WINAPI HTMLElement2_get_dir(IHTMLElement2 *iface, BSTR *p)
3102 {
3103 HTMLElement *This = impl_from_IHTMLElement2(iface);
3104 nsAString dir_str;
3105 nsresult nsres;
3106
3107 TRACE("(%p)->(%p)\n", This, p);
3108
3109 if(!This->html_element) {
3110 if(This->dom_element)
3111 FIXME("non-HTML element\n");
3112 *p = NULL;
3113 return S_OK;
3114 }
3115
3116 nsAString_Init(&dir_str, NULL);
3117 nsres = nsIDOMHTMLElement_GetDir(This->html_element, &dir_str);
3118 return return_nsstr(nsres, &dir_str, p);
3119 }
3120
3121 static HRESULT WINAPI HTMLElement2_createControlRange(IHTMLElement2 *iface, IDispatch **range)
3122 {
3123 HTMLElement *This = impl_from_IHTMLElement2(iface);
3124 FIXME("(%p)->(%p)\n", This, range);
3125 return E_NOTIMPL;
3126 }
3127
3128 static HRESULT WINAPI HTMLElement2_get_scrollHeight(IHTMLElement2 *iface, LONG *p)
3129 {
3130 HTMLElement *This = impl_from_IHTMLElement2(iface);
3131 nsresult nsres;
3132
3133 TRACE("(%p)->(%p)\n", This, p);
3134
3135 if(!This->dom_element) {
3136 FIXME("comment element\n");
3137 return E_NOTIMPL;
3138 }
3139
3140 nsres = nsIDOMElement_GetScrollHeight(This->dom_element, p);
3141 assert(nsres == NS_OK);
3142 TRACE("*p = %d\n", *p);
3143 return S_OK;
3144 }
3145
3146 static HRESULT WINAPI HTMLElement2_get_scrollWidth(IHTMLElement2 *iface, LONG *p)
3147 {
3148 HTMLElement *This = impl_from_IHTMLElement2(iface);
3149 nsresult nsres;
3150
3151 TRACE("(%p)->(%p)\n", This, p);
3152
3153 if(!This->dom_element) {
3154 FIXME("comment element\n");
3155 return E_NOTIMPL;
3156 }
3157
3158 nsres = nsIDOMElement_GetScrollWidth(This->dom_element, p);
3159 assert(nsres == NS_OK);
3160
3161 TRACE("*p = %d\n", *p);
3162 return S_OK;
3163 }
3164
3165 static HRESULT WINAPI HTMLElement2_put_scrollTop(IHTMLElement2 *iface, LONG v)
3166 {
3167 HTMLElement *This = impl_from_IHTMLElement2(iface);
3168
3169 TRACE("(%p)->(%d)\n", This, v);
3170
3171 if(!This->dom_element) {
3172 FIXME("comment element\n");
3173 return E_NOTIMPL;
3174 }
3175
3176 nsIDOMElement_SetScrollTop(This->dom_element, v);
3177 return S_OK;
3178 }
3179
3180 static HRESULT WINAPI HTMLElement2_get_scrollTop(IHTMLElement2 *iface, LONG *p)
3181 {
3182 HTMLElement *This = impl_from_IHTMLElement2(iface);
3183 nsresult nsres;
3184
3185 TRACE("(%p)->(%p)\n", This, p);
3186
3187 if(!This->dom_element) {
3188 FIXME("comment element\n");
3189 return E_NOTIMPL;
3190 }
3191
3192 nsres = nsIDOMElement_GetScrollTop(This->dom_element, p);
3193 assert(nsres == NS_OK);
3194
3195 TRACE("*p = %d\n", *p);
3196 return S_OK;
3197 }
3198
3199 static HRESULT WINAPI HTMLElement2_put_scrollLeft(IHTMLElement2 *iface, LONG v)
3200 {
3201 HTMLElement *This = impl_from_IHTMLElement2(iface);
3202
3203 TRACE("(%p)->(%d)\n", This, v);
3204
3205 if(!This->dom_element) {
3206 FIXME("comment element\n");
3207 return E_NOTIMPL;
3208 }
3209
3210 nsIDOMElement_SetScrollLeft(This->dom_element, v);
3211 return S_OK;
3212 }
3213
3214 static HRESULT WINAPI HTMLElement2_get_scrollLeft(IHTMLElement2 *iface, LONG *p)
3215 {
3216 HTMLElement *This = impl_from_IHTMLElement2(iface);
3217 nsresult nsres;
3218
3219 TRACE("(%p)->(%p)\n", This, p);
3220
3221 if(!p)
3222 return E_INVALIDARG;
3223
3224 if(!This->dom_element) {
3225 FIXME("comment element\n");
3226 return E_NOTIMPL;
3227 }
3228
3229 nsres = nsIDOMElement_GetScrollLeft(This->dom_element, p);
3230 assert(nsres == NS_OK);
3231 TRACE("*p = %d\n", *p);
3232 return S_OK;
3233 }
3234
3235 static HRESULT WINAPI HTMLElement2_clearAttributes(IHTMLElement2 *iface)
3236 {
3237 HTMLElement *This = impl_from_IHTMLElement2(iface);
3238 FIXME("(%p)\n", This);
3239 return E_NOTIMPL;
3240 }
3241
3242 static HRESULT WINAPI HTMLElement2_mergeAttributes(IHTMLElement2 *iface, IHTMLElement *mergeThis)
3243 {
3244 HTMLElement *This = impl_from_IHTMLElement2(iface);
3245 FIXME("(%p)->(%p)\n", This, mergeThis);
3246 return E_NOTIMPL;
3247 }
3248
3249 static HRESULT WINAPI HTMLElement2_put_oncontextmenu(IHTMLElement2 *iface, VARIANT v)
3250 {
3251 HTMLElement *This = impl_from_IHTMLElement2(iface);
3252
3253 TRACE("(%p)->()\n", This);
3254
3255 return set_node_event(&This->node, EVENTID_CONTEXTMENU, &v);
3256 }
3257
3258 static HRESULT WINAPI HTMLElement2_get_oncontextmenu(IHTMLElement2 *iface, VARIANT *p)
3259 {
3260 HTMLElement *This = impl_from_IHTMLElement2(iface);
3261
3262 TRACE("(%p)->(%p)\n", This, p);
3263
3264 return get_node_event(&This->node, EVENTID_CONTEXTMENU, p);
3265 }
3266
3267 static HRESULT WINAPI HTMLElement2_insertAdjacentElement(IHTMLElement2 *iface, BSTR where,
3268 IHTMLElement *insertedElement, IHTMLElement **inserted)
3269 {
3270 HTMLElement *This = impl_from_IHTMLElement2(iface);
3271 HTMLDOMNode *ret_node;
3272 HTMLElement *elem;
3273 HRESULT hres;
3274
3275 TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(where), insertedElement, inserted);
3276
3277 elem = unsafe_impl_from_IHTMLElement(insertedElement);
3278 if(!elem)
3279 return E_INVALIDARG;
3280
3281 hres = insert_adjacent_node(This, where, elem->node.nsnode, &ret_node);
3282 if(FAILED(hres))
3283 return hres;
3284
3285 hres = IHTMLDOMNode_QueryInterface(&ret_node->IHTMLDOMNode_iface, &IID_IHTMLElement, (void**)inserted);
3286 IHTMLDOMNode_Release(&ret_node->IHTMLDOMNode_iface);
3287 return hres;
3288 }
3289
3290 static HRESULT WINAPI HTMLElement2_applyElement(IHTMLElement2 *iface, IHTMLElement *apply,
3291 BSTR where, IHTMLElement **applied)
3292 {
3293 HTMLElement *This = impl_from_IHTMLElement2(iface);
3294 FIXME("(%p)->(%p %s %p)\n", This, apply, debugstr_w(where), applied);
3295 return E_NOTIMPL;
3296 }
3297
3298 static HRESULT WINAPI HTMLElement2_getAdjacentText(IHTMLElement2 *iface, BSTR where, BSTR *text)
3299 {
3300 HTMLElement *This = impl_from_IHTMLElement2(iface);
3301 FIXME("(%p)->(%s %p)\n", This, debugstr_w(where), text);
3302 return E_NOTIMPL;
3303 }
3304
3305 static HRESULT WINAPI HTMLElement2_replaceAdjacentText(IHTMLElement2 *iface, BSTR where,
3306 BSTR newText, BSTR *oldText)
3307 {
3308 HTMLElement *This = impl_from_IHTMLElement2(iface);
3309 FIXME("(%p)->(%s %s %p)\n", This, debugstr_w(where), debugstr_w(newText), oldText);
3310 return E_NOTIMPL;
3311 }
3312
3313 static HRESULT WINAPI HTMLElement2_get_canHandleChildren(IHTMLElement2 *iface, VARIANT_BOOL *p)
3314 {
3315 HTMLElement *This = impl_from_IHTMLElement2(iface);
3316 FIXME("(%p)->(%p)\n", This, p);
3317 return E_NOTIMPL;
3318 }
3319
3320 static HRESULT WINAPI HTMLElement2_addBehavior(IHTMLElement2 *iface, BSTR bstrUrl,
3321 VARIANT *pvarFactory, LONG *pCookie)
3322 {
3323 HTMLElement *This = impl_from_IHTMLElement2(iface);
3324 FIXME("(%p)->(%s %p %p)\n", This, debugstr_w(bstrUrl), pvarFactory, pCookie);
3325 return E_NOTIMPL;
3326 }
3327
3328 static HRESULT WINAPI HTMLElement2_removeBehavior(IHTMLElement2 *iface, LONG cookie,
3329 VARIANT_BOOL *pfResult)
3330 {
3331 HTMLElement *This = impl_from_IHTMLElement2(iface);
3332 FIXME("(%p)->(%d %p)\n", This, cookie, pfResult);
3333 return E_NOTIMPL;
3334 }
3335
3336 static HRESULT WINAPI HTMLElement2_get_runtimeStyle(IHTMLElement2 *iface, IHTMLStyle **p)
3337 {
3338 HTMLElement *This = impl_from_IHTMLElement2(iface);
3339
3340 FIXME("(%p)->(%p): hack\n", This, p);
3341
3342 /* We can't implement correct behavior on top of Gecko (although we could
3343 try a bit harder). Making runtimeStyle behave like regular style is
3344 enough for most use cases. */
3345 if(!This->runtime_style) {
3346 HRESULT hres;
3347
3348 hres = HTMLStyle_Create(This, &This->runtime_style);
3349 if(FAILED(hres))
3350 return hres;
3351 }
3352
3353 *p = &This->runtime_style->IHTMLStyle_iface;
3354 IHTMLStyle_AddRef(*p);
3355 return S_OK;
3356 }
3357
3358 static HRESULT WINAPI HTMLElement2_get_behaviorUrns(IHTMLElement2 *iface, IDispatch **p)
3359 {
3360 HTMLElement *This = impl_from_IHTMLElement2(iface);
3361 FIXME("(%p)->(%p)\n", This, p);
3362 return E_NOTIMPL;
3363 }
3364
3365 static HRESULT WINAPI HTMLElement2_put_tagUrn(IHTMLElement2 *iface, BSTR v)
3366 {
3367 HTMLElement *This = impl_from_IHTMLElement2(iface);
3368 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
3369 return E_NOTIMPL;
3370 }
3371
3372 static HRESULT WINAPI HTMLElement2_get_tagUrn(IHTMLElement2 *iface, BSTR *p)
3373 {
3374 HTMLElement *This = impl_from_IHTMLElement2(iface);
3375 FIXME("(%p)->(%p)\n", This, p);
3376 return E_NOTIMPL;
3377 }
3378
3379 static HRESULT WINAPI HTMLElement2_put_onbeforeeditfocus(IHTMLElement2 *iface, VARIANT vv)
3380 {
3381 HTMLElement *This = impl_from_IHTMLElement2(iface);
3382 FIXME("(%p)->()\n", This);
3383 return E_NOTIMPL;
3384 }
3385
3386 static HRESULT WINAPI HTMLElement2_get_onbeforeeditfocus(IHTMLElement2 *iface, VARIANT *p)
3387 {
3388 HTMLElement *This = impl_from_IHTMLElement2(iface);
3389 FIXME("(%p)->(%p)\n", This, p);
3390 return E_NOTIMPL;
3391 }
3392
3393 static HRESULT WINAPI HTMLElement2_get_readyStateValue(IHTMLElement2 *iface, LONG *p)
3394 {
3395 HTMLElement *This = impl_from_IHTMLElement2(iface);
3396 FIXME("(%p)->(%p)\n", This, p);
3397 return E_NOTIMPL;
3398 }
3399
3400 static HRESULT WINAPI HTMLElement2_getElementsByTagName(IHTMLElement2 *iface, BSTR v,
3401 IHTMLElementCollection **pelColl)
3402 {
3403 HTMLElement *This = impl_from_IHTMLElement2(iface);
3404 nsIDOMHTMLCollection *nscol;
3405 nsAString tag_str;
3406 nsresult nsres;
3407
3408 TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pelColl);
3409
3410 if(!This->dom_element) {
3411 *pelColl = create_collection_from_htmlcol(NULL, This->node.doc->document_mode);
3412 return S_OK;
3413 }
3414
3415 nsAString_InitDepend(&tag_str, v);
3416 nsres = nsIDOMElement_GetElementsByTagName(This->dom_element, &tag_str, &nscol);
3417 nsAString_Finish(&tag_str);
3418 if(NS_FAILED(nsres)) {
3419 ERR("GetElementByTagName failed: %08x\n", nsres);
3420 return E_FAIL;
3421 }
3422
3423 *pelColl = create_collection_from_htmlcol(nscol, dispex_compat_mode(&This->node.event_target.dispex));
3424 nsIDOMHTMLCollection_Release(nscol);
3425 return S_OK;
3426 }
3427
3428 static const IHTMLElement2Vtbl HTMLElement2Vtbl = {
3429 HTMLElement2_QueryInterface,
3430 HTMLElement2_AddRef,
3431 HTMLElement2_Release,
3432 HTMLElement2_GetTypeInfoCount,
3433 HTMLElement2_GetTypeInfo,
3434 HTMLElement2_GetIDsOfNames,
3435 HTMLElement2_Invoke,
3436 HTMLElement2_get_scopeName,
3437 HTMLElement2_setCapture,
3438 HTMLElement2_releaseCapture,
3439 HTMLElement2_put_onlosecapture,
3440 HTMLElement2_get_onlosecapture,
3441 HTMLElement2_componentFromPoint,
3442 HTMLElement2_doScroll,
3443 HTMLElement2_put_onscroll,
3444 HTMLElement2_get_onscroll,
3445 HTMLElement2_put_ondrag,
3446 HTMLElement2_get_ondrag,
3447 HTMLElement2_put_ondragend,
3448 HTMLElement2_get_ondragend,
3449 HTMLElement2_put_ondragenter,
3450 HTMLElement2_get_ondragenter,
3451 HTMLElement2_put_ondragover,
3452 HTMLElement2_get_ondragover,
3453 HTMLElement2_put_ondragleave,
3454 HTMLElement2_get_ondragleave,
3455 HTMLElement2_put_ondrop,
3456 HTMLElement2_get_ondrop,
3457 HTMLElement2_put_onbeforecut,
3458 HTMLElement2_get_onbeforecut,
3459 HTMLElement2_put_oncut,
3460 HTMLElement2_get_oncut,
3461 HTMLElement2_put_onbeforecopy,
3462 HTMLElement2_get_onbeforecopy,
3463 HTMLElement2_put_oncopy,
3464 HTMLElement2_get_oncopy,
3465 HTMLElement2_put_onbeforepaste,
3466 HTMLElement2_get_onbeforepaste,
3467 HTMLElement2_put_onpaste,
3468 HTMLElement2_get_onpaste,
3469 HTMLElement2_get_currentStyle,
3470 HTMLElement2_put_onpropertychange,
3471 HTMLElement2_get_onpropertychange,
3472 HTMLElement2_getClientRects,
3473 HTMLElement2_getBoundingClientRect,
3474 HTMLElement2_setExpression,
3475 HTMLElement2_getExpression,
3476 HTMLElement2_removeExpression,
3477 HTMLElement2_put_tabIndex,
3478 HTMLElement2_get_tabIndex,
3479 HTMLElement2_focus,
3480 HTMLElement2_put_accessKey,
3481 HTMLElement2_get_accessKey,
3482 HTMLElement2_put_onblur,
3483 HTMLElement2_get_onblur,
3484 HTMLElement2_put_onfocus,
3485 HTMLElement2_get_onfocus,
3486 HTMLElement2_put_onresize,
3487 HTMLElement2_get_onresize,
3488 HTMLElement2_blur,
3489 HTMLElement2_addFilter,
3490 HTMLElement2_removeFilter,
3491 HTMLElement2_get_clientHeight,
3492 HTMLElement2_get_clientWidth,
3493 HTMLElement2_get_clientTop,
3494 HTMLElement2_get_clientLeft,
3495 HTMLElement2_attachEvent,
3496 HTMLElement2_detachEvent,
3497 HTMLElement2_get_readyState,
3498 HTMLElement2_put_onreadystatechange,
3499 HTMLElement2_get_onreadystatechange,
3500 HTMLElement2_put_onrowsdelete,
3501 HTMLElement2_get_onrowsdelete,
3502 HTMLElement2_put_onrowsinserted,
3503 HTMLElement2_get_onrowsinserted,
3504 HTMLElement2_put_oncellchange,
3505 HTMLElement2_get_oncellchange,
3506 HTMLElement2_put_dir,
3507 HTMLElement2_get_dir,
3508 HTMLElement2_createControlRange,
3509 HTMLElement2_get_scrollHeight,
3510 HTMLElement2_get_scrollWidth,
3511 HTMLElement2_put_scrollTop,
3512 HTMLElement2_get_scrollTop,
3513 HTMLElement2_put_scrollLeft,
3514 HTMLElement2_get_scrollLeft,
3515 HTMLElement2_clearAttributes,
3516 HTMLElement2_mergeAttributes,
3517 HTMLElement2_put_oncontextmenu,
3518 HTMLElement2_get_oncontextmenu,
3519 HTMLElement2_insertAdjacentElement,
3520 HTMLElement2_applyElement,
3521 HTMLElement2_getAdjacentText,
3522 HTMLElement2_replaceAdjacentText,
3523 HTMLElement2_get_canHandleChildren,
3524 HTMLElement2_addBehavior,
3525 HTMLElement2_removeBehavior,
3526 HTMLElement2_get_runtimeStyle,
3527 HTMLElement2_get_behaviorUrns,
3528 HTMLElement2_put_tagUrn,
3529 HTMLElement2_get_tagUrn,
3530 HTMLElement2_put_onbeforeeditfocus,
3531 HTMLElement2_get_onbeforeeditfocus,
3532 HTMLElement2_get_readyStateValue,
3533 HTMLElement2_getElementsByTagName,
3534 };
3535
3536 static inline HTMLElement *impl_from_IHTMLElement3(IHTMLElement3 *iface)
3537 {
3538 return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement3_iface);
3539 }
3540
3541 static HRESULT WINAPI HTMLElement3_QueryInterface(IHTMLElement3 *iface,
3542 REFIID riid, void **ppv)
3543 {
3544 HTMLElement *This = impl_from_IHTMLElement3(iface);
3545 return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
3546 }
3547
3548 static ULONG WINAPI HTMLElement3_AddRef(IHTMLElement3 *iface)
3549 {
3550 HTMLElement *This = impl_from_IHTMLElement3(iface);
3551 return IHTMLElement_AddRef(&This->IHTMLElement_iface);
3552 }
3553
3554 static ULONG WINAPI HTMLElement3_Release(IHTMLElement3 *iface)
3555 {
3556 HTMLElement *This = impl_from_IHTMLElement3(iface);
3557 return IHTMLElement_Release(&This->IHTMLElement_iface);
3558 }
3559
3560 static HRESULT WINAPI HTMLElement3_GetTypeInfoCount(IHTMLElement3 *iface, UINT *pctinfo)
3561 {
3562 HTMLElement *This = impl_from_IHTMLElement3(iface);
3563 return IDispatchEx_GetTypeInfoCount(&This->node.event_target.dispex.IDispatchEx_iface, pctinfo);
3564 }
3565
3566 static HRESULT WINAPI HTMLElement3_GetTypeInfo(IHTMLElement3 *iface, UINT iTInfo,
3567 LCID lcid, ITypeInfo **ppTInfo)
3568 {
3569 HTMLElement *This = impl_from_IHTMLElement3(iface);
3570 return IDispatchEx_GetTypeInfo(&This->node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
3571 }
3572
3573 static HRESULT WINAPI HTMLElement3_GetIDsOfNames(IHTMLElement3 *iface, REFIID riid,
3574 LPOLESTR *rgszNames, UINT cNames,
3575 LCID lcid, DISPID *rgDispId)
3576 {
3577 HTMLElement *This = impl_from_IHTMLElement3(iface);
3578 return IDispatchEx_GetIDsOfNames(&This->node.event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
3579 lcid, rgDispId);
3580 }
3581
3582 static HRESULT WINAPI HTMLElement3_Invoke(IHTMLElement3 *iface, DISPID dispIdMember,
3583 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
3584 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3585 {
3586 HTMLElement *This = impl_from_IHTMLElement3(iface);
3587 return IDispatchEx_Invoke(&This->node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
3588 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3589 }
3590
3591 static HRESULT WINAPI HTMLElement3_mergeAttributes(IHTMLElement3 *iface, IHTMLElement *mergeThis, VARIANT *pvarFlags)
3592 {
3593 HTMLElement *This = impl_from_IHTMLElement3(iface);
3594 FIXME("(%p)->(%p %p)\n", This, mergeThis, pvarFlags);
3595 return E_NOTIMPL;
3596 }
3597
3598 static HRESULT WINAPI HTMLElement3_get_isMultiLine(IHTMLElement3 *iface, VARIANT_BOOL *p)
3599 {
3600 HTMLElement *This = impl_from_IHTMLElement3(iface);
3601 FIXME("(%p)->(%p)\n", This, p);
3602 return E_NOTIMPL;
3603 }
3604
3605 static HRESULT WINAPI HTMLElement3_get_canHaveHTML(IHTMLElement3 *iface, VARIANT_BOOL *p)
3606 {
3607 HTMLElement *This = impl_from_IHTMLElement3(iface);
3608 FIXME("(%p)->(%p)\n", This, p);
3609 return E_NOTIMPL;
3610 }
3611
3612 static HRESULT WINAPI HTMLElement3_put_onlayoutcomplete(IHTMLElement3 *iface, VARIANT v)
3613 {
3614 HTMLElement *This = impl_from_IHTMLElement3(iface);
3615 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3616 return E_NOTIMPL;
3617 }
3618
3619 static HRESULT WINAPI HTMLElement3_get_onlayoutcomplete(IHTMLElement3 *iface, VARIANT *p)
3620 {
3621 HTMLElement *This = impl_from_IHTMLElement3(iface);
3622 FIXME("(%p)->(%p)\n", This, p);
3623 return E_NOTIMPL;
3624 }
3625
3626 static HRESULT WINAPI HTMLElement3_put_onpage(IHTMLElement3 *iface, VARIANT v)
3627 {
3628 HTMLElement *This = impl_from_IHTMLElement3(iface);
3629 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3630 return E_NOTIMPL;
3631 }
3632
3633 static HRESULT WINAPI HTMLElement3_get_onpage(IHTMLElement3 *iface, VARIANT *p)
3634 {
3635 HTMLElement *This = impl_from_IHTMLElement3(iface);
3636 FIXME("(%p)->(%p)\n", This, p);
3637 return E_NOTIMPL;
3638 }
3639
3640 static HRESULT WINAPI HTMLElement3_put_inflateBlock(IHTMLElement3 *iface, VARIANT_BOOL v)
3641 {
3642 HTMLElement *This = impl_from_IHTMLElement3(iface);
3643 FIXME("(%p)->(%x)\n", This, v);
3644 return E_NOTIMPL;
3645 }
3646
3647 static HRESULT WINAPI HTMLElement3_get_inflateBlock(IHTMLElement3 *iface, VARIANT_BOOL *p)
3648 {
3649 HTMLElement *This = impl_from_IHTMLElement3(iface);
3650 FIXME("(%p)->(%p)\n", This, p);
3651 return E_NOTIMPL;
3652 }
3653
3654 static HRESULT WINAPI HTMLElement3_put_onbeforedeactivate(IHTMLElement3 *iface, VARIANT v)
3655 {
3656 HTMLElement *This = impl_from_IHTMLElement3(iface);
3657 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3658 return E_NOTIMPL;
3659 }
3660
3661 static HRESULT WINAPI HTMLElement3_get_onbeforedeactivate(IHTMLElement3 *iface, VARIANT *p)
3662 {
3663 HTMLElement *This = impl_from_IHTMLElement3(iface);
3664 FIXME("(%p)->(%p)\n", This, p);
3665 return E_NOTIMPL;
3666 }
3667
3668 static HRESULT WINAPI HTMLElement3_setActive(IHTMLElement3 *iface)
3669 {
3670 HTMLElement *This = impl_from_IHTMLElement3(iface);
3671 FIXME("(%p)\n", This);
3672 return E_NOTIMPL;
3673 }
3674
3675 static HRESULT WINAPI HTMLElement3_put_contentEditable(IHTMLElement3 *iface, BSTR v)
3676 {
3677 HTMLElement *This = impl_from_IHTMLElement3(iface);
3678 nsresult nsres;
3679 nsAString str;
3680
3681 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
3682
3683 if(!This->html_element) {
3684 FIXME("non-HTML element\n");
3685 return E_NOTIMPL;
3686 }
3687
3688 nsAString_InitDepend(&str, v);
3689 nsres = nsIDOMHTMLElement_SetContentEditable(This->html_element, &str);
3690 nsAString_Finish(&str);
3691
3692 if (NS_FAILED(nsres)){
3693 ERR("SetContentEditable(%s) failed!\n", debugstr_w(v));
3694 return E_FAIL;
3695 }
3696
3697 return S_OK;
3698 }
3699
3700 static HRESULT WINAPI HTMLElement3_get_contentEditable(IHTMLElement3 *iface, BSTR *p)
3701 {
3702 HTMLElement *This = impl_from_IHTMLElement3(iface);
3703 nsresult nsres;
3704 nsAString str;
3705
3706 TRACE("(%p)->(%p)\n", This, p);
3707
3708 if(!This->html_element) {
3709 FIXME("non-HTML element\n");
3710 return E_NOTIMPL;
3711 }
3712
3713 nsAString_Init(&str, NULL);
3714 nsres = nsIDOMHTMLElement_GetContentEditable(This->html_element, &str);
3715 return return_nsstr(nsres, &str, p);
3716 }
3717
3718 static HRESULT WINAPI HTMLElement3_get_isContentEditable(IHTMLElement3 *iface, VARIANT_BOOL *p)
3719 {
3720 HTMLElement *This = impl_from_IHTMLElement3(iface);
3721 FIXME("(%p)->(%p)\n", This, p);
3722 return E_NOTIMPL;
3723 }
3724
3725 static HRESULT WINAPI HTMLElement3_put_hideFocus(IHTMLElement3 *iface, VARIANT_BOOL v)
3726 {
3727 HTMLElement *This = impl_from_IHTMLElement3(iface);
3728 FIXME("(%p)->(%x)\n", This, v);
3729 return E_NOTIMPL;
3730 }
3731
3732 static HRESULT WINAPI HTMLElement3_get_hideFocus(IHTMLElement3 *iface, VARIANT_BOOL *p)
3733 {
3734 HTMLElement *This = impl_from_IHTMLElement3(iface);
3735 FIXME("(%p)->(%p)\n", This, p);
3736 return E_NOTIMPL;
3737 }
3738
3739 static HRESULT WINAPI HTMLElement3_put_disabled(IHTMLElement3 *iface, VARIANT_BOOL v)
3740 {
3741 HTMLElement *This = impl_from_IHTMLElement3(iface);
3742 VARIANT *var;
3743 HRESULT hres;
3744
3745 TRACE("(%p)->(%x)\n", This, v);
3746
3747 if(This->node.vtbl->put_disabled)
3748 return This->node.vtbl->put_disabled(&This->node, v);
3749
3750 hres = dispex_get_dprop_ref(&This->node.event_target.dispex, L"disabled", TRUE, &var);
3751 if(FAILED(hres))
3752 return hres;
3753
3754 VariantClear(var);
3755 V_VT(var) = VT_BOOL;
3756 V_BOOL(var) = v;
3757 return S_OK;
3758 }
3759
3760 static HRESULT WINAPI HTMLElement3_get_disabled(IHTMLElement3 *iface, VARIANT_BOOL *p)
3761 {
3762 HTMLElement *This = impl_from_IHTMLElement3(iface);
3763 VARIANT *var;
3764 HRESULT hres;
3765
3766 TRACE("(%p)->(%p)\n", This, p);
3767
3768 if(This->node.vtbl->get_disabled)
3769 return This->node.vtbl->get_disabled(&This->node, p);
3770
3771 hres = dispex_get_dprop_ref(&This->node.event_target.dispex, L"disabled", FALSE, &var);
3772 if(hres == DISP_E_UNKNOWNNAME) {
3773 *p = VARIANT_FALSE;
3774 return S_OK;
3775 }
3776 if(FAILED(hres))
3777 return hres;
3778
3779 if(V_VT(var) != VT_BOOL) {
3780 FIXME("value is %s\n", debugstr_variant(var));
3781 return E_NOTIMPL;
3782 }
3783
3784 *p = V_BOOL(var);
3785 return S_OK;
3786 }
3787
3788 static HRESULT WINAPI HTMLElement3_get_isDisabled(IHTMLElement3 *iface, VARIANT_BOOL *p)
3789 {
3790 HTMLElement *This = impl_from_IHTMLElement3(iface);
3791 FIXME("(%p)->(%p)\n", This, p);
3792 return E_NOTIMPL;
3793 }
3794
3795 static HRESULT WINAPI HTMLElement3_put_onmove(IHTMLElement3 *iface, VARIANT v)
3796 {
3797 HTMLElement *This = impl_from_IHTMLElement3(iface);
3798 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3799 return E_NOTIMPL;
3800 }
3801
3802 static HRESULT WINAPI HTMLElement3_get_onmove(IHTMLElement3 *iface, VARIANT *p)
3803 {
3804 HTMLElement *This = impl_from_IHTMLElement3(iface);
3805 FIXME("(%p)->(%p)\n", This, p);
3806 return E_NOTIMPL;
3807 }
3808
3809 static HRESULT WINAPI HTMLElement3_put_oncontrolselect(IHTMLElement3 *iface, VARIANT v)
3810 {
3811 HTMLElement *This = impl_from_IHTMLElement3(iface);
3812 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3813 return E_NOTIMPL;
3814 }
3815
3816 static HRESULT WINAPI HTMLElement3_get_oncontrolselect(IHTMLElement3 *iface, VARIANT *p)
3817 {
3818 HTMLElement *This = impl_from_IHTMLElement3(iface);
3819 FIXME("(%p)->(%p)\n", This, p);
3820 return E_NOTIMPL;
3821 }
3822
3823 static HRESULT WINAPI HTMLElement3_fireEvent(IHTMLElement3 *iface, BSTR bstrEventName,
3824 VARIANT *pvarEventObject, VARIANT_BOOL *pfCancelled)
3825 {
3826 HTMLElement *This = impl_from_IHTMLElement3(iface);
3827
3828 TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(bstrEventName), debugstr_variant(pvarEventObject),
3829 pfCancelled);
3830
3831 return fire_event(&This->node, bstrEventName, pvarEventObject, pfCancelled);
3832 }
3833
3834 static HRESULT WINAPI HTMLElement3_put_onresizestart(IHTMLElement3 *iface, VARIANT v)
3835 {
3836 HTMLElement *This = impl_from_IHTMLElement3(iface);
3837 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3838 return E_NOTIMPL;
3839 }
3840
3841 static HRESULT WINAPI HTMLElement3_get_onresizestart(IHTMLElement3 *iface, VARIANT *p)
3842 {
3843 HTMLElement *This = impl_from_IHTMLElement3(iface);
3844 FIXME("(%p)->(%p)\n", This, p);
3845 return E_NOTIMPL;
3846 }
3847
3848 static HRESULT WINAPI HTMLElement3_put_onresizeend(IHTMLElement3 *iface, VARIANT v)
3849 {
3850 HTMLElement *This = impl_from_IHTMLElement3(iface);
3851 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3852 return E_NOTIMPL;
3853 }
3854
3855 static HRESULT WINAPI HTMLElement3_get_onresizeend(IHTMLElement3 *iface, VARIANT *p)
3856 {
3857 HTMLElement *This = impl_from_IHTMLElement3(iface);
3858 FIXME("(%p)->(%p)\n", This, p);
3859 return E_NOTIMPL;
3860 }
3861
3862 static HRESULT WINAPI HTMLElement3_put_onmovestart(IHTMLElement3 *iface, VARIANT v)
3863 {
3864 HTMLElement *This = impl_from_IHTMLElement3(iface);
3865 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3866 return E_NOTIMPL;
3867 }
3868
3869 static HRESULT WINAPI HTMLElement3_get_onmovestart(IHTMLElement3 *iface, VARIANT *p)
3870 {
3871 HTMLElement *This = impl_from_IHTMLElement3(iface);
3872 FIXME("(%p)->(%p)\n", This, p);
3873 return E_NOTIMPL;
3874 }
3875
3876 static HRESULT WINAPI HTMLElement3_put_onmoveend(IHTMLElement3 *iface, VARIANT v)
3877 {
3878 HTMLElement *This = impl_from_IHTMLElement3(iface);
3879 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3880 return E_NOTIMPL;
3881 }
3882
3883 static HRESULT WINAPI HTMLElement3_get_onmoveend(IHTMLElement3 *iface, VARIANT *p)
3884 {
3885 HTMLElement *This = impl_from_IHTMLElement3(iface);
3886 FIXME("(%p)->(%p)\n", This, p);
3887 return E_NOTIMPL;
3888 }
3889
3890 static HRESULT WINAPI HTMLElement3_put_onmousecenter(IHTMLElement3 *iface, VARIANT v)
3891 {
3892 HTMLElement *This = impl_from_IHTMLElement3(iface);
3893 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3894 return E_NOTIMPL;
3895 }
3896
3897 static HRESULT WINAPI HTMLElement3_get_onmousecenter(IHTMLElement3 *iface, VARIANT *p)
3898 {
3899 HTMLElement *This = impl_from_IHTMLElement3(iface);
3900 FIXME("(%p)->(%p)\n", This, p);
3901 return E_NOTIMPL;
3902 }
3903
3904 static HRESULT WINAPI HTMLElement3_put_onmouseleave(IHTMLElement3 *iface, VARIANT v)
3905 {
3906 HTMLElement *This = impl_from_IHTMLElement3(iface);
3907 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3908 return E_NOTIMPL;
3909 }
3910
3911 static HRESULT WINAPI HTMLElement3_get_onmouseleave(IHTMLElement3 *iface, VARIANT *p)
3912 {
3913 HTMLElement *This = impl_from_IHTMLElement3(iface);
3914 FIXME("(%p)->(%p)\n", This, p);
3915 return E_NOTIMPL;
3916 }
3917
3918 static HRESULT WINAPI HTMLElement3_put_onactivate(IHTMLElement3 *iface, VARIANT v)
3919 {
3920 HTMLElement *This = impl_from_IHTMLElement3(iface);
3921 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3922 return E_NOTIMPL;
3923 }
3924
3925 static HRESULT WINAPI HTMLElement3_get_onactivate(IHTMLElement3 *iface, VARIANT *p)
3926 {
3927 HTMLElement *This = impl_from_IHTMLElement3(iface);
3928 FIXME("(%p)->(%p)\n", This, p);
3929 return E_NOTIMPL;
3930 }
3931
3932 static HRESULT WINAPI HTMLElement3_put_ondeactivate(IHTMLElement3 *iface, VARIANT v)
3933 {
3934 HTMLElement *This = impl_from_IHTMLElement3(iface);
3935 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3936 return E_NOTIMPL;
3937 }
3938
3939 static HRESULT WINAPI HTMLElement3_get_ondeactivate(IHTMLElement3 *iface, VARIANT *p)
3940 {
3941 HTMLElement *This = impl_from_IHTMLElement3(iface);
3942 FIXME("(%p)->(%p)\n", This, p);
3943 return E_NOTIMPL;
3944 }
3945
3946 static HRESULT WINAPI HTMLElement3_dragDrop(IHTMLElement3 *iface, VARIANT_BOOL *pfRet)
3947 {
3948 HTMLElement *This = impl_from_IHTMLElement3(iface);
3949 FIXME("(%p)->(%p)\n", This, pfRet);
3950 return E_NOTIMPL;
3951 }
3952
3953 static HRESULT WINAPI HTMLElement3_get_glyphMode(IHTMLElement3 *iface, LONG *p)
3954 {
3955 HTMLElement *This = impl_from_IHTMLElement3(iface);
3956 FIXME("(%p)->(%p)\n", This, p);
3957 return E_NOTIMPL;
3958 }
3959
3960 static const IHTMLElement3Vtbl HTMLElement3Vtbl = {
3961 HTMLElement3_QueryInterface,
3962 HTMLElement3_AddRef,
3963 HTMLElement3_Release,
3964 HTMLElement3_GetTypeInfoCount,
3965 HTMLElement3_GetTypeInfo,
3966 HTMLElement3_GetIDsOfNames,
3967 HTMLElement3_Invoke,
3968 HTMLElement3_mergeAttributes,
3969 HTMLElement3_get_isMultiLine,
3970 HTMLElement3_get_canHaveHTML,
3971 HTMLElement3_put_onlayoutcomplete,
3972 HTMLElement3_get_onlayoutcomplete,
3973 HTMLElement3_put_onpage,
3974 HTMLElement3_get_onpage,
3975 HTMLElement3_put_inflateBlock,
3976 HTMLElement3_get_inflateBlock,
3977 HTMLElement3_put_onbeforedeactivate,
3978 HTMLElement3_get_onbeforedeactivate,
3979 HTMLElement3_setActive,
3980 HTMLElement3_put_contentEditable,
3981 HTMLElement3_get_contentEditable,
3982 HTMLElement3_get_isContentEditable,
3983 HTMLElement3_put_hideFocus,
3984 HTMLElement3_get_hideFocus,
3985 HTMLElement3_put_disabled,
3986 HTMLElement3_get_disabled,
3987 HTMLElement3_get_isDisabled,
3988 HTMLElement3_put_onmove,
3989 HTMLElement3_get_onmove,
3990 HTMLElement3_put_oncontrolselect,
3991 HTMLElement3_get_oncontrolselect,
3992 HTMLElement3_fireEvent,
3993 HTMLElement3_put_onresizestart,
3994 HTMLElement3_get_onresizestart,
3995 HTMLElement3_put_onresizeend,
3996 HTMLElement3_get_onresizeend,
3997 HTMLElement3_put_onmovestart,
3998 HTMLElement3_get_onmovestart,
3999 HTMLElement3_put_onmoveend,
4000 HTMLElement3_get_onmoveend,
4001 HTMLElement3_put_onmousecenter,
4002 HTMLElement3_get_onmousecenter,
4003 HTMLElement3_put_onmouseleave,
4004 HTMLElement3_get_onmouseleave,
4005 HTMLElement3_put_onactivate,
4006 HTMLElement3_get_onactivate,
4007 HTMLElement3_put_ondeactivate,
4008 HTMLElement3_get_ondeactivate,
4009 HTMLElement3_dragDrop,
4010 HTMLElement3_get_glyphMode
4011 };
4012
4013 static inline HTMLElement *impl_from_IHTMLElement4(IHTMLElement4 *iface)
4014 {
4015 return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement4_iface);
4016 }
4017
4018 static HRESULT WINAPI HTMLElement4_QueryInterface(IHTMLElement4 *iface,
4019 REFIID riid, void **ppv)
4020 {
4021 HTMLElement *This = impl_from_IHTMLElement4(iface);
4022 return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
4023 }
4024
4025 static ULONG WINAPI HTMLElement4_AddRef(IHTMLElement4 *iface)
4026 {
4027 HTMLElement *This = impl_from_IHTMLElement4(iface);
4028 return IHTMLElement_AddRef(&This->IHTMLElement_iface);
4029 }
4030
4031 static ULONG WINAPI HTMLElement4_Release(IHTMLElement4 *iface)
4032 {
4033 HTMLElement *This = impl_from_IHTMLElement4(iface);
4034 return IHTMLElement_Release(&This->IHTMLElement_iface);
4035 }
4036
4037 static HRESULT WINAPI HTMLElement4_GetTypeInfoCount(IHTMLElement4 *iface, UINT *pctinfo)
4038 {
4039 HTMLElement *This = impl_from_IHTMLElement4(iface);
4040 return IDispatchEx_GetTypeInfoCount(&This->node.event_target.dispex.IDispatchEx_iface, pctinfo);
4041 }
4042
4043 static HRESULT WINAPI HTMLElement4_GetTypeInfo(IHTMLElement4 *iface, UINT iTInfo,
4044 LCID lcid, ITypeInfo **ppTInfo)
4045 {
4046 HTMLElement *This = impl_from_IHTMLElement4(iface);
4047 return IDispatchEx_GetTypeInfo(&This->node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4048 }
4049
4050 static HRESULT WINAPI HTMLElement4_GetIDsOfNames(IHTMLElement4 *iface, REFIID riid,
4051 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4052 {
4053 HTMLElement *This = impl_from_IHTMLElement4(iface);
4054 return IDispatchEx_GetIDsOfNames(&This->node.event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
4055 lcid, rgDispId);
4056 }
4057
4058 static HRESULT WINAPI HTMLElement4_Invoke(IHTMLElement4 *iface, DISPID dispIdMember, REFIID riid,
4059 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4060 {
4061 HTMLElement *This = impl_from_IHTMLElement4(iface);
4062 return IDispatchEx_Invoke(&This->node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
4063 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4064 }
4065
4066 static HRESULT WINAPI HTMLElement4_put_onmousewheel(IHTMLElement4 *iface, VARIANT v)
4067 {
4068 HTMLElement *This = impl_from_IHTMLElement4(iface);
4069
4070 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4071
4072 return set_node_event(&This->node, EVENTID_MOUSEWHEEL, &v);
4073 }
4074
4075 static HRESULT WINAPI HTMLElement4_get_onmousewheel(IHTMLElement4 *iface, VARIANT *p)
4076 {
4077 HTMLElement *This = impl_from_IHTMLElement4(iface);
4078
4079 TRACE("(%p)->(%p)\n", This, p);
4080
4081 return get_node_event(&This->node, EVENTID_MOUSEWHEEL, p);
4082 }
4083
4084 static HRESULT WINAPI HTMLElement4_normalize(IHTMLElement4 *iface)
4085 {
4086 HTMLElement *This = impl_from_IHTMLElement4(iface);
4087 FIXME("(%p)\n", This);
4088 return E_NOTIMPL;
4089 }
4090
4091 static HRESULT WINAPI HTMLElement4_getAttributeNode(IHTMLElement4 *iface, BSTR bstrname, IHTMLDOMAttribute **ppAttribute)
4092 {
4093 HTMLElement *This = impl_from_IHTMLElement4(iface);
4094 HTMLAttributeCollection *attrs;
4095 HRESULT hres;
4096
4097 TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrname), ppAttribute);
4098
4099 hres = HTMLElement_get_attr_col(&This->node, &attrs);
4100 if(FAILED(hres))
4101 return hres;
4102
4103 hres = IHTMLAttributeCollection2_getNamedItem(&attrs->IHTMLAttributeCollection2_iface, bstrname, ppAttribute);
4104 IHTMLAttributeCollection_Release(&attrs->IHTMLAttributeCollection_iface);
4105 return hres;
4106 }
4107
4108 static HRESULT WINAPI HTMLElement4_setAttributeNode(IHTMLElement4 *iface, IHTMLDOMAttribute *pattr,
4109 IHTMLDOMAttribute **ppretAttribute)
4110 {
4111 HTMLElement *This = impl_from_IHTMLElement4(iface);
4112 HTMLDOMAttribute *attr, *iter, *replace = NULL;
4113 HTMLAttributeCollection *attrs;
4114 DISPID dispid;
4115 HRESULT hres;
4116
4117 TRACE("(%p)->(%p %p)\n", This, pattr, ppretAttribute);
4118
4119 attr = unsafe_impl_from_IHTMLDOMAttribute(pattr);
4120 if(!attr)
4121 return E_INVALIDARG;
4122
4123 if(attr->elem) {
4124 WARN("Tried to set already attached attribute.\n");
4125 return E_INVALIDARG;
4126 }
4127
4128 hres = IDispatchEx_GetDispID(&This->node.event_target.dispex.IDispatchEx_iface,
4129 attr->name, fdexNameCaseInsensitive|fdexNameEnsure, &dispid);
4130 if(FAILED(hres))
4131 return hres;
4132
4133 hres = HTMLElement_get_attr_col(&This->node, &attrs);
4134 if(FAILED(hres))
4135 return hres;
4136
4137 LIST_FOR_EACH_ENTRY(iter, &attrs->attrs, HTMLDOMAttribute, entry) {
4138 if(iter->dispid == dispid) {
4139 replace = iter;
4140 break;
4141 }
4142 }
4143
4144 if(replace) {
4145 hres = get_elem_attr_value_by_dispid(This, dispid, &replace->value);
4146 if(FAILED(hres)) {
4147 WARN("could not get attr value: %08x\n", hres);
4148 V_VT(&replace->value) = VT_EMPTY;
4149 }
4150 if(!replace->name) {
4151 replace->name = attr->name;
4152 attr->name = NULL;
4153 }
4154 list_add_head(&replace->entry, &attr->entry);
4155 list_remove(&replace->entry);
4156 replace->elem = NULL;
4157 }else {
4158 list_add_tail(&attrs->attrs, &attr->entry);
4159 }
4160
4161 IHTMLDOMAttribute_AddRef(&attr->IHTMLDOMAttribute_iface);
4162 attr->elem = This;
4163 attr->dispid = dispid;
4164
4165 IHTMLAttributeCollection_Release(&attrs->IHTMLAttributeCollection_iface);
4166
4167 hres = set_elem_attr_value_by_dispid(This, dispid, &attr->value);
4168 if(FAILED(hres))
4169 WARN("Could not set attribute value: %08x\n", hres);
4170 VariantClear(&attr->value);
4171
4172 *ppretAttribute = replace ? &replace->IHTMLDOMAttribute_iface : NULL;
4173 return S_OK;
4174 }
4175
4176 static HRESULT WINAPI HTMLElement4_removeAttributeNode(IHTMLElement4 *iface, IHTMLDOMAttribute *pattr,
4177 IHTMLDOMAttribute **ppretAttribute)
4178 {
4179 HTMLElement *This = impl_from_IHTMLElement4(iface);
4180 FIXME("(%p)->(%p %p)\n", This, pattr, ppretAttribute);
4181 return E_NOTIMPL;
4182 }
4183
4184 static HRESULT WINAPI HTMLElement4_put_onbeforeactivate(IHTMLElement4 *iface, VARIANT v)
4185 {
4186 HTMLElement *This = impl_from_IHTMLElement4(iface);
4187
4188 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4189
4190 return set_node_event(&This->node, EVENTID_BEFOREACTIVATE, &v);
4191 }
4192
4193 static HRESULT WINAPI HTMLElement4_get_onbeforeactivate(IHTMLElement4 *iface, VARIANT *p)
4194 {
4195 HTMLElement *This = impl_from_IHTMLElement4(iface);
4196
4197 TRACE("(%p)->(%p)\n", This, p);
4198
4199 return get_node_event(&This->node, EVENTID_BEFOREACTIVATE, p);
4200 }
4201
4202 static HRESULT WINAPI HTMLElement4_put_onfocusin(IHTMLElement4 *iface, VARIANT v)
4203 {
4204 HTMLElement *This = impl_from_IHTMLElement4(iface);
4205
4206 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4207
4208 return set_node_event(&This->node, EVENTID_FOCUSIN, &v);
4209 }
4210
4211 static HRESULT WINAPI HTMLElement4_get_onfocusin(IHTMLElement4 *iface, VARIANT *p)
4212 {
4213 HTMLElement *This = impl_from_IHTMLElement4(iface);
4214
4215 TRACE("(%p)->(%p)\n", This, p);
4216
4217 return get_node_event(&This->node, EVENTID_FOCUSIN, p);
4218 }
4219
4220 static HRESULT WINAPI HTMLElement4_put_onfocusout(IHTMLElement4 *iface, VARIANT v)
4221 {
4222 HTMLElement *This = impl_from_IHTMLElement4(iface);
4223
4224 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4225
4226 return set_node_event(&This->node, EVENTID_FOCUSOUT, &v);
4227 }
4228
4229 static HRESULT WINAPI HTMLElement4_get_onfocusout(IHTMLElement4 *iface, VARIANT *p)
4230 {
4231 HTMLElement *This = impl_from_IHTMLElement4(iface);
4232
4233 TRACE("(%p)->(%p)\n", This, p);
4234
4235 return get_node_event(&This->node, EVENTID_FOCUSOUT, p);
4236 }
4237
4238 static const IHTMLElement4Vtbl HTMLElement4Vtbl = {
4239 HTMLElement4_QueryInterface,
4240 HTMLElement4_AddRef,
4241 HTMLElement4_Release,
4242 HTMLElement4_GetTypeInfoCount,
4243 HTMLElement4_GetTypeInfo,
4244 HTMLElement4_GetIDsOfNames,
4245 HTMLElement4_Invoke,
4246 HTMLElement4_put_onmousewheel,
4247 HTMLElement4_get_onmousewheel,
4248 HTMLElement4_normalize,
4249 HTMLElement4_getAttributeNode,
4250 HTMLElement4_setAttributeNode,
4251 HTMLElement4_removeAttributeNode,
4252 HTMLElement4_put_onbeforeactivate,
4253 HTMLElement4_get_onbeforeactivate,
4254 HTMLElement4_put_onfocusin,
4255 HTMLElement4_get_onfocusin,
4256 HTMLElement4_put_onfocusout,
4257 HTMLElement4_get_onfocusout
4258 };
4259
4260 static inline HTMLElement *impl_from_IHTMLElement6(IHTMLElement6 *iface)
4261 {
4262 return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement6_iface);
4263 }
4264
4265 static HRESULT WINAPI HTMLElement6_QueryInterface(IHTMLElement6 *iface,
4266 REFIID riid, void **ppv)
4267 {
4268 HTMLElement *This = impl_from_IHTMLElement6(iface);
4269 return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
4270 }
4271
4272 static ULONG WINAPI HTMLElement6_AddRef(IHTMLElement6 *iface)
4273 {
4274 HTMLElement *This = impl_from_IHTMLElement6(iface);
4275 return IHTMLElement_AddRef(&This->IHTMLElement_iface);
4276 }
4277
4278 static ULONG WINAPI HTMLElement6_Release(IHTMLElement6 *iface)
4279 {
4280 HTMLElement *This = impl_from_IHTMLElement6(iface);
4281 return IHTMLElement_Release(&This->IHTMLElement_iface);
4282 }
4283
4284 static HRESULT WINAPI HTMLElement6_GetTypeInfoCount(IHTMLElement6 *iface, UINT *pctinfo)
4285 {
4286 HTMLElement *This = impl_from_IHTMLElement6(iface);
4287 return IDispatchEx_GetTypeInfoCount(&This->node.event_target.dispex.IDispatchEx_iface, pctinfo);
4288 }
4289
4290 static HRESULT WINAPI HTMLElement6_GetTypeInfo(IHTMLElement6 *iface, UINT iTInfo,
4291 LCID lcid, ITypeInfo **ppTInfo)
4292 {
4293 HTMLElement *This = impl_from_IHTMLElement6(iface);
4294 return IDispatchEx_GetTypeInfo(&This->node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4295 }
4296
4297 static HRESULT WINAPI HTMLElement6_GetIDsOfNames(IHTMLElement6 *iface, REFIID riid,
4298 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4299 {
4300 HTMLElement *This = impl_from_IHTMLElement6(iface);
4301 return IDispatchEx_GetIDsOfNames(&This->node.event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
4302 lcid, rgDispId);
4303 }
4304
4305 static HRESULT WINAPI HTMLElement6_Invoke(IHTMLElement6 *iface, DISPID dispIdMember, REFIID riid,
4306 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4307 {
4308 HTMLElement *This = impl_from_IHTMLElement6(iface);
4309 return IDispatchEx_Invoke(&This->node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
4310 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4311 }
4312
4313 static HRESULT WINAPI HTMLElement6_getAttributeNS(IHTMLElement6 *iface, VARIANT *pvarNS, BSTR strAttributeName, VARIANT *AttributeValue)
4314 {
4315 HTMLElement *This = impl_from_IHTMLElement6(iface);
4316 FIXME("(%p)->(%s %s %p)\n", This, debugstr_variant(pvarNS), debugstr_w(strAttributeName), AttributeValue);
4317 return E_NOTIMPL;
4318 }
4319
4320 static HRESULT WINAPI HTMLElement6_setAttributeNS(IHTMLElement6 *iface, VARIANT *pvarNS, BSTR strAttributeName, VARIANT *pvarAttributeValue)
4321 {
4322 HTMLElement *This = impl_from_IHTMLElement6(iface);
4323 FIXME("(%p)->(%s %s %s)\n", This, debugstr_variant(pvarNS), debugstr_w(strAttributeName), debugstr_variant(pvarAttributeValue));
4324 return E_NOTIMPL;
4325 }
4326
4327 static HRESULT WINAPI HTMLElement6_removeAttributeNS(IHTMLElement6 *iface, VARIANT *pvarNS, BSTR strAttributeName)
4328 {
4329 HTMLElement *This = impl_from_IHTMLElement6(iface);
4330 FIXME("(%p)->(%s %s)\n", This, debugstr_variant(pvarNS), debugstr_w(strAttributeName));
4331 return E_NOTIMPL;
4332 }
4333
4334 static HRESULT WINAPI HTMLElement6_getAttributeNodeNS(IHTMLElement6 *iface, VARIANT *pvarNS, BSTR name, IHTMLDOMAttribute2 **ppretAttribute)
4335 {
4336 HTMLElement *This = impl_from_IHTMLElement6(iface);
4337 FIXME("(%p)->(%s %s %p)\n", This, debugstr_variant(pvarNS), debugstr_w(name), ppretAttribute);
4338 return E_NOTIMPL;
4339 }
4340
4341 static HRESULT WINAPI HTMLElement6_setAttributeNodeNS(IHTMLElement6 *iface, IHTMLDOMAttribute2 *pattr, IHTMLDOMAttribute2 **ppretAttribute)
4342 {
4343 HTMLElement *This = impl_from_IHTMLElement6(iface);
4344 FIXME("(%p)->(%p %p)\n", This, pattr, ppretAttribute);
4345 return E_NOTIMPL;
4346 }
4347
4348 static HRESULT WINAPI HTMLElement6_hasAttributeNS(IHTMLElement6 *iface, VARIANT *pvarNS, BSTR name, VARIANT_BOOL *pfHasAttribute)
4349 {
4350 HTMLElement *This = impl_from_IHTMLElement6(iface);
4351 FIXME("(%p)->(%s %s %p)\n", This, debugstr_variant(pvarNS), debugstr_w(name), pfHasAttribute);
4352 return E_NOTIMPL;
4353 }
4354
4355 static HRESULT WINAPI HTMLElement6_getAttribute(IHTMLElement6 *iface, BSTR strAttributeName, VARIANT *AttributeValue)
4356 {
4357 HTMLElement *This = impl_from_IHTMLElement6(iface);
4358
4359 WARN("(%p)->(%s %p) forwarding to IHTMLElement\n", This, debugstr_w(strAttributeName), AttributeValue);
4360
4361 return IHTMLElement_getAttribute(&This->IHTMLElement_iface, strAttributeName, 0, AttributeValue);
4362 }
4363
4364 static HRESULT WINAPI HTMLElement6_setAttribute(IHTMLElement6 *iface, BSTR strAttributeName, VARIANT *pvarAttributeValue)
4365 {
4366 HTMLElement *This = impl_from_IHTMLElement6(iface);
4367
4368 WARN("(%p)->(%s %p) forwarding to IHTMLElement\n", This, debugstr_w(strAttributeName), pvarAttributeValue);
4369
4370 return IHTMLElement_setAttribute(&This->IHTMLElement_iface, strAttributeName, *pvarAttributeValue, 0);
4371 }
4372
4373 static HRESULT WINAPI HTMLElement6_removeAttribute(IHTMLElement6 *iface, BSTR strAttributeName)
4374 {
4375 HTMLElement *This = impl_from_IHTMLElement6(iface);
4376 VARIANT_BOOL success;
4377
4378 WARN("(%p)->(%s) forwarding to IHTMLElement\n", This, debugstr_w(strAttributeName));
4379
4380 return IHTMLElement_removeAttribute(&This->IHTMLElement_iface, strAttributeName, 0, &success);
4381 }
4382
4383 static HRESULT WINAPI HTMLElement6_getAttributeNode(IHTMLElement6 *iface, BSTR strAttributeName, IHTMLDOMAttribute2 **ppretAttribute)
4384 {
4385 HTMLElement *This = impl_from_IHTMLElement6(iface);
4386 IHTMLDOMAttribute *attr;
4387 HRESULT hres;
4388
4389 WARN("(%p)->(%s %p) forwarding to IHTMLElement4\n", This, debugstr_w(strAttributeName), ppretAttribute);
4390
4391 hres = IHTMLElement4_getAttributeNode(&This->IHTMLElement4_iface, strAttributeName, &attr);
4392 if(FAILED(hres))
4393 return hres;
4394
4395 if(attr) {
4396 hres = IHTMLDOMAttribute_QueryInterface(attr, &IID_IHTMLDOMAttribute2, (void**)ppretAttribute);
4397 IHTMLDOMAttribute_Release(attr);
4398 }else {
4399 *ppretAttribute = NULL;
4400 }
4401 return hres;
4402 }
4403
4404 static HRESULT WINAPI HTMLElement6_setAttributeNode(IHTMLElement6 *iface, IHTMLDOMAttribute2 *pattr, IHTMLDOMAttribute2 **ppretAttribute)
4405 {
4406 HTMLElement *This = impl_from_IHTMLElement6(iface);
4407 IHTMLDOMAttribute *attr, *ret_attr;
4408 HRESULT hres;
4409
4410 WARN("(%p)->(%p %p) forwarding to IHTMLElement4\n", This, pattr, ppretAttribute);
4411
4412 hres = IHTMLDOMAttribute2_QueryInterface(pattr, &IID_IHTMLDOMAttribute, (void**)&attr);
4413 if(FAILED(hres))
4414 return hres;
4415
4416 hres = IHTMLElement4_setAttributeNode(&This->IHTMLElement4_iface, attr, &ret_attr);
4417 if(FAILED(hres))
4418 return hres;
4419
4420 if(ret_attr) {
4421 hres = IHTMLDOMAttribute_QueryInterface(ret_attr, &IID_IHTMLDOMAttribute2, (void**)ppretAttribute);
4422 IHTMLDOMAttribute_Release(ret_attr);
4423 }else {
4424 *ppretAttribute = NULL;
4425 }
4426 return hres;
4427 }
4428
4429 static HRESULT WINAPI HTMLElement6_removeAttributeNode(IHTMLElement6 *iface, IHTMLDOMAttribute2 *pattr, IHTMLDOMAttribute2 **ppretAttribute)
4430 {
4431 HTMLElement *This = impl_from_IHTMLElement6(iface);
4432 FIXME("(%p)->()\n", This);
4433 return E_NOTIMPL;
4434 }
4435
4436 static HRESULT WINAPI HTMLElement6_hasAttribute(IHTMLElement6 *iface, BSTR name, VARIANT_BOOL *pfHasAttribute)
4437 {
4438 HTMLElement *This = impl_from_IHTMLElement6(iface);
4439 FIXME("(%p)->(%s %p)\n", This, debugstr_w(name), pfHasAttribute);
4440 return E_NOTIMPL;
4441 }
4442
4443 static HRESULT WINAPI HTMLElement6_getElementsByTagNameNS(IHTMLElement6 *iface, VARIANT *varNS, BSTR bstrLocalName, IHTMLElementCollection **pelColl)
4444 {
4445 HTMLElement *This = impl_from_IHTMLElement6(iface);
4446 FIXME("(%p)->(%s %s %p)\n", This, debugstr_variant(varNS), debugstr_w(bstrLocalName), pelColl);
4447 return E_NOTIMPL;
4448 }
4449
4450 static HRESULT WINAPI HTMLElement6_get_tagName(IHTMLElement6 *iface, BSTR *p)
4451 {
4452 HTMLElement *This = impl_from_IHTMLElement6(iface);
4453
4454 TRACE("(%p)->(%p)\n", This, p);
4455
4456 return IHTMLElement_get_tagName(&This->IHTMLElement_iface, p);
4457 }
4458
4459 static HRESULT WINAPI HTMLElement6_get_nodeName(IHTMLElement6 *iface, BSTR *p)
4460 {
4461 HTMLElement *This = impl_from_IHTMLElement6(iface);
4462
4463 TRACE("(%p)->(%p)\n", This, p);
4464
4465 return IHTMLDOMNode_get_nodeName(&This->node.IHTMLDOMNode_iface, p);
4466 }
4467
4468 static HRESULT WINAPI HTMLElement6_getElementsByClassName(IHTMLElement6 *iface, BSTR v, IHTMLElementCollection **pel)
4469 {
4470 HTMLElement *This = impl_from_IHTMLElement6(iface);
4471 nsIDOMHTMLCollection *nscol = NULL;
4472 nsAString nsstr;
4473 nsresult nsres;
4474
4475 TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pel);
4476
4477 if(This->dom_element) {
4478 nsAString_InitDepend(&nsstr, v);
4479 nsres = nsIDOMElement_GetElementsByClassName(This->dom_element, &nsstr, &nscol);
4480 nsAString_Finish(&nsstr);
4481 if(NS_FAILED(nsres)) {
4482 ERR("GetElementsByClassName failed: %08x\n", nsres);
4483 return E_FAIL;
4484 }
4485 }
4486
4487 *pel = create_collection_from_htmlcol(nscol, dispex_compat_mode(&This->node.event_target.dispex));
4488 nsIDOMHTMLCollection_Release(nscol);
4489 return S_OK;
4490 }
4491
4492 static HRESULT WINAPI HTMLElement6_msMatchesSelector(IHTMLElement6 *iface, BSTR v, VARIANT_BOOL *pfMatches)
4493 {
4494 HTMLElement *This = impl_from_IHTMLElement6(iface);
4495 nsAString nsstr;
4496 cpp_bool b;
4497 nsresult nsres;
4498
4499 TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pfMatches);
4500
4501 if(!This->dom_element) {
4502 FIXME("No dom element\n");
4503 return E_UNEXPECTED;
4504 }
4505
4506 nsAString_InitDepend(&nsstr, v);
4507 nsres = nsIDOMElement_MozMatchesSelector(This->dom_element, &nsstr, &b);
4508 nsAString_Finish(&nsstr);
4509 if(NS_FAILED(nsres)) {
4510 WARN("MozMatchesSelector failed: %08x\n", nsres);
4511 return map_nsresult(nsres);
4512 }
4513
4514 *pfMatches = b;
4515 return S_OK;
4516 }
4517
4518 static HRESULT WINAPI HTMLElement6_put_onabort(IHTMLElement6 *iface, VARIANT v)
4519 {
4520 HTMLElement *This = impl_from_IHTMLElement6(iface);
4521
4522 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4523
4524 return set_node_event(&This->node, EVENTID_ABORT, &v);
4525 }
4526
4527 static HRESULT WINAPI HTMLElement6_get_onabort(IHTMLElement6 *iface, VARIANT *p)
4528 {
4529 HTMLElement *This = impl_from_IHTMLElement6(iface);
4530
4531 TRACE("(%p)->(%p)\n", This, p);
4532
4533 return get_node_event(&This->node, EVENTID_ABORT, p);
4534 }
4535
4536 static HRESULT WINAPI HTMLElement6_put_oncanplay(IHTMLElement6 *iface, VARIANT v)
4537 {
4538 HTMLElement *This = impl_from_IHTMLElement6(iface);
4539 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4540 return E_NOTIMPL;
4541 }
4542
4543 static HRESULT WINAPI HTMLElement6_get_oncanplay(IHTMLElement6 *iface, VARIANT *p)
4544 {
4545 HTMLElement *This = impl_from_IHTMLElement6(iface);
4546 FIXME("(%p)->(%p)\n", This, p);
4547 return E_NOTIMPL;
4548 }
4549
4550 static HRESULT WINAPI HTMLElement6_put_oncanplaythrough(IHTMLElement6 *iface, VARIANT v)
4551 {
4552 HTMLElement *This = impl_from_IHTMLElement6(iface);
4553 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4554 return E_NOTIMPL;
4555 }
4556
4557 static HRESULT WINAPI HTMLElement6_get_oncanplaythrough(IHTMLElement6 *iface, VARIANT *p)
4558 {
4559 HTMLElement *This = impl_from_IHTMLElement6(iface);
4560 FIXME("(%p)->(%p)\n", This, p);
4561 return E_NOTIMPL;
4562 }
4563
4564 static HRESULT WINAPI HTMLElement6_put_onchange(IHTMLElement6 *iface, VARIANT v)
4565 {
4566 HTMLElement *This = impl_from_IHTMLElement6(iface);
4567
4568 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4569
4570 return set_node_event(&This->node, EVENTID_CHANGE, &v);
4571 }
4572
4573 static HRESULT WINAPI HTMLElement6_get_onchange(IHTMLElement6 *iface, VARIANT *p)
4574 {
4575 HTMLElement *This = impl_from_IHTMLElement6(iface);
4576
4577 TRACE("(%p)->(%p)\n", This, p);
4578
4579 return get_node_event(&This->node, EVENTID_CHANGE, p);
4580 }
4581
4582 static HRESULT WINAPI HTMLElement6_put_ondurationchange(IHTMLElement6 *iface, VARIANT v)
4583 {
4584 HTMLElement *This = impl_from_IHTMLElement6(iface);
4585 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4586 return E_NOTIMPL;
4587 }
4588
4589 static HRESULT WINAPI HTMLElement6_get_ondurationchange(IHTMLElement6 *iface, VARIANT *p)
4590 {
4591 HTMLElement *This = impl_from_IHTMLElement6(iface);
4592 FIXME("(%p)->(%p)\n", This, p);
4593 return E_NOTIMPL;
4594 }
4595
4596 static HRESULT WINAPI HTMLElement6_put_onemptied(IHTMLElement6 *iface, VARIANT v)
4597 {
4598 HTMLElement *This = impl_from_IHTMLElement6(iface);
4599 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4600 return E_NOTIMPL;
4601 }
4602
4603 static HRESULT WINAPI HTMLElement6_get_onemptied(IHTMLElement6 *iface, VARIANT *p)
4604 {
4605 HTMLElement *This = impl_from_IHTMLElement6(iface);
4606 FIXME("(%p)->(%p)\n", This, p);
4607 return E_NOTIMPL;
4608 }
4609
4610 static HRESULT WINAPI HTMLElement6_put_onended(IHTMLElement6 *iface, VARIANT v)
4611 {
4612 HTMLElement *This = impl_from_IHTMLElement6(iface);
4613 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4614 return E_NOTIMPL;
4615 }
4616
4617 static HRESULT WINAPI HTMLElement6_get_onended(IHTMLElement6 *iface, VARIANT *p)
4618 {
4619 HTMLElement *This = impl_from_IHTMLElement6(iface);
4620 FIXME("(%p)->(%p)\n", This, p);
4621 return E_NOTIMPL;
4622 }
4623
4624 static HRESULT WINAPI HTMLElement6_put_onerror(IHTMLElement6 *iface, VARIANT v)
4625 {
4626 HTMLElement *This = impl_from_IHTMLElement6(iface);
4627
4628 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4629
4630 return set_node_event(&This->node, EVENTID_ERROR, &v);
4631 }
4632
4633 static HRESULT WINAPI HTMLElement6_get_onerror(IHTMLElement6 *iface, VARIANT *p)
4634 {
4635 HTMLElement *This = impl_from_IHTMLElement6(iface);
4636
4637 TRACE("(%p)->(%p)\n", This, p);
4638
4639 return get_node_event(&This->node, EVENTID_ERROR, p);
4640 }
4641
4642 static HRESULT WINAPI HTMLElement6_put_oninput(IHTMLElement6 *iface, VARIANT v)
4643 {
4644 HTMLElement *This = impl_from_IHTMLElement6(iface);
4645
4646 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4647
4648 return set_node_event(&This->node, EVENTID_INPUT, &v);
4649 }
4650
4651 static HRESULT WINAPI HTMLElement6_get_oninput(IHTMLElement6 *iface, VARIANT *p)
4652 {
4653 HTMLElement *This = impl_from_IHTMLElement6(iface);
4654
4655 TRACE("(%p)->(%p)\n", This, p);
4656
4657 return get_node_event(&This->node, EVENTID_INPUT, p);
4658 }
4659
4660 static HRESULT WINAPI HTMLElement6_put_onload(IHTMLElement6 *iface, VARIANT v)
4661 {
4662 HTMLElement *This = impl_from_IHTMLElement6(iface);
4663
4664 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4665
4666 return set_node_event(&This->node, EVENTID_LOAD, &v);
4667 }
4668
4669 static HRESULT WINAPI HTMLElement6_get_onload(IHTMLElement6 *iface, VARIANT *p)
4670 {
4671 HTMLElement *This = impl_from_IHTMLElement6(iface);
4672
4673 TRACE("(%p)->(%p)\n", This, p);
4674
4675 return get_node_event(&This->node, EVENTID_LOAD, p);
4676 }
4677
4678 static HRESULT WINAPI HTMLElement6_put_onloadeddata(IHTMLElement6 *iface, VARIANT v)
4679 {
4680 HTMLElement *This = impl_from_IHTMLElement6(iface);
4681 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4682 return E_NOTIMPL;
4683 }
4684
4685 static HRESULT WINAPI HTMLElement6_get_onloadeddata(IHTMLElement6 *iface, VARIANT *p)
4686 {
4687 HTMLElement *This = impl_from_IHTMLElement6(iface);
4688 FIXME("(%p)->(%p)\n", This, p);
4689 return E_NOTIMPL;
4690 }
4691
4692 static HRESULT WINAPI HTMLElement6_put_onloadedmetadata(IHTMLElement6 *iface, VARIANT v)
4693 {
4694 HTMLElement *This = impl_from_IHTMLElement6(iface);
4695 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4696 return E_NOTIMPL;
4697 }
4698
4699 static HRESULT WINAPI HTMLElement6_get_onloadedmetadata(IHTMLElement6 *iface, VARIANT *p)
4700 {
4701 HTMLElement *This = impl_from_IHTMLElement6(iface);
4702 FIXME("(%p)->(%p)\n", This, p);
4703 return E_NOTIMPL;
4704 }
4705
4706 static HRESULT WINAPI HTMLElement6_put_onloadstart(IHTMLElement6 *iface, VARIANT v)
4707 {
4708 HTMLElement *This = impl_from_IHTMLElement6(iface);
4709 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4710 return E_NOTIMPL;
4711 }
4712
4713 static HRESULT WINAPI HTMLElement6_get_onloadstart(IHTMLElement6 *iface, VARIANT *p)
4714 {
4715 HTMLElement *This = impl_from_IHTMLElement6(iface);
4716 FIXME("(%p)->(%p)\n", This, p);
4717 return E_NOTIMPL;
4718 }
4719
4720 static HRESULT WINAPI HTMLElement6_put_onpause(IHTMLElement6 *iface, VARIANT v)
4721 {
4722 HTMLElement *This = impl_from_IHTMLElement6(iface);
4723 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4724 return E_NOTIMPL;
4725 }
4726
4727 static HRESULT WINAPI HTMLElement6_get_onpause(IHTMLElement6 *iface, VARIANT *p)
4728 {
4729 HTMLElement *This = impl_from_IHTMLElement6(iface);
4730 FIXME("(%p)->(%p)\n", This, p);
4731 return E_NOTIMPL;
4732 }
4733
4734 static HRESULT WINAPI HTMLElement6_put_onplay(IHTMLElement6 *iface, VARIANT v)
4735 {
4736 HTMLElement *This = impl_from_IHTMLElement6(iface);
4737 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4738 return E_NOTIMPL;
4739 }
4740
4741 static HRESULT WINAPI HTMLElement6_get_onplay(IHTMLElement6 *iface, VARIANT *p)
4742 {
4743 HTMLElement *This = impl_from_IHTMLElement6(iface);
4744 FIXME("(%p)->(%p)\n", This, p);
4745 return E_NOTIMPL;
4746 }
4747
4748 static HRESULT WINAPI HTMLElement6_put_onplaying(IHTMLElement6 *iface, VARIANT v)
4749 {
4750 HTMLElement *This = impl_from_IHTMLElement6(iface);
4751 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4752 return E_NOTIMPL;
4753 }
4754
4755 static HRESULT WINAPI HTMLElement6_get_onplaying(IHTMLElement6 *iface, VARIANT *p)
4756 {
4757 HTMLElement *This = impl_from_IHTMLElement6(iface);
4758 FIXME("(%p)->(%p)\n", This, p);
4759 return E_NOTIMPL;
4760 }
4761
4762 static HRESULT WINAPI HTMLElement6_put_onprogress(IHTMLElement6 *iface, VARIANT v)
4763 {
4764 HTMLElement *This = impl_from_IHTMLElement6(iface);
4765 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4766 return E_NOTIMPL;
4767 }
4768
4769 static HRESULT WINAPI HTMLElement6_get_onprogress(IHTMLElement6 *iface, VARIANT *p)
4770 {
4771 HTMLElement *This = impl_from_IHTMLElement6(iface);
4772 FIXME("(%p)->(%p)\n", This, p);
4773 return E_NOTIMPL;
4774 }
4775
4776 static HRESULT WINAPI HTMLElement6_put_onratechange(IHTMLElement6 *iface, VARIANT v)
4777 {
4778 HTMLElement *This = impl_from_IHTMLElement6(iface);
4779 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4780 return E_NOTIMPL;
4781 }
4782
4783 static HRESULT WINAPI HTMLElement6_get_onratechange(IHTMLElement6 *iface, VARIANT *p)
4784 {
4785 HTMLElement *This = impl_from_IHTMLElement6(iface);
4786 FIXME("(%p)->(%p)\n", This, p);
4787 return E_NOTIMPL;
4788 }
4789
4790 static HRESULT WINAPI HTMLElement6_put_onreset(IHTMLElement6 *iface, VARIANT v)
4791 {
4792 HTMLElement *This = impl_from_IHTMLElement6(iface);
4793 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4794 return E_NOTIMPL;
4795 }
4796
4797 static HRESULT WINAPI HTMLElement6_get_onreset(IHTMLElement6 *iface, VARIANT *p)
4798 {
4799 HTMLElement *This = impl_from_IHTMLElement6(iface);
4800 FIXME("(%p)->(%p)\n", This, p);
4801 return E_NOTIMPL;
4802 }
4803
4804 static HRESULT WINAPI HTMLElement6_put_onseeked(IHTMLElement6 *iface, VARIANT v)
4805 {
4806 HTMLElement *This = impl_from_IHTMLElement6(iface);
4807 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4808 return E_NOTIMPL;
4809 }
4810
4811 static HRESULT WINAPI HTMLElement6_get_onseeked(IHTMLElement6 *iface, VARIANT *p)
4812 {
4813 HTMLElement *This = impl_from_IHTMLElement6(iface);
4814 FIXME("(%p)->(%p)\n", This, p);
4815 return E_NOTIMPL;
4816 }
4817
4818 static HRESULT WINAPI HTMLElement6_put_onseeking(IHTMLElement6 *iface, VARIANT v)
4819 {
4820 HTMLElement *This = impl_from_IHTMLElement6(iface);
4821 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4822 return E_NOTIMPL;
4823 }
4824
4825 static HRESULT WINAPI HTMLElement6_get_onseeking(IHTMLElement6 *iface, VARIANT *p)
4826 {
4827 HTMLElement *This = impl_from_IHTMLElement6(iface);
4828 FIXME("(%p)->(%p)\n", This, p);
4829 return E_NOTIMPL;
4830 }
4831
4832 static HRESULT WINAPI HTMLElement6_put_onselect(IHTMLElement6 *iface, VARIANT v)
4833 {
4834 HTMLElement *This = impl_from_IHTMLElement6(iface);
4835 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4836 return E_NOTIMPL;
4837 }
4838
4839 static HRESULT WINAPI HTMLElement6_get_onselect(IHTMLElement6 *iface, VARIANT *p)
4840 {
4841 HTMLElement *This = impl_from_IHTMLElement6(iface);
4842 FIXME("(%p)->(%p)\n", This, p);
4843 return E_NOTIMPL;
4844 }
4845
4846 static HRESULT WINAPI HTMLElement6_put_onstalled(IHTMLElement6 *iface, VARIANT v)
4847 {
4848 HTMLElement *This = impl_from_IHTMLElement6(iface);
4849 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4850 return E_NOTIMPL;
4851 }
4852
4853 static HRESULT WINAPI HTMLElement6_get_onstalled(IHTMLElement6 *iface, VARIANT *p)
4854 {
4855 HTMLElement *This = impl_from_IHTMLElement6(iface);
4856 FIXME("(%p)->(%p)\n", This, p);
4857 return E_NOTIMPL;
4858 }
4859
4860 static HRESULT WINAPI HTMLElement6_put_onsubmit(IHTMLElement6 *iface, VARIANT v)
4861 {
4862 HTMLElement *This = impl_from_IHTMLElement6(iface);
4863
4864 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
4865
4866 return set_node_event(&This->node, EVENTID_SUBMIT, &v);
4867 }
4868
4869 static HRESULT WINAPI HTMLElement6_get_onsubmit(IHTMLElement6 *iface, VARIANT *p)
4870 {
4871 HTMLElement *This = impl_from_IHTMLElement6(iface);
4872
4873 TRACE("(%p)->(%p)\n", This, p);
4874
4875 return get_node_event(&This->node, EVENTID_SUBMIT, p);
4876 }
4877
4878 static HRESULT WINAPI HTMLElement6_put_onsuspend(IHTMLElement6 *iface, VARIANT v)
4879 {
4880 HTMLElement *This = impl_from_IHTMLElement6(iface);
4881 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4882 return E_NOTIMPL;
4883 }
4884
4885 static HRESULT WINAPI HTMLElement6_get_onsuspend(IHTMLElement6 *iface, VARIANT *p)
4886 {
4887 HTMLElement *This = impl_from_IHTMLElement6(iface);
4888 FIXME("(%p)->(%p)\n", This, p);
4889 return E_NOTIMPL;
4890 }
4891
4892 static HRESULT WINAPI HTMLElement6_put_ontimeupdate(IHTMLElement6 *iface, VARIANT v)
4893 {
4894 HTMLElement *This = impl_from_IHTMLElement6(iface);
4895 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4896 return E_NOTIMPL;
4897 }
4898
4899 static HRESULT WINAPI HTMLElement6_get_ontimeupdate(IHTMLElement6 *iface, VARIANT *p)
4900 {
4901 HTMLElement *This = impl_from_IHTMLElement6(iface);
4902 FIXME("(%p)->(%p)\n", This, p);
4903 return E_NOTIMPL;
4904 }
4905
4906 static HRESULT WINAPI HTMLElement6_put_onvolumechange(IHTMLElement6 *iface, VARIANT v)
4907 {
4908 HTMLElement *This = impl_from_IHTMLElement6(iface);
4909 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4910 return E_NOTIMPL;
4911 }
4912
4913 static HRESULT WINAPI HTMLElement6_get_onvolumechange(IHTMLElement6 *iface, VARIANT *p)
4914 {
4915 HTMLElement *This = impl_from_IHTMLElement6(iface);
4916 FIXME("(%p)->(%p)\n", This, p);
4917 return E_NOTIMPL;
4918 }
4919
4920 static HRESULT WINAPI HTMLElement6_put_onwaiting(IHTMLElement6 *iface, VARIANT v)
4921 {
4922 HTMLElement *This = impl_from_IHTMLElement6(iface);
4923 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
4924 return E_NOTIMPL;
4925 }
4926
4927 static HRESULT WINAPI HTMLElement6_get_onwaiting(IHTMLElement6 *iface, VARIANT *p)
4928 {
4929 HTMLElement *This = impl_from_IHTMLElement6(iface);
4930 FIXME("(%p)->(%p)\n", This, p);
4931 return E_NOTIMPL;
4932 }
4933
4934 static HRESULT WINAPI HTMLElement6_hasAttributes(IHTMLElement6 *iface, VARIANT_BOOL *pfHasAttributes)
4935 {
4936 HTMLElement *This = impl_from_IHTMLElement6(iface);
4937 FIXME("(%p)->(%p)\n", This, pfHasAttributes);
4938 return E_NOTIMPL;
4939 }
4940
4941 static const IHTMLElement6Vtbl HTMLElement6Vtbl = {
4942 HTMLElement6_QueryInterface,
4943 HTMLElement6_AddRef,
4944 HTMLElement6_Release,
4945 HTMLElement6_GetTypeInfoCount,
4946 HTMLElement6_GetTypeInfo,
4947 HTMLElement6_GetIDsOfNames,
4948 HTMLElement6_Invoke,
4949 HTMLElement6_getAttributeNS,
4950 HTMLElement6_setAttributeNS,
4951 HTMLElement6_removeAttributeNS,
4952 HTMLElement6_getAttributeNodeNS,
4953 HTMLElement6_setAttributeNodeNS,
4954 HTMLElement6_hasAttributeNS,
4955 HTMLElement6_getAttribute,
4956 HTMLElement6_setAttribute,
4957 HTMLElement6_removeAttribute,
4958 HTMLElement6_getAttributeNode,
4959 HTMLElement6_setAttributeNode,
4960 HTMLElement6_removeAttributeNode,
4961 HTMLElement6_hasAttribute,
4962 HTMLElement6_getElementsByTagNameNS,
4963 HTMLElement6_get_tagName,
4964 HTMLElement6_get_nodeName,
4965 HTMLElement6_getElementsByClassName,
4966 HTMLElement6_msMatchesSelector,
4967 HTMLElement6_put_onabort,
4968 HTMLElement6_get_onabort,
4969 HTMLElement6_put_oncanplay,
4970 HTMLElement6_get_oncanplay,
4971 HTMLElement6_put_oncanplaythrough,
4972 HTMLElement6_get_oncanplaythrough,
4973 HTMLElement6_put_onchange,
4974 HTMLElement6_get_onchange,
4975 HTMLElement6_put_ondurationchange,
4976 HTMLElement6_get_ondurationchange,
4977 HTMLElement6_put_onemptied,
4978 HTMLElement6_get_onemptied,
4979 HTMLElement6_put_onended,
4980 HTMLElement6_get_onended,
4981 HTMLElement6_put_onerror,
4982 HTMLElement6_get_onerror,
4983 HTMLElement6_put_oninput,
4984 HTMLElement6_get_oninput,
4985 HTMLElement6_put_onload,
4986 HTMLElement6_get_onload,
4987 HTMLElement6_put_onloadeddata,
4988 HTMLElement6_get_onloadeddata,
4989 HTMLElement6_put_onloadedmetadata,
4990 HTMLElement6_get_onloadedmetadata,
4991 HTMLElement6_put_onloadstart,
4992 HTMLElement6_get_onloadstart,
4993 HTMLElement6_put_onpause,
4994 HTMLElement6_get_onpause,
4995 HTMLElement6_put_onplay,
4996 HTMLElement6_get_onplay,
4997 HTMLElement6_put_onplaying,
4998 HTMLElement6_get_onplaying,
4999 HTMLElement6_put_onprogress,
5000 HTMLElement6_get_onprogress,
5001 HTMLElement6_put_onratechange,
5002 HTMLElement6_get_onratechange,
5003 HTMLElement6_put_onreset,
5004 HTMLElement6_get_onreset,
5005 HTMLElement6_put_onseeked,
5006 HTMLElement6_get_onseeked,
5007 HTMLElement6_put_onseeking,
5008 HTMLElement6_get_onseeking,
5009 HTMLElement6_put_onselect,
5010 HTMLElement6_get_onselect,
5011 HTMLElement6_put_onstalled,
5012 HTMLElement6_get_onstalled,
5013 HTMLElement6_put_onsubmit,
5014 HTMLElement6_get_onsubmit,
5015 HTMLElement6_put_onsuspend,
5016 HTMLElement6_get_onsuspend,
5017 HTMLElement6_put_ontimeupdate,
5018 HTMLElement6_get_ontimeupdate,
5019 HTMLElement6_put_onvolumechange,
5020 HTMLElement6_get_onvolumechange,
5021 HTMLElement6_put_onwaiting,
5022 HTMLElement6_get_onwaiting,
5023 HTMLElement6_hasAttributes
5024 };
5025
5026 static inline HTMLElement *impl_from_IHTMLElement7(IHTMLElement7 *iface)
5027 {
5028 return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement7_iface);
5029 }
5030
5031 static HRESULT WINAPI HTMLElement7_QueryInterface(IHTMLElement7 *iface,
5032 REFIID riid, void **ppv)
5033 {
5034 HTMLElement *This = impl_from_IHTMLElement7(iface);
5035 return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
5036 }
5037
5038 static ULONG WINAPI HTMLElement7_AddRef(IHTMLElement7 *iface)
5039 {
5040 HTMLElement *This = impl_from_IHTMLElement7(iface);
5041 return IHTMLElement_AddRef(&This->IHTMLElement_iface);
5042 }
5043
5044 static ULONG WINAPI HTMLElement7_Release(IHTMLElement7 *iface)
5045 {
5046 HTMLElement *This = impl_from_IHTMLElement7(iface);
5047 return IHTMLElement_Release(&This->IHTMLElement_iface);
5048 }
5049
5050 static HRESULT WINAPI HTMLElement7_GetTypeInfoCount(IHTMLElement7 *iface, UINT *pctinfo)
5051 {
5052 HTMLElement *This = impl_from_IHTMLElement7(iface);
5053 return IDispatchEx_GetTypeInfoCount(&This->node.event_target.dispex.IDispatchEx_iface, pctinfo);
5054 }
5055
5056 static HRESULT WINAPI HTMLElement7_GetTypeInfo(IHTMLElement7 *iface, UINT iTInfo,
5057 LCID lcid, ITypeInfo **ppTInfo)
5058 {
5059 HTMLElement *This = impl_from_IHTMLElement7(iface);
5060 return IDispatchEx_GetTypeInfo(&This->node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
5061 }
5062
5063 static HRESULT WINAPI HTMLElement7_GetIDsOfNames(IHTMLElement7 *iface, REFIID riid,
5064 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
5065 {
5066 HTMLElement *This = impl_from_IHTMLElement7(iface);
5067 return IDispatchEx_GetIDsOfNames(&This->node.event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
5068 lcid, rgDispId);
5069 }
5070
5071 static HRESULT WINAPI HTMLElement7_Invoke(IHTMLElement7 *iface, DISPID dispIdMember, REFIID riid,
5072 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
5073 {
5074 HTMLElement *This = impl_from_IHTMLElement7(iface);
5075 return IDispatchEx_Invoke(&This->node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
5076 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
5077 }
5078
5079 static HRESULT WINAPI HTMLElement7_put_onmspointerdown(IHTMLElement7 *iface, VARIANT v)
5080 {
5081 HTMLElement *This = impl_from_IHTMLElement7(iface);
5082 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5083 return E_NOTIMPL;
5084 }
5085
5086 static HRESULT WINAPI HTMLElement7_get_onmspointerdown(IHTMLElement7 *iface, VARIANT *p)
5087 {
5088 HTMLElement *This = impl_from_IHTMLElement7(iface);
5089 FIXME("(%p)->(%p)\n", This, p);
5090 return E_NOTIMPL;
5091 }
5092
5093 static HRESULT WINAPI HTMLElement7_put_onmspointermove(IHTMLElement7 *iface, VARIANT v)
5094 {
5095 HTMLElement *This = impl_from_IHTMLElement7(iface);
5096 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5097 return E_NOTIMPL;
5098 }
5099
5100 static HRESULT WINAPI HTMLElement7_get_onmspointermove(IHTMLElement7 *iface, VARIANT *p)
5101 {
5102 HTMLElement *This = impl_from_IHTMLElement7(iface);
5103 FIXME("(%p)->(%p)\n", This, p);
5104 return E_NOTIMPL;
5105 }
5106
5107 static HRESULT WINAPI HTMLElement7_put_onmspointerup(IHTMLElement7 *iface, VARIANT v)
5108 {
5109 HTMLElement *This = impl_from_IHTMLElement7(iface);
5110 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5111 return E_NOTIMPL;
5112 }
5113
5114 static HRESULT WINAPI HTMLElement7_get_onmspointerup(IHTMLElement7 *iface, VARIANT *p)
5115 {
5116 HTMLElement *This = impl_from_IHTMLElement7(iface);
5117 FIXME("(%p)->(%p)\n", This, p);
5118 return E_NOTIMPL;
5119 }
5120
5121 static HRESULT WINAPI HTMLElement7_put_onmspointerover(IHTMLElement7 *iface, VARIANT v)
5122 {
5123 HTMLElement *This = impl_from_IHTMLElement7(iface);
5124 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5125 return E_NOTIMPL;
5126 }
5127
5128 static HRESULT WINAPI HTMLElement7_get_onmspointerover(IHTMLElement7 *iface, VARIANT *p)
5129 {
5130 HTMLElement *This = impl_from_IHTMLElement7(iface);
5131 FIXME("(%p)->(%p)\n", This, p);
5132 return E_NOTIMPL;
5133 }
5134
5135 static HRESULT WINAPI HTMLElement7_put_onmspointerout(IHTMLElement7 *iface, VARIANT v)
5136 {
5137 HTMLElement *This = impl_from_IHTMLElement7(iface);
5138 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5139 return E_NOTIMPL;
5140 }
5141
5142 static HRESULT WINAPI HTMLElement7_get_onmspointerout(IHTMLElement7 *iface, VARIANT *p)
5143 {
5144 HTMLElement *This = impl_from_IHTMLElement7(iface);
5145 FIXME("(%p)->(%p)\n", This, p);
5146 return E_NOTIMPL;
5147 }
5148
5149 static HRESULT WINAPI HTMLElement7_put_onmspointercancel(IHTMLElement7 *iface, VARIANT v)
5150 {
5151 HTMLElement *This = impl_from_IHTMLElement7(iface);
5152 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5153 return E_NOTIMPL;
5154 }
5155
5156 static HRESULT WINAPI HTMLElement7_get_onmspointercancel(IHTMLElement7 *iface, VARIANT *p)
5157 {
5158 HTMLElement *This = impl_from_IHTMLElement7(iface);
5159 FIXME("(%p)->(%p)\n", This, p);
5160 return E_NOTIMPL;
5161 }
5162
5163 static HRESULT WINAPI HTMLElement7_put_onmspointerhover(IHTMLElement7 *iface, VARIANT v)
5164 {
5165 HTMLElement *This = impl_from_IHTMLElement7(iface);
5166 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5167 return E_NOTIMPL;
5168 }
5169
5170 static HRESULT WINAPI HTMLElement7_get_onmspointerhover(IHTMLElement7 *iface, VARIANT *p)
5171 {
5172 HTMLElement *This = impl_from_IHTMLElement7(iface);
5173 FIXME("(%p)->(%p)\n", This, p);
5174 return E_NOTIMPL;
5175 }
5176
5177 static HRESULT WINAPI HTMLElement7_put_onmslostpointercapture(IHTMLElement7 *iface, VARIANT v)
5178 {
5179 HTMLElement *This = impl_from_IHTMLElement7(iface);
5180 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5181 return E_NOTIMPL;
5182 }
5183
5184 static HRESULT WINAPI HTMLElement7_get_onmslostpointercapture(IHTMLElement7 *iface, VARIANT *p)
5185 {
5186 HTMLElement *This = impl_from_IHTMLElement7(iface);
5187 FIXME("(%p)->(%p)\n", This, p);
5188 return E_NOTIMPL;
5189 }
5190
5191 static HRESULT WINAPI HTMLElement7_put_onmsgotpointercapture(IHTMLElement7 *iface, VARIANT v)
5192 {
5193 HTMLElement *This = impl_from_IHTMLElement7(iface);
5194 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5195 return E_NOTIMPL;
5196 }
5197
5198 static HRESULT WINAPI HTMLElement7_get_onmsgotpointercapture(IHTMLElement7 *iface, VARIANT *p)
5199 {
5200 HTMLElement *This = impl_from_IHTMLElement7(iface);
5201 FIXME("(%p)->(%p)\n", This, p);
5202 return E_NOTIMPL;
5203 }
5204
5205 static HRESULT WINAPI HTMLElement7_put_onmsgesturestart(IHTMLElement7 *iface, VARIANT v)
5206 {
5207 HTMLElement *This = impl_from_IHTMLElement7(iface);
5208 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5209 return E_NOTIMPL;
5210 }
5211
5212 static HRESULT WINAPI HTMLElement7_get_onmsgesturestart(IHTMLElement7 *iface, VARIANT *p)
5213 {
5214 HTMLElement *This = impl_from_IHTMLElement7(iface);
5215 FIXME("(%p)->(%p)\n", This, p);
5216 return E_NOTIMPL;
5217 }
5218
5219 static HRESULT WINAPI HTMLElement7_put_onmsgesturechange(IHTMLElement7 *iface, VARIANT v)
5220 {
5221 HTMLElement *This = impl_from_IHTMLElement7(iface);
5222 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5223 return E_NOTIMPL;
5224 }
5225
5226 static HRESULT WINAPI HTMLElement7_get_onmsgesturechange(IHTMLElement7 *iface, VARIANT *p)
5227 {
5228 HTMLElement *This = impl_from_IHTMLElement7(iface);
5229 FIXME("(%p)->(%p)\n", This, p);
5230 return E_NOTIMPL;
5231 }
5232
5233 static HRESULT WINAPI HTMLElement7_put_onmsgestureend(IHTMLElement7 *iface, VARIANT v)
5234 {
5235 HTMLElement *This = impl_from_IHTMLElement7(iface);
5236 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5237 return E_NOTIMPL;
5238 }
5239
5240 static HRESULT WINAPI HTMLElement7_get_onmsgestureend(IHTMLElement7 *iface, VARIANT *p)
5241 {
5242 HTMLElement *This = impl_from_IHTMLElement7(iface);
5243 FIXME("(%p)->(%p)\n", This, p);
5244 return E_NOTIMPL;
5245 }
5246
5247 static HRESULT WINAPI HTMLElement7_put_onmsgesturehold(IHTMLElement7 *iface, VARIANT v)
5248 {
5249 HTMLElement *This = impl_from_IHTMLElement7(iface);
5250 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5251 return E_NOTIMPL;
5252 }
5253
5254 static HRESULT WINAPI HTMLElement7_get_onmsgesturehold(IHTMLElement7 *iface, VARIANT *p)
5255 {
5256 HTMLElement *This = impl_from_IHTMLElement7(iface);
5257 FIXME("(%p)->(%p)\n", This, p);
5258 return E_NOTIMPL;
5259 }
5260
5261 static HRESULT WINAPI HTMLElement7_put_onmsgesturetap(IHTMLElement7 *iface, VARIANT v)
5262 {
5263 HTMLElement *This = impl_from_IHTMLElement7(iface);
5264 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5265 return E_NOTIMPL;
5266 }
5267
5268 static HRESULT WINAPI HTMLElement7_get_onmsgesturetap(IHTMLElement7 *iface, VARIANT *p)
5269 {
5270 HTMLElement *This = impl_from_IHTMLElement7(iface);
5271 FIXME("(%p)->(%p)\n", This, p);
5272 return E_NOTIMPL;
5273 }
5274
5275 static HRESULT WINAPI HTMLElement7_put_onmsgesturedoubletap(IHTMLElement7 *iface, VARIANT v)
5276 {
5277 HTMLElement *This = impl_from_IHTMLElement7(iface);
5278 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5279 return E_NOTIMPL;
5280 }
5281
5282 static HRESULT WINAPI HTMLElement7_get_onmsgesturedoubletap(IHTMLElement7 *iface, VARIANT *p)
5283 {
5284 HTMLElement *This = impl_from_IHTMLElement7(iface);
5285 FIXME("(%p)->(%p)\n", This, p);
5286 return E_NOTIMPL;
5287 }
5288
5289 static HRESULT WINAPI HTMLElement7_put_onmsinertiastart(IHTMLElement7 *iface, VARIANT v)
5290 {
5291 HTMLElement *This = impl_from_IHTMLElement7(iface);
5292 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5293 return E_NOTIMPL;
5294 }
5295
5296 static HRESULT WINAPI HTMLElement7_get_onmsinertiastart(IHTMLElement7 *iface, VARIANT *p)
5297 {
5298 HTMLElement *This = impl_from_IHTMLElement7(iface);
5299 FIXME("(%p)->(%p)\n", This, p);
5300 return E_NOTIMPL;
5301 }
5302
5303 static HRESULT WINAPI HTMLElement7_msSetPointerCapture(IHTMLElement7 *iface, LONG pointer_id)
5304 {
5305 HTMLElement *This = impl_from_IHTMLElement7(iface);
5306 FIXME("(%p)->(%d)\n", This, pointer_id);
5307 return E_NOTIMPL;
5308 }
5309
5310 static HRESULT WINAPI HTMLElement7_msReleasePointerCapture(IHTMLElement7 *iface, LONG pointer_id)
5311 {
5312 HTMLElement *This = impl_from_IHTMLElement7(iface);
5313 FIXME("(%p)->(%d)\n", This, pointer_id);
5314 return E_NOTIMPL;
5315 }
5316
5317 static HRESULT WINAPI HTMLElement7_put_onmstransitionstart(IHTMLElement7 *iface, VARIANT v)
5318 {
5319 HTMLElement *This = impl_from_IHTMLElement7(iface);
5320 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5321 return E_NOTIMPL;
5322 }
5323
5324 static HRESULT WINAPI HTMLElement7_get_onmstransitionstart(IHTMLElement7 *iface, VARIANT *p)
5325 {
5326 HTMLElement *This = impl_from_IHTMLElement7(iface);
5327 FIXME("(%p)->(%p)\n", This, p);
5328 return E_NOTIMPL;
5329 }
5330
5331 static HRESULT WINAPI HTMLElement7_put_onmstransitionend(IHTMLElement7 *iface, VARIANT v)
5332 {
5333 HTMLElement *This = impl_from_IHTMLElement7(iface);
5334 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5335 return E_NOTIMPL;
5336 }
5337
5338 static HRESULT WINAPI HTMLElement7_get_onmstransitionend(IHTMLElement7 *iface, VARIANT *p)
5339 {
5340 HTMLElement *This = impl_from_IHTMLElement7(iface);
5341 FIXME("(%p)->(%p)\n", This, p);
5342 return E_NOTIMPL;
5343 }
5344
5345 static HRESULT WINAPI HTMLElement7_put_onmsanimationstart(IHTMLElement7 *iface, VARIANT v)
5346 {
5347 HTMLElement *This = impl_from_IHTMLElement7(iface);
5348 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5349 return E_NOTIMPL;
5350 }
5351
5352 static HRESULT WINAPI HTMLElement7_get_onmsanimationstart(IHTMLElement7 *iface, VARIANT *p)
5353 {
5354 HTMLElement *This = impl_from_IHTMLElement7(iface);
5355 FIXME("(%p)->(%p)\n", This, p);
5356 return E_NOTIMPL;
5357 }
5358
5359 static HRESULT WINAPI HTMLElement7_put_onmsanimationend(IHTMLElement7 *iface, VARIANT v)
5360 {
5361 HTMLElement *This = impl_from_IHTMLElement7(iface);
5362 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5363 return E_NOTIMPL;
5364 }
5365
5366 static HRESULT WINAPI HTMLElement7_get_onmsanimationend(IHTMLElement7 *iface, VARIANT *p)
5367 {
5368 HTMLElement *This = impl_from_IHTMLElement7(iface);
5369 FIXME("(%p)->(%p)\n", This, p);
5370 return E_NOTIMPL;
5371 }
5372
5373 static HRESULT WINAPI HTMLElement7_put_onmsanimationiteration(IHTMLElement7 *iface, VARIANT v)
5374 {
5375 HTMLElement *This = impl_from_IHTMLElement7(iface);
5376 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5377 return E_NOTIMPL;
5378 }
5379
5380 static HRESULT WINAPI HTMLElement7_get_onmsanimationiteration(IHTMLElement7 *iface, VARIANT *p)
5381 {
5382 HTMLElement *This = impl_from_IHTMLElement7(iface);
5383 FIXME("(%p)->(%p)\n", This, p);
5384 return E_NOTIMPL;
5385 }
5386
5387 static HRESULT WINAPI HTMLElement7_put_oninvalid(IHTMLElement7 *iface, VARIANT v)
5388 {
5389 HTMLElement *This = impl_from_IHTMLElement7(iface);
5390 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5391 return E_NOTIMPL;
5392 }
5393
5394 static HRESULT WINAPI HTMLElement7_get_oninvalid(IHTMLElement7 *iface, VARIANT *p)
5395 {
5396 HTMLElement *This = impl_from_IHTMLElement7(iface);
5397 FIXME("(%p)->(%p)\n", This, p);
5398 return E_NOTIMPL;
5399 }
5400
5401 static HRESULT WINAPI HTMLElement7_put_xmsAcceleratorKey(IHTMLElement7 *iface, BSTR v)
5402 {
5403 HTMLElement *This = impl_from_IHTMLElement7(iface);
5404 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
5405 return E_NOTIMPL;
5406 }
5407
5408 static HRESULT WINAPI HTMLElement7_get_xmsAcceleratorKey(IHTMLElement7 *iface, BSTR *p)
5409 {
5410 HTMLElement *This = impl_from_IHTMLElement7(iface);
5411 FIXME("(%p)->(%p)\n", This, p);
5412 return E_NOTIMPL;
5413 }
5414
5415 static HRESULT WINAPI HTMLElement7_put_spellcheck(IHTMLElement7 *iface, VARIANT v)
5416 {
5417 HTMLElement *This = impl_from_IHTMLElement7(iface);
5418
5419 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
5420
5421 if(!This->html_element) {
5422 FIXME("non-HTML element\n");
5423 return E_NOTIMPL;
5424 }
5425
5426 if(V_VT(&v) != VT_BOOL) {
5427 FIXME("unsupported argument %s\n", debugstr_variant(&v));
5428 return E_NOTIMPL;
5429 }
5430
5431 return map_nsresult(nsIDOMHTMLElement_SetSpellcheck(This->html_element, !!V_BOOL(&v)));
5432 }
5433
5434 static HRESULT WINAPI HTMLElement7_get_spellcheck(IHTMLElement7 *iface, VARIANT *p)
5435 {
5436 HTMLElement *This = impl_from_IHTMLElement7(iface);
5437 cpp_bool spellcheck;
5438 nsresult nsres;
5439
5440 TRACE("(%p)->(%p)\n", This, p);
5441
5442 if(!This->html_element) {
5443 FIXME("non-HTML element\n");
5444 return E_NOTIMPL;
5445 }
5446
5447 nsres = nsIDOMHTMLElement_GetSpellcheck(This->html_element, &spellcheck);
5448 if(NS_FAILED(nsres))
5449 return map_nsresult(nsres);
5450
5451 V_VT(p) = VT_BOOL;
5452 V_BOOL(p) = spellcheck ? VARIANT_TRUE : VARIANT_FALSE;
5453 return S_OK;
5454 }
5455
5456 static HRESULT WINAPI HTMLElement7_put_onmsmanipulationstatechanged(IHTMLElement7 *iface, VARIANT v)
5457 {
5458 HTMLElement *This = impl_from_IHTMLElement7(iface);
5459 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5460 return E_NOTIMPL;
5461 }
5462
5463 static HRESULT WINAPI HTMLElement7_get_onmsmanipulationstatechanged(IHTMLElement7 *iface, VARIANT *p)
5464 {
5465 HTMLElement *This = impl_from_IHTMLElement7(iface);
5466 FIXME("(%p)->(%p)\n", This, p);
5467 return E_NOTIMPL;
5468 }
5469
5470 static HRESULT WINAPI HTMLElement7_put_oncuechange(IHTMLElement7 *iface, VARIANT v)
5471 {
5472 HTMLElement *This = impl_from_IHTMLElement7(iface);
5473 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
5474 return E_NOTIMPL;
5475 }
5476
5477 static HRESULT WINAPI HTMLElement7_get_oncuechange(IHTMLElement7 *iface, VARIANT *p)
5478 {
5479 HTMLElement *This = impl_from_IHTMLElement7(iface);
5480 FIXME("(%p)->(%p)\n", This, p);
5481 return E_NOTIMPL;
5482 }
5483
5484 static const IHTMLElement7Vtbl HTMLElement7Vtbl = {
5485 HTMLElement7_QueryInterface,
5486 HTMLElement7_AddRef,
5487 HTMLElement7_Release,
5488 HTMLElement7_GetTypeInfoCount,
5489 HTMLElement7_GetTypeInfo,
5490 HTMLElement7_GetIDsOfNames,
5491 HTMLElement7_Invoke,
5492 HTMLElement7_put_onmspointerdown,
5493 HTMLElement7_get_onmspointerdown,
5494 HTMLElement7_put_onmspointermove,
5495 HTMLElement7_get_onmspointermove,
5496 HTMLElement7_put_onmspointerup,
5497 HTMLElement7_get_onmspointerup,
5498 HTMLElement7_put_onmspointerover,
5499 HTMLElement7_get_onmspointerover,
5500 HTMLElement7_put_onmspointerout,
5501 HTMLElement7_get_onmspointerout,
5502 HTMLElement7_put_onmspointercancel,
5503 HTMLElement7_get_onmspointercancel,
5504 HTMLElement7_put_onmspointerhover,
5505 HTMLElement7_get_onmspointerhover,
5506 HTMLElement7_put_onmslostpointercapture,
5507 HTMLElement7_get_onmslostpointercapture,
5508 HTMLElement7_put_onmsgotpointercapture,
5509 HTMLElement7_get_onmsgotpointercapture,
5510 HTMLElement7_put_onmsgesturestart,
5511 HTMLElement7_get_onmsgesturestart,
5512 HTMLElement7_put_onmsgesturechange,
5513 HTMLElement7_get_onmsgesturechange,
5514 HTMLElement7_put_onmsgestureend,
5515 HTMLElement7_get_onmsgestureend,
5516 HTMLElement7_put_onmsgesturehold,
5517 HTMLElement7_get_onmsgesturehold,
5518 HTMLElement7_put_onmsgesturetap,
5519 HTMLElement7_get_onmsgesturetap,
5520 HTMLElement7_put_onmsgesturedoubletap,
5521 HTMLElement7_get_onmsgesturedoubletap,
5522 HTMLElement7_put_onmsinertiastart,
5523 HTMLElement7_get_onmsinertiastart,
5524 HTMLElement7_msSetPointerCapture,
5525 HTMLElement7_msReleasePointerCapture,
5526 HTMLElement7_put_onmstransitionstart,
5527 HTMLElement7_get_onmstransitionstart,
5528 HTMLElement7_put_onmstransitionend,
5529 HTMLElement7_get_onmstransitionend,
5530 HTMLElement7_put_onmsanimationstart,
5531 HTMLElement7_get_onmsanimationstart,
5532 HTMLElement7_put_onmsanimationend,
5533 HTMLElement7_get_onmsanimationend,
5534 HTMLElement7_put_onmsanimationiteration,
5535 HTMLElement7_get_onmsanimationiteration,
5536 HTMLElement7_put_oninvalid,
5537 HTMLElement7_get_oninvalid,
5538 HTMLElement7_put_xmsAcceleratorKey,
5539 HTMLElement7_get_xmsAcceleratorKey,
5540 HTMLElement7_put_spellcheck,
5541 HTMLElement7_get_spellcheck,
5542 HTMLElement7_put_onmsmanipulationstatechanged,
5543 HTMLElement7_get_onmsmanipulationstatechanged,
5544 HTMLElement7_put_oncuechange,
5545 HTMLElement7_get_oncuechange
5546 };
5547
5548
5549 static inline HTMLElement *impl_from_IHTMLUniqueName(IHTMLUniqueName *iface)
5550 {
5551 return CONTAINING_RECORD(iface, HTMLElement, IHTMLUniqueName_iface);
5552 }
5553
5554 static HRESULT WINAPI HTMLUniqueName_QueryInterface(IHTMLUniqueName *iface, REFIID riid, void **ppv)
5555 {
5556 HTMLElement *This = impl_from_IHTMLUniqueName(iface);
5557 return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
5558 }
5559
5560 static ULONG WINAPI HTMLUniqueName_AddRef(IHTMLUniqueName *iface)
5561 {
5562 HTMLElement *This = impl_from_IHTMLUniqueName(iface);
5563 return IHTMLElement_AddRef(&This->IHTMLElement_iface);
5564 }
5565
5566 static ULONG WINAPI HTMLUniqueName_Release(IHTMLUniqueName *iface)
5567 {
5568 HTMLElement *This = impl_from_IHTMLUniqueName(iface);
5569 return IHTMLElement_Release(&This->IHTMLElement_iface);
5570 }
5571
5572 static HRESULT WINAPI HTMLUniqueName_GetTypeInfoCount(IHTMLUniqueName *iface, UINT *pctinfo)
5573 {
5574 HTMLElement *This = impl_from_IHTMLUniqueName(iface);
5575 return IDispatchEx_GetTypeInfoCount(&This->node.event_target.dispex.IDispatchEx_iface, pctinfo);
5576 }
5577
5578 static HRESULT WINAPI HTMLUniqueName_GetTypeInfo(IHTMLUniqueName *iface, UINT iTInfo,
5579 LCID lcid, ITypeInfo **ppTInfo)
5580 {
5581 HTMLElement *This = impl_from_IHTMLUniqueName(iface);
5582 return IDispatchEx_GetTypeInfo(&This->node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
5583 }
5584
5585 static HRESULT WINAPI HTMLUniqueName_GetIDsOfNames(IHTMLUniqueName *iface, REFIID riid,
5586 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
5587 {
5588 HTMLElement *This = impl_from_IHTMLUniqueName(iface);
5589 return IDispatchEx_GetIDsOfNames(&This->node.event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
5590 lcid, rgDispId);
5591 }
5592
5593 static HRESULT WINAPI HTMLUniqueName_Invoke(IHTMLUniqueName *iface, DISPID dispIdMember, REFIID riid,
5594 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
5595 {
5596 HTMLElement *This = impl_from_IHTMLUniqueName(iface);
5597 return IDispatchEx_Invoke(&This->node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
5598 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
5599 }
5600
5601 HRESULT elem_unique_id(unsigned id, BSTR *p)
5602 {
5603 WCHAR buf[32];
5604
5605 swprintf(buf, ARRAY_SIZE(buf), L"ms__id%u", id);
5606 *p = SysAllocString(buf);
5607 return *p ? S_OK : E_OUTOFMEMORY;
5608 }
5609
5610 static void ensure_unique_id(HTMLElement *elem)
5611 {
5612 if(!elem->unique_id)
5613 elem->unique_id = ++elem->node.doc->unique_id;
5614 }
5615
5616 static HRESULT WINAPI HTMLUniqueName_get_uniqueNumber(IHTMLUniqueName *iface, LONG *p)
5617 {
5618 HTMLElement *This = impl_from_IHTMLUniqueName(iface);
5619
5620 TRACE("(%p)->(%p)\n", This, p);
5621
5622 ensure_unique_id(This);
5623 *p = This->unique_id;
5624 return S_OK;
5625 }
5626
5627 static HRESULT WINAPI HTMLUniqueName_get_uniqueID(IHTMLUniqueName *iface, BSTR *p)
5628 {
5629 HTMLElement *This = impl_from_IHTMLUniqueName(iface);
5630
5631 TRACE("(%p)->(%p)\n", This, p);
5632
5633 ensure_unique_id(This);
5634 return elem_unique_id(This->unique_id, p);
5635 }
5636
5637 static const IHTMLUniqueNameVtbl HTMLUniqueNameVtbl = {
5638 HTMLUniqueName_QueryInterface,
5639 HTMLUniqueName_AddRef,
5640 HTMLUniqueName_Release,
5641 HTMLUniqueName_GetTypeInfoCount,
5642 HTMLUniqueName_GetTypeInfo,
5643 HTMLUniqueName_GetIDsOfNames,
5644 HTMLUniqueName_Invoke,
5645 HTMLUniqueName_get_uniqueNumber,
5646 HTMLUniqueName_get_uniqueID
5647 };
5648
5649 static inline HTMLElement *impl_from_IElementSelector(IElementSelector *iface)
5650 {
5651 return CONTAINING_RECORD(iface, HTMLElement, IElementSelector_iface);
5652 }
5653
5654 static HRESULT WINAPI ElementSelector_QueryInterface(IElementSelector *iface, REFIID riid, void **ppv)
5655 {
5656 HTMLElement *This = impl_from_IElementSelector(iface);
5657 return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
5658 }
5659
5660 static ULONG WINAPI ElementSelector_AddRef(IElementSelector *iface)
5661 {
5662 HTMLElement *This = impl_from_IElementSelector(iface);
5663 return IHTMLElement_AddRef(&This->IHTMLElement_iface);
5664 }
5665
5666 static ULONG WINAPI ElementSelector_Release(IElementSelector *iface)
5667 {
5668 HTMLElement *This = impl_from_IElementSelector(iface);
5669 return IHTMLElement_Release(&This->IHTMLElement_iface);
5670 }
5671
5672 static HRESULT WINAPI ElementSelector_GetTypeInfoCount(IElementSelector *iface, UINT *pctinfo)
5673 {
5674 HTMLElement *This = impl_from_IElementSelector(iface);
5675 return IDispatchEx_GetTypeInfoCount(&This->node.event_target.dispex.IDispatchEx_iface, pctinfo);
5676 }
5677
5678 static HRESULT WINAPI ElementSelector_GetTypeInfo(IElementSelector *iface, UINT iTInfo,
5679 LCID lcid, ITypeInfo **ppTInfo)
5680 {
5681 HTMLElement *This = impl_from_IElementSelector(iface);
5682 return IDispatchEx_GetTypeInfo(&This->node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
5683 }
5684
5685 static HRESULT WINAPI ElementSelector_GetIDsOfNames(IElementSelector *iface, REFIID riid,
5686 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
5687 {
5688 HTMLElement *This = impl_from_IElementSelector(iface);
5689 return IDispatchEx_GetIDsOfNames(&This->node.event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames, lcid, rgDispId);
5690 }
5691
5692 static HRESULT WINAPI ElementSelector_Invoke(IElementSelector *iface, DISPID dispIdMember, REFIID riid,
5693 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
5694 {
5695 HTMLElement *This = impl_from_IElementSelector(iface);
5696 return IDispatchEx_Invoke(&This->node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
5697 pDispParams, pVarResult, pExcepInfo, puArgErr);
5698 }
5699
5700 static HRESULT WINAPI ElementSelector_querySelector(IElementSelector *iface, BSTR v, IHTMLElement **pel)
5701 {
5702 HTMLElement *This = impl_from_IElementSelector(iface);
5703 nsIDOMElement *nselem;
5704 HTMLElement *elem;
5705 nsAString nsstr;
5706 nsresult nsres;
5707 HRESULT hres;
5708
5709 TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pel);
5710
5711 if(!This->dom_element) {
5712 FIXME("comment element\n");
5713 return E_NOTIMPL;
5714 }
5715
5716 nsAString_InitDepend(&nsstr, v);
5717 nsres = nsIDOMElement_QuerySelector(This->dom_element, &nsstr, &nselem);
5718 nsAString_Finish(&nsstr);
5719 if(NS_FAILED(nsres)) {
5720 ERR("QuerySelector failed: %08x\n", nsres);
5721 return E_FAIL;
5722 }
5723
5724 if(!nselem) {
5725 *pel = NULL;
5726 return S_OK;
5727 }
5728
5729 hres = get_element(nselem, &elem);
5730 nsIDOMElement_Release(nselem);
5731 if(FAILED(hres))
5732 return hres;
5733
5734 *pel = &elem->IHTMLElement_iface;
5735 return S_OK;
5736 }
5737
5738 static HRESULT WINAPI ElementSelector_querySelectorAll(IElementSelector *iface, BSTR v, IHTMLDOMChildrenCollection **pel)
5739 {
5740 HTMLElement *This = impl_from_IElementSelector(iface);
5741 nsIDOMNodeList *node_list;
5742 nsAString nsstr;
5743 nsresult nsres;
5744
5745 TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pel);
5746
5747 if(!This->dom_element) {
5748 FIXME("comment element\n");
5749 return E_NOTIMPL;
5750 }
5751
5752 nsAString_InitDepend(&nsstr, v);
5753 nsres = nsIDOMElement_QuerySelectorAll(This->dom_element, &nsstr, &node_list);
5754 nsAString_Finish(&nsstr);
5755 if(NS_FAILED(nsres)) {
5756 ERR("QuerySelectorAll failed: %08x\n", nsres);
5757 return E_FAIL;
5758 }
5759
5760 *pel = create_child_collection(node_list);
5761 nsIDOMNodeList_Release(node_list);
5762 return *pel ? S_OK : E_OUTOFMEMORY;
5763 }
5764
5765 static const IElementSelectorVtbl ElementSelectorVtbl = {
5766 ElementSelector_QueryInterface,
5767 ElementSelector_AddRef,
5768 ElementSelector_Release,
5769 ElementSelector_GetTypeInfoCount,
5770 ElementSelector_GetTypeInfo,
5771 ElementSelector_GetIDsOfNames,
5772 ElementSelector_Invoke,
5773 ElementSelector_querySelector,
5774 ElementSelector_querySelectorAll
5775 };
5776
5777 static inline HTMLElement *impl_from_IProvideMultipleClassInfo(IProvideMultipleClassInfo *iface)
5778 {
5779 return CONTAINING_RECORD(iface, HTMLElement, IProvideMultipleClassInfo_iface);
5780 }
5781
5782 static HRESULT WINAPI ProvideClassInfo_QueryInterface(IProvideMultipleClassInfo *iface,
5783 REFIID riid, void **ppv)
5784 {
5785 HTMLElement *This = impl_from_IProvideMultipleClassInfo(iface);
5786 return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
5787 }
5788
5789 static ULONG WINAPI ProvideClassInfo_AddRef(IProvideMultipleClassInfo *iface)
5790 {
5791 HTMLElement *This = impl_from_IProvideMultipleClassInfo(iface);
5792 return IHTMLElement_AddRef(&This->IHTMLElement_iface);
5793 }
5794
5795 static ULONG WINAPI ProvideClassInfo_Release(IProvideMultipleClassInfo *iface)
5796 {
5797 HTMLElement *This = impl_from_IProvideMultipleClassInfo(iface);
5798 return IHTMLElement_Release(&This->IHTMLElement_iface);
5799 }
5800
5801 static HRESULT WINAPI ProvideClassInfo_GetClassInfo(IProvideMultipleClassInfo *iface, ITypeInfo **ppTI)
5802 {
5803 HTMLElement *This = impl_from_IProvideMultipleClassInfo(iface);
5804 TRACE("(%p)->(%p)\n", This, ppTI);
5805 return get_class_typeinfo(This->node.vtbl->clsid, ppTI);
5806 }
5807
5808 static HRESULT WINAPI ProvideClassInfo2_GetGUID(IProvideMultipleClassInfo *iface, DWORD dwGuidKind, GUID *pGUID)
5809 {
5810 HTMLElement *This = impl_from_IProvideMultipleClassInfo(iface);
5811 FIXME("(%p)->(%u %p)\n", This, dwGuidKind, pGUID);
5812 return E_NOTIMPL;
5813 }
5814
5815 static HRESULT WINAPI ProvideMultipleClassInfo_GetMultiTypeInfoCount(IProvideMultipleClassInfo *iface, ULONG *pcti)
5816 {
5817 HTMLElement *This = impl_from_IProvideMultipleClassInfo(iface);
5818 FIXME("(%p)->(%p)\n", This, pcti);
5819 *pcti = 1;
5820 return S_OK;
5821 }
5822
5823 static HRESULT WINAPI ProvideMultipleClassInfo_GetInfoOfIndex(IProvideMultipleClassInfo *iface, ULONG iti,
5824 DWORD dwFlags, ITypeInfo **pptiCoClass, DWORD *pdwTIFlags, ULONG *pcdispidReserved, IID *piidPrimary, IID *piidSource)
5825 {
5826 HTMLElement *This = impl_from_IProvideMultipleClassInfo(iface);
5827 FIXME("(%p)->(%u %x %p %p %p %p %p)\n", This, iti, dwFlags, pptiCoClass, pdwTIFlags, pcdispidReserved, piidPrimary, piidSource);
5828 return E_NOTIMPL;
5829 }
5830
5831 static const IProvideMultipleClassInfoVtbl ProvideMultipleClassInfoVtbl = {
5832 ProvideClassInfo_QueryInterface,
5833 ProvideClassInfo_AddRef,
5834 ProvideClassInfo_Release,
5835 ProvideClassInfo_GetClassInfo,
5836 ProvideClassInfo2_GetGUID,
5837 ProvideMultipleClassInfo_GetMultiTypeInfoCount,
5838 ProvideMultipleClassInfo_GetInfoOfIndex
5839 };
5840
5841 static inline HTMLElement *impl_from_IElementTraversal(IElementTraversal *iface)
5842 {
5843 return CONTAINING_RECORD(iface, HTMLElement, IElementTraversal_iface);
5844 }
5845
5846 static HRESULT WINAPI ElementTraversal_QueryInterface(IElementTraversal *iface, REFIID riid, void **ppv)
5847 {
5848 HTMLElement *This = impl_from_IElementTraversal(iface);
5849 return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
5850 }
5851
5852 static ULONG WINAPI ElementTraversal_AddRef(IElementTraversal *iface)
5853 {
5854 HTMLElement *This = impl_from_IElementTraversal(iface);
5855
5856 return IHTMLElement_AddRef(&This->IHTMLElement_iface);
5857 }
5858
5859 static ULONG WINAPI ElementTraversal_Release(IElementTraversal *iface)
5860 {
5861 HTMLElement *This = impl_from_IElementTraversal(iface);
5862
5863 return IHTMLElement_Release(&This->IHTMLElement_iface);
5864 }
5865
5866 static HRESULT WINAPI ElementTraversal_GetTypeInfoCount(IElementTraversal *iface, UINT *pctinfo)
5867 {
5868 HTMLElement *This = impl_from_IElementTraversal(iface);
5869 return IDispatchEx_GetTypeInfoCount(&This->node.event_target.dispex.IDispatchEx_iface, pctinfo);
5870 }
5871
5872 static HRESULT WINAPI ElementTraversal_GetTypeInfo(IElementTraversal *iface, UINT iTInfo,
5873 LCID lcid, ITypeInfo **ppTInfo)
5874 {
5875 HTMLElement *This = impl_from_IElementTraversal(iface);
5876 return IDispatchEx_GetTypeInfo(&This->node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
5877 }
5878
5879 static HRESULT WINAPI ElementTraversal_GetIDsOfNames(IElementTraversal *iface, REFIID riid,
5880 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
5881 {
5882 HTMLElement *This = impl_from_IElementTraversal(iface);
5883 return IDispatchEx_GetIDsOfNames(&This->node.event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
5884 lcid, rgDispId);
5885 }
5886
5887 static HRESULT WINAPI ElementTraversal_Invoke(IElementTraversal *iface, DISPID dispIdMember, REFIID riid,
5888 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
5889 {
5890 HTMLElement *This = impl_from_IElementTraversal(iface);
5891 return IDispatchEx_Invoke(&This->node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
5892 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
5893 }
5894
5895 static HRESULT WINAPI ElementTraversal_get_firstElementChild(IElementTraversal *iface, IHTMLElement **p)
5896 {
5897 HTMLElement *This = impl_from_IElementTraversal(iface);
5898 nsIDOMElement *nselem = NULL;
5899 HTMLElement *elem;
5900 HRESULT hres;
5901
5902 TRACE("(%p)->(%p)\n", This, p);
5903
5904 if(!This->dom_element) {
5905 *p = NULL;
5906 return S_OK;
5907 }
5908
5909 nsIDOMElement_GetFirstElementChild(This->dom_element, &nselem);
5910 if(!nselem) {
5911 *p = NULL;
5912 return S_OK;
5913 }
5914
5915 hres = get_element(nselem, &elem);
5916 nsIDOMElement_Release(nselem);
5917 if(FAILED(hres))
5918 return hres;
5919
5920 *p = &elem->IHTMLElement_iface;
5921 return S_OK;
5922 }
5923
5924 static HRESULT WINAPI ElementTraversal_get_lastElementChild(IElementTraversal *iface, IHTMLElement **p)
5925 {
5926 HTMLElement *This = impl_from_IElementTraversal(iface);
5927 FIXME("(%p)->(%p)\n", This, p);
5928 return E_NOTIMPL;
5929 }
5930
5931 static HRESULT WINAPI ElementTraversal_get_previousElementSibling(IElementTraversal *iface, IHTMLElement **p)
5932 {
5933 HTMLElement *This = impl_from_IElementTraversal(iface);
5934 FIXME("(%p)->(%p)\n", This, p);
5935 return E_NOTIMPL;
5936 }
5937
5938 static HRESULT WINAPI ElementTraversal_get_nextElementSibling(IElementTraversal *iface, IHTMLElement **p)
5939 {
5940 HTMLElement *This = impl_from_IElementTraversal(iface);
5941 FIXME("(%p)->(%p)\n", This, p);
5942 return E_NOTIMPL;
5943 }
5944
5945 static HRESULT WINAPI ElementTraversal_get_childElementCount(IElementTraversal *iface, LONG *p)
5946 {
5947 HTMLElement *This = impl_from_IElementTraversal(iface);
5948 FIXME("(%p)->(%p)\n", This, p);
5949 return E_NOTIMPL;
5950 }
5951
5952 static const IElementTraversalVtbl ElementTraversalVtbl = {
5953 ElementTraversal_QueryInterface,
5954 ElementTraversal_AddRef,
5955 ElementTraversal_Release,
5956 ElementTraversal_GetTypeInfoCount,
5957 ElementTraversal_GetTypeInfo,
5958 ElementTraversal_GetIDsOfNames,
5959 ElementTraversal_Invoke,
5960 ElementTraversal_get_firstElementChild,
5961 ElementTraversal_get_lastElementChild,
5962 ElementTraversal_get_previousElementSibling,
5963 ElementTraversal_get_nextElementSibling,
5964 ElementTraversal_get_childElementCount
5965 };
5966
5967 static inline HTMLElement *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
5968 {
5969 return CONTAINING_RECORD(iface, HTMLElement, node);
5970 }
5971
5972 HRESULT HTMLElement_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
5973 {
5974 HTMLElement *This = impl_from_HTMLDOMNode(iface);
5975
5976 if(IsEqualGUID(&IID_IUnknown, riid)) {
5977 *ppv = &This->IHTMLElement_iface;
5978 }else if(IsEqualGUID(&IID_IDispatch, riid)) {
5979 *ppv = &This->IHTMLElement_iface;
5980 }else if(IsEqualGUID(&IID_IHTMLElement, riid)) {
5981 *ppv = &This->IHTMLElement_iface;
5982 }else if(IsEqualGUID(&IID_IHTMLElement2, riid)) {
5983 *ppv = &This->IHTMLElement2_iface;
5984 }else if(IsEqualGUID(&IID_IHTMLElement3, riid)) {
5985 *ppv = &This->IHTMLElement3_iface;
5986 }else if(IsEqualGUID(&IID_IHTMLElement4, riid)) {
5987 *ppv = &This->IHTMLElement4_iface;
5988 }else if(IsEqualGUID(&IID_IHTMLElement6, riid)) {
5989 *ppv = &This->IHTMLElement6_iface;
5990 }else if(IsEqualGUID(&IID_IHTMLElement7, riid)) {
5991 *ppv = &This->IHTMLElement7_iface;
5992 }else if(IsEqualGUID(&IID_IHTMLUniqueName, riid)) {
5993 *ppv = &This->IHTMLUniqueName_iface;
5994 }else if(IsEqualGUID(&IID_IElementSelector, riid)) {
5995 *ppv = &This->IElementSelector_iface;
5996 }else if(IsEqualGUID(&IID_IElementTraversal, riid)) {
5997 *ppv = &This->IElementTraversal_iface;
5998 }else if(IsEqualGUID(&IID_IConnectionPointContainer, riid)) {
5999 *ppv = &This->cp_container.IConnectionPointContainer_iface;
6000 }else if(IsEqualGUID(&IID_IProvideClassInfo, riid)) {
6001 *ppv = &This->IProvideMultipleClassInfo_iface;
6002 }else if(IsEqualGUID(&IID_IProvideClassInfo2, riid)) {
6003 *ppv = &This->IProvideMultipleClassInfo_iface;
6004 }else if(IsEqualGUID(&IID_IProvideMultipleClassInfo, riid)) {
6005 *ppv = &This->IProvideMultipleClassInfo_iface;
6006 }else {
6007 return HTMLDOMNode_QI(&This->node, riid, ppv);
6008 }
6009
6010 IUnknown_AddRef((IUnknown*)*ppv);
6011 return S_OK;
6012 }
6013
6014 void HTMLElement_destructor(HTMLDOMNode *iface)
6015 {
6016 HTMLElement *This = impl_from_HTMLDOMNode(iface);
6017
6018 ConnectionPointContainer_Destroy(&This->cp_container);
6019
6020 if(This->style) {
6021 This->style->elem = NULL;
6022 IHTMLStyle_Release(&This->style->IHTMLStyle_iface);
6023 }
6024 if(This->runtime_style) {
6025 This->runtime_style->elem = NULL;
6026 IHTMLStyle_Release(&This->runtime_style->IHTMLStyle_iface);
6027 }
6028 if(This->attrs) {
6029 HTMLDOMAttribute *attr;
6030
6031 LIST_FOR_EACH_ENTRY(attr, &This->attrs->attrs, HTMLDOMAttribute, entry)
6032 attr->elem = NULL;
6033
6034 This->attrs->elem = NULL;
6035 IHTMLAttributeCollection_Release(&This->attrs->IHTMLAttributeCollection_iface);
6036 }
6037
6038 heap_free(This->filter);
6039
6040 HTMLDOMNode_destructor(&This->node);
6041 }
6042
6043 HRESULT HTMLElement_clone(HTMLDOMNode *iface, nsIDOMNode *nsnode, HTMLDOMNode **ret)
6044 {
6045 HTMLElement *This = impl_from_HTMLDOMNode(iface);
6046 HTMLElement *new_elem;
6047 HRESULT hres;
6048
6049 hres = HTMLElement_Create(This->node.doc, nsnode, FALSE, &new_elem);
6050 if(FAILED(hres))
6051 return hres;
6052
6053 if(This->filter) {
6054 new_elem->filter = heap_strdupW(This->filter);
6055 if(!new_elem->filter) {
6056 IHTMLElement_Release(&This->IHTMLElement_iface);
6057 return E_OUTOFMEMORY;
6058 }
6059 }
6060
6061 *ret = &new_elem->node;
6062 return S_OK;
6063 }
6064
6065 HRESULT HTMLElement_handle_event(HTMLDOMNode *iface, DWORD eid, nsIDOMEvent *event, BOOL *prevent_default)
6066 {
6067 HTMLElement *This = impl_from_HTMLDOMNode(iface);
6068
6069 switch(eid) {
6070 case EVENTID_KEYDOWN: {
6071 nsIDOMKeyEvent *key_event;
6072 nsresult nsres;
6073
6074 nsres = nsIDOMEvent_QueryInterface(event, &IID_nsIDOMKeyEvent, (void**)&key_event);
6075 if(NS_SUCCEEDED(nsres)) {
6076 UINT32 code = 0;
6077
6078 nsIDOMKeyEvent_GetKeyCode(key_event, &code);
6079
6080 if(code == VK_F1 /* DOM_VK_F1 */) {
6081 DOMEvent *help_event;
6082 HRESULT hres;
6083
6084 TRACE("F1 pressed\n");
6085
6086 hres = create_document_event(This->node.doc, EVENTID_HELP, &help_event);
6087 if(SUCCEEDED(hres)) {
6088 dispatch_event(&This->node.event_target, help_event);
6089 IDOMEvent_Release(&help_event->IDOMEvent_iface);
6090 }
6091 *prevent_default = TRUE;
6092 }
6093
6094 nsIDOMKeyEvent_Release(key_event);
6095 }
6096 }
6097 }
6098
6099 return S_OK;
6100 }
6101
6102 cp_static_data_t HTMLElementEvents2_data = { HTMLElementEvents2_tid, NULL /* FIXME */, TRUE };
6103
6104 const cpc_entry_t HTMLElement_cpc[] = {
6105 HTMLELEMENT_CPC,
6106 {NULL}
6107 };
6108
6109 static const NodeImplVtbl HTMLElementImplVtbl = {
6110 &CLSID_HTMLUnknownElement,
6111 HTMLElement_QI,
6112 HTMLElement_destructor,
6113 HTMLElement_cpc,
6114 HTMLElement_clone,
6115 HTMLElement_handle_event,
6116 HTMLElement_get_attr_col
6117 };
6118
6119 static inline HTMLElement *impl_from_DispatchEx(DispatchEx *iface)
6120 {
6121 return CONTAINING_RECORD(iface, HTMLElement, node.event_target.dispex);
6122 }
6123
6124 static HRESULT HTMLElement_get_dispid(DispatchEx *dispex, BSTR name,
6125 DWORD grfdex, DISPID *pid)
6126 {
6127 HTMLElement *This = impl_from_DispatchEx(dispex);
6128
6129 if(This->node.vtbl->get_dispid)
6130 return This->node.vtbl->get_dispid(&This->node, name, grfdex, pid);
6131
6132 return DISP_E_UNKNOWNNAME;
6133 }
6134
6135 static HRESULT HTMLElement_invoke(DispatchEx *dispex, DISPID id, LCID lcid,
6136 WORD flags, DISPPARAMS *params, VARIANT *res, EXCEPINFO *ei,
6137 IServiceProvider *caller)
6138 {
6139 HTMLElement *This = impl_from_DispatchEx(dispex);
6140
6141 if(This->node.vtbl->invoke)
6142 return This->node.vtbl->invoke(&This->node, id, lcid, flags,
6143 params, res, ei, caller);
6144
6145 ERR("(%p): element has no invoke method\n", This);
6146 return E_NOTIMPL;
6147 }
6148
6149 static HRESULT HTMLElement_populate_props(DispatchEx *dispex)
6150 {
6151 HTMLElement *This = impl_from_DispatchEx(dispex);
6152 nsIDOMMozNamedAttrMap *attrs;
6153 nsIDOMAttr *attr;
6154 nsAString nsstr;
6155 const PRUnichar *str;
6156 BSTR name;
6157 VARIANT value;
6158 unsigned i;
6159 UINT32 len;
6160 DISPID id;
6161 nsresult nsres;
6162 HRESULT hres;
6163
6164 if(!This->dom_element)
6165 return S_FALSE;
6166
6167 nsres = nsIDOMElement_GetAttributes(This->dom_element, &attrs);
6168 if(NS_FAILED(nsres))
6169 return E_FAIL;
6170
6171 nsres = nsIDOMMozNamedAttrMap_GetLength(attrs, &len);
6172 if(NS_FAILED(nsres)) {
6173 nsIDOMMozNamedAttrMap_Release(attrs);
6174 return E_FAIL;
6175 }
6176
6177 nsAString_Init(&nsstr, NULL);
6178 for(i=0; i<len; i++) {
6179 nsres = nsIDOMMozNamedAttrMap_Item(attrs, i, &attr);
6180 if(NS_FAILED(nsres))
6181 continue;
6182
6183 nsres = nsIDOMAttr_GetNodeName(attr, &nsstr);
6184 if(NS_FAILED(nsres)) {
6185 nsIDOMAttr_Release(attr);
6186 continue;
6187 }
6188
6189 nsAString_GetData(&nsstr, &str);
6190 name = SysAllocString(str);
6191 if(!name) {
6192 nsIDOMAttr_Release(attr);
6193 continue;
6194 }
6195
6196 hres = IDispatchEx_GetDispID(&dispex->IDispatchEx_iface, name, fdexNameCaseInsensitive, &id);
6197 if(hres != DISP_E_UNKNOWNNAME) {
6198 nsIDOMAttr_Release(attr);
6199 SysFreeString(name);
6200 continue;
6201 }
6202
6203 nsres = nsIDOMAttr_GetNodeValue(attr, &nsstr);
6204 nsIDOMAttr_Release(attr);
6205 if(NS_FAILED(nsres)) {
6206 SysFreeString(name);
6207 continue;
6208 }
6209
6210 nsAString_GetData(&nsstr, &str);
6211 V_VT(&value) = VT_BSTR;
6212 if(*str) {
6213 V_BSTR(&value) = SysAllocString(str);
6214 if(!V_BSTR(&value)) {
6215 SysFreeString(name);
6216 continue;
6217 }
6218 } else
6219 V_BSTR(&value) = NULL;
6220
6221 IHTMLElement_setAttribute(&This->IHTMLElement_iface, name, value, 0);
6222 SysFreeString(name);
6223 VariantClear(&value);
6224 }
6225 nsAString_Finish(&nsstr);
6226
6227 nsIDOMMozNamedAttrMap_Release(attrs);
6228 return S_OK;
6229 }
6230
6231 static nsISupports *HTMLElement_get_gecko_target(DispatchEx *dispex)
6232 {
6233 HTMLElement *This = impl_from_DispatchEx(dispex);
6234 return (nsISupports*)This->node.nsnode;
6235 }
6236
6237 static void HTMLElement_bind_event(DispatchEx *dispex, eventid_t eid)
6238 {
6239 HTMLElement *This = impl_from_DispatchEx(dispex);
6240 ensure_doc_nsevent_handler(This->node.doc, This->node.nsnode, eid);
6241 }
6242
6243 static HRESULT HTMLElement_handle_event_default(DispatchEx *dispex, eventid_t eid, nsIDOMEvent *nsevent, BOOL *prevent_default)
6244 {
6245 HTMLElement *This = impl_from_DispatchEx(dispex);
6246
6247 if(!This->node.vtbl->handle_event)
6248 return S_OK;
6249 return This->node.vtbl->handle_event(&This->node, eid, nsevent, prevent_default);
6250 }
6251
6252 static EventTarget *HTMLElement_get_parent_event_target(DispatchEx *dispex)
6253 {
6254 HTMLElement *This = impl_from_DispatchEx(dispex);
6255 HTMLDOMNode *node;
6256 nsIDOMNode *nsnode;
6257 nsresult nsres;
6258 HRESULT hres;
6259
6260 nsres = nsIDOMNode_GetParentNode(This->node.nsnode, &nsnode);
6261 assert(nsres == NS_OK);
6262 if(!nsnode)
6263 return NULL;
6264
6265 hres = get_node(nsnode, TRUE, &node);
6266 nsIDOMNode_Release(nsnode);
6267 if(FAILED(hres))
6268 return NULL;
6269
6270 return &node->event_target;
6271 }
6272
6273 static ConnectionPointContainer *HTMLElement_get_cp_container(DispatchEx *dispex)
6274 {
6275 HTMLElement *This = impl_from_DispatchEx(dispex);
6276 IConnectionPointContainer_AddRef(&This->cp_container.IConnectionPointContainer_iface);
6277 return &This->cp_container;
6278 }
6279
6280 static IHTMLEventObj *HTMLElement_set_current_event(DispatchEx *dispex, IHTMLEventObj *event)
6281 {
6282 HTMLElement *This = impl_from_DispatchEx(dispex);
6283 return default_set_current_event(This->node.doc->window, event);
6284 }
6285
6286 void HTMLElement_init_dispex_info(dispex_data_t *info, compat_mode_t mode)
6287 {
6288 static const dispex_hook_t elem2_ie11_hooks[] = {
6289 {DISPID_IHTMLELEMENT2_DOSCROLL, NULL},
6290 {DISPID_UNKNOWN}
6291 };
6292
6293 HTMLDOMNode_init_dispex_info(info, mode);
6294
6295 dispex_info_add_interface(info, IHTMLElement2_tid, mode >= COMPAT_MODE_IE11 ? elem2_ie11_hooks : NULL);
6296
6297 if(mode >= COMPAT_MODE_IE8)
6298 dispex_info_add_interface(info, IElementSelector_tid, NULL);
6299
6300 if(mode >= COMPAT_MODE_IE9) {
6301 dispex_info_add_interface(info, IHTMLElement6_tid, NULL);
6302 dispex_info_add_interface(info, IElementTraversal_tid, NULL);
6303 }
6304
6305 if(mode >= COMPAT_MODE_IE10)
6306 dispex_info_add_interface(info, IHTMLElement7_tid, NULL);
6307 }
6308
6309 static const tid_t HTMLElement_iface_tids[] = {
6310 HTMLELEMENT_TIDS,
6311 0
6312 };
6313
6314 static event_target_vtbl_t HTMLElement_event_target_vtbl = {
6315 {
6316 NULL,
6317 HTMLElement_get_dispid,
6318 HTMLElement_invoke,
6319 NULL,
6320 HTMLElement_populate_props
6321 },
6322 HTMLElement_get_gecko_target,
6323 HTMLElement_bind_event,
6324 HTMLElement_get_parent_event_target,
6325 HTMLElement_handle_event_default,
6326 HTMLElement_get_cp_container,
6327 HTMLElement_set_current_event
6328 };
6329
6330 static dispex_static_data_t HTMLElement_dispex = {
6331 &HTMLElement_event_target_vtbl.dispex_vtbl,
6332 DispHTMLUnknownElement_tid,
6333 HTMLElement_iface_tids,
6334 HTMLElement_init_dispex_info
6335 };
6336
6337 void HTMLElement_Init(HTMLElement *This, HTMLDocumentNode *doc, nsIDOMElement *nselem, dispex_static_data_t *dispex_data)
6338 {
6339 This->IHTMLElement_iface.lpVtbl = &HTMLElementVtbl;
6340 This->IHTMLElement2_iface.lpVtbl = &HTMLElement2Vtbl;
6341 This->IHTMLElement3_iface.lpVtbl = &HTMLElement3Vtbl;
6342 This->IHTMLElement4_iface.lpVtbl = &HTMLElement4Vtbl;
6343 This->IHTMLElement6_iface.lpVtbl = &HTMLElement6Vtbl;
6344 This->IHTMLElement7_iface.lpVtbl = &HTMLElement7Vtbl;
6345 This->IHTMLUniqueName_iface.lpVtbl = &HTMLUniqueNameVtbl;
6346 This->IElementSelector_iface.lpVtbl = &ElementSelectorVtbl;
6347 This->IElementTraversal_iface.lpVtbl = &ElementTraversalVtbl;
6348 This->IProvideMultipleClassInfo_iface.lpVtbl = &ProvideMultipleClassInfoVtbl;
6349
6350 if(dispex_data && !dispex_data->vtbl)
6351 dispex_data->vtbl = &HTMLElement_event_target_vtbl.dispex_vtbl;
6352
6353 if(nselem) {
6354 nsIDOMHTMLElement *html_element;
6355 nsresult nsres;
6356
6357 HTMLDOMNode_Init(doc, &This->node, (nsIDOMNode*)nselem, dispex_data ? dispex_data : &HTMLElement_dispex);
6358
6359 /* No AddRef, share reference with HTMLDOMNode */
6360 assert((nsIDOMNode*)nselem == This->node.nsnode);
6361 This->dom_element = nselem;
6362
6363 nsres = nsIDOMElement_QueryInterface(nselem, &IID_nsIDOMHTMLElement, (void**)&html_element);
6364 if(NS_SUCCEEDED(nsres)) {
6365 This->html_element = html_element;
6366 /* share reference with HTMLDOMNode */
6367 assert((nsIDOMNode*)html_element == This->node.nsnode);
6368 nsIDOMHTMLElement_Release(html_element);
6369 }
6370 }
6371
6372 ConnectionPointContainer_Init(&This->cp_container, (IUnknown*)&This->IHTMLElement_iface, This->node.vtbl->cpc_entries);
6373 }
6374
6375 HRESULT HTMLElement_Create(HTMLDocumentNode *doc, nsIDOMNode *nsnode, BOOL use_generic, HTMLElement **ret)
6376 {
6377 nsIDOMElement *nselem;
6378 nsAString tag_name_str;
6379 const PRUnichar *tag_name;
6380 const tag_desc_t *tag;
6381 HTMLElement *elem;
6382 nsresult nsres;
6383 HRESULT hres;
6384
6385 nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMElement, (void**)&nselem);
6386 if(NS_FAILED(nsres)) {
6387 ERR("no nsIDOMElement iface\n");
6388 return E_FAIL;
6389 }
6390
6391 nsAString_Init(&tag_name_str, NULL);
6392 nsIDOMElement_GetTagName(nselem, &tag_name_str);
6393
6394 nsAString_GetData(&tag_name_str, &tag_name);
6395
6396 tag = get_tag_desc(tag_name);
6397 if(tag) {
6398 hres = tag->constructor(doc, nselem, &elem);
6399 }else {
6400 nsIDOMSVGElement *svg_element;
6401
6402 nsres = nsIDOMElement_QueryInterface(nselem, &IID_nsIDOMSVGElement, (void**)&svg_element);
6403 if(NS_SUCCEEDED(nsres)) {
6404 hres = create_svg_element(doc, svg_element, tag_name, &elem);
6405 nsIDOMSVGElement_Release(svg_element);
6406 }else if(use_generic) {
6407 hres = HTMLGenericElement_Create(doc, nselem, &elem);
6408 }else {
6409 elem = heap_alloc_zero(sizeof(HTMLElement));
6410 if(elem) {
6411 elem->node.vtbl = &HTMLElementImplVtbl;
6412 HTMLElement_Init(elem, doc, nselem, &HTMLElement_dispex);
6413 hres = S_OK;
6414 }else {
6415 hres = E_OUTOFMEMORY;
6416 }
6417 }
6418 }
6419
6420 TRACE("%s ret %p\n", debugstr_w(tag_name), elem);
6421
6422 nsIDOMElement_Release(nselem);
6423 nsAString_Finish(&tag_name_str);
6424 if(FAILED(hres))
6425 return hres;
6426
6427 *ret = elem;
6428 return S_OK;
6429 }
6430
6431 HRESULT get_element(nsIDOMElement *nselem, HTMLElement **ret)
6432 {
6433 HTMLDOMNode *node;
6434 HRESULT hres;
6435
6436 hres = get_node((nsIDOMNode*)nselem, TRUE, &node);
6437 if(FAILED(hres))
6438 return hres;
6439
6440 *ret = impl_from_HTMLDOMNode(node);
6441 return S_OK;
6442 }
6443
6444 /* interface IHTMLFiltersCollection */
6445 static HRESULT WINAPI HTMLFiltersCollection_QueryInterface(IHTMLFiltersCollection *iface, REFIID riid, void **ppv)
6446 {
6447 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
6448
6449 TRACE("%p %s %p\n", This, debugstr_mshtml_guid(riid), ppv );
6450
6451 if(IsEqualGUID(&IID_IUnknown, riid)) {
6452 *ppv = &This->IHTMLFiltersCollection_iface;
6453 }else if(IsEqualGUID(&IID_IHTMLFiltersCollection, riid)) {
6454 TRACE("(%p)->(IID_IHTMLFiltersCollection %p)\n", This, ppv);
6455 *ppv = &This->IHTMLFiltersCollection_iface;
6456 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
6457 return *ppv ? S_OK : E_NOINTERFACE;
6458 }else {
6459 *ppv = NULL;
6460 FIXME("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
6461 return E_NOINTERFACE;
6462 }
6463
6464 IUnknown_AddRef((IUnknown*)*ppv);
6465 return S_OK;
6466 }
6467
6468 static ULONG WINAPI HTMLFiltersCollection_AddRef(IHTMLFiltersCollection *iface)
6469 {
6470 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
6471 LONG ref = InterlockedIncrement(&This->ref);
6472
6473 TRACE("(%p) ref=%d\n", This, ref);
6474
6475 return ref;
6476 }
6477
6478 static ULONG WINAPI HTMLFiltersCollection_Release(IHTMLFiltersCollection *iface)
6479 {
6480 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
6481 LONG ref = InterlockedDecrement(&This->ref);
6482
6483 TRACE("(%p) ref=%d\n", This, ref);
6484
6485 if(!ref)
6486 {
6487 heap_free(This);
6488 }
6489
6490 return ref;
6491 }
6492
6493 static HRESULT WINAPI HTMLFiltersCollection_GetTypeInfoCount(IHTMLFiltersCollection *iface, UINT *pctinfo)
6494 {
6495 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
6496 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
6497 }
6498
6499 static HRESULT WINAPI HTMLFiltersCollection_GetTypeInfo(IHTMLFiltersCollection *iface,
6500 UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
6501 {
6502 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
6503 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
6504 }
6505
6506 static HRESULT WINAPI HTMLFiltersCollection_GetIDsOfNames(IHTMLFiltersCollection *iface,
6507 REFIID riid, LPOLESTR *rgszNames, UINT cNames,
6508 LCID lcid, DISPID *rgDispId)
6509 {
6510 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
6511 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
6512 lcid, rgDispId);
6513 }
6514
6515 static HRESULT WINAPI HTMLFiltersCollection_Invoke(IHTMLFiltersCollection *iface, DISPID dispIdMember, REFIID riid,
6516 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
6517 EXCEPINFO *pExcepInfo, UINT *puArgErr)
6518 {
6519 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
6520 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
6521 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
6522 }
6523
6524 static HRESULT WINAPI HTMLFiltersCollection_get_length(IHTMLFiltersCollection *iface, LONG *p)
6525 {
6526 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
6527
6528 if(!p)
6529 return E_POINTER;
6530
6531 FIXME("(%p)->(%p) Always returning 0\n", This, p);
6532 *p = 0;
6533
6534 return S_OK;
6535 }
6536
6537 static HRESULT WINAPI HTMLFiltersCollection_get__newEnum(IHTMLFiltersCollection *iface, IUnknown **p)
6538 {
6539 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
6540 FIXME("(%p)->(%p)\n", This, p);
6541 return E_NOTIMPL;
6542 }
6543
6544 static HRESULT WINAPI HTMLFiltersCollection_item(IHTMLFiltersCollection *iface, VARIANT *pvarIndex, VARIANT *pvarResult)
6545 {
6546 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
6547 FIXME("(%p)->(%p, %p)\n", This, pvarIndex, pvarResult);
6548 return E_NOTIMPL;
6549 }
6550
6551 static const IHTMLFiltersCollectionVtbl HTMLFiltersCollectionVtbl = {
6552 HTMLFiltersCollection_QueryInterface,
6553 HTMLFiltersCollection_AddRef,
6554 HTMLFiltersCollection_Release,
6555 HTMLFiltersCollection_GetTypeInfoCount,
6556 HTMLFiltersCollection_GetTypeInfo,
6557 HTMLFiltersCollection_GetIDsOfNames,
6558 HTMLFiltersCollection_Invoke,
6559 HTMLFiltersCollection_get_length,
6560 HTMLFiltersCollection_get__newEnum,
6561 HTMLFiltersCollection_item
6562 };
6563
6564 static HRESULT HTMLFiltersCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
6565 {
6566 WCHAR *ptr;
6567 int idx = 0;
6568
6569 for(ptr = name; *ptr && is_digit(*ptr); ptr++)
6570 idx = idx*10 + (*ptr-'0');
6571 if(*ptr)
6572 return DISP_E_UNKNOWNNAME;
6573
6574 *dispid = MSHTML_DISPID_CUSTOM_MIN + idx;
6575 TRACE("ret %x\n", *dispid);
6576 return S_OK;
6577 }
6578
6579 static HRESULT HTMLFiltersCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
6580 VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
6581 {
6582 TRACE("(%p)->(%x %x %x %p %p %p)\n", dispex, id, lcid, flags, params, res, ei);
6583
6584 V_VT(res) = VT_DISPATCH;
6585 V_DISPATCH(res) = NULL;
6586
6587 FIXME("always returning NULL\n");
6588
6589 return S_OK;
6590 }
6591
6592 static const dispex_static_data_vtbl_t HTMLFiltersCollection_dispex_vtbl = {
6593 NULL,
6594 HTMLFiltersCollection_get_dispid,
6595 HTMLFiltersCollection_invoke,
6596 NULL
6597 };
6598
6599 static const tid_t HTMLFiltersCollection_iface_tids[] = {
6600 IHTMLFiltersCollection_tid,
6601 0
6602 };
6603 static dispex_static_data_t HTMLFiltersCollection_dispex = {
6604 &HTMLFiltersCollection_dispex_vtbl,
6605 IHTMLFiltersCollection_tid,
6606 HTMLFiltersCollection_iface_tids
6607 };
6608
6609 static IHTMLFiltersCollection *HTMLFiltersCollection_Create(void)
6610 {
6611 HTMLFiltersCollection *ret = heap_alloc(sizeof(HTMLFiltersCollection));
6612
6613 ret->IHTMLFiltersCollection_iface.lpVtbl = &HTMLFiltersCollectionVtbl;
6614 ret->ref = 1;
6615
6616 init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLFiltersCollection_iface,
6617 &HTMLFiltersCollection_dispex);
6618
6619 return &ret->IHTMLFiltersCollection_iface;
6620 }
6621
6622 /* interface IHTMLAttributeCollection */
6623 static inline HTMLAttributeCollection *impl_from_IHTMLAttributeCollection(IHTMLAttributeCollection *iface)
6624 {
6625 return CONTAINING_RECORD(iface, HTMLAttributeCollection, IHTMLAttributeCollection_iface);
6626 }
6627
6628 static HRESULT WINAPI HTMLAttributeCollection_QueryInterface(IHTMLAttributeCollection *iface, REFIID riid, void **ppv)
6629 {
6630 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
6631
6632 TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
6633
6634 if(IsEqualGUID(&IID_IUnknown, riid)) {
6635 *ppv = &This->IHTMLAttributeCollection_iface;
6636 }else if(IsEqualGUID(&IID_IHTMLAttributeCollection, riid)) {
6637 *ppv = &This->IHTMLAttributeCollection_iface;
6638 }else if(IsEqualGUID(&IID_IHTMLAttributeCollection2, riid)) {
6639 *ppv = &This->IHTMLAttributeCollection2_iface;
6640 }else if(IsEqualGUID(&IID_IHTMLAttributeCollection3, riid)) {
6641 *ppv = &This->IHTMLAttributeCollection3_iface;
6642 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
6643 return *ppv ? S_OK : E_NOINTERFACE;
6644 }else {
6645 *ppv = NULL;
6646 WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
6647 return E_NOINTERFACE;
6648 }
6649
6650 IUnknown_AddRef((IUnknown*)*ppv);
6651 return S_OK;
6652 }
6653
6654 static ULONG WINAPI HTMLAttributeCollection_AddRef(IHTMLAttributeCollection *iface)
6655 {
6656 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
6657 LONG ref = InterlockedIncrement(&This->ref);
6658
6659 TRACE("(%p) ref=%d\n", This, ref);
6660
6661 return ref;
6662 }
6663
6664 static ULONG WINAPI HTMLAttributeCollection_Release(IHTMLAttributeCollection *iface)
6665 {
6666 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
6667 LONG ref = InterlockedDecrement(&This->ref);
6668
6669 TRACE("(%p) ref=%d\n", This, ref);
6670
6671 if(!ref) {
6672 while(!list_empty(&This->attrs)) {
6673 HTMLDOMAttribute *attr = LIST_ENTRY(list_head(&This->attrs), HTMLDOMAttribute, entry);
6674
6675 list_remove(&attr->entry);
6676 attr->elem = NULL;
6677 IHTMLDOMAttribute_Release(&attr->IHTMLDOMAttribute_iface);
6678 }
6679
6680 heap_free(This);
6681 }
6682
6683 return ref;
6684 }
6685
6686 static HRESULT WINAPI HTMLAttributeCollection_GetTypeInfoCount(IHTMLAttributeCollection *iface, UINT *pctinfo)
6687 {
6688 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
6689 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
6690 }
6691
6692 static HRESULT WINAPI HTMLAttributeCollection_GetTypeInfo(IHTMLAttributeCollection *iface, UINT iTInfo,
6693 LCID lcid, ITypeInfo **ppTInfo)
6694 {
6695 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
6696 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
6697 }
6698
6699 static HRESULT WINAPI HTMLAttributeCollection_GetIDsOfNames(IHTMLAttributeCollection *iface, REFIID riid,
6700 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
6701 {
6702 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
6703 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
6704 lcid, rgDispId);
6705 }
6706
6707 static HRESULT WINAPI HTMLAttributeCollection_Invoke(IHTMLAttributeCollection *iface, DISPID dispIdMember,
6708 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
6709 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
6710 {
6711 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
6712 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
6713 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
6714 }
6715
6716 static HRESULT get_attr_dispid_by_idx(HTMLAttributeCollection *This, LONG *idx, DISPID *dispid)
6717 {
6718 IDispatchEx *dispex = &This->elem->node.event_target.dispex.IDispatchEx_iface;
6719 DISPID id = DISPID_STARTENUM;
6720 LONG len = -1;
6721 HRESULT hres;
6722
6723 FIXME("filter non-enumerable attributes out\n");
6724
6725 while(1) {
6726 hres = IDispatchEx_GetNextDispID(dispex, fdexEnumAll, id, &id);
6727 if(FAILED(hres))
6728 return hres;
6729 else if(hres == S_FALSE)
6730 break;
6731
6732 len++;
6733 if(len == *idx)
6734 break;
6735 }
6736
6737 if(dispid) {
6738 *dispid = id;
6739 return *idx==len ? S_OK : DISP_E_UNKNOWNNAME;
6740 }
6741
6742 *idx = len+1;
6743 return S_OK;
6744 }
6745
6746 static inline HRESULT get_attr_dispid_by_name(HTMLAttributeCollection *This, BSTR name, DISPID *id)
6747 {
6748 HRESULT hres;
6749
6750 if(name[0]>='0' && name[0]<='9') {
6751 WCHAR *end_ptr;
6752 LONG idx;
6753
6754 idx = wcstoul(name, &end_ptr, 10);
6755 if(!*end_ptr) {
6756 hres = get_attr_dispid_by_idx(This, &idx, id);
6757 if(SUCCEEDED(hres))
6758 return hres;
6759 }
6760 }
6761
6762 if(!This->elem) {
6763 WARN("NULL elem\n");
6764 return E_UNEXPECTED;
6765 }
6766
6767 hres = IDispatchEx_GetDispID(&This->elem->node.event_target.dispex.IDispatchEx_iface,
6768 name, fdexNameCaseInsensitive, id);
6769 return hres;
6770 }
6771
6772 static inline HRESULT get_domattr(HTMLAttributeCollection *This, DISPID id, LONG *list_pos, HTMLDOMAttribute **attr)
6773 {
6774 HTMLDOMAttribute *iter;
6775 LONG pos = 0;
6776 HRESULT hres;
6777
6778 *attr = NULL;
6779 LIST_FOR_EACH_ENTRY(iter, &This->attrs, HTMLDOMAttribute, entry) {
6780 if(iter->dispid == id) {
6781 *attr = iter;
6782 break;
6783 }
6784 pos++;
6785 }
6786
6787 if(!*attr) {
6788 if(!This->elem) {
6789 WARN("NULL elem\n");
6790 return E_UNEXPECTED;
6791 }
6792
6793 hres = HTMLDOMAttribute_Create(NULL, This->elem, id, attr);
6794 if(FAILED(hres))
6795 return hres;
6796 }
6797
6798 IHTMLDOMAttribute_AddRef(&(*attr)->IHTMLDOMAttribute_iface);
6799 if(list_pos)
6800 *list_pos = pos;
6801 return S_OK;
6802 }
6803
6804 static HRESULT WINAPI HTMLAttributeCollection_get_length(IHTMLAttributeCollection *iface, LONG *p)
6805 {
6806 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
6807 HRESULT hres;
6808
6809 TRACE("(%p)->(%p)\n", This, p);
6810
6811 *p = -1;
6812 hres = get_attr_dispid_by_idx(This, p, NULL);
6813 return hres;
6814 }
6815
6816 static HRESULT WINAPI HTMLAttributeCollection__newEnum(IHTMLAttributeCollection *iface, IUnknown **p)
6817 {
6818 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
6819 FIXME("(%p)->(%p)\n", This, p);
6820 return E_NOTIMPL;
6821 }
6822
6823 static HRESULT WINAPI HTMLAttributeCollection_item(IHTMLAttributeCollection *iface, VARIANT *name, IDispatch **ppItem)
6824 {
6825 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
6826 HTMLDOMAttribute *attr;
6827 DISPID id;
6828 HRESULT hres;
6829
6830 TRACE("(%p)->(%s %p)\n", This, debugstr_variant(name), ppItem);
6831
6832 switch(V_VT(name)) {
6833 case VT_I4:
6834 hres = get_attr_dispid_by_idx(This, &V_I4(name), &id);
6835 break;
6836 case VT_BSTR:
6837 hres = get_attr_dispid_by_name(This, V_BSTR(name), &id);
6838 break;
6839 default:
6840 FIXME("unsupported name %s\n", debugstr_variant(name));
6841 hres = E_NOTIMPL;
6842 }
6843 if(hres == DISP_E_UNKNOWNNAME)
6844 return E_INVALIDARG;
6845 if(FAILED(hres))
6846 return hres;
6847
6848 hres = get_domattr(This, id, NULL, &attr);
6849 if(FAILED(hres))
6850 return hres;
6851
6852 *ppItem = (IDispatch*)&attr->IHTMLDOMAttribute_iface;
6853 return S_OK;
6854 }
6855
6856 static const IHTMLAttributeCollectionVtbl HTMLAttributeCollectionVtbl = {
6857 HTMLAttributeCollection_QueryInterface,
6858 HTMLAttributeCollection_AddRef,
6859 HTMLAttributeCollection_Release,
6860 HTMLAttributeCollection_GetTypeInfoCount,
6861 HTMLAttributeCollection_GetTypeInfo,
6862 HTMLAttributeCollection_GetIDsOfNames,
6863 HTMLAttributeCollection_Invoke,
6864 HTMLAttributeCollection_get_length,
6865 HTMLAttributeCollection__newEnum,
6866 HTMLAttributeCollection_item
6867 };
6868
6869 static inline HTMLAttributeCollection *impl_from_IHTMLAttributeCollection2(IHTMLAttributeCollection2 *iface)
6870 {
6871 return CONTAINING_RECORD(iface, HTMLAttributeCollection, IHTMLAttributeCollection2_iface);
6872 }
6873
6874 static HRESULT WINAPI HTMLAttributeCollection2_QueryInterface(IHTMLAttributeCollection2 *iface, REFIID riid, void **ppv)
6875 {
6876 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
6877 return IHTMLAttributeCollection_QueryInterface(&This->IHTMLAttributeCollection_iface, riid, ppv);
6878 }
6879
6880 static ULONG WINAPI HTMLAttributeCollection2_AddRef(IHTMLAttributeCollection2 *iface)
6881 {
6882 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
6883 return IHTMLAttributeCollection_AddRef(&This->IHTMLAttributeCollection_iface);
6884 }
6885
6886 static ULONG WINAPI HTMLAttributeCollection2_Release(IHTMLAttributeCollection2 *iface)
6887 {
6888 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
6889 return IHTMLAttributeCollection_Release(&This->IHTMLAttributeCollection_iface);
6890 }
6891
6892 static HRESULT WINAPI HTMLAttributeCollection2_GetTypeInfoCount(IHTMLAttributeCollection2 *iface, UINT *pctinfo)
6893 {
6894 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
6895 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
6896 }
6897
6898 static HRESULT WINAPI HTMLAttributeCollection2_GetTypeInfo(IHTMLAttributeCollection2 *iface, UINT iTInfo,
6899 LCID lcid, ITypeInfo **ppTInfo)
6900 {
6901 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
6902 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
6903 }
6904
6905 static HRESULT WINAPI HTMLAttributeCollection2_GetIDsOfNames(IHTMLAttributeCollection2 *iface, REFIID riid,
6906 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
6907 {
6908 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
6909 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
6910 lcid, rgDispId);
6911 }
6912
6913 static HRESULT WINAPI HTMLAttributeCollection2_Invoke(IHTMLAttributeCollection2 *iface, DISPID dispIdMember,
6914 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
6915 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
6916 {
6917 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
6918 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
6919 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
6920 }
6921
6922 static HRESULT WINAPI HTMLAttributeCollection2_getNamedItem(IHTMLAttributeCollection2 *iface, BSTR bstrName,
6923 IHTMLDOMAttribute **newretNode)
6924 {
6925 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
6926 HTMLDOMAttribute *attr;
6927 DISPID id;
6928 HRESULT hres;
6929
6930 TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrName), newretNode);
6931
6932 hres = get_attr_dispid_by_name(This, bstrName, &id);
6933 if(hres == DISP_E_UNKNOWNNAME) {
6934 *newretNode = NULL;
6935 return S_OK;
6936 } else if(FAILED(hres)) {
6937 return hres;
6938 }
6939
6940 hres = get_domattr(This, id, NULL, &attr);
6941 if(FAILED(hres))
6942 return hres;
6943
6944 *newretNode = &attr->IHTMLDOMAttribute_iface;
6945 return S_OK;
6946 }
6947
6948 static HRESULT WINAPI HTMLAttributeCollection2_setNamedItem(IHTMLAttributeCollection2 *iface,
6949 IHTMLDOMAttribute *ppNode, IHTMLDOMAttribute **newretNode)
6950 {
6951 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
6952 FIXME("(%p)->(%p %p)\n", This, ppNode, newretNode);
6953 return E_NOTIMPL;
6954 }
6955
6956 static HRESULT WINAPI HTMLAttributeCollection2_removeNamedItem(IHTMLAttributeCollection2 *iface,
6957 BSTR bstrName, IHTMLDOMAttribute **newretNode)
6958 {
6959 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
6960 FIXME("(%p)->(%s %p)\n", This, debugstr_w(bstrName), newretNode);
6961 return E_NOTIMPL;
6962 }
6963
6964 static const IHTMLAttributeCollection2Vtbl HTMLAttributeCollection2Vtbl = {
6965 HTMLAttributeCollection2_QueryInterface,
6966 HTMLAttributeCollection2_AddRef,
6967 HTMLAttributeCollection2_Release,
6968 HTMLAttributeCollection2_GetTypeInfoCount,
6969 HTMLAttributeCollection2_GetTypeInfo,
6970 HTMLAttributeCollection2_GetIDsOfNames,
6971 HTMLAttributeCollection2_Invoke,
6972 HTMLAttributeCollection2_getNamedItem,
6973 HTMLAttributeCollection2_setNamedItem,
6974 HTMLAttributeCollection2_removeNamedItem
6975 };
6976
6977 static inline HTMLAttributeCollection *impl_from_IHTMLAttributeCollection3(IHTMLAttributeCollection3 *iface)
6978 {
6979 return CONTAINING_RECORD(iface, HTMLAttributeCollection, IHTMLAttributeCollection3_iface);
6980 }
6981
6982 static HRESULT WINAPI HTMLAttributeCollection3_QueryInterface(IHTMLAttributeCollection3 *iface, REFIID riid, void **ppv)
6983 {
6984 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
6985 return IHTMLAttributeCollection_QueryInterface(&This->IHTMLAttributeCollection_iface, riid, ppv);
6986 }
6987
6988 static ULONG WINAPI HTMLAttributeCollection3_AddRef(IHTMLAttributeCollection3 *iface)
6989 {
6990 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
6991 return IHTMLAttributeCollection_AddRef(&This->IHTMLAttributeCollection_iface);
6992 }
6993
6994 static ULONG WINAPI HTMLAttributeCollection3_Release(IHTMLAttributeCollection3 *iface)
6995 {
6996 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
6997 return IHTMLAttributeCollection_Release(&This->IHTMLAttributeCollection_iface);
6998 }
6999
7000 static HRESULT WINAPI HTMLAttributeCollection3_GetTypeInfoCount(IHTMLAttributeCollection3 *iface, UINT *pctinfo)
7001 {
7002 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
7003 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
7004 }
7005
7006 static HRESULT WINAPI HTMLAttributeCollection3_GetTypeInfo(IHTMLAttributeCollection3 *iface, UINT iTInfo,
7007 LCID lcid, ITypeInfo **ppTInfo)
7008 {
7009 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
7010 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
7011 }
7012
7013 static HRESULT WINAPI HTMLAttributeCollection3_GetIDsOfNames(IHTMLAttributeCollection3 *iface, REFIID riid,
7014 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
7015 {
7016 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
7017 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
7018 lcid, rgDispId);
7019 }
7020
7021 static HRESULT WINAPI HTMLAttributeCollection3_Invoke(IHTMLAttributeCollection3 *iface, DISPID dispIdMember,
7022 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
7023 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
7024 {
7025 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
7026 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
7027 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
7028 }
7029
7030 static HRESULT WINAPI HTMLAttributeCollection3_getNamedItem(IHTMLAttributeCollection3 *iface, BSTR bstrName,
7031 IHTMLDOMAttribute **ppNodeOut)
7032 {
7033 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
7034 return IHTMLAttributeCollection2_getNamedItem(&This->IHTMLAttributeCollection2_iface, bstrName, ppNodeOut);
7035 }
7036
7037 static HRESULT WINAPI HTMLAttributeCollection3_setNamedItem(IHTMLAttributeCollection3 *iface,
7038 IHTMLDOMAttribute *pNodeIn, IHTMLDOMAttribute **ppNodeOut)
7039 {
7040 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
7041 FIXME("(%p)->(%p %p)\n", This, pNodeIn, ppNodeOut);
7042 return E_NOTIMPL;
7043 }
7044
7045 static HRESULT WINAPI HTMLAttributeCollection3_removeNamedItem(IHTMLAttributeCollection3 *iface,
7046 BSTR bstrName, IHTMLDOMAttribute **ppNodeOut)
7047 {
7048 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
7049 FIXME("(%p)->(%s %p)\n", This, debugstr_w(bstrName), ppNodeOut);
7050 return E_NOTIMPL;
7051 }
7052
7053 static HRESULT WINAPI HTMLAttributeCollection3_item(IHTMLAttributeCollection3 *iface, LONG index, IHTMLDOMAttribute **ppNodeOut)
7054 {
7055 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
7056 HTMLDOMAttribute *attr;
7057 DISPID id;
7058 HRESULT hres;
7059
7060 TRACE("(%p)->(%d %p)\n", This, index, ppNodeOut);
7061
7062 hres = get_attr_dispid_by_idx(This, &index, &id);
7063 if(hres == DISP_E_UNKNOWNNAME)
7064 return E_INVALIDARG;
7065 if(FAILED(hres))
7066 return hres;
7067
7068 hres = get_domattr(This, id, NULL, &attr);
7069 if(FAILED(hres))
7070 return hres;
7071
7072 *ppNodeOut = &attr->IHTMLDOMAttribute_iface;
7073 return S_OK;
7074 }
7075
7076 static HRESULT WINAPI HTMLAttributeCollection3_get_length(IHTMLAttributeCollection3 *iface, LONG *p)
7077 {
7078 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
7079 return IHTMLAttributeCollection_get_length(&This->IHTMLAttributeCollection_iface, p);
7080 }
7081
7082 static const IHTMLAttributeCollection3Vtbl HTMLAttributeCollection3Vtbl = {
7083 HTMLAttributeCollection3_QueryInterface,
7084 HTMLAttributeCollection3_AddRef,
7085 HTMLAttributeCollection3_Release,
7086 HTMLAttributeCollection3_GetTypeInfoCount,
7087 HTMLAttributeCollection3_GetTypeInfo,
7088 HTMLAttributeCollection3_GetIDsOfNames,
7089 HTMLAttributeCollection3_Invoke,
7090 HTMLAttributeCollection3_getNamedItem,
7091 HTMLAttributeCollection3_setNamedItem,
7092 HTMLAttributeCollection3_removeNamedItem,
7093 HTMLAttributeCollection3_item,
7094 HTMLAttributeCollection3_get_length
7095 };
7096
7097 static inline HTMLAttributeCollection *HTMLAttributeCollection_from_DispatchEx(DispatchEx *iface)
7098 {
7099 return CONTAINING_RECORD(iface, HTMLAttributeCollection, dispex);
7100 }
7101
7102 static HRESULT HTMLAttributeCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
7103 {
7104 HTMLAttributeCollection *This = HTMLAttributeCollection_from_DispatchEx(dispex);
7105 HTMLDOMAttribute *attr;
7106 LONG pos;
7107 HRESULT hres;
7108
7109 TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(name), flags, dispid);
7110
7111 hres = get_attr_dispid_by_name(This, name, dispid);
7112 if(FAILED(hres))
7113 return hres;
7114
7115 hres = get_domattr(This, *dispid, &pos, &attr);
7116 if(FAILED(hres))
7117 return hres;
7118 IHTMLDOMAttribute_Release(&attr->IHTMLDOMAttribute_iface);
7119
7120 *dispid = MSHTML_DISPID_CUSTOM_MIN+pos;
7121 return S_OK;
7122 }
7123
7124 static HRESULT HTMLAttributeCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid,
7125 WORD flags, DISPPARAMS *params, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
7126 {
7127 HTMLAttributeCollection *This = HTMLAttributeCollection_from_DispatchEx(dispex);
7128
7129 TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, flags, params, res, ei, caller);
7130
7131 switch(flags) {
7132 case DISPATCH_PROPERTYGET: {
7133 HTMLDOMAttribute *iter;
7134 DWORD pos;
7135
7136 pos = id-MSHTML_DISPID_CUSTOM_MIN;
7137
7138 LIST_FOR_EACH_ENTRY(iter, &This->attrs, HTMLDOMAttribute, entry) {
7139 if(!pos) {
7140 IHTMLDOMAttribute_AddRef(&iter->IHTMLDOMAttribute_iface);
7141 V_VT(res) = VT_DISPATCH;
7142 V_DISPATCH(res) = (IDispatch*)&iter->IHTMLDOMAttribute_iface;
7143 return S_OK;
7144 }
7145 pos--;
7146 }
7147
7148 WARN("invalid arg\n");
7149 return E_INVALIDARG;
7150 }
7151
7152 default:
7153 FIXME("unimplemented flags %x\n", flags);
7154 return E_NOTIMPL;
7155 }
7156 }
7157
7158 static const dispex_static_data_vtbl_t HTMLAttributeCollection_dispex_vtbl = {
7159 NULL,
7160 HTMLAttributeCollection_get_dispid,
7161 HTMLAttributeCollection_invoke,
7162 NULL
7163 };
7164
7165 static const tid_t HTMLAttributeCollection_iface_tids[] = {
7166 IHTMLAttributeCollection_tid,
7167 IHTMLAttributeCollection2_tid,
7168 IHTMLAttributeCollection3_tid,
7169 0
7170 };
7171
7172 static dispex_static_data_t HTMLAttributeCollection_dispex = {
7173 &HTMLAttributeCollection_dispex_vtbl,
7174 DispHTMLAttributeCollection_tid,
7175 HTMLAttributeCollection_iface_tids
7176 };
7177
7178 HRESULT HTMLElement_get_attr_col(HTMLDOMNode *iface, HTMLAttributeCollection **ac)
7179 {
7180 HTMLElement *This = impl_from_HTMLDOMNode(iface);
7181
7182 if(This->attrs) {
7183 IHTMLAttributeCollection_AddRef(&This->attrs->IHTMLAttributeCollection_iface);
7184 *ac = This->attrs;
7185 return S_OK;
7186 }
7187
7188 This->attrs = heap_alloc_zero(sizeof(HTMLAttributeCollection));
7189 if(!This->attrs)
7190 return E_OUTOFMEMORY;
7191
7192 This->attrs->IHTMLAttributeCollection_iface.lpVtbl = &HTMLAttributeCollectionVtbl;
7193 This->attrs->IHTMLAttributeCollection2_iface.lpVtbl = &HTMLAttributeCollection2Vtbl;
7194 This->attrs->IHTMLAttributeCollection3_iface.lpVtbl = &HTMLAttributeCollection3Vtbl;
7195 This->attrs->ref = 2;
7196
7197 This->attrs->elem = This;
7198 list_init(&This->attrs->attrs);
7199 init_dispex_with_compat_mode(&This->attrs->dispex, (IUnknown*)&This->attrs->IHTMLAttributeCollection_iface,
7200 &HTMLAttributeCollection_dispex, dispex_compat_mode(&iface->event_target.dispex));
7201
7202 *ac = This->attrs;
7203 return S_OK;
7204 }
Zebediah Figura's local tree