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