?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mshtml: Merge htmlelem3.c into htmlelem.c.
[wine.git] / dlls / mshtml / htmlelem.c
blob1140776455af43c03bcb281cfb244b1d87fcbf78
1 /*
2 * Copyright 2006-2010 Jacek Caban for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <stdarg.h>
20 #include <assert.h>
21 #include <math.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "winreg.h"
29 #include "ole2.h"
30 #include "shlwapi.h"
31
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 static const WCHAR aW[] = {'A',0};
41 static const WCHAR bodyW[] = {'B','O','D','Y',0};
42 static const WCHAR buttonW[] = {'B','U','T','T','O','N',0};
43 static const WCHAR embedW[] = {'E','M','B','E','D',0};
44 static const WCHAR formW[] = {'F','O','R','M',0};
45 static const WCHAR frameW[] = {'F','R','A','M','E',0};
46 static const WCHAR headW[] = {'H','E','A','D',0};
47 static const WCHAR iframeW[] = {'I','F','R','A','M','E',0};
48 static const WCHAR imgW[] = {'I','M','G',0};
49 static const WCHAR inputW[] = {'I','N','P','U','T',0};
50 static const WCHAR labelW[] = {'L','A','B','E','L',0};
51 static const WCHAR linkW[] = {'L','I','N','K',0};
52 static const WCHAR metaW[] = {'M','E','T','A',0};
53 static const WCHAR objectW[] = {'O','B','J','E','C','T',0};
54 static const WCHAR optionW[] = {'O','P','T','I','O','N',0};
55 static const WCHAR scriptW[] = {'S','C','R','I','P','T',0};
56 static const WCHAR selectW[] = {'S','E','L','E','C','T',0};
57 static const WCHAR styleW[] = {'S','T','Y','L','E',0};
58 static const WCHAR tableW[] = {'T','A','B','L','E',0};
59 static const WCHAR tdW[] = {'T','D',0};
60 static const WCHAR textareaW[] = {'T','E','X','T','A','R','E','A',0};
61 static const WCHAR title_tagW[]= {'T','I','T','L','E',0};
62 static const WCHAR trW[] = {'T','R',0};
63
64 typedef struct {
65 const WCHAR *name;
66 HRESULT (*constructor)(HTMLDocumentNode*,nsIDOMHTMLElement*,HTMLElement**);
67 } tag_desc_t;
68
69 static const tag_desc_t tag_descs[] = {
70 {aW, HTMLAnchorElement_Create},
71 {bodyW, HTMLBodyElement_Create},
72 {buttonW, HTMLButtonElement_Create},
73 {embedW, HTMLEmbedElement_Create},
74 {formW, HTMLFormElement_Create},
75 {frameW, HTMLFrameElement_Create},
76 {headW, HTMLHeadElement_Create},
77 {iframeW, HTMLIFrame_Create},
78 {imgW, HTMLImgElement_Create},
79 {inputW, HTMLInputElement_Create},
80 {labelW, HTMLLabelElement_Create},
81 {linkW, HTMLLinkElement_Create},
82 {metaW, HTMLMetaElement_Create},
83 {objectW, HTMLObjectElement_Create},
84 {optionW, HTMLOptionElement_Create},
85 {scriptW, HTMLScriptElement_Create},
86 {selectW, HTMLSelectElement_Create},
87 {styleW, HTMLStyleElement_Create},
88 {tableW, HTMLTable_Create},
89 {tdW, HTMLTableCell_Create},
90 {textareaW, HTMLTextAreaElement_Create},
91 {title_tagW, HTMLTitleElement_Create},
92 {trW, HTMLTableRow_Create}
93 };
94
95 static const tag_desc_t *get_tag_desc(const WCHAR *tag_name)
96 {
97 DWORD min=0, max=sizeof(tag_descs)/sizeof(*tag_descs)-1, i;
98 int r;
99
100 while(min <= max) {
101 i = (min+max)/2;
102 r = strcmpW(tag_name, tag_descs[i].name);
103 if(!r)
104 return tag_descs+i;
105
106 if(r < 0)
107 max = i-1;
108 else
109 min = i+1;
110 }
111
112 return NULL;
113 }
114
115 HRESULT replace_node_by_html(nsIDOMHTMLDocument *nsdoc, nsIDOMNode *nsnode, const WCHAR *html)
116 {
117 nsIDOMDocumentFragment *nsfragment;
118 nsIDOMNode *nsparent;
119 nsIDOMRange *range;
120 nsAString html_str;
121 nsresult nsres;
122 HRESULT hres = S_OK;
123
124 nsres = nsIDOMHTMLDocument_CreateRange(nsdoc, &range);
125 if(NS_FAILED(nsres)) {
126 ERR("CreateRange failed: %08x\n", nsres);
127 return E_FAIL;
128 }
129
130 nsAString_InitDepend(&html_str, html);
131 nsIDOMRange_CreateContextualFragment(range, &html_str, &nsfragment);
132 nsIDOMRange_Release(range);
133 nsAString_Finish(&html_str);
134 if(NS_FAILED(nsres)) {
135 ERR("CreateContextualFragment failed: %08x\n", nsres);
136 return E_FAIL;
137 }
138
139 nsres = nsIDOMNode_GetParentNode(nsnode, &nsparent);
140 if(NS_SUCCEEDED(nsres) && nsparent) {
141 nsIDOMNode *nstmp;
142
143 nsres = nsIDOMNode_ReplaceChild(nsparent, (nsIDOMNode*)nsfragment, nsnode, &nstmp);
144 nsIDOMNode_Release(nsparent);
145 if(NS_FAILED(nsres)) {
146 ERR("ReplaceChild failed: %08x\n", nsres);
147 hres = E_FAIL;
148 }else if(nstmp) {
149 nsIDOMNode_Release(nstmp);
150 }
151 }else {
152 ERR("GetParentNode failed: %08x\n", nsres);
153 hres = E_FAIL;
154 }
155
156 nsIDOMDocumentFragment_Release(nsfragment);
157 return hres;
158 }
159
160 nsresult get_elem_attr_value(nsIDOMHTMLElement *nselem, const WCHAR *name, nsAString *val_str, const PRUnichar **val)
161 {
162 nsAString name_str;
163 nsresult nsres;
164
165 nsAString_InitDepend(&name_str, name);
166 nsAString_Init(val_str, NULL);
167 nsres = nsIDOMHTMLElement_GetAttribute(nselem, &name_str, val_str);
168 nsAString_Finish(&name_str);
169 if(NS_FAILED(nsres)) {
170 ERR("GetAttribute(%s) failed: %08x\n", debugstr_w(name), nsres);
171 nsAString_Finish(val_str);
172 return nsres;
173 }
174
175 nsAString_GetData(val_str, val);
176 return NS_OK;
177 }
178
179 HRESULT elem_string_attr_getter(HTMLElement *elem, const WCHAR *name, BOOL use_null, BSTR *p)
180 {
181 const PRUnichar *val;
182 nsAString val_str;
183 nsresult nsres;
184 HRESULT hres = S_OK;
185
186 nsres = get_elem_attr_value(elem->nselem, name, &val_str, &val);
187 if(NS_FAILED(nsres))
188 return E_FAIL;
189
190 TRACE("%s: returning %s\n", debugstr_w(name), debugstr_w(val));
191
192 if(*val || !use_null) {
193 *p = SysAllocString(val);
194 if(!*p)
195 hres = E_OUTOFMEMORY;
196 }else {
197 *p = NULL;
198 }
199 nsAString_Finish(&val_str);
200 return hres;
201 }
202
203 HRESULT elem_string_attr_setter(HTMLElement *elem, const WCHAR *name, const WCHAR *value)
204 {
205 nsAString name_str, val_str;
206 nsresult nsres;
207
208 nsAString_InitDepend(&name_str, name);
209 nsAString_InitDepend(&val_str, value);
210 nsres = nsIDOMHTMLElement_SetAttribute(elem->nselem, &name_str, &val_str);
211 nsAString_Finish(&name_str);
212 nsAString_Finish(&val_str);
213
214 if(NS_FAILED(nsres)) {
215 WARN("SetAttribute failed: %08x\n", nsres);
216 return E_FAIL;
217 }
218
219 return S_OK;
220 }
221
222 HRESULT get_readystate_string(READYSTATE readystate, BSTR *p)
223 {
224 static const WCHAR uninitializedW[] = {'u','n','i','n','i','t','i','a','l','i','z','e','d',0};
225 static const WCHAR loadingW[] = {'l','o','a','d','i','n','g',0};
226 static const WCHAR loadedW[] = {'l','o','a','d','e','d',0};
227 static const WCHAR interactiveW[] = {'i','n','t','e','r','a','c','t','i','v','e',0};
228 static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
229
230 static const LPCWSTR readystate_strs[] = {
231 uninitializedW,
232 loadingW,
233 loadedW,
234 interactiveW,
235 completeW
236 };
237
238 assert(readystate <= READYSTATE_COMPLETE);
239 *p = SysAllocString(readystate_strs[readystate]);
240 return *p ? S_OK : E_OUTOFMEMORY;
241 }
242
243 typedef struct
244 {
245 DispatchEx dispex;
246 IHTMLFiltersCollection IHTMLFiltersCollection_iface;
247
248 LONG ref;
249 } HTMLFiltersCollection;
250
251 static inline HTMLFiltersCollection *impl_from_IHTMLFiltersCollection(IHTMLFiltersCollection *iface)
252 {
253 return CONTAINING_RECORD(iface, HTMLFiltersCollection, IHTMLFiltersCollection_iface);
254 }
255
256 static IHTMLFiltersCollection *HTMLFiltersCollection_Create(void);
257
258 static inline HTMLElement *impl_from_IHTMLElement(IHTMLElement *iface)
259 {
260 return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement_iface);
261 }
262
263 HRESULT create_nselem(HTMLDocumentNode *doc, const WCHAR *tag, nsIDOMHTMLElement **ret)
264 {
265 nsIDOMElement *nselem;
266 nsAString tag_str;
267 nsresult nsres;
268
269 if(!doc->nsdoc) {
270 WARN("NULL nsdoc\n");
271 return E_UNEXPECTED;
272 }
273
274 nsAString_InitDepend(&tag_str, tag);
275 nsres = nsIDOMHTMLDocument_CreateElement(doc->nsdoc, &tag_str, &nselem);
276 nsAString_Finish(&tag_str);
277 if(NS_FAILED(nsres)) {
278 ERR("CreateElement failed: %08x\n", nsres);
279 return E_FAIL;
280 }
281
282 nsres = nsIDOMElement_QueryInterface(nselem, &IID_nsIDOMHTMLElement, (void**)ret);
283 nsIDOMElement_Release(nselem);
284 if(NS_FAILED(nsres)) {
285 ERR("Could not get nsIDOMHTMLElement iface: %08x\n", nsres);
286 return E_FAIL;
287 }
288
289 return S_OK;
290 }
291
292 HRESULT create_element(HTMLDocumentNode *doc, const WCHAR *tag, HTMLElement **ret)
293 {
294 nsIDOMHTMLElement *nselem;
295 HRESULT hres;
296
297 /* Use owner doc if called on document fragment */
298 if(!doc->nsdoc)
299 doc = doc->node.doc;
300
301 hres = create_nselem(doc, tag, &nselem);
302 if(FAILED(hres))
303 return hres;
304
305 hres = HTMLElement_Create(doc, (nsIDOMNode*)nselem, TRUE, ret);
306 nsIDOMHTMLElement_Release(nselem);
307 return hres;
308 }
309
310 typedef struct {
311 DispatchEx dispex;
312 IHTMLRect IHTMLRect_iface;
313
314 LONG ref;
315
316 nsIDOMClientRect *nsrect;
317 } HTMLRect;
318
319 static inline HTMLRect *impl_from_IHTMLRect(IHTMLRect *iface)
320 {
321 return CONTAINING_RECORD(iface, HTMLRect, IHTMLRect_iface);
322 }
323
324 static HRESULT WINAPI HTMLRect_QueryInterface(IHTMLRect *iface, REFIID riid, void **ppv)
325 {
326 HTMLRect *This = impl_from_IHTMLRect(iface);
327
328 TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
329
330 if(IsEqualGUID(&IID_IUnknown, riid)) {
331 *ppv = &This->IHTMLRect_iface;
332 }else if(IsEqualGUID(&IID_IHTMLRect, riid)) {
333 *ppv = &This->IHTMLRect_iface;
334 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
335 return *ppv ? S_OK : E_NOINTERFACE;
336 }else {
337 FIXME("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
338 *ppv = NULL;
339 return E_NOINTERFACE;
340 }
341
342 IUnknown_AddRef((IUnknown*)*ppv);
343 return S_OK;
344 }
345
346 static ULONG WINAPI HTMLRect_AddRef(IHTMLRect *iface)
347 {
348 HTMLRect *This = impl_from_IHTMLRect(iface);
349 LONG ref = InterlockedIncrement(&This->ref);
350
351 TRACE("(%p) ref=%d\n", This, ref);
352
353 return ref;
354 }
355
356 static ULONG WINAPI HTMLRect_Release(IHTMLRect *iface)
357 {
358 HTMLRect *This = impl_from_IHTMLRect(iface);
359 LONG ref = InterlockedDecrement(&This->ref);
360
361 TRACE("(%p) ref=%d\n", This, ref);
362
363 if(!ref) {
364 if(This->nsrect)
365 nsIDOMClientRect_Release(This->nsrect);
366 heap_free(This);
367 }
368
369 return ref;
370 }
371
372 static HRESULT WINAPI HTMLRect_GetTypeInfoCount(IHTMLRect *iface, UINT *pctinfo)
373 {
374 HTMLRect *This = impl_from_IHTMLRect(iface);
375 FIXME("(%p)->(%p)\n", This, pctinfo);
376 return E_NOTIMPL;
377 }
378
379 static HRESULT WINAPI HTMLRect_GetTypeInfo(IHTMLRect *iface, UINT iTInfo,
380 LCID lcid, ITypeInfo **ppTInfo)
381 {
382 HTMLRect *This = impl_from_IHTMLRect(iface);
383
384 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
385 }
386
387 static HRESULT WINAPI HTMLRect_GetIDsOfNames(IHTMLRect *iface, REFIID riid,
388 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
389 {
390 HTMLRect *This = impl_from_IHTMLRect(iface);
391
392 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
393 lcid, rgDispId);
394 }
395
396 static HRESULT WINAPI HTMLRect_Invoke(IHTMLRect *iface, DISPID dispIdMember,
397 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
398 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
399 {
400 HTMLRect *This = impl_from_IHTMLRect(iface);
401
402 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
403 pDispParams, pVarResult, pExcepInfo, puArgErr);
404 }
405
406 static HRESULT WINAPI HTMLRect_put_left(IHTMLRect *iface, LONG v)
407 {
408 HTMLRect *This = impl_from_IHTMLRect(iface);
409 FIXME("(%p)->(%d)\n", This, v);
410 return E_NOTIMPL;
411 }
412
413 static HRESULT WINAPI HTMLRect_get_left(IHTMLRect *iface, LONG *p)
414 {
415 HTMLRect *This = impl_from_IHTMLRect(iface);
416 float left;
417 nsresult nsres;
418
419 TRACE("(%p)->(%p)\n", This, p);
420
421 nsres = nsIDOMClientRect_GetLeft(This->nsrect, &left);
422 if(NS_FAILED(nsres)) {
423 ERR("GetLeft failed: %08x\n", nsres);
424 return E_FAIL;
425 }
426
427 *p = floor(left+0.5);
428 return S_OK;
429 }
430
431 static HRESULT WINAPI HTMLRect_put_top(IHTMLRect *iface, LONG v)
432 {
433 HTMLRect *This = impl_from_IHTMLRect(iface);
434 FIXME("(%p)->(%d)\n", This, v);
435 return E_NOTIMPL;
436 }
437
438 static HRESULT WINAPI HTMLRect_get_top(IHTMLRect *iface, LONG *p)
439 {
440 HTMLRect *This = impl_from_IHTMLRect(iface);
441 float top;
442 nsresult nsres;
443
444 TRACE("(%p)->(%p)\n", This, p);
445
446 nsres = nsIDOMClientRect_GetTop(This->nsrect, &top);
447 if(NS_FAILED(nsres)) {
448 ERR("GetTop failed: %08x\n", nsres);
449 return E_FAIL;
450 }
451
452 *p = floor(top+0.5);
453 return S_OK;
454 }
455
456 static HRESULT WINAPI HTMLRect_put_right(IHTMLRect *iface, LONG v)
457 {
458 HTMLRect *This = impl_from_IHTMLRect(iface);
459 FIXME("(%p)->(%d)\n", This, v);
460 return E_NOTIMPL;
461 }
462
463 static HRESULT WINAPI HTMLRect_get_right(IHTMLRect *iface, LONG *p)
464 {
465 HTMLRect *This = impl_from_IHTMLRect(iface);
466 float right;
467 nsresult nsres;
468
469 TRACE("(%p)->(%p)\n", This, p);
470
471 nsres = nsIDOMClientRect_GetRight(This->nsrect, &right);
472 if(NS_FAILED(nsres)) {
473 ERR("GetRight failed: %08x\n", nsres);
474 return E_FAIL;
475 }
476
477 *p = floor(right+0.5);
478 return S_OK;
479 }
480
481 static HRESULT WINAPI HTMLRect_put_bottom(IHTMLRect *iface, LONG v)
482 {
483 HTMLRect *This = impl_from_IHTMLRect(iface);
484 FIXME("(%p)->(%d)\n", This, v);
485 return E_NOTIMPL;
486 }
487
488 static HRESULT WINAPI HTMLRect_get_bottom(IHTMLRect *iface, LONG *p)
489 {
490 HTMLRect *This = impl_from_IHTMLRect(iface);
491 float bottom;
492 nsresult nsres;
493
494 TRACE("(%p)->(%p)\n", This, p);
495
496 nsres = nsIDOMClientRect_GetBottom(This->nsrect, &bottom);
497 if(NS_FAILED(nsres)) {
498 ERR("GetBottom failed: %08x\n", nsres);
499 return E_FAIL;
500 }
501
502 *p = floor(bottom+0.5);
503 return S_OK;
504 }
505
506 static const IHTMLRectVtbl HTMLRectVtbl = {
507 HTMLRect_QueryInterface,
508 HTMLRect_AddRef,
509 HTMLRect_Release,
510 HTMLRect_GetTypeInfoCount,
511 HTMLRect_GetTypeInfo,
512 HTMLRect_GetIDsOfNames,
513 HTMLRect_Invoke,
514 HTMLRect_put_left,
515 HTMLRect_get_left,
516 HTMLRect_put_top,
517 HTMLRect_get_top,
518 HTMLRect_put_right,
519 HTMLRect_get_right,
520 HTMLRect_put_bottom,
521 HTMLRect_get_bottom
522 };
523
524 static const tid_t HTMLRect_iface_tids[] = {
525 IHTMLRect_tid,
526 0
527 };
528 static dispex_static_data_t HTMLRect_dispex = {
529 NULL,
530 IHTMLRect_tid,
531 NULL,
532 HTMLRect_iface_tids
533 };
534
535 static HRESULT create_html_rect(nsIDOMClientRect *nsrect, IHTMLRect **ret)
536 {
537 HTMLRect *rect;
538
539 rect = heap_alloc_zero(sizeof(HTMLRect));
540 if(!rect)
541 return E_OUTOFMEMORY;
542
543 rect->IHTMLRect_iface.lpVtbl = &HTMLRectVtbl;
544 rect->ref = 1;
545
546 init_dispex(&rect->dispex, (IUnknown*)&rect->IHTMLRect_iface, &HTMLRect_dispex);
547
548 nsIDOMClientRect_AddRef(nsrect);
549 rect->nsrect = nsrect;
550
551 *ret = &rect->IHTMLRect_iface;
552 return S_OK;
553 }
554
555 static HRESULT WINAPI HTMLElement_QueryInterface(IHTMLElement *iface,
556 REFIID riid, void **ppv)
557 {
558 HTMLElement *This = impl_from_IHTMLElement(iface);
559
560 return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
561 }
562
563 static ULONG WINAPI HTMLElement_AddRef(IHTMLElement *iface)
564 {
565 HTMLElement *This = impl_from_IHTMLElement(iface);
566
567 return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
568 }
569
570 static ULONG WINAPI HTMLElement_Release(IHTMLElement *iface)
571 {
572 HTMLElement *This = impl_from_IHTMLElement(iface);
573
574 return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
575 }
576
577 static HRESULT WINAPI HTMLElement_GetTypeInfoCount(IHTMLElement *iface, UINT *pctinfo)
578 {
579 HTMLElement *This = impl_from_IHTMLElement(iface);
580 return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
581 }
582
583 static HRESULT WINAPI HTMLElement_GetTypeInfo(IHTMLElement *iface, UINT iTInfo,
584 LCID lcid, ITypeInfo **ppTInfo)
585 {
586 HTMLElement *This = impl_from_IHTMLElement(iface);
587 return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
588 }
589
590 static HRESULT WINAPI HTMLElement_GetIDsOfNames(IHTMLElement *iface, REFIID riid,
591 LPOLESTR *rgszNames, UINT cNames,
592 LCID lcid, DISPID *rgDispId)
593 {
594 HTMLElement *This = impl_from_IHTMLElement(iface);
595 return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
596 lcid, rgDispId);
597 }
598
599 static HRESULT WINAPI HTMLElement_Invoke(IHTMLElement *iface, DISPID dispIdMember,
600 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
601 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
602 {
603 HTMLElement *This = impl_from_IHTMLElement(iface);
604 return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
605 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
606 }
607
608 static HRESULT WINAPI HTMLElement_setAttribute(IHTMLElement *iface, BSTR strAttributeName,
609 VARIANT AttributeValue, LONG lFlags)
610 {
611 HTMLElement *This = impl_from_IHTMLElement(iface);
612 HRESULT hres;
613 DISPID dispid, dispidNamed = DISPID_PROPERTYPUT;
614 DISPPARAMS dispParams;
615 EXCEPINFO excep;
616
617 TRACE("(%p)->(%s %s %08x)\n", This, debugstr_w(strAttributeName), debugstr_variant(&AttributeValue), lFlags);
618
619 hres = IDispatchEx_GetDispID(&This->node.dispex.IDispatchEx_iface, strAttributeName,
620 fdexNameCaseInsensitive | fdexNameEnsure, &dispid);
621 if(FAILED(hres))
622 return hres;
623
624 dispParams.cArgs = 1;
625 dispParams.cNamedArgs = 1;
626 dispParams.rgdispidNamedArgs = &dispidNamed;
627 dispParams.rgvarg = &AttributeValue;
628
629 hres = IDispatchEx_InvokeEx(&This->node.dispex.IDispatchEx_iface, dispid,
630 LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYPUT, &dispParams, NULL, &excep, NULL);
631 return hres;
632 }
633
634 static HRESULT WINAPI HTMLElement_getAttribute(IHTMLElement *iface, BSTR strAttributeName,
635 LONG lFlags, VARIANT *AttributeValue)
636 {
637 HTMLElement *This = impl_from_IHTMLElement(iface);
638 DISPID dispid;
639 HRESULT hres;
640 DISPPARAMS dispParams = {NULL, NULL, 0, 0};
641 EXCEPINFO excep;
642
643 TRACE("(%p)->(%s %08x %p)\n", This, debugstr_w(strAttributeName), lFlags, AttributeValue);
644
645 hres = IDispatchEx_GetDispID(&This->node.dispex.IDispatchEx_iface, strAttributeName,
646 fdexNameCaseInsensitive, &dispid);
647 if(hres == DISP_E_UNKNOWNNAME) {
648 V_VT(AttributeValue) = VT_NULL;
649 return S_OK;
650 }
651
652 if(FAILED(hres)) {
653 V_VT(AttributeValue) = VT_NULL;
654 return hres;
655 }
656
657 hres = IDispatchEx_InvokeEx(&This->node.dispex.IDispatchEx_iface, dispid, LOCALE_SYSTEM_DEFAULT,
658 DISPATCH_PROPERTYGET, &dispParams, AttributeValue, &excep, NULL);
659
660 return hres;
661 }
662
663 static HRESULT WINAPI HTMLElement_removeAttribute(IHTMLElement *iface, BSTR strAttributeName,
664 LONG lFlags, VARIANT_BOOL *pfSuccess)
665 {
666 HTMLElement *This = impl_from_IHTMLElement(iface);
667
668 TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(strAttributeName), lFlags, pfSuccess);
669
670 return remove_prop(&This->node.dispex, strAttributeName, pfSuccess);
671 }
672
673 static HRESULT WINAPI HTMLElement_put_className(IHTMLElement *iface, BSTR v)
674 {
675 HTMLElement *This = impl_from_IHTMLElement(iface);
676 nsAString classname_str;
677 nsresult nsres;
678
679 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
680
681 if(!This->nselem) {
682 FIXME("NULL nselem\n");
683 return E_NOTIMPL;
684 }
685
686 nsAString_InitDepend(&classname_str, v);
687 nsres = nsIDOMHTMLElement_SetClassName(This->nselem, &classname_str);
688 nsAString_Finish(&classname_str);
689 if(NS_FAILED(nsres))
690 ERR("SetClassName failed: %08x\n", nsres);
691
692 return S_OK;
693 }
694
695 static HRESULT WINAPI HTMLElement_get_className(IHTMLElement *iface, BSTR *p)
696 {
697 HTMLElement *This = impl_from_IHTMLElement(iface);
698 nsAString class_str;
699 nsresult nsres;
700
701 TRACE("(%p)->(%p)\n", This, p);
702
703 if(!This->nselem) {
704 FIXME("NULL nselem\n");
705 return E_NOTIMPL;
706 }
707
708 nsAString_Init(&class_str, NULL);
709 nsres = nsIDOMHTMLElement_GetClassName(This->nselem, &class_str);
710 return return_nsstr(nsres, &class_str, p);
711 }
712
713 static HRESULT WINAPI HTMLElement_put_id(IHTMLElement *iface, BSTR v)
714 {
715 HTMLElement *This = impl_from_IHTMLElement(iface);
716 nsAString id_str;
717 nsresult nsres;
718
719 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
720
721 if(!This->nselem) {
722 FIXME("nselem == NULL\n");
723 return S_OK;
724 }
725
726 nsAString_InitDepend(&id_str, v);
727 nsres = nsIDOMHTMLElement_SetId(This->nselem, &id_str);
728 nsAString_Finish(&id_str);
729 if(NS_FAILED(nsres))
730 ERR("SetId failed: %08x\n", nsres);
731
732 return S_OK;
733 }
734
735 static HRESULT WINAPI HTMLElement_get_id(IHTMLElement *iface, BSTR *p)
736 {
737 HTMLElement *This = impl_from_IHTMLElement(iface);
738 nsAString id_str;
739 nsresult nsres;
740
741 TRACE("(%p)->(%p)\n", This, p);
742
743 if(!This->nselem) {
744 *p = NULL;
745 return S_OK;
746 }
747
748 nsAString_Init(&id_str, NULL);
749 nsres = nsIDOMHTMLElement_GetId(This->nselem, &id_str);
750 return return_nsstr(nsres, &id_str, p);
751 }
752
753 static HRESULT WINAPI HTMLElement_get_tagName(IHTMLElement *iface, BSTR *p)
754 {
755 HTMLElement *This = impl_from_IHTMLElement(iface);
756 nsAString tag_str;
757 nsresult nsres;
758
759 TRACE("(%p)->(%p)\n", This, p);
760
761 if(!This->nselem) {
762 static const WCHAR comment_tagW[] = {'!',0};
763
764 WARN("NULL nselem, assuming comment\n");
765
766 *p = SysAllocString(comment_tagW);
767 return *p ? S_OK : E_OUTOFMEMORY;
768 }
769
770 nsAString_Init(&tag_str, NULL);
771 nsres = nsIDOMHTMLElement_GetTagName(This->nselem, &tag_str);
772 return return_nsstr(nsres, &tag_str, p);
773 }
774
775 static HRESULT WINAPI HTMLElement_get_parentElement(IHTMLElement *iface, IHTMLElement **p)
776 {
777 HTMLElement *This = impl_from_IHTMLElement(iface);
778 IHTMLDOMNode *node;
779 HRESULT hres;
780
781 TRACE("(%p)->(%p)\n", This, p);
782
783 hres = IHTMLDOMNode_get_parentNode(&This->node.IHTMLDOMNode_iface, &node);
784 if(FAILED(hres))
785 return hres;
786
787 hres = IHTMLDOMNode_QueryInterface(node, &IID_IHTMLElement, (void**)p);
788 IHTMLDOMNode_Release(node);
789 if(FAILED(hres))
790 *p = NULL;
791
792 return S_OK;
793 }
794
795 static HRESULT WINAPI HTMLElement_get_style(IHTMLElement *iface, IHTMLStyle **p)
796 {
797 HTMLElement *This = impl_from_IHTMLElement(iface);
798
799 TRACE("(%p)->(%p)\n", This, p);
800
801 if(!This->style) {
802 HRESULT hres;
803
804 hres = HTMLStyle_Create(This, &This->style);
805 if(FAILED(hres))
806 return hres;
807 }
808
809 *p = &This->style->IHTMLStyle_iface;
810 IHTMLStyle_AddRef(*p);
811 return S_OK;
812 }
813
814 static HRESULT WINAPI HTMLElement_put_onhelp(IHTMLElement *iface, VARIANT v)
815 {
816 HTMLElement *This = impl_from_IHTMLElement(iface);
817 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
818 return E_NOTIMPL;
819 }
820
821 static HRESULT WINAPI HTMLElement_get_onhelp(IHTMLElement *iface, VARIANT *p)
822 {
823 HTMLElement *This = impl_from_IHTMLElement(iface);
824 FIXME("(%p)->(%p)\n", This, p);
825 return E_NOTIMPL;
826 }
827
828 static HRESULT WINAPI HTMLElement_put_onclick(IHTMLElement *iface, VARIANT v)
829 {
830 HTMLElement *This = impl_from_IHTMLElement(iface);
831
832 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
833
834 return set_node_event(&This->node, EVENTID_CLICK, &v);
835 }
836
837 static HRESULT WINAPI HTMLElement_get_onclick(IHTMLElement *iface, VARIANT *p)
838 {
839 HTMLElement *This = impl_from_IHTMLElement(iface);
840
841 TRACE("(%p)->(%p)\n", This, p);
842
843 return get_node_event(&This->node, EVENTID_CLICK, p);
844 }
845
846 static HRESULT WINAPI HTMLElement_put_ondblclick(IHTMLElement *iface, VARIANT v)
847 {
848 HTMLElement *This = impl_from_IHTMLElement(iface);
849
850 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
851
852 return set_node_event(&This->node, EVENTID_DBLCLICK, &v);
853 }
854
855 static HRESULT WINAPI HTMLElement_get_ondblclick(IHTMLElement *iface, VARIANT *p)
856 {
857 HTMLElement *This = impl_from_IHTMLElement(iface);
858
859 TRACE("(%p)->(%p)\n", This, p);
860
861 return get_node_event(&This->node, EVENTID_DBLCLICK, p);
862 }
863
864 static HRESULT WINAPI HTMLElement_put_onkeydown(IHTMLElement *iface, VARIANT v)
865 {
866 HTMLElement *This = impl_from_IHTMLElement(iface);
867
868 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
869
870 return set_node_event(&This->node, EVENTID_KEYDOWN, &v);
871 }
872
873 static HRESULT WINAPI HTMLElement_get_onkeydown(IHTMLElement *iface, VARIANT *p)
874 {
875 HTMLElement *This = impl_from_IHTMLElement(iface);
876
877 TRACE("(%p)->(%p)\n", This, p);
878
879 return get_node_event(&This->node, EVENTID_KEYDOWN, p);
880 }
881
882 static HRESULT WINAPI HTMLElement_put_onkeyup(IHTMLElement *iface, VARIANT v)
883 {
884 HTMLElement *This = impl_from_IHTMLElement(iface);
885
886 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
887
888 return set_node_event(&This->node, EVENTID_KEYUP, &v);
889 }
890
891 static HRESULT WINAPI HTMLElement_get_onkeyup(IHTMLElement *iface, VARIANT *p)
892 {
893 HTMLElement *This = impl_from_IHTMLElement(iface);
894 FIXME("(%p)->(%p)\n", This, p);
895 return E_NOTIMPL;
896 }
897
898 static HRESULT WINAPI HTMLElement_put_onkeypress(IHTMLElement *iface, VARIANT v)
899 {
900 HTMLElement *This = impl_from_IHTMLElement(iface);
901
902 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
903
904 return set_node_event(&This->node, EVENTID_KEYPRESS, &v);
905 }
906
907 static HRESULT WINAPI HTMLElement_get_onkeypress(IHTMLElement *iface, VARIANT *p)
908 {
909 HTMLElement *This = impl_from_IHTMLElement(iface);
910
911 TRACE("(%p)->(%p)\n", This, p);
912
913 return get_node_event(&This->node, EVENTID_KEYPRESS, p);
914 }
915
916 static HRESULT WINAPI HTMLElement_put_onmouseout(IHTMLElement *iface, VARIANT v)
917 {
918 HTMLElement *This = impl_from_IHTMLElement(iface);
919
920 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
921
922 return set_node_event(&This->node, EVENTID_MOUSEOUT, &v);
923 }
924
925 static HRESULT WINAPI HTMLElement_get_onmouseout(IHTMLElement *iface, VARIANT *p)
926 {
927 HTMLElement *This = impl_from_IHTMLElement(iface);
928
929 TRACE("(%p)->(%p)\n", This, p);
930
931 return get_node_event(&This->node, EVENTID_MOUSEOUT, p);
932 }
933
934 static HRESULT WINAPI HTMLElement_put_onmouseover(IHTMLElement *iface, VARIANT v)
935 {
936 HTMLElement *This = impl_from_IHTMLElement(iface);
937
938 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
939
940 return set_node_event(&This->node, EVENTID_MOUSEOVER, &v);
941 }
942
943 static HRESULT WINAPI HTMLElement_get_onmouseover(IHTMLElement *iface, VARIANT *p)
944 {
945 HTMLElement *This = impl_from_IHTMLElement(iface);
946
947 TRACE("(%p)->(%p)\n", This, p);
948
949 return get_node_event(&This->node, EVENTID_MOUSEOVER, p);
950 }
951
952 static HRESULT WINAPI HTMLElement_put_onmousemove(IHTMLElement *iface, VARIANT v)
953 {
954 HTMLElement *This = impl_from_IHTMLElement(iface);
955
956 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
957
958 return set_node_event(&This->node, EVENTID_MOUSEMOVE, &v);
959 }
960
961 static HRESULT WINAPI HTMLElement_get_onmousemove(IHTMLElement *iface, VARIANT *p)
962 {
963 HTMLElement *This = impl_from_IHTMLElement(iface);
964
965 TRACE("(%p)->(%p)\n", This, p);
966
967 return get_node_event(&This->node, EVENTID_MOUSEMOVE, p);
968 }
969
970 static HRESULT WINAPI HTMLElement_put_onmousedown(IHTMLElement *iface, VARIANT v)
971 {
972 HTMLElement *This = impl_from_IHTMLElement(iface);
973
974 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
975
976 return set_node_event(&This->node, EVENTID_MOUSEDOWN, &v);
977 }
978
979 static HRESULT WINAPI HTMLElement_get_onmousedown(IHTMLElement *iface, VARIANT *p)
980 {
981 HTMLElement *This = impl_from_IHTMLElement(iface);
982
983 TRACE("(%p)->(%p)\n", This, p);
984
985 return get_node_event(&This->node, EVENTID_MOUSEDOWN, p);
986 }
987
988 static HRESULT WINAPI HTMLElement_put_onmouseup(IHTMLElement *iface, VARIANT v)
989 {
990 HTMLElement *This = impl_from_IHTMLElement(iface);
991
992 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
993
994 return set_node_event(&This->node, EVENTID_MOUSEUP, &v);
995 }
996
997 static HRESULT WINAPI HTMLElement_get_onmouseup(IHTMLElement *iface, VARIANT *p)
998 {
999 HTMLElement *This = impl_from_IHTMLElement(iface);
1000
1001 TRACE("(%p)->(%p)\n", This, p);
1002
1003 return get_node_event(&This->node, EVENTID_MOUSEUP, p);
1004 }
1005
1006 static HRESULT WINAPI HTMLElement_get_document(IHTMLElement *iface, IDispatch **p)
1007 {
1008 HTMLElement *This = impl_from_IHTMLElement(iface);
1009
1010 TRACE("(%p)->(%p)\n", This, p);
1011
1012 if(!p)
1013 return E_POINTER;
1014
1015 if(This->node.vtbl->get_document)
1016 return This->node.vtbl->get_document(&This->node, p);
1017
1018 *p = (IDispatch*)&This->node.doc->basedoc.IHTMLDocument2_iface;
1019 IDispatch_AddRef(*p);
1020 return S_OK;
1021 }
1022
1023 static const WCHAR titleW[] = {'t','i','t','l','e',0};
1024
1025 static HRESULT WINAPI HTMLElement_put_title(IHTMLElement *iface, BSTR v)
1026 {
1027 HTMLElement *This = impl_from_IHTMLElement(iface);
1028 nsAString title_str;
1029 nsresult nsres;
1030
1031 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1032
1033 if(!This->nselem) {
1034 VARIANT *var;
1035 HRESULT hres;
1036
1037 hres = dispex_get_dprop_ref(&This->node.dispex, titleW, TRUE, &var);
1038 if(FAILED(hres))
1039 return hres;
1040
1041 VariantClear(var);
1042 V_VT(var) = VT_BSTR;
1043 V_BSTR(var) = v ? SysAllocString(v) : NULL;
1044 return S_OK;
1045 }
1046
1047 nsAString_InitDepend(&title_str, v);
1048 nsres = nsIDOMHTMLElement_SetTitle(This->nselem, &title_str);
1049 nsAString_Finish(&title_str);
1050 if(NS_FAILED(nsres))
1051 ERR("SetTitle failed: %08x\n", nsres);
1052
1053 return S_OK;
1054 }
1055
1056 static HRESULT WINAPI HTMLElement_get_title(IHTMLElement *iface, BSTR *p)
1057 {
1058 HTMLElement *This = impl_from_IHTMLElement(iface);
1059 nsAString title_str;
1060 nsresult nsres;
1061
1062 TRACE("(%p)->(%p)\n", This, p);
1063
1064 if(!This->nselem) {
1065 VARIANT *var;
1066 HRESULT hres;
1067
1068 hres = dispex_get_dprop_ref(&This->node.dispex, titleW, FALSE, &var);
1069 if(hres == DISP_E_UNKNOWNNAME) {
1070 *p = NULL;
1071 }else if(V_VT(var) != VT_BSTR) {
1072 FIXME("title = %s\n", debugstr_variant(var));
1073 return E_FAIL;
1074 }else {
1075 *p = V_BSTR(var) ? SysAllocString(V_BSTR(var)) : NULL;
1076 }
1077
1078 return S_OK;
1079 }
1080
1081 nsAString_Init(&title_str, NULL);
1082 nsres = nsIDOMHTMLElement_GetTitle(This->nselem, &title_str);
1083 return return_nsstr(nsres, &title_str, p);
1084 }
1085
1086 static const WCHAR languageW[] = {'l','a','n','g','u','a','g','e',0};
1087
1088 static HRESULT WINAPI HTMLElement_put_language(IHTMLElement *iface, BSTR v)
1089 {
1090 HTMLElement *This = impl_from_IHTMLElement(iface);
1091
1092 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1093
1094 return elem_string_attr_setter(This, languageW, v);
1095 }
1096
1097 static HRESULT WINAPI HTMLElement_get_language(IHTMLElement *iface, BSTR *p)
1098 {
1099 HTMLElement *This = impl_from_IHTMLElement(iface);
1100
1101 TRACE("(%p)->(%p)\n", This, p);
1102
1103 return elem_string_attr_getter(This, languageW, TRUE, p);
1104 }
1105
1106 static HRESULT WINAPI HTMLElement_put_onselectstart(IHTMLElement *iface, VARIANT v)
1107 {
1108 HTMLElement *This = impl_from_IHTMLElement(iface);
1109
1110 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1111
1112 return set_node_event(&This->node, EVENTID_SELECTSTART, &v);
1113 }
1114
1115 static HRESULT WINAPI HTMLElement_get_onselectstart(IHTMLElement *iface, VARIANT *p)
1116 {
1117 HTMLElement *This = impl_from_IHTMLElement(iface);
1118
1119 TRACE("(%p)->(%p)\n", This, p);
1120
1121 return get_node_event(&This->node, EVENTID_SELECTSTART, p);
1122 }
1123
1124 static HRESULT WINAPI HTMLElement_scrollIntoView(IHTMLElement *iface, VARIANT varargStart)
1125 {
1126 HTMLElement *This = impl_from_IHTMLElement(iface);
1127 cpp_bool start = TRUE;
1128 nsresult nsres;
1129
1130 TRACE("(%p)->(%s)\n", This, debugstr_variant(&varargStart));
1131
1132 switch(V_VT(&varargStart)) {
1133 case VT_EMPTY:
1134 case VT_ERROR:
1135 break;
1136 case VT_BOOL:
1137 start = V_BOOL(&varargStart) != VARIANT_FALSE;
1138 break;
1139 default:
1140 FIXME("Unsupported argument %s\n", debugstr_variant(&varargStart));
1141 }
1142
1143 if(!This->nselem) {
1144 FIXME("Unsupported for comments\n");
1145 return E_NOTIMPL;
1146 }
1147
1148 nsres = nsIDOMHTMLElement_ScrollIntoView(This->nselem, start, 1);
1149 assert(nsres == NS_OK);
1150
1151 return S_OK;
1152 }
1153
1154 static HRESULT WINAPI HTMLElement_contains(IHTMLElement *iface, IHTMLElement *pChild,
1155 VARIANT_BOOL *pfResult)
1156 {
1157 HTMLElement *This = impl_from_IHTMLElement(iface);
1158 cpp_bool result = FALSE;
1159
1160 TRACE("(%p)->(%p %p)\n", This, pChild, pfResult);
1161
1162 if(pChild) {
1163 HTMLElement *child;
1164 nsresult nsres;
1165
1166 child = unsafe_impl_from_IHTMLElement(pChild);
1167 if(!child) {
1168 ERR("not our element\n");
1169 return E_FAIL;
1170 }
1171
1172 nsres = nsIDOMNode_Contains(This->node.nsnode, child->node.nsnode, &result);
1173 assert(nsres == NS_OK);
1174 }
1175
1176 *pfResult = result ? VARIANT_TRUE : VARIANT_FALSE;
1177 return S_OK;
1178 }
1179
1180 static HRESULT WINAPI HTMLElement_get_sourceIndex(IHTMLElement *iface, LONG *p)
1181 {
1182 HTMLElement *This = impl_from_IHTMLElement(iface);
1183
1184 TRACE("(%p)->(%p)\n", This, p);
1185
1186 return get_elem_source_index(This, p);
1187 }
1188
1189 static HRESULT WINAPI HTMLElement_get_recordNumber(IHTMLElement *iface, VARIANT *p)
1190 {
1191 HTMLElement *This = impl_from_IHTMLElement(iface);
1192 FIXME("(%p)->(%p)\n", This, p);
1193 return E_NOTIMPL;
1194 }
1195
1196 static HRESULT WINAPI HTMLElement_put_lang(IHTMLElement *iface, BSTR v)
1197 {
1198 HTMLElement *This = impl_from_IHTMLElement(iface);
1199 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1200 return E_NOTIMPL;
1201 }
1202
1203 static HRESULT WINAPI HTMLElement_get_lang(IHTMLElement *iface, BSTR *p)
1204 {
1205 HTMLElement *This = impl_from_IHTMLElement(iface);
1206 FIXME("(%p)->(%p)\n", This, p);
1207 return E_NOTIMPL;
1208 }
1209
1210 static HRESULT WINAPI HTMLElement_get_offsetLeft(IHTMLElement *iface, LONG *p)
1211 {
1212 HTMLElement *This = impl_from_IHTMLElement(iface);
1213 nsresult nsres;
1214
1215 TRACE("(%p)->(%p)\n", This, p);
1216
1217 nsres = nsIDOMHTMLElement_GetOffsetLeft(This->nselem, p);
1218 if(NS_FAILED(nsres)) {
1219 ERR("GetOffsetLeft failed: %08x\n", nsres);
1220 return E_FAIL;
1221 }
1222
1223 return S_OK;
1224 }
1225
1226 static HRESULT WINAPI HTMLElement_get_offsetTop(IHTMLElement *iface, LONG *p)
1227 {
1228 HTMLElement *This = impl_from_IHTMLElement(iface);
1229 nsresult nsres;
1230
1231 TRACE("(%p)->(%p)\n", This, p);
1232
1233 nsres = nsIDOMHTMLElement_GetOffsetTop(This->nselem, p);
1234 if(NS_FAILED(nsres)) {
1235 ERR("GetOffsetTop failed: %08x\n", nsres);
1236 return E_FAIL;
1237 }
1238
1239 return S_OK;
1240 }
1241
1242 static HRESULT WINAPI HTMLElement_get_offsetWidth(IHTMLElement *iface, LONG *p)
1243 {
1244 HTMLElement *This = impl_from_IHTMLElement(iface);
1245 nsresult nsres;
1246
1247 TRACE("(%p)->(%p)\n", This, p);
1248
1249 nsres = nsIDOMHTMLElement_GetOffsetWidth(This->nselem, p);
1250 if(NS_FAILED(nsres)) {
1251 ERR("GetOffsetWidth failed: %08x\n", nsres);
1252 return E_FAIL;
1253 }
1254
1255 return S_OK;
1256 }
1257
1258 static HRESULT WINAPI HTMLElement_get_offsetHeight(IHTMLElement *iface, LONG *p)
1259 {
1260 HTMLElement *This = impl_from_IHTMLElement(iface);
1261 nsresult nsres;
1262
1263 TRACE("(%p)->(%p)\n", This, p);
1264
1265 nsres = nsIDOMHTMLElement_GetOffsetHeight(This->nselem, p);
1266 if(NS_FAILED(nsres)) {
1267 ERR("GetOffsetHeight failed: %08x\n", nsres);
1268 return E_FAIL;
1269 }
1270
1271 return S_OK;
1272 }
1273
1274 static HRESULT WINAPI HTMLElement_get_offsetParent(IHTMLElement *iface, IHTMLElement **p)
1275 {
1276 HTMLElement *This = impl_from_IHTMLElement(iface);
1277 nsIDOMElement *nsparent;
1278 nsresult nsres;
1279 HRESULT hres;
1280
1281 TRACE("(%p)->(%p)\n", This, p);
1282
1283 nsres = nsIDOMHTMLElement_GetOffsetParent(This->nselem, &nsparent);
1284 if(NS_FAILED(nsres)) {
1285 ERR("GetOffsetParent failed: %08x\n", nsres);
1286 return E_FAIL;
1287 }
1288
1289 if(nsparent) {
1290 HTMLDOMNode *node;
1291
1292 hres = get_node(This->node.doc, (nsIDOMNode*)nsparent, TRUE, &node);
1293 nsIDOMElement_Release(nsparent);
1294 if(FAILED(hres))
1295 return hres;
1296
1297 hres = IHTMLDOMNode_QueryInterface(&node->IHTMLDOMNode_iface, &IID_IHTMLElement, (void**)p);
1298 node_release(node);
1299 }else {
1300 *p = NULL;
1301 hres = S_OK;
1302 }
1303
1304 return hres;
1305 }
1306
1307 static HRESULT WINAPI HTMLElement_put_innerHTML(IHTMLElement *iface, BSTR v)
1308 {
1309 HTMLElement *This = impl_from_IHTMLElement(iface);
1310 nsAString html_str;
1311 nsresult nsres;
1312
1313 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1314
1315 if(!This->nselem) {
1316 FIXME("NULL nselem\n");
1317 return E_NOTIMPL;
1318 }
1319
1320 nsAString_InitDepend(&html_str, v);
1321 nsres = nsIDOMHTMLElement_SetInnerHTML(This->nselem, &html_str);
1322 nsAString_Finish(&html_str);
1323 if(NS_FAILED(nsres)) {
1324 FIXME("SetInnerHtml failed %08x\n", nsres);
1325 return E_FAIL;
1326 }
1327
1328 return S_OK;
1329 }
1330
1331 static HRESULT WINAPI HTMLElement_get_innerHTML(IHTMLElement *iface, BSTR *p)
1332 {
1333 HTMLElement *This = impl_from_IHTMLElement(iface);
1334 nsAString html_str;
1335 nsresult nsres;
1336
1337 TRACE("(%p)->(%p)\n", This, p);
1338
1339 if(!This->nselem) {
1340 FIXME("NULL nselem\n");
1341 return E_NOTIMPL;
1342 }
1343
1344 nsAString_Init(&html_str, NULL);
1345 nsres = nsIDOMHTMLElement_GetInnerHTML(This->nselem, &html_str);
1346 return return_nsstr(nsres, &html_str, p);
1347 }
1348
1349 static HRESULT WINAPI HTMLElement_put_innerText(IHTMLElement *iface, BSTR v)
1350 {
1351 HTMLElement *This = impl_from_IHTMLElement(iface);
1352 nsIDOMNode *nschild, *tmp;
1353 nsIDOMText *text_node;
1354 nsAString text_str;
1355 nsresult nsres;
1356
1357 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1358
1359 while(1) {
1360 nsres = nsIDOMHTMLElement_GetLastChild(This->nselem, &nschild);
1361 if(NS_FAILED(nsres)) {
1362 ERR("GetLastChild failed: %08x\n", nsres);
1363 return E_FAIL;
1364 }
1365 if(!nschild)
1366 break;
1367
1368 nsres = nsIDOMHTMLElement_RemoveChild(This->nselem, nschild, &tmp);
1369 nsIDOMNode_Release(nschild);
1370 if(NS_FAILED(nsres)) {
1371 ERR("RemoveChild failed: %08x\n", nsres);
1372 return E_FAIL;
1373 }
1374 nsIDOMNode_Release(tmp);
1375 }
1376
1377 nsAString_InitDepend(&text_str, v);
1378 nsres = nsIDOMHTMLDocument_CreateTextNode(This->node.doc->nsdoc, &text_str, &text_node);
1379 nsAString_Finish(&text_str);
1380 if(NS_FAILED(nsres)) {
1381 ERR("CreateTextNode failed: %08x\n", nsres);
1382 return E_FAIL;
1383 }
1384
1385 nsres = nsIDOMHTMLElement_AppendChild(This->nselem, (nsIDOMNode*)text_node, &tmp);
1386 if(NS_FAILED(nsres)) {
1387 ERR("AppendChild failed: %08x\n", nsres);
1388 return E_FAIL;
1389 }
1390
1391 nsIDOMNode_Release(tmp);
1392 return S_OK;
1393 }
1394
1395 static HRESULT WINAPI HTMLElement_get_innerText(IHTMLElement *iface, BSTR *p)
1396 {
1397 HTMLElement *This = impl_from_IHTMLElement(iface);
1398
1399 TRACE("(%p)->(%p)\n", This, p);
1400
1401 return get_node_text(&This->node, p);
1402 }
1403
1404 static HRESULT WINAPI HTMLElement_put_outerHTML(IHTMLElement *iface, BSTR v)
1405 {
1406 HTMLElement *This = impl_from_IHTMLElement(iface);
1407
1408 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1409
1410 return replace_node_by_html(This->node.doc->nsdoc, This->node.nsnode, v);
1411 }
1412
1413 static HRESULT WINAPI HTMLElement_get_outerHTML(IHTMLElement *iface, BSTR *p)
1414 {
1415 HTMLElement *This = impl_from_IHTMLElement(iface);
1416 nsAString html_str;
1417 HRESULT hres;
1418
1419 WARN("(%p)->(%p) semi-stub\n", This, p);
1420
1421 nsAString_Init(&html_str, NULL);
1422 hres = nsnode_to_nsstring(This->node.nsnode, &html_str);
1423 if(SUCCEEDED(hres)) {
1424 const PRUnichar *html;
1425
1426 nsAString_GetData(&html_str, &html);
1427 *p = SysAllocString(html);
1428 if(!*p)
1429 hres = E_OUTOFMEMORY;
1430 }
1431
1432 nsAString_Finish(&html_str);
1433
1434 TRACE("ret %s\n", debugstr_w(*p));
1435 return hres;
1436 }
1437
1438 static HRESULT WINAPI HTMLElement_put_outerText(IHTMLElement *iface, BSTR v)
1439 {
1440 HTMLElement *This = impl_from_IHTMLElement(iface);
1441 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1442 return E_NOTIMPL;
1443 }
1444
1445 static HRESULT WINAPI HTMLElement_get_outerText(IHTMLElement *iface, BSTR *p)
1446 {
1447 HTMLElement *This = impl_from_IHTMLElement(iface);
1448 FIXME("(%p)->(%p)\n", This, p);
1449 return E_NOTIMPL;
1450 }
1451
1452 HRESULT insert_adjacent_node(HTMLElement *This, const WCHAR *where, nsIDOMNode *nsnode, HTMLDOMNode **ret_node)
1453 {
1454 nsIDOMNode *ret_nsnode;
1455 nsresult nsres;
1456 HRESULT hres = S_OK;
1457
1458 static const WCHAR beforebeginW[] = {'b','e','f','o','r','e','b','e','g','i','n',0};
1459 static const WCHAR afterbeginW[] = {'a','f','t','e','r','b','e','g','i','n',0};
1460 static const WCHAR beforeendW[] = {'b','e','f','o','r','e','e','n','d',0};
1461 static const WCHAR afterendW[] = {'a','f','t','e','r','e','n','d',0};
1462
1463 if (!strcmpiW(where, beforebeginW)) {
1464 nsIDOMNode *parent;
1465
1466 nsres = nsIDOMNode_GetParentNode(This->node.nsnode, &parent);
1467 if(NS_FAILED(nsres))
1468 return E_FAIL;
1469
1470 if(!parent)
1471 return E_INVALIDARG;
1472
1473 nsres = nsIDOMNode_InsertBefore(parent, nsnode, This->node.nsnode, &ret_nsnode);
1474 nsIDOMNode_Release(parent);
1475 }else if(!strcmpiW(where, afterbeginW)) {
1476 nsIDOMNode *first_child;
1477
1478 nsres = nsIDOMNode_GetFirstChild(This->node.nsnode, &first_child);
1479 if(NS_FAILED(nsres))
1480 return E_FAIL;
1481
1482 nsres = nsIDOMNode_InsertBefore(This->node.nsnode, nsnode, first_child, &ret_nsnode);
1483 if(NS_FAILED(nsres))
1484 return E_FAIL;
1485
1486 if (first_child)
1487 nsIDOMNode_Release(first_child);
1488 }else if (!strcmpiW(where, beforeendW)) {
1489 nsres = nsIDOMNode_AppendChild(This->node.nsnode, nsnode, &ret_nsnode);
1490 }else if (!strcmpiW(where, afterendW)) {
1491 nsIDOMNode *next_sibling, *parent;
1492
1493 nsres = nsIDOMNode_GetParentNode(This->node.nsnode, &parent);
1494 if(NS_FAILED(nsres))
1495 return E_FAIL;
1496 if(!parent)
1497 return E_INVALIDARG;
1498
1499 nsres = nsIDOMNode_GetNextSibling(This->node.nsnode, &next_sibling);
1500 if(NS_SUCCEEDED(nsres)) {
1501 if(next_sibling) {
1502 nsres = nsIDOMNode_InsertBefore(parent, nsnode, next_sibling, &ret_nsnode);
1503 nsIDOMNode_Release(next_sibling);
1504 }else {
1505 nsres = nsIDOMNode_AppendChild(parent, nsnode, &ret_nsnode);
1506 }
1507 }
1508
1509 nsIDOMNode_Release(parent);
1510 }else {
1511 ERR("invalid where: %s\n", debugstr_w(where));
1512 return E_INVALIDARG;
1513 }
1514
1515 if (NS_FAILED(nsres))
1516 return E_FAIL;
1517
1518 if(ret_node)
1519 hres = get_node(This->node.doc, ret_nsnode, TRUE, ret_node);
1520 nsIDOMNode_Release(ret_nsnode);
1521 return hres;
1522 }
1523
1524 static HRESULT WINAPI HTMLElement_insertAdjacentHTML(IHTMLElement *iface, BSTR where,
1525 BSTR html)
1526 {
1527 HTMLElement *This = impl_from_IHTMLElement(iface);
1528 nsIDOMRange *range;
1529 nsIDOMNode *nsnode;
1530 nsAString ns_html;
1531 nsresult nsres;
1532 HRESULT hr;
1533
1534 TRACE("(%p)->(%s %s)\n", This, debugstr_w(where), debugstr_w(html));
1535
1536 if(!This->node.doc->nsdoc) {
1537 WARN("NULL nsdoc\n");
1538 return E_UNEXPECTED;
1539 }
1540
1541 nsres = nsIDOMHTMLDocument_CreateRange(This->node.doc->nsdoc, &range);
1542 if(NS_FAILED(nsres))
1543 {
1544 ERR("CreateRange failed: %08x\n", nsres);
1545 return E_FAIL;
1546 }
1547
1548 nsIDOMRange_SetStartBefore(range, This->node.nsnode);
1549
1550 nsAString_InitDepend(&ns_html, html);
1551 nsres = nsIDOMRange_CreateContextualFragment(range, &ns_html, (nsIDOMDocumentFragment **)&nsnode);
1552 nsAString_Finish(&ns_html);
1553 nsIDOMRange_Release(range);
1554
1555 if(NS_FAILED(nsres) || !nsnode)
1556 {
1557 ERR("CreateTextNode failed: %08x\n", nsres);
1558 return E_FAIL;
1559 }
1560
1561 hr = insert_adjacent_node(This, where, nsnode, NULL);
1562 nsIDOMNode_Release(nsnode);
1563 return hr;
1564 }
1565
1566 static HRESULT WINAPI HTMLElement_insertAdjacentText(IHTMLElement *iface, BSTR where,
1567 BSTR text)
1568 {
1569 HTMLElement *This = impl_from_IHTMLElement(iface);
1570 nsIDOMNode *nsnode;
1571 nsAString ns_text;
1572 nsresult nsres;
1573 HRESULT hr;
1574
1575 TRACE("(%p)->(%s %s)\n", This, debugstr_w(where), debugstr_w(text));
1576
1577 if(!This->node.doc->nsdoc) {
1578 WARN("NULL nsdoc\n");
1579 return E_UNEXPECTED;
1580 }
1581
1582
1583 nsAString_InitDepend(&ns_text, text);
1584 nsres = nsIDOMHTMLDocument_CreateTextNode(This->node.doc->nsdoc, &ns_text, (nsIDOMText **)&nsnode);
1585 nsAString_Finish(&ns_text);
1586
1587 if(NS_FAILED(nsres) || !nsnode)
1588 {
1589 ERR("CreateTextNode failed: %08x\n", nsres);
1590 return E_FAIL;
1591 }
1592
1593 hr = insert_adjacent_node(This, where, nsnode, NULL);
1594 nsIDOMNode_Release(nsnode);
1595
1596 return hr;
1597 }
1598
1599 static HRESULT WINAPI HTMLElement_get_parentTextEdit(IHTMLElement *iface, IHTMLElement **p)
1600 {
1601 HTMLElement *This = impl_from_IHTMLElement(iface);
1602 FIXME("(%p)->(%p)\n", This, p);
1603 return E_NOTIMPL;
1604 }
1605
1606 static HRESULT WINAPI HTMLElement_get_isTextEdit(IHTMLElement *iface, VARIANT_BOOL *p)
1607 {
1608 HTMLElement *This = impl_from_IHTMLElement(iface);
1609 FIXME("(%p)->(%p)\n", This, p);
1610 return E_NOTIMPL;
1611 }
1612
1613 static HRESULT WINAPI HTMLElement_click(IHTMLElement *iface)
1614 {
1615 HTMLElement *This = impl_from_IHTMLElement(iface);
1616
1617 TRACE("(%p)\n", This);
1618
1619 return call_fire_event(&This->node, EVENTID_CLICK);
1620 }
1621
1622 static HRESULT WINAPI HTMLElement_get_filters(IHTMLElement *iface,
1623 IHTMLFiltersCollection **p)
1624 {
1625 HTMLElement *This = impl_from_IHTMLElement(iface);
1626 TRACE("(%p)->(%p)\n", This, p);
1627
1628 if(!p)
1629 return E_POINTER;
1630
1631 *p = HTMLFiltersCollection_Create();
1632
1633 return S_OK;
1634 }
1635
1636 static HRESULT WINAPI HTMLElement_put_ondragstart(IHTMLElement *iface, VARIANT v)
1637 {
1638 HTMLElement *This = impl_from_IHTMLElement(iface);
1639 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1640 return E_NOTIMPL;
1641 }
1642
1643 static HRESULT WINAPI HTMLElement_get_ondragstart(IHTMLElement *iface, VARIANT *p)
1644 {
1645 HTMLElement *This = impl_from_IHTMLElement(iface);
1646 FIXME("(%p)->(%p)\n", This, p);
1647 return E_NOTIMPL;
1648 }
1649
1650 static HRESULT WINAPI HTMLElement_toString(IHTMLElement *iface, BSTR *String)
1651 {
1652 HTMLElement *This = impl_from_IHTMLElement(iface);
1653 FIXME("(%p)->(%p)\n", This, String);
1654 return E_NOTIMPL;
1655 }
1656
1657 static HRESULT WINAPI HTMLElement_put_onbeforeupdate(IHTMLElement *iface, VARIANT v)
1658 {
1659 HTMLElement *This = impl_from_IHTMLElement(iface);
1660 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1661 return E_NOTIMPL;
1662 }
1663
1664 static HRESULT WINAPI HTMLElement_get_onbeforeupdate(IHTMLElement *iface, VARIANT *p)
1665 {
1666 HTMLElement *This = impl_from_IHTMLElement(iface);
1667 FIXME("(%p)->(%p)\n", This, p);
1668 return E_NOTIMPL;
1669 }
1670
1671 static HRESULT WINAPI HTMLElement_put_onafterupdate(IHTMLElement *iface, VARIANT v)
1672 {
1673 HTMLElement *This = impl_from_IHTMLElement(iface);
1674 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1675 return E_NOTIMPL;
1676 }
1677
1678 static HRESULT WINAPI HTMLElement_get_onafterupdate(IHTMLElement *iface, VARIANT *p)
1679 {
1680 HTMLElement *This = impl_from_IHTMLElement(iface);
1681 FIXME("(%p)->(%p)\n", This, p);
1682 return E_NOTIMPL;
1683 }
1684
1685 static HRESULT WINAPI HTMLElement_put_onerrorupdate(IHTMLElement *iface, VARIANT v)
1686 {
1687 HTMLElement *This = impl_from_IHTMLElement(iface);
1688 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1689 return E_NOTIMPL;
1690 }
1691
1692 static HRESULT WINAPI HTMLElement_get_onerrorupdate(IHTMLElement *iface, VARIANT *p)
1693 {
1694 HTMLElement *This = impl_from_IHTMLElement(iface);
1695 FIXME("(%p)->(%p)\n", This, p);
1696 return E_NOTIMPL;
1697 }
1698
1699 static HRESULT WINAPI HTMLElement_put_onrowexit(IHTMLElement *iface, VARIANT v)
1700 {
1701 HTMLElement *This = impl_from_IHTMLElement(iface);
1702 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1703 return E_NOTIMPL;
1704 }
1705
1706 static HRESULT WINAPI HTMLElement_get_onrowexit(IHTMLElement *iface, VARIANT *p)
1707 {
1708 HTMLElement *This = impl_from_IHTMLElement(iface);
1709 FIXME("(%p)->(%p)\n", This, p);
1710 return E_NOTIMPL;
1711 }
1712
1713 static HRESULT WINAPI HTMLElement_put_onrowenter(IHTMLElement *iface, VARIANT v)
1714 {
1715 HTMLElement *This = impl_from_IHTMLElement(iface);
1716 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1717 return E_NOTIMPL;
1718 }
1719
1720 static HRESULT WINAPI HTMLElement_get_onrowenter(IHTMLElement *iface, VARIANT *p)
1721 {
1722 HTMLElement *This = impl_from_IHTMLElement(iface);
1723 FIXME("(%p)->(%p)\n", This, p);
1724 return E_NOTIMPL;
1725 }
1726
1727 static HRESULT WINAPI HTMLElement_put_ondatasetchanged(IHTMLElement *iface, VARIANT v)
1728 {
1729 HTMLElement *This = impl_from_IHTMLElement(iface);
1730 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1731 return E_NOTIMPL;
1732 }
1733
1734 static HRESULT WINAPI HTMLElement_get_ondatasetchanged(IHTMLElement *iface, VARIANT *p)
1735 {
1736 HTMLElement *This = impl_from_IHTMLElement(iface);
1737 FIXME("(%p)->(%p)\n", This, p);
1738 return E_NOTIMPL;
1739 }
1740
1741 static HRESULT WINAPI HTMLElement_put_ondataavailable(IHTMLElement *iface, VARIANT v)
1742 {
1743 HTMLElement *This = impl_from_IHTMLElement(iface);
1744
1745 FIXME("(%p)->(%s) semi-stub\n", This, debugstr_variant(&v));
1746
1747 return set_node_event(&This->node, EVENTID_DATAAVAILABLE, &v);
1748 }
1749
1750 static HRESULT WINAPI HTMLElement_get_ondataavailable(IHTMLElement *iface, VARIANT *p)
1751 {
1752 HTMLElement *This = impl_from_IHTMLElement(iface);
1753
1754 TRACE("(%p)->(%p)\n", This, p);
1755
1756 return get_node_event(&This->node, EVENTID_DATAAVAILABLE, p);
1757 }
1758
1759 static HRESULT WINAPI HTMLElement_put_ondatasetcomplete(IHTMLElement *iface, VARIANT v)
1760 {
1761 HTMLElement *This = impl_from_IHTMLElement(iface);
1762 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1763 return E_NOTIMPL;
1764 }
1765
1766 static HRESULT WINAPI HTMLElement_get_ondatasetcomplete(IHTMLElement *iface, VARIANT *p)
1767 {
1768 HTMLElement *This = impl_from_IHTMLElement(iface);
1769 FIXME("(%p)->(%p)\n", This, p);
1770 return E_NOTIMPL;
1771 }
1772
1773 static HRESULT WINAPI HTMLElement_put_onfilterchange(IHTMLElement *iface, VARIANT v)
1774 {
1775 HTMLElement *This = impl_from_IHTMLElement(iface);
1776 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1777 return E_NOTIMPL;
1778 }
1779
1780 static HRESULT WINAPI HTMLElement_get_onfilterchange(IHTMLElement *iface, VARIANT *p)
1781 {
1782 HTMLElement *This = impl_from_IHTMLElement(iface);
1783 FIXME("(%p)->(%p)\n", This, p);
1784 return E_NOTIMPL;
1785 }
1786
1787 static HRESULT WINAPI HTMLElement_get_children(IHTMLElement *iface, IDispatch **p)
1788 {
1789 HTMLElement *This = impl_from_IHTMLElement(iface);
1790 nsIDOMNodeList *nsnode_list;
1791 nsresult nsres;
1792
1793 TRACE("(%p)->(%p)\n", This, p);
1794
1795 nsres = nsIDOMNode_GetChildNodes(This->node.nsnode, &nsnode_list);
1796 if(NS_FAILED(nsres)) {
1797 ERR("GetChildNodes failed: %08x\n", nsres);
1798 return E_FAIL;
1799 }
1800
1801 *p = (IDispatch*)create_collection_from_nodelist(This->node.doc, nsnode_list);
1802
1803 nsIDOMNodeList_Release(nsnode_list);
1804 return S_OK;
1805 }
1806
1807 static HRESULT WINAPI HTMLElement_get_all(IHTMLElement *iface, IDispatch **p)
1808 {
1809 HTMLElement *This = impl_from_IHTMLElement(iface);
1810
1811 TRACE("(%p)->(%p)\n", This, p);
1812
1813 *p = (IDispatch*)create_all_collection(&This->node, FALSE);
1814 return S_OK;
1815 }
1816
1817 static const IHTMLElementVtbl HTMLElementVtbl = {
1818 HTMLElement_QueryInterface,
1819 HTMLElement_AddRef,
1820 HTMLElement_Release,
1821 HTMLElement_GetTypeInfoCount,
1822 HTMLElement_GetTypeInfo,
1823 HTMLElement_GetIDsOfNames,
1824 HTMLElement_Invoke,
1825 HTMLElement_setAttribute,
1826 HTMLElement_getAttribute,
1827 HTMLElement_removeAttribute,
1828 HTMLElement_put_className,
1829 HTMLElement_get_className,
1830 HTMLElement_put_id,
1831 HTMLElement_get_id,
1832 HTMLElement_get_tagName,
1833 HTMLElement_get_parentElement,
1834 HTMLElement_get_style,
1835 HTMLElement_put_onhelp,
1836 HTMLElement_get_onhelp,
1837 HTMLElement_put_onclick,
1838 HTMLElement_get_onclick,
1839 HTMLElement_put_ondblclick,
1840 HTMLElement_get_ondblclick,
1841 HTMLElement_put_onkeydown,
1842 HTMLElement_get_onkeydown,
1843 HTMLElement_put_onkeyup,
1844 HTMLElement_get_onkeyup,
1845 HTMLElement_put_onkeypress,
1846 HTMLElement_get_onkeypress,
1847 HTMLElement_put_onmouseout,
1848 HTMLElement_get_onmouseout,
1849 HTMLElement_put_onmouseover,
1850 HTMLElement_get_onmouseover,
1851 HTMLElement_put_onmousemove,
1852 HTMLElement_get_onmousemove,
1853 HTMLElement_put_onmousedown,
1854 HTMLElement_get_onmousedown,
1855 HTMLElement_put_onmouseup,
1856 HTMLElement_get_onmouseup,
1857 HTMLElement_get_document,
1858 HTMLElement_put_title,
1859 HTMLElement_get_title,
1860 HTMLElement_put_language,
1861 HTMLElement_get_language,
1862 HTMLElement_put_onselectstart,
1863 HTMLElement_get_onselectstart,
1864 HTMLElement_scrollIntoView,
1865 HTMLElement_contains,
1866 HTMLElement_get_sourceIndex,
1867 HTMLElement_get_recordNumber,
1868 HTMLElement_put_lang,
1869 HTMLElement_get_lang,
1870 HTMLElement_get_offsetLeft,
1871 HTMLElement_get_offsetTop,
1872 HTMLElement_get_offsetWidth,
1873 HTMLElement_get_offsetHeight,
1874 HTMLElement_get_offsetParent,
1875 HTMLElement_put_innerHTML,
1876 HTMLElement_get_innerHTML,
1877 HTMLElement_put_innerText,
1878 HTMLElement_get_innerText,
1879 HTMLElement_put_outerHTML,
1880 HTMLElement_get_outerHTML,
1881 HTMLElement_put_outerText,
1882 HTMLElement_get_outerText,
1883 HTMLElement_insertAdjacentHTML,
1884 HTMLElement_insertAdjacentText,
1885 HTMLElement_get_parentTextEdit,
1886 HTMLElement_get_isTextEdit,
1887 HTMLElement_click,
1888 HTMLElement_get_filters,
1889 HTMLElement_put_ondragstart,
1890 HTMLElement_get_ondragstart,
1891 HTMLElement_toString,
1892 HTMLElement_put_onbeforeupdate,
1893 HTMLElement_get_onbeforeupdate,
1894 HTMLElement_put_onafterupdate,
1895 HTMLElement_get_onafterupdate,
1896 HTMLElement_put_onerrorupdate,
1897 HTMLElement_get_onerrorupdate,
1898 HTMLElement_put_onrowexit,
1899 HTMLElement_get_onrowexit,
1900 HTMLElement_put_onrowenter,
1901 HTMLElement_get_onrowenter,
1902 HTMLElement_put_ondatasetchanged,
1903 HTMLElement_get_ondatasetchanged,
1904 HTMLElement_put_ondataavailable,
1905 HTMLElement_get_ondataavailable,
1906 HTMLElement_put_ondatasetcomplete,
1907 HTMLElement_get_ondatasetcomplete,
1908 HTMLElement_put_onfilterchange,
1909 HTMLElement_get_onfilterchange,
1910 HTMLElement_get_children,
1911 HTMLElement_get_all
1912 };
1913
1914 HTMLElement *unsafe_impl_from_IHTMLElement(IHTMLElement *iface)
1915 {
1916 return iface->lpVtbl == &HTMLElementVtbl ? impl_from_IHTMLElement(iface) : NULL;
1917 }
1918
1919 static inline HTMLElement *impl_from_IHTMLElement2(IHTMLElement2 *iface)
1920 {
1921 return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement2_iface);
1922 }
1923
1924 static HRESULT WINAPI HTMLElement2_QueryInterface(IHTMLElement2 *iface,
1925 REFIID riid, void **ppv)
1926 {
1927 HTMLElement *This = impl_from_IHTMLElement2(iface);
1928 return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
1929 }
1930
1931 static ULONG WINAPI HTMLElement2_AddRef(IHTMLElement2 *iface)
1932 {
1933 HTMLElement *This = impl_from_IHTMLElement2(iface);
1934 return IHTMLElement_AddRef(&This->IHTMLElement_iface);
1935 }
1936
1937 static ULONG WINAPI HTMLElement2_Release(IHTMLElement2 *iface)
1938 {
1939 HTMLElement *This = impl_from_IHTMLElement2(iface);
1940 return IHTMLElement_Release(&This->IHTMLElement_iface);
1941 }
1942
1943 static HRESULT WINAPI HTMLElement2_GetTypeInfoCount(IHTMLElement2 *iface, UINT *pctinfo)
1944 {
1945 HTMLElement *This = impl_from_IHTMLElement2(iface);
1946 return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
1947 }
1948
1949 static HRESULT WINAPI HTMLElement2_GetTypeInfo(IHTMLElement2 *iface, UINT iTInfo,
1950 LCID lcid, ITypeInfo **ppTInfo)
1951 {
1952 HTMLElement *This = impl_from_IHTMLElement2(iface);
1953 return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1954 }
1955
1956 static HRESULT WINAPI HTMLElement2_GetIDsOfNames(IHTMLElement2 *iface, REFIID riid,
1957 LPOLESTR *rgszNames, UINT cNames,
1958 LCID lcid, DISPID *rgDispId)
1959 {
1960 HTMLElement *This = impl_from_IHTMLElement2(iface);
1961 return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1962 lcid, rgDispId);
1963 }
1964
1965 static HRESULT WINAPI HTMLElement2_Invoke(IHTMLElement2 *iface, DISPID dispIdMember,
1966 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1967 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1968 {
1969 HTMLElement *This = impl_from_IHTMLElement2(iface);
1970 return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
1971 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1972 }
1973
1974 static HRESULT WINAPI HTMLElement2_get_scopeName(IHTMLElement2 *iface, BSTR *p)
1975 {
1976 HTMLElement *This = impl_from_IHTMLElement2(iface);
1977 FIXME("(%p)->(%p)\n", This, p);
1978 return E_NOTIMPL;
1979 }
1980
1981 static HRESULT WINAPI HTMLElement2_setCapture(IHTMLElement2 *iface, VARIANT_BOOL containerCapture)
1982 {
1983 HTMLElement *This = impl_from_IHTMLElement2(iface);
1984 FIXME("(%p)->(%x)\n", This, containerCapture);
1985 return E_NOTIMPL;
1986 }
1987
1988 static HRESULT WINAPI HTMLElement2_releaseCapture(IHTMLElement2 *iface)
1989 {
1990 HTMLElement *This = impl_from_IHTMLElement2(iface);
1991 FIXME("(%p)\n", This);
1992 return E_NOTIMPL;
1993 }
1994
1995 static HRESULT WINAPI HTMLElement2_put_onlosecapture(IHTMLElement2 *iface, VARIANT v)
1996 {
1997 HTMLElement *This = impl_from_IHTMLElement2(iface);
1998 FIXME("(%p)->()\n", This);
1999 return E_NOTIMPL;
2000 }
2001
2002 static HRESULT WINAPI HTMLElement2_get_onlosecapture(IHTMLElement2 *iface, VARIANT *p)
2003 {
2004 HTMLElement *This = impl_from_IHTMLElement2(iface);
2005 FIXME("(%p)->(%p)\n", This, p);
2006 return E_NOTIMPL;
2007 }
2008
2009 static HRESULT WINAPI HTMLElement2_componentFromPoint(IHTMLElement2 *iface,
2010 LONG x, LONG y, BSTR *component)
2011 {
2012 HTMLElement *This = impl_from_IHTMLElement2(iface);
2013 FIXME("(%p)->(%d %d %p)\n", This, x, y, component);
2014 return E_NOTIMPL;
2015 }
2016
2017 static HRESULT WINAPI HTMLElement2_doScroll(IHTMLElement2 *iface, VARIANT component)
2018 {
2019 HTMLElement *This = impl_from_IHTMLElement2(iface);
2020
2021 TRACE("(%p)->(%s)\n", This, debugstr_variant(&component));
2022
2023 if(!This->node.doc->content_ready
2024 || !This->node.doc->basedoc.doc_obj->in_place_active)
2025 return E_PENDING;
2026
2027 WARN("stub\n");
2028 return S_OK;
2029 }
2030
2031 static HRESULT WINAPI HTMLElement2_put_onscroll(IHTMLElement2 *iface, VARIANT v)
2032 {
2033 HTMLElement *This = impl_from_IHTMLElement2(iface);
2034 FIXME("(%p)->()\n", This);
2035 return E_NOTIMPL;
2036 }
2037
2038 static HRESULT WINAPI HTMLElement2_get_onscroll(IHTMLElement2 *iface, VARIANT *p)
2039 {
2040 HTMLElement *This = impl_from_IHTMLElement2(iface);
2041 FIXME("(%p)->(%p)\n", This, p);
2042 return E_NOTIMPL;
2043 }
2044
2045 static HRESULT WINAPI HTMLElement2_put_ondrag(IHTMLElement2 *iface, VARIANT v)
2046 {
2047 HTMLElement *This = impl_from_IHTMLElement2(iface);
2048
2049 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2050
2051 return set_node_event(&This->node, EVENTID_DRAG, &v);
2052 }
2053
2054 static HRESULT WINAPI HTMLElement2_get_ondrag(IHTMLElement2 *iface, VARIANT *p)
2055 {
2056 HTMLElement *This = impl_from_IHTMLElement2(iface);
2057
2058 TRACE("(%p)->(%p)\n", This, p);
2059
2060 return get_node_event(&This->node, EVENTID_DRAG, p);
2061 }
2062
2063 static HRESULT WINAPI HTMLElement2_put_ondragend(IHTMLElement2 *iface, VARIANT v)
2064 {
2065 HTMLElement *This = impl_from_IHTMLElement2(iface);
2066 FIXME("(%p)->()\n", This);
2067 return E_NOTIMPL;
2068 }
2069
2070 static HRESULT WINAPI HTMLElement2_get_ondragend(IHTMLElement2 *iface, VARIANT *p)
2071 {
2072 HTMLElement *This = impl_from_IHTMLElement2(iface);
2073 FIXME("(%p)->(%p)\n", This, p);
2074 return E_NOTIMPL;
2075 }
2076
2077 static HRESULT WINAPI HTMLElement2_put_ondragenter(IHTMLElement2 *iface, VARIANT v)
2078 {
2079 HTMLElement *This = impl_from_IHTMLElement2(iface);
2080 FIXME("(%p)->()\n", This);
2081 return E_NOTIMPL;
2082 }
2083
2084 static HRESULT WINAPI HTMLElement2_get_ondragenter(IHTMLElement2 *iface, VARIANT *p)
2085 {
2086 HTMLElement *This = impl_from_IHTMLElement2(iface);
2087 FIXME("(%p)->(%p)\n", This, p);
2088 return E_NOTIMPL;
2089 }
2090
2091 static HRESULT WINAPI HTMLElement2_put_ondragover(IHTMLElement2 *iface, VARIANT v)
2092 {
2093 HTMLElement *This = impl_from_IHTMLElement2(iface);
2094 FIXME("(%p)->()\n", This);
2095 return E_NOTIMPL;
2096 }
2097
2098 static HRESULT WINAPI HTMLElement2_get_ondragover(IHTMLElement2 *iface, VARIANT *p)
2099 {
2100 HTMLElement *This = impl_from_IHTMLElement2(iface);
2101 FIXME("(%p)->(%p)\n", This, p);
2102 return E_NOTIMPL;
2103 }
2104
2105 static HRESULT WINAPI HTMLElement2_put_ondragleave(IHTMLElement2 *iface, VARIANT v)
2106 {
2107 HTMLElement *This = impl_from_IHTMLElement2(iface);
2108 FIXME("(%p)->()\n", This);
2109 return E_NOTIMPL;
2110 }
2111
2112 static HRESULT WINAPI HTMLElement2_get_ondragleave(IHTMLElement2 *iface, VARIANT *p)
2113 {
2114 HTMLElement *This = impl_from_IHTMLElement2(iface);
2115 FIXME("(%p)->(%p)\n", This, p);
2116 return E_NOTIMPL;
2117 }
2118
2119 static HRESULT WINAPI HTMLElement2_put_ondrop(IHTMLElement2 *iface, VARIANT v)
2120 {
2121 HTMLElement *This = impl_from_IHTMLElement2(iface);
2122 FIXME("(%p)->()\n", This);
2123 return E_NOTIMPL;
2124 }
2125
2126 static HRESULT WINAPI HTMLElement2_get_ondrop(IHTMLElement2 *iface, VARIANT *p)
2127 {
2128 HTMLElement *This = impl_from_IHTMLElement2(iface);
2129 FIXME("(%p)->(%p)\n", This, p);
2130 return E_NOTIMPL;
2131 }
2132
2133 static HRESULT WINAPI HTMLElement2_put_onbeforecut(IHTMLElement2 *iface, VARIANT v)
2134 {
2135 HTMLElement *This = impl_from_IHTMLElement2(iface);
2136 FIXME("(%p)->()\n", This);
2137 return E_NOTIMPL;
2138 }
2139
2140 static HRESULT WINAPI HTMLElement2_get_onbeforecut(IHTMLElement2 *iface, VARIANT *p)
2141 {
2142 HTMLElement *This = impl_from_IHTMLElement2(iface);
2143 FIXME("(%p)->(%p)\n", This, p);
2144 return E_NOTIMPL;
2145 }
2146
2147 static HRESULT WINAPI HTMLElement2_put_oncut(IHTMLElement2 *iface, VARIANT v)
2148 {
2149 HTMLElement *This = impl_from_IHTMLElement2(iface);
2150 FIXME("(%p)->()\n", This);
2151 return E_NOTIMPL;
2152 }
2153
2154 static HRESULT WINAPI HTMLElement2_get_oncut(IHTMLElement2 *iface, VARIANT *p)
2155 {
2156 HTMLElement *This = impl_from_IHTMLElement2(iface);
2157 FIXME("(%p)->(%p)\n", This, p);
2158 return E_NOTIMPL;
2159 }
2160
2161 static HRESULT WINAPI HTMLElement2_put_onbeforecopy(IHTMLElement2 *iface, VARIANT v)
2162 {
2163 HTMLElement *This = impl_from_IHTMLElement2(iface);
2164 FIXME("(%p)->()\n", This);
2165 return E_NOTIMPL;
2166 }
2167
2168 static HRESULT WINAPI HTMLElement2_get_onbeforecopy(IHTMLElement2 *iface, VARIANT *p)
2169 {
2170 HTMLElement *This = impl_from_IHTMLElement2(iface);
2171 FIXME("(%p)->(%p)\n", This, p);
2172 return E_NOTIMPL;
2173 }
2174
2175 static HRESULT WINAPI HTMLElement2_put_oncopy(IHTMLElement2 *iface, VARIANT v)
2176 {
2177 HTMLElement *This = impl_from_IHTMLElement2(iface);
2178 FIXME("(%p)->()\n", This);
2179 return E_NOTIMPL;
2180 }
2181
2182 static HRESULT WINAPI HTMLElement2_get_oncopy(IHTMLElement2 *iface, VARIANT *p)
2183 {
2184 HTMLElement *This = impl_from_IHTMLElement2(iface);
2185 FIXME("(%p)->(%p)\n", This, p);
2186 return E_NOTIMPL;
2187 }
2188
2189 static HRESULT WINAPI HTMLElement2_put_onbeforepaste(IHTMLElement2 *iface, VARIANT v)
2190 {
2191 HTMLElement *This = impl_from_IHTMLElement2(iface);
2192 FIXME("(%p)->()\n", This);
2193 return E_NOTIMPL;
2194 }
2195
2196 static HRESULT WINAPI HTMLElement2_get_onbeforepaste(IHTMLElement2 *iface, VARIANT *p)
2197 {
2198 HTMLElement *This = impl_from_IHTMLElement2(iface);
2199 FIXME("(%p)->(%p)\n", This, p);
2200 return E_NOTIMPL;
2201 }
2202
2203 static HRESULT WINAPI HTMLElement2_put_onpaste(IHTMLElement2 *iface, VARIANT v)
2204 {
2205 HTMLElement *This = impl_from_IHTMLElement2(iface);
2206
2207 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2208
2209 return set_node_event(&This->node, EVENTID_PASTE, &v);
2210 }
2211
2212 static HRESULT WINAPI HTMLElement2_get_onpaste(IHTMLElement2 *iface, VARIANT *p)
2213 {
2214 HTMLElement *This = impl_from_IHTMLElement2(iface);
2215
2216 TRACE("(%p)->(%p)\n", This, p);
2217
2218 return get_node_event(&This->node, EVENTID_PASTE, p);
2219 }
2220
2221 static HRESULT WINAPI HTMLElement2_get_currentStyle(IHTMLElement2 *iface, IHTMLCurrentStyle **p)
2222 {
2223 HTMLElement *This = impl_from_IHTMLElement2(iface);
2224
2225 TRACE("(%p)->(%p)\n", This, p);
2226
2227 return HTMLCurrentStyle_Create(This, p);
2228 }
2229
2230 static HRESULT WINAPI HTMLElement2_put_onpropertychange(IHTMLElement2 *iface, VARIANT v)
2231 {
2232 HTMLElement *This = impl_from_IHTMLElement2(iface);
2233 FIXME("(%p)->()\n", This);
2234 return E_NOTIMPL;
2235 }
2236
2237 static HRESULT WINAPI HTMLElement2_get_onpropertychange(IHTMLElement2 *iface, VARIANT *p)
2238 {
2239 HTMLElement *This = impl_from_IHTMLElement2(iface);
2240 FIXME("(%p)->(%p)\n", This, p);
2241 return E_NOTIMPL;
2242 }
2243
2244 static HRESULT WINAPI HTMLElement2_getClientRects(IHTMLElement2 *iface, IHTMLRectCollection **pRectCol)
2245 {
2246 HTMLElement *This = impl_from_IHTMLElement2(iface);
2247 FIXME("(%p)->(%p)\n", This, pRectCol);
2248 return E_NOTIMPL;
2249 }
2250
2251 static HRESULT WINAPI HTMLElement2_getBoundingClientRect(IHTMLElement2 *iface, IHTMLRect **pRect)
2252 {
2253 HTMLElement *This = impl_from_IHTMLElement2(iface);
2254 nsIDOMClientRect *nsrect;
2255 nsresult nsres;
2256 HRESULT hres;
2257
2258 TRACE("(%p)->(%p)\n", This, pRect);
2259
2260 nsres = nsIDOMHTMLElement_GetBoundingClientRect(This->nselem, &nsrect);
2261 if(NS_FAILED(nsres) || !nsrect) {
2262 ERR("GetBoindingClientRect failed: %08x\n", nsres);
2263 return E_FAIL;
2264 }
2265
2266 hres = create_html_rect(nsrect, pRect);
2267
2268 nsIDOMClientRect_Release(nsrect);
2269 return hres;
2270 }
2271
2272 static HRESULT WINAPI HTMLElement2_setExpression(IHTMLElement2 *iface, BSTR propname,
2273 BSTR expression, BSTR language)
2274 {
2275 HTMLElement *This = impl_from_IHTMLElement2(iface);
2276 FIXME("(%p)->(%s %s %s)\n", This, debugstr_w(propname), debugstr_w(expression),
2277 debugstr_w(language));
2278 return E_NOTIMPL;
2279 }
2280
2281 static HRESULT WINAPI HTMLElement2_getExpression(IHTMLElement2 *iface, BSTR propname,
2282 VARIANT *expression)
2283 {
2284 HTMLElement *This = impl_from_IHTMLElement2(iface);
2285 FIXME("(%p)->(%s %p)\n", This, debugstr_w(propname), expression);
2286 return E_NOTIMPL;
2287 }
2288
2289 static HRESULT WINAPI HTMLElement2_removeExpression(IHTMLElement2 *iface, BSTR propname,
2290 VARIANT_BOOL *pfSuccess)
2291 {
2292 HTMLElement *This = impl_from_IHTMLElement2(iface);
2293 FIXME("(%p)->(%s %p)\n", This, debugstr_w(propname), pfSuccess);
2294 return E_NOTIMPL;
2295 }
2296
2297 static HRESULT WINAPI HTMLElement2_put_tabIndex(IHTMLElement2 *iface, short v)
2298 {
2299 HTMLElement *This = impl_from_IHTMLElement2(iface);
2300 nsresult nsres;
2301
2302 TRACE("(%p)->(%d)\n", This, v);
2303
2304 nsres = nsIDOMHTMLElement_SetTabIndex(This->nselem, v);
2305 if(NS_FAILED(nsres))
2306 ERR("GetTabIndex failed: %08x\n", nsres);
2307
2308 return S_OK;
2309 }
2310
2311 static HRESULT WINAPI HTMLElement2_get_tabIndex(IHTMLElement2 *iface, short *p)
2312 {
2313 HTMLElement *This = impl_from_IHTMLElement2(iface);
2314 LONG index;
2315 nsresult nsres;
2316
2317 TRACE("(%p)->(%p)\n", This, p);
2318
2319 nsres = nsIDOMHTMLElement_GetTabIndex(This->nselem, &index);
2320 if(NS_FAILED(nsres)) {
2321 ERR("GetTabIndex failed: %08x\n", nsres);
2322 return E_FAIL;
2323 }
2324
2325 *p = index;
2326 return S_OK;
2327 }
2328
2329 static HRESULT WINAPI HTMLElement2_focus(IHTMLElement2 *iface)
2330 {
2331 HTMLElement *This = impl_from_IHTMLElement2(iface);
2332 nsresult nsres;
2333
2334 TRACE("(%p)\n", This);
2335
2336 nsres = nsIDOMHTMLElement_Focus(This->nselem);
2337 if(NS_FAILED(nsres))
2338 ERR("Focus failed: %08x\n", nsres);
2339
2340 return S_OK;
2341 }
2342
2343 static HRESULT WINAPI HTMLElement2_put_accessKey(IHTMLElement2 *iface, BSTR v)
2344 {
2345 HTMLElement *This = impl_from_IHTMLElement2(iface);
2346 VARIANT var;
2347
2348 static WCHAR accessKeyW[] = {'a','c','c','e','s','s','K','e','y',0};
2349
2350 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2351
2352 V_VT(&var) = VT_BSTR;
2353 V_BSTR(&var) = v;
2354 return IHTMLElement_setAttribute(&This->IHTMLElement_iface, accessKeyW, var, 0);
2355 }
2356
2357 static HRESULT WINAPI HTMLElement2_get_accessKey(IHTMLElement2 *iface, BSTR *p)
2358 {
2359 HTMLElement *This = impl_from_IHTMLElement2(iface);
2360 FIXME("(%p)->(%p)\n", This, p);
2361 return E_NOTIMPL;
2362 }
2363
2364 static HRESULT WINAPI HTMLElement2_put_onblur(IHTMLElement2 *iface, VARIANT v)
2365 {
2366 HTMLElement *This = impl_from_IHTMLElement2(iface);
2367
2368 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2369
2370 return set_node_event(&This->node, EVENTID_BLUR, &v);
2371 }
2372
2373 static HRESULT WINAPI HTMLElement2_get_onblur(IHTMLElement2 *iface, VARIANT *p)
2374 {
2375 HTMLElement *This = impl_from_IHTMLElement2(iface);
2376
2377 TRACE("(%p)->(%p)\n", This, p);
2378
2379 return get_node_event(&This->node, EVENTID_BLUR, p);
2380 }
2381
2382 static HRESULT WINAPI HTMLElement2_put_onfocus(IHTMLElement2 *iface, VARIANT v)
2383 {
2384 HTMLElement *This = impl_from_IHTMLElement2(iface);
2385
2386 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2387
2388 return set_node_event(&This->node, EVENTID_FOCUS, &v);
2389 }
2390
2391 static HRESULT WINAPI HTMLElement2_get_onfocus(IHTMLElement2 *iface, VARIANT *p)
2392 {
2393 HTMLElement *This = impl_from_IHTMLElement2(iface);
2394
2395 TRACE("(%p)->(%p)\n", This, p);
2396
2397 return get_node_event(&This->node, EVENTID_FOCUS, p);
2398 }
2399
2400 static HRESULT WINAPI HTMLElement2_put_onresize(IHTMLElement2 *iface, VARIANT v)
2401 {
2402 HTMLElement *This = impl_from_IHTMLElement2(iface);
2403 FIXME("(%p)->()\n", This);
2404 return E_NOTIMPL;
2405 }
2406
2407 static HRESULT WINAPI HTMLElement2_get_onresize(IHTMLElement2 *iface, VARIANT *p)
2408 {
2409 HTMLElement *This = impl_from_IHTMLElement2(iface);
2410 FIXME("(%p)->(%p)\n", This, p);
2411 return E_NOTIMPL;
2412 }
2413
2414 static HRESULT WINAPI HTMLElement2_blur(IHTMLElement2 *iface)
2415 {
2416 HTMLElement *This = impl_from_IHTMLElement2(iface);
2417 nsresult nsres;
2418
2419 TRACE("(%p)\n", This);
2420
2421 nsres = nsIDOMHTMLElement_Blur(This->nselem);
2422 if(NS_FAILED(nsres)) {
2423 ERR("Blur failed: %08x\n", nsres);
2424 return E_FAIL;
2425 }
2426
2427 return S_OK;
2428 }
2429
2430 static HRESULT WINAPI HTMLElement2_addFilter(IHTMLElement2 *iface, IUnknown *pUnk)
2431 {
2432 HTMLElement *This = impl_from_IHTMLElement2(iface);
2433 FIXME("(%p)->(%p)\n", This, pUnk);
2434 return E_NOTIMPL;
2435 }
2436
2437 static HRESULT WINAPI HTMLElement2_removeFilter(IHTMLElement2 *iface, IUnknown *pUnk)
2438 {
2439 HTMLElement *This = impl_from_IHTMLElement2(iface);
2440 FIXME("(%p)->(%p)\n", This, pUnk);
2441 return E_NOTIMPL;
2442 }
2443
2444 static HRESULT WINAPI HTMLElement2_get_clientHeight(IHTMLElement2 *iface, LONG *p)
2445 {
2446 HTMLElement *This = impl_from_IHTMLElement2(iface);
2447 nsresult nsres;
2448
2449 TRACE("(%p)->(%p)\n", This, p);
2450
2451 nsres = nsIDOMHTMLElement_GetClientHeight(This->nselem, p);
2452 assert(nsres == NS_OK);
2453 return S_OK;
2454 }
2455
2456 static HRESULT WINAPI HTMLElement2_get_clientWidth(IHTMLElement2 *iface, LONG *p)
2457 {
2458 HTMLElement *This = impl_from_IHTMLElement2(iface);
2459 nsresult nsres;
2460
2461 TRACE("(%p)->(%p)\n", This, p);
2462
2463 nsres = nsIDOMHTMLElement_GetClientWidth(This->nselem, p);
2464 assert(nsres == NS_OK);
2465 return S_OK;
2466 }
2467
2468 static HRESULT WINAPI HTMLElement2_get_clientTop(IHTMLElement2 *iface, LONG *p)
2469 {
2470 HTMLElement *This = impl_from_IHTMLElement2(iface);
2471 nsresult nsres;
2472
2473 TRACE("(%p)->(%p)\n", This, p);
2474
2475 nsres = nsIDOMHTMLElement_GetClientTop(This->nselem, p);
2476 assert(nsres == NS_OK);
2477
2478 TRACE("*p = %d\n", *p);
2479 return S_OK;
2480 }
2481
2482 static HRESULT WINAPI HTMLElement2_get_clientLeft(IHTMLElement2 *iface, LONG *p)
2483 {
2484 HTMLElement *This = impl_from_IHTMLElement2(iface);
2485 nsresult nsres;
2486
2487 TRACE("(%p)->(%p)\n", This, p);
2488
2489 nsres = nsIDOMHTMLElement_GetClientLeft(This->nselem, p);
2490 assert(nsres == NS_OK);
2491
2492 TRACE("*p = %d\n", *p);
2493 return S_OK;
2494 }
2495
2496 static HRESULT WINAPI HTMLElement2_attachEvent(IHTMLElement2 *iface, BSTR event,
2497 IDispatch *pDisp, VARIANT_BOOL *pfResult)
2498 {
2499 HTMLElement *This = impl_from_IHTMLElement2(iface);
2500
2501 TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(event), pDisp, pfResult);
2502
2503 return attach_event(get_node_event_target(&This->node), &This->node.doc->basedoc, event, pDisp, pfResult);
2504 }
2505
2506 static HRESULT WINAPI HTMLElement2_detachEvent(IHTMLElement2 *iface, BSTR event, IDispatch *pDisp)
2507 {
2508 HTMLElement *This = impl_from_IHTMLElement2(iface);
2509
2510 TRACE("(%p)->(%s %p)\n", This, debugstr_w(event), pDisp);
2511
2512 return detach_event(*get_node_event_target(&This->node), &This->node.doc->basedoc, event, pDisp);
2513 }
2514
2515 static HRESULT WINAPI HTMLElement2_get_readyState(IHTMLElement2 *iface, VARIANT *p)
2516 {
2517 HTMLElement *This = impl_from_IHTMLElement2(iface);
2518 BSTR str;
2519
2520 TRACE("(%p)->(%p)\n", This, p);
2521
2522 if(This->node.vtbl->get_readystate) {
2523 HRESULT hres;
2524
2525 hres = This->node.vtbl->get_readystate(&This->node, &str);
2526 if(FAILED(hres))
2527 return hres;
2528 }else {
2529 static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
2530
2531 str = SysAllocString(completeW);
2532 if(!str)
2533 return E_OUTOFMEMORY;
2534 }
2535
2536 V_VT(p) = VT_BSTR;
2537 V_BSTR(p) = str;
2538 return S_OK;
2539 }
2540
2541 static HRESULT WINAPI HTMLElement2_put_onreadystatechange(IHTMLElement2 *iface, VARIANT v)
2542 {
2543 HTMLElement *This = impl_from_IHTMLElement2(iface);
2544
2545 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2546
2547 return set_node_event(&This->node, EVENTID_READYSTATECHANGE, &v);
2548 }
2549
2550 static HRESULT WINAPI HTMLElement2_get_onreadystatechange(IHTMLElement2 *iface, VARIANT *p)
2551 {
2552 HTMLElement *This = impl_from_IHTMLElement2(iface);
2553
2554 TRACE("(%p)->(%p)\n", This, p);
2555
2556 return get_node_event(&This->node, EVENTID_READYSTATECHANGE, p);
2557 }
2558
2559 static HRESULT WINAPI HTMLElement2_put_onrowsdelete(IHTMLElement2 *iface, VARIANT v)
2560 {
2561 HTMLElement *This = impl_from_IHTMLElement2(iface);
2562 FIXME("(%p)->()\n", This);
2563 return E_NOTIMPL;
2564 }
2565
2566 static HRESULT WINAPI HTMLElement2_get_onrowsdelete(IHTMLElement2 *iface, VARIANT *p)
2567 {
2568 HTMLElement *This = impl_from_IHTMLElement2(iface);
2569 FIXME("(%p)->(%p)\n", This, p);
2570 return E_NOTIMPL;
2571 }
2572
2573 static HRESULT WINAPI HTMLElement2_put_onrowsinserted(IHTMLElement2 *iface, VARIANT v)
2574 {
2575 HTMLElement *This = impl_from_IHTMLElement2(iface);
2576 FIXME("(%p)->()\n", This);
2577 return E_NOTIMPL;
2578 }
2579
2580 static HRESULT WINAPI HTMLElement2_get_onrowsinserted(IHTMLElement2 *iface, VARIANT *p)
2581 {
2582 HTMLElement *This = impl_from_IHTMLElement2(iface);
2583 FIXME("(%p)->(%p)\n", This, p);
2584 return E_NOTIMPL;
2585 }
2586
2587 static HRESULT WINAPI HTMLElement2_put_oncellchange(IHTMLElement2 *iface, VARIANT v)
2588 {
2589 HTMLElement *This = impl_from_IHTMLElement2(iface);
2590 FIXME("(%p)->()\n", This);
2591 return E_NOTIMPL;
2592 }
2593
2594 static HRESULT WINAPI HTMLElement2_get_oncellchange(IHTMLElement2 *iface, VARIANT *p)
2595 {
2596 HTMLElement *This = impl_from_IHTMLElement2(iface);
2597 FIXME("(%p)->(%p)\n", This, p);
2598 return E_NOTIMPL;
2599 }
2600
2601 static HRESULT WINAPI HTMLElement2_put_dir(IHTMLElement2 *iface, BSTR v)
2602 {
2603 HTMLElement *This = impl_from_IHTMLElement2(iface);
2604 nsAString nsstr;
2605 nsresult nsres;
2606
2607 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2608
2609 if(!This->nselem) {
2610 FIXME("Unsupported for comment nodes.\n");
2611 return S_OK;
2612 }
2613
2614 nsAString_InitDepend(&nsstr, v);
2615 nsres = nsIDOMHTMLElement_SetDir(This->nselem, &nsstr);
2616 nsAString_Finish(&nsstr);
2617 if(NS_FAILED(nsres)) {
2618 ERR("SetDir failed: %08x\n", nsres);
2619 return E_FAIL;
2620 }
2621
2622 return S_OK;
2623 }
2624
2625 static HRESULT WINAPI HTMLElement2_get_dir(IHTMLElement2 *iface, BSTR *p)
2626 {
2627 HTMLElement *This = impl_from_IHTMLElement2(iface);
2628 nsAString dir_str;
2629 nsresult nsres;
2630
2631 TRACE("(%p)->(%p)\n", This, p);
2632
2633 if(!This->nselem) {
2634 *p = NULL;
2635 return S_OK;
2636 }
2637
2638 nsAString_Init(&dir_str, NULL);
2639 nsres = nsIDOMHTMLElement_GetDir(This->nselem, &dir_str);
2640 return return_nsstr(nsres, &dir_str, p);
2641 }
2642
2643 static HRESULT WINAPI HTMLElement2_createControlRange(IHTMLElement2 *iface, IDispatch **range)
2644 {
2645 HTMLElement *This = impl_from_IHTMLElement2(iface);
2646 FIXME("(%p)->(%p)\n", This, range);
2647 return E_NOTIMPL;
2648 }
2649
2650 static HRESULT WINAPI HTMLElement2_get_scrollHeight(IHTMLElement2 *iface, LONG *p)
2651 {
2652 HTMLElement *This = impl_from_IHTMLElement2(iface);
2653 nsresult nsres;
2654
2655 TRACE("(%p)->(%p)\n", This, p);
2656
2657 nsres = nsIDOMHTMLElement_GetScrollHeight(This->nselem, p);
2658 assert(nsres == NS_OK);
2659
2660 TRACE("*p = %d\n", *p);
2661 return S_OK;
2662 }
2663
2664 static HRESULT WINAPI HTMLElement2_get_scrollWidth(IHTMLElement2 *iface, LONG *p)
2665 {
2666 HTMLElement *This = impl_from_IHTMLElement2(iface);
2667 nsresult nsres;
2668
2669 TRACE("(%p)->(%p)\n", This, p);
2670
2671 nsres = nsIDOMHTMLElement_GetScrollWidth(This->nselem, p);
2672 assert(nsres == NS_OK);
2673
2674 TRACE("*p = %d\n", *p);
2675 return S_OK;
2676 }
2677
2678 static HRESULT WINAPI HTMLElement2_put_scrollTop(IHTMLElement2 *iface, LONG v)
2679 {
2680 HTMLElement *This = impl_from_IHTMLElement2(iface);
2681
2682 TRACE("(%p)->(%d)\n", This, v);
2683
2684 if(!This->nselem) {
2685 FIXME("NULL nselem\n");
2686 return E_NOTIMPL;
2687 }
2688
2689 nsIDOMHTMLElement_SetScrollTop(This->nselem, v);
2690 return S_OK;
2691 }
2692
2693 static HRESULT WINAPI HTMLElement2_get_scrollTop(IHTMLElement2 *iface, LONG *p)
2694 {
2695 HTMLElement *This = impl_from_IHTMLElement2(iface);
2696 nsresult nsres;
2697
2698 TRACE("(%p)->(%p)\n", This, p);
2699
2700 nsres = nsIDOMHTMLElement_GetScrollTop(This->nselem, p);
2701 assert(nsres == NS_OK);
2702
2703 TRACE("*p = %d\n", *p);
2704 return S_OK;
2705 }
2706
2707 static HRESULT WINAPI HTMLElement2_put_scrollLeft(IHTMLElement2 *iface, LONG v)
2708 {
2709 HTMLElement *This = impl_from_IHTMLElement2(iface);
2710
2711 TRACE("(%p)->(%d)\n", This, v);
2712
2713 if(!This->nselem) {
2714 FIXME("NULL nselem\n");
2715 return E_NOTIMPL;
2716 }
2717
2718 nsIDOMHTMLElement_SetScrollLeft(This->nselem, v);
2719 return S_OK;
2720 }
2721
2722 static HRESULT WINAPI HTMLElement2_get_scrollLeft(IHTMLElement2 *iface, LONG *p)
2723 {
2724 HTMLElement *This = impl_from_IHTMLElement2(iface);
2725 nsresult nsres;
2726
2727 TRACE("(%p)->(%p)\n", This, p);
2728
2729 if(!p)
2730 return E_INVALIDARG;
2731
2732 if(!This->nselem)
2733 {
2734 FIXME("NULL nselem\n");
2735 return E_NOTIMPL;
2736 }
2737
2738 nsres = nsIDOMHTMLElement_GetScrollLeft(This->nselem, p);
2739 assert(nsres == NS_OK);
2740
2741 TRACE("*p = %d\n", *p);
2742 return S_OK;
2743 }
2744
2745 static HRESULT WINAPI HTMLElement2_clearAttributes(IHTMLElement2 *iface)
2746 {
2747 HTMLElement *This = impl_from_IHTMLElement2(iface);
2748 FIXME("(%p)\n", This);
2749 return E_NOTIMPL;
2750 }
2751
2752 static HRESULT WINAPI HTMLElement2_mergeAttributes(IHTMLElement2 *iface, IHTMLElement *mergeThis)
2753 {
2754 HTMLElement *This = impl_from_IHTMLElement2(iface);
2755 FIXME("(%p)->(%p)\n", This, mergeThis);
2756 return E_NOTIMPL;
2757 }
2758
2759 static HRESULT WINAPI HTMLElement2_put_oncontextmenu(IHTMLElement2 *iface, VARIANT v)
2760 {
2761 HTMLElement *This = impl_from_IHTMLElement2(iface);
2762 FIXME("(%p)->()\n", This);
2763 return E_NOTIMPL;
2764 }
2765
2766 static HRESULT WINAPI HTMLElement2_get_oncontextmenu(IHTMLElement2 *iface, VARIANT *p)
2767 {
2768 HTMLElement *This = impl_from_IHTMLElement2(iface);
2769 FIXME("(%p)->(%p)\n", This, p);
2770 return E_NOTIMPL;
2771 }
2772
2773 static HRESULT WINAPI HTMLElement2_insertAdjacentElement(IHTMLElement2 *iface, BSTR where,
2774 IHTMLElement *insertedElement, IHTMLElement **inserted)
2775 {
2776 HTMLElement *This = impl_from_IHTMLElement2(iface);
2777 HTMLDOMNode *ret_node;
2778 HTMLElement *elem;
2779 HRESULT hres;
2780
2781 TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(where), insertedElement, inserted);
2782
2783 elem = unsafe_impl_from_IHTMLElement(insertedElement);
2784 if(!elem)
2785 return E_INVALIDARG;
2786
2787 hres = insert_adjacent_node(This, where, elem->node.nsnode, &ret_node);
2788 if(FAILED(hres))
2789 return hres;
2790
2791 hres = IHTMLDOMNode_QueryInterface(&ret_node->IHTMLDOMNode_iface, &IID_IHTMLElement, (void**)inserted);
2792 IHTMLDOMNode_Release(&ret_node->IHTMLDOMNode_iface);
2793 return hres;
2794 }
2795
2796 static HRESULT WINAPI HTMLElement2_applyElement(IHTMLElement2 *iface, IHTMLElement *apply,
2797 BSTR where, IHTMLElement **applied)
2798 {
2799 HTMLElement *This = impl_from_IHTMLElement2(iface);
2800 FIXME("(%p)->(%p %s %p)\n", This, apply, debugstr_w(where), applied);
2801 return E_NOTIMPL;
2802 }
2803
2804 static HRESULT WINAPI HTMLElement2_getAdjacentText(IHTMLElement2 *iface, BSTR where, BSTR *text)
2805 {
2806 HTMLElement *This = impl_from_IHTMLElement2(iface);
2807 FIXME("(%p)->(%s %p)\n", This, debugstr_w(where), text);
2808 return E_NOTIMPL;
2809 }
2810
2811 static HRESULT WINAPI HTMLElement2_replaceAdjacentText(IHTMLElement2 *iface, BSTR where,
2812 BSTR newText, BSTR *oldText)
2813 {
2814 HTMLElement *This = impl_from_IHTMLElement2(iface);
2815 FIXME("(%p)->(%s %s %p)\n", This, debugstr_w(where), debugstr_w(newText), oldText);
2816 return E_NOTIMPL;
2817 }
2818
2819 static HRESULT WINAPI HTMLElement2_get_canHandleChildren(IHTMLElement2 *iface, VARIANT_BOOL *p)
2820 {
2821 HTMLElement *This = impl_from_IHTMLElement2(iface);
2822 FIXME("(%p)->(%p)\n", This, p);
2823 return E_NOTIMPL;
2824 }
2825
2826 static HRESULT WINAPI HTMLElement2_addBehavior(IHTMLElement2 *iface, BSTR bstrUrl,
2827 VARIANT *pvarFactory, LONG *pCookie)
2828 {
2829 HTMLElement *This = impl_from_IHTMLElement2(iface);
2830 FIXME("(%p)->(%s %p %p)\n", This, debugstr_w(bstrUrl), pvarFactory, pCookie);
2831 return E_NOTIMPL;
2832 }
2833
2834 static HRESULT WINAPI HTMLElement2_removeBehavior(IHTMLElement2 *iface, LONG cookie,
2835 VARIANT_BOOL *pfResult)
2836 {
2837 HTMLElement *This = impl_from_IHTMLElement2(iface);
2838 FIXME("(%p)->(%d %p)\n", This, cookie, pfResult);
2839 return E_NOTIMPL;
2840 }
2841
2842 static HRESULT WINAPI HTMLElement2_get_runtimeStyle(IHTMLElement2 *iface, IHTMLStyle **p)
2843 {
2844 HTMLElement *This = impl_from_IHTMLElement2(iface);
2845
2846 FIXME("(%p)->(%p): hack\n", This, p);
2847
2848 /* We can't implement correct behavior on top of Gecko (although we could
2849 try a bit harder). Making runtimeStyle behave like regular style is
2850 enough for most use cases. */
2851 if(!This->runtime_style) {
2852 HRESULT hres;
2853
2854 hres = HTMLStyle_Create(This, &This->runtime_style);
2855 if(FAILED(hres))
2856 return hres;
2857 }
2858
2859 *p = &This->runtime_style->IHTMLStyle_iface;
2860 IHTMLStyle_AddRef(*p);
2861 return S_OK;
2862 }
2863
2864 static HRESULT WINAPI HTMLElement2_get_behaviorUrns(IHTMLElement2 *iface, IDispatch **p)
2865 {
2866 HTMLElement *This = impl_from_IHTMLElement2(iface);
2867 FIXME("(%p)->(%p)\n", This, p);
2868 return E_NOTIMPL;
2869 }
2870
2871 static HRESULT WINAPI HTMLElement2_put_tagUrn(IHTMLElement2 *iface, BSTR v)
2872 {
2873 HTMLElement *This = impl_from_IHTMLElement2(iface);
2874 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2875 return E_NOTIMPL;
2876 }
2877
2878 static HRESULT WINAPI HTMLElement2_get_tagUrn(IHTMLElement2 *iface, BSTR *p)
2879 {
2880 HTMLElement *This = impl_from_IHTMLElement2(iface);
2881 FIXME("(%p)->(%p)\n", This, p);
2882 return E_NOTIMPL;
2883 }
2884
2885 static HRESULT WINAPI HTMLElement2_put_onbeforeeditfocus(IHTMLElement2 *iface, VARIANT vv)
2886 {
2887 HTMLElement *This = impl_from_IHTMLElement2(iface);
2888 FIXME("(%p)->()\n", This);
2889 return E_NOTIMPL;
2890 }
2891
2892 static HRESULT WINAPI HTMLElement2_get_onbeforeeditfocus(IHTMLElement2 *iface, VARIANT *p)
2893 {
2894 HTMLElement *This = impl_from_IHTMLElement2(iface);
2895 FIXME("(%p)->(%p)\n", This, p);
2896 return E_NOTIMPL;
2897 }
2898
2899 static HRESULT WINAPI HTMLElement2_get_readyStateValue(IHTMLElement2 *iface, LONG *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_getElementsByTagName(IHTMLElement2 *iface, BSTR v,
2907 IHTMLElementCollection **pelColl)
2908 {
2909 HTMLElement *This = impl_from_IHTMLElement2(iface);
2910 nsIDOMHTMLCollection *nscol;
2911 nsAString tag_str;
2912 nsresult nsres;
2913
2914 TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pelColl);
2915
2916 nsAString_InitDepend(&tag_str, v);
2917 nsres = nsIDOMHTMLElement_GetElementsByTagName(This->nselem, &tag_str, &nscol);
2918 nsAString_Finish(&tag_str);
2919 if(NS_FAILED(nsres)) {
2920 ERR("GetElementByTagName failed: %08x\n", nsres);
2921 return E_FAIL;
2922 }
2923
2924 *pelColl = create_collection_from_htmlcol(This->node.doc, nscol);
2925 nsIDOMHTMLCollection_Release(nscol);
2926 return S_OK;
2927 }
2928
2929 static const IHTMLElement2Vtbl HTMLElement2Vtbl = {
2930 HTMLElement2_QueryInterface,
2931 HTMLElement2_AddRef,
2932 HTMLElement2_Release,
2933 HTMLElement2_GetTypeInfoCount,
2934 HTMLElement2_GetTypeInfo,
2935 HTMLElement2_GetIDsOfNames,
2936 HTMLElement2_Invoke,
2937 HTMLElement2_get_scopeName,
2938 HTMLElement2_setCapture,
2939 HTMLElement2_releaseCapture,
2940 HTMLElement2_put_onlosecapture,
2941 HTMLElement2_get_onlosecapture,
2942 HTMLElement2_componentFromPoint,
2943 HTMLElement2_doScroll,
2944 HTMLElement2_put_onscroll,
2945 HTMLElement2_get_onscroll,
2946 HTMLElement2_put_ondrag,
2947 HTMLElement2_get_ondrag,
2948 HTMLElement2_put_ondragend,
2949 HTMLElement2_get_ondragend,
2950 HTMLElement2_put_ondragenter,
2951 HTMLElement2_get_ondragenter,
2952 HTMLElement2_put_ondragover,
2953 HTMLElement2_get_ondragover,
2954 HTMLElement2_put_ondragleave,
2955 HTMLElement2_get_ondragleave,
2956 HTMLElement2_put_ondrop,
2957 HTMLElement2_get_ondrop,
2958 HTMLElement2_put_onbeforecut,
2959 HTMLElement2_get_onbeforecut,
2960 HTMLElement2_put_oncut,
2961 HTMLElement2_get_oncut,
2962 HTMLElement2_put_onbeforecopy,
2963 HTMLElement2_get_onbeforecopy,
2964 HTMLElement2_put_oncopy,
2965 HTMLElement2_get_oncopy,
2966 HTMLElement2_put_onbeforepaste,
2967 HTMLElement2_get_onbeforepaste,
2968 HTMLElement2_put_onpaste,
2969 HTMLElement2_get_onpaste,
2970 HTMLElement2_get_currentStyle,
2971 HTMLElement2_put_onpropertychange,
2972 HTMLElement2_get_onpropertychange,
2973 HTMLElement2_getClientRects,
2974 HTMLElement2_getBoundingClientRect,
2975 HTMLElement2_setExpression,
2976 HTMLElement2_getExpression,
2977 HTMLElement2_removeExpression,
2978 HTMLElement2_put_tabIndex,
2979 HTMLElement2_get_tabIndex,
2980 HTMLElement2_focus,
2981 HTMLElement2_put_accessKey,
2982 HTMLElement2_get_accessKey,
2983 HTMLElement2_put_onblur,
2984 HTMLElement2_get_onblur,
2985 HTMLElement2_put_onfocus,
2986 HTMLElement2_get_onfocus,
2987 HTMLElement2_put_onresize,
2988 HTMLElement2_get_onresize,
2989 HTMLElement2_blur,
2990 HTMLElement2_addFilter,
2991 HTMLElement2_removeFilter,
2992 HTMLElement2_get_clientHeight,
2993 HTMLElement2_get_clientWidth,
2994 HTMLElement2_get_clientTop,
2995 HTMLElement2_get_clientLeft,
2996 HTMLElement2_attachEvent,
2997 HTMLElement2_detachEvent,
2998 HTMLElement2_get_readyState,
2999 HTMLElement2_put_onreadystatechange,
3000 HTMLElement2_get_onreadystatechange,
3001 HTMLElement2_put_onrowsdelete,
3002 HTMLElement2_get_onrowsdelete,
3003 HTMLElement2_put_onrowsinserted,
3004 HTMLElement2_get_onrowsinserted,
3005 HTMLElement2_put_oncellchange,
3006 HTMLElement2_get_oncellchange,
3007 HTMLElement2_put_dir,
3008 HTMLElement2_get_dir,
3009 HTMLElement2_createControlRange,
3010 HTMLElement2_get_scrollHeight,
3011 HTMLElement2_get_scrollWidth,
3012 HTMLElement2_put_scrollTop,
3013 HTMLElement2_get_scrollTop,
3014 HTMLElement2_put_scrollLeft,
3015 HTMLElement2_get_scrollLeft,
3016 HTMLElement2_clearAttributes,
3017 HTMLElement2_mergeAttributes,
3018 HTMLElement2_put_oncontextmenu,
3019 HTMLElement2_get_oncontextmenu,
3020 HTMLElement2_insertAdjacentElement,
3021 HTMLElement2_applyElement,
3022 HTMLElement2_getAdjacentText,
3023 HTMLElement2_replaceAdjacentText,
3024 HTMLElement2_get_canHandleChildren,
3025 HTMLElement2_addBehavior,
3026 HTMLElement2_removeBehavior,
3027 HTMLElement2_get_runtimeStyle,
3028 HTMLElement2_get_behaviorUrns,
3029 HTMLElement2_put_tagUrn,
3030 HTMLElement2_get_tagUrn,
3031 HTMLElement2_put_onbeforeeditfocus,
3032 HTMLElement2_get_onbeforeeditfocus,
3033 HTMLElement2_get_readyStateValue,
3034 HTMLElement2_getElementsByTagName,
3035 };
3036
3037 static inline HTMLElement *impl_from_IHTMLElement3(IHTMLElement3 *iface)
3038 {
3039 return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement3_iface);
3040 }
3041
3042 static HRESULT WINAPI HTMLElement3_QueryInterface(IHTMLElement3 *iface,
3043 REFIID riid, void **ppv)
3044 {
3045 HTMLElement *This = impl_from_IHTMLElement3(iface);
3046 return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
3047 }
3048
3049 static ULONG WINAPI HTMLElement3_AddRef(IHTMLElement3 *iface)
3050 {
3051 HTMLElement *This = impl_from_IHTMLElement3(iface);
3052 return IHTMLElement_AddRef(&This->IHTMLElement_iface);
3053 }
3054
3055 static ULONG WINAPI HTMLElement3_Release(IHTMLElement3 *iface)
3056 {
3057 HTMLElement *This = impl_from_IHTMLElement3(iface);
3058 return IHTMLElement_Release(&This->IHTMLElement_iface);
3059 }
3060
3061 static HRESULT WINAPI HTMLElement3_GetTypeInfoCount(IHTMLElement3 *iface, UINT *pctinfo)
3062 {
3063 HTMLElement *This = impl_from_IHTMLElement3(iface);
3064 return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
3065 }
3066
3067 static HRESULT WINAPI HTMLElement3_GetTypeInfo(IHTMLElement3 *iface, UINT iTInfo,
3068 LCID lcid, ITypeInfo **ppTInfo)
3069 {
3070 HTMLElement *This = impl_from_IHTMLElement3(iface);
3071 return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
3072 }
3073
3074 static HRESULT WINAPI HTMLElement3_GetIDsOfNames(IHTMLElement3 *iface, REFIID riid,
3075 LPOLESTR *rgszNames, UINT cNames,
3076 LCID lcid, DISPID *rgDispId)
3077 {
3078 HTMLElement *This = impl_from_IHTMLElement3(iface);
3079 return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
3080 lcid, rgDispId);
3081 }
3082
3083 static HRESULT WINAPI HTMLElement3_Invoke(IHTMLElement3 *iface, DISPID dispIdMember,
3084 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
3085 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3086 {
3087 HTMLElement *This = impl_from_IHTMLElement3(iface);
3088 return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
3089 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3090 }
3091
3092 static HRESULT WINAPI HTMLElement3_mergeAttributes(IHTMLElement3 *iface, IHTMLElement *mergeThis, VARIANT *pvarFlags)
3093 {
3094 HTMLElement *This = impl_from_IHTMLElement3(iface);
3095 FIXME("(%p)->(%p %p)\n", This, mergeThis, pvarFlags);
3096 return E_NOTIMPL;
3097 }
3098
3099 static HRESULT WINAPI HTMLElement3_get_isMultiLine(IHTMLElement3 *iface, VARIANT_BOOL *p)
3100 {
3101 HTMLElement *This = impl_from_IHTMLElement3(iface);
3102 FIXME("(%p)->(%p)\n", This, p);
3103 return E_NOTIMPL;
3104 }
3105
3106 static HRESULT WINAPI HTMLElement3_get_canHaveHTML(IHTMLElement3 *iface, VARIANT_BOOL *p)
3107 {
3108 HTMLElement *This = impl_from_IHTMLElement3(iface);
3109 FIXME("(%p)->(%p)\n", This, p);
3110 return E_NOTIMPL;
3111 }
3112
3113 static HRESULT WINAPI HTMLElement3_put_onlayoutcomplete(IHTMLElement3 *iface, VARIANT v)
3114 {
3115 HTMLElement *This = impl_from_IHTMLElement3(iface);
3116 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3117 return E_NOTIMPL;
3118 }
3119
3120 static HRESULT WINAPI HTMLElement3_get_onlayoutcomplete(IHTMLElement3 *iface, VARIANT *p)
3121 {
3122 HTMLElement *This = impl_from_IHTMLElement3(iface);
3123 FIXME("(%p)->(%p)\n", This, p);
3124 return E_NOTIMPL;
3125 }
3126
3127 static HRESULT WINAPI HTMLElement3_put_onpage(IHTMLElement3 *iface, VARIANT v)
3128 {
3129 HTMLElement *This = impl_from_IHTMLElement3(iface);
3130 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3131 return E_NOTIMPL;
3132 }
3133
3134 static HRESULT WINAPI HTMLElement3_get_onpage(IHTMLElement3 *iface, VARIANT *p)
3135 {
3136 HTMLElement *This = impl_from_IHTMLElement3(iface);
3137 FIXME("(%p)->(%p)\n", This, p);
3138 return E_NOTIMPL;
3139 }
3140
3141 static HRESULT WINAPI HTMLElement3_put_inflateBlock(IHTMLElement3 *iface, VARIANT_BOOL v)
3142 {
3143 HTMLElement *This = impl_from_IHTMLElement3(iface);
3144 FIXME("(%p)->(%x)\n", This, v);
3145 return E_NOTIMPL;
3146 }
3147
3148 static HRESULT WINAPI HTMLElement3_get_inflateBlock(IHTMLElement3 *iface, VARIANT_BOOL *p)
3149 {
3150 HTMLElement *This = impl_from_IHTMLElement3(iface);
3151 FIXME("(%p)->(%p)\n", This, p);
3152 return E_NOTIMPL;
3153 }
3154
3155 static HRESULT WINAPI HTMLElement3_put_onbeforedeactivate(IHTMLElement3 *iface, VARIANT v)
3156 {
3157 HTMLElement *This = impl_from_IHTMLElement3(iface);
3158 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3159 return E_NOTIMPL;
3160 }
3161
3162 static HRESULT WINAPI HTMLElement3_get_onbeforedeactivate(IHTMLElement3 *iface, VARIANT *p)
3163 {
3164 HTMLElement *This = impl_from_IHTMLElement3(iface);
3165 FIXME("(%p)->(%p)\n", This, p);
3166 return E_NOTIMPL;
3167 }
3168
3169 static HRESULT WINAPI HTMLElement3_setActive(IHTMLElement3 *iface)
3170 {
3171 HTMLElement *This = impl_from_IHTMLElement3(iface);
3172 FIXME("(%p)\n", This);
3173 return E_NOTIMPL;
3174 }
3175
3176 static HRESULT WINAPI HTMLElement3_put_contentEditable(IHTMLElement3 *iface, BSTR v)
3177 {
3178 HTMLElement *This = impl_from_IHTMLElement3(iface);
3179 nsresult nsres;
3180 nsAString str;
3181
3182 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
3183
3184 nsAString_InitDepend(&str, v);
3185 nsres = nsIDOMHTMLElement_SetContentEditable(This->nselem, &str);
3186 nsAString_Finish(&str);
3187
3188 if (NS_FAILED(nsres)){
3189 ERR("SetContentEditable(%s) failed!\n", debugstr_w(v));
3190 return E_FAIL;
3191 }
3192
3193 return S_OK;
3194 }
3195
3196 static HRESULT WINAPI HTMLElement3_get_contentEditable(IHTMLElement3 *iface, BSTR *p)
3197 {
3198 HTMLElement *This = impl_from_IHTMLElement3(iface);
3199 nsresult nsres;
3200 nsAString str;
3201
3202 TRACE("(%p)->(%p)\n", This, p);
3203
3204 nsAString_Init(&str, NULL);
3205 nsres = nsIDOMHTMLElement_GetContentEditable(This->nselem, &str);
3206 return return_nsstr(nsres, &str, p);
3207 }
3208
3209 static HRESULT WINAPI HTMLElement3_get_isContentEditable(IHTMLElement3 *iface, VARIANT_BOOL *p)
3210 {
3211 HTMLElement *This = impl_from_IHTMLElement3(iface);
3212 FIXME("(%p)->(%p)\n", This, p);
3213 return E_NOTIMPL;
3214 }
3215
3216 static HRESULT WINAPI HTMLElement3_put_hideFocus(IHTMLElement3 *iface, VARIANT_BOOL v)
3217 {
3218 HTMLElement *This = impl_from_IHTMLElement3(iface);
3219 FIXME("(%p)->(%x)\n", This, v);
3220 return E_NOTIMPL;
3221 }
3222
3223 static HRESULT WINAPI HTMLElement3_get_hideFocus(IHTMLElement3 *iface, VARIANT_BOOL *p)
3224 {
3225 HTMLElement *This = impl_from_IHTMLElement3(iface);
3226 FIXME("(%p)->(%p)\n", This, p);
3227 return E_NOTIMPL;
3228 }
3229
3230 static const WCHAR disabledW[] = {'d','i','s','a','b','l','e','d',0};
3231
3232 static HRESULT WINAPI HTMLElement3_put_disabled(IHTMLElement3 *iface, VARIANT_BOOL v)
3233 {
3234 HTMLElement *This = impl_from_IHTMLElement3(iface);
3235 VARIANT *var;
3236 HRESULT hres;
3237
3238 TRACE("(%p)->(%x)\n", This, v);
3239
3240 if(This->node.vtbl->put_disabled)
3241 return This->node.vtbl->put_disabled(&This->node, v);
3242
3243 hres = dispex_get_dprop_ref(&This->node.dispex, disabledW, TRUE, &var);
3244 if(FAILED(hres))
3245 return hres;
3246
3247 VariantClear(var);
3248 V_VT(var) = VT_BOOL;
3249 V_BOOL(var) = v;
3250 return S_OK;
3251 }
3252
3253 static HRESULT WINAPI HTMLElement3_get_disabled(IHTMLElement3 *iface, VARIANT_BOOL *p)
3254 {
3255 HTMLElement *This = impl_from_IHTMLElement3(iface);
3256 VARIANT *var;
3257 HRESULT hres;
3258
3259 TRACE("(%p)->(%p)\n", This, p);
3260
3261 if(This->node.vtbl->get_disabled)
3262 return This->node.vtbl->get_disabled(&This->node, p);
3263
3264 hres = dispex_get_dprop_ref(&This->node.dispex, disabledW, FALSE, &var);
3265 if(hres == DISP_E_UNKNOWNNAME) {
3266 *p = VARIANT_FALSE;
3267 return S_OK;
3268 }
3269 if(FAILED(hres))
3270 return hres;
3271
3272 if(V_VT(var) != VT_BOOL) {
3273 FIXME("value is %s\n", debugstr_variant(var));
3274 return E_NOTIMPL;
3275 }
3276
3277 *p = V_BOOL(var);
3278 return S_OK;
3279 }
3280
3281 static HRESULT WINAPI HTMLElement3_get_isDisabled(IHTMLElement3 *iface, VARIANT_BOOL *p)
3282 {
3283 HTMLElement *This = impl_from_IHTMLElement3(iface);
3284 FIXME("(%p)->(%p)\n", This, p);
3285 return E_NOTIMPL;
3286 }
3287
3288 static HRESULT WINAPI HTMLElement3_put_onmove(IHTMLElement3 *iface, VARIANT v)
3289 {
3290 HTMLElement *This = impl_from_IHTMLElement3(iface);
3291 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3292 return E_NOTIMPL;
3293 }
3294
3295 static HRESULT WINAPI HTMLElement3_get_onmove(IHTMLElement3 *iface, VARIANT *p)
3296 {
3297 HTMLElement *This = impl_from_IHTMLElement3(iface);
3298 FIXME("(%p)->(%p)\n", This, p);
3299 return E_NOTIMPL;
3300 }
3301
3302 static HRESULT WINAPI HTMLElement3_put_oncontrolselect(IHTMLElement3 *iface, VARIANT v)
3303 {
3304 HTMLElement *This = impl_from_IHTMLElement3(iface);
3305 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3306 return E_NOTIMPL;
3307 }
3308
3309 static HRESULT WINAPI HTMLElement3_get_oncontrolselect(IHTMLElement3 *iface, VARIANT *p)
3310 {
3311 HTMLElement *This = impl_from_IHTMLElement3(iface);
3312 FIXME("(%p)->(%p)\n", This, p);
3313 return E_NOTIMPL;
3314 }
3315
3316 static HRESULT WINAPI HTMLElement3_fireEvent(IHTMLElement3 *iface, BSTR bstrEventName,
3317 VARIANT *pvarEventObject, VARIANT_BOOL *pfCancelled)
3318 {
3319 HTMLElement *This = impl_from_IHTMLElement3(iface);
3320
3321 TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(bstrEventName), debugstr_variant(pvarEventObject),
3322 pfCancelled);
3323
3324 return dispatch_event(&This->node, bstrEventName, pvarEventObject, pfCancelled);
3325 }
3326
3327 static HRESULT WINAPI HTMLElement3_put_onresizestart(IHTMLElement3 *iface, VARIANT v)
3328 {
3329 HTMLElement *This = impl_from_IHTMLElement3(iface);
3330 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3331 return E_NOTIMPL;
3332 }
3333
3334 static HRESULT WINAPI HTMLElement3_get_onresizestart(IHTMLElement3 *iface, VARIANT *p)
3335 {
3336 HTMLElement *This = impl_from_IHTMLElement3(iface);
3337 FIXME("(%p)->(%p)\n", This, p);
3338 return E_NOTIMPL;
3339 }
3340
3341 static HRESULT WINAPI HTMLElement3_put_onresizeend(IHTMLElement3 *iface, VARIANT v)
3342 {
3343 HTMLElement *This = impl_from_IHTMLElement3(iface);
3344 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3345 return E_NOTIMPL;
3346 }
3347
3348 static HRESULT WINAPI HTMLElement3_get_onresizeend(IHTMLElement3 *iface, VARIANT *p)
3349 {
3350 HTMLElement *This = impl_from_IHTMLElement3(iface);
3351 FIXME("(%p)->(%p)\n", This, p);
3352 return E_NOTIMPL;
3353 }
3354
3355 static HRESULT WINAPI HTMLElement3_put_onmovestart(IHTMLElement3 *iface, VARIANT v)
3356 {
3357 HTMLElement *This = impl_from_IHTMLElement3(iface);
3358 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3359 return E_NOTIMPL;
3360 }
3361
3362 static HRESULT WINAPI HTMLElement3_get_onmovestart(IHTMLElement3 *iface, VARIANT *p)
3363 {
3364 HTMLElement *This = impl_from_IHTMLElement3(iface);
3365 FIXME("(%p)->(%p)\n", This, p);
3366 return E_NOTIMPL;
3367 }
3368
3369 static HRESULT WINAPI HTMLElement3_put_onmoveend(IHTMLElement3 *iface, VARIANT v)
3370 {
3371 HTMLElement *This = impl_from_IHTMLElement3(iface);
3372 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3373 return E_NOTIMPL;
3374 }
3375
3376 static HRESULT WINAPI HTMLElement3_get_onmoveend(IHTMLElement3 *iface, VARIANT *p)
3377 {
3378 HTMLElement *This = impl_from_IHTMLElement3(iface);
3379 FIXME("(%p)->(%p)\n", This, p);
3380 return E_NOTIMPL;
3381 }
3382
3383 static HRESULT WINAPI HTMLElement3_put_onmousecenter(IHTMLElement3 *iface, VARIANT v)
3384 {
3385 HTMLElement *This = impl_from_IHTMLElement3(iface);
3386 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3387 return E_NOTIMPL;
3388 }
3389
3390 static HRESULT WINAPI HTMLElement3_get_onmousecenter(IHTMLElement3 *iface, VARIANT *p)
3391 {
3392 HTMLElement *This = impl_from_IHTMLElement3(iface);
3393 FIXME("(%p)->(%p)\n", This, p);
3394 return E_NOTIMPL;
3395 }
3396
3397 static HRESULT WINAPI HTMLElement3_put_onmouseleave(IHTMLElement3 *iface, VARIANT v)
3398 {
3399 HTMLElement *This = impl_from_IHTMLElement3(iface);
3400 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3401 return E_NOTIMPL;
3402 }
3403
3404 static HRESULT WINAPI HTMLElement3_get_onmouseleave(IHTMLElement3 *iface, VARIANT *p)
3405 {
3406 HTMLElement *This = impl_from_IHTMLElement3(iface);
3407 FIXME("(%p)->(%p)\n", This, p);
3408 return E_NOTIMPL;
3409 }
3410
3411 static HRESULT WINAPI HTMLElement3_put_onactivate(IHTMLElement3 *iface, VARIANT v)
3412 {
3413 HTMLElement *This = impl_from_IHTMLElement3(iface);
3414 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3415 return E_NOTIMPL;
3416 }
3417
3418 static HRESULT WINAPI HTMLElement3_get_onactivate(IHTMLElement3 *iface, VARIANT *p)
3419 {
3420 HTMLElement *This = impl_from_IHTMLElement3(iface);
3421 FIXME("(%p)->(%p)\n", This, p);
3422 return E_NOTIMPL;
3423 }
3424
3425 static HRESULT WINAPI HTMLElement3_put_ondeactivate(IHTMLElement3 *iface, VARIANT v)
3426 {
3427 HTMLElement *This = impl_from_IHTMLElement3(iface);
3428 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3429 return E_NOTIMPL;
3430 }
3431
3432 static HRESULT WINAPI HTMLElement3_get_ondeactivate(IHTMLElement3 *iface, VARIANT *p)
3433 {
3434 HTMLElement *This = impl_from_IHTMLElement3(iface);
3435 FIXME("(%p)->(%p)\n", This, p);
3436 return E_NOTIMPL;
3437 }
3438
3439 static HRESULT WINAPI HTMLElement3_dragDrop(IHTMLElement3 *iface, VARIANT_BOOL *pfRet)
3440 {
3441 HTMLElement *This = impl_from_IHTMLElement3(iface);
3442 FIXME("(%p)->(%p)\n", This, pfRet);
3443 return E_NOTIMPL;
3444 }
3445
3446 static HRESULT WINAPI HTMLElement3_get_glyphMode(IHTMLElement3 *iface, LONG *p)
3447 {
3448 HTMLElement *This = impl_from_IHTMLElement3(iface);
3449 FIXME("(%p)->(%p)\n", This, p);
3450 return E_NOTIMPL;
3451 }
3452
3453 static const IHTMLElement3Vtbl HTMLElement3Vtbl = {
3454 HTMLElement3_QueryInterface,
3455 HTMLElement3_AddRef,
3456 HTMLElement3_Release,
3457 HTMLElement3_GetTypeInfoCount,
3458 HTMLElement3_GetTypeInfo,
3459 HTMLElement3_GetIDsOfNames,
3460 HTMLElement3_Invoke,
3461 HTMLElement3_mergeAttributes,
3462 HTMLElement3_get_isMultiLine,
3463 HTMLElement3_get_canHaveHTML,
3464 HTMLElement3_put_onlayoutcomplete,
3465 HTMLElement3_get_onlayoutcomplete,
3466 HTMLElement3_put_onpage,
3467 HTMLElement3_get_onpage,
3468 HTMLElement3_put_inflateBlock,
3469 HTMLElement3_get_inflateBlock,
3470 HTMLElement3_put_onbeforedeactivate,
3471 HTMLElement3_get_onbeforedeactivate,
3472 HTMLElement3_setActive,
3473 HTMLElement3_put_contentEditable,
3474 HTMLElement3_get_contentEditable,
3475 HTMLElement3_get_isContentEditable,
3476 HTMLElement3_put_hideFocus,
3477 HTMLElement3_get_hideFocus,
3478 HTMLElement3_put_disabled,
3479 HTMLElement3_get_disabled,
3480 HTMLElement3_get_isDisabled,
3481 HTMLElement3_put_onmove,
3482 HTMLElement3_get_onmove,
3483 HTMLElement3_put_oncontrolselect,
3484 HTMLElement3_get_oncontrolselect,
3485 HTMLElement3_fireEvent,
3486 HTMLElement3_put_onresizestart,
3487 HTMLElement3_get_onresizestart,
3488 HTMLElement3_put_onresizeend,
3489 HTMLElement3_get_onresizeend,
3490 HTMLElement3_put_onmovestart,
3491 HTMLElement3_get_onmovestart,
3492 HTMLElement3_put_onmoveend,
3493 HTMLElement3_get_onmoveend,
3494 HTMLElement3_put_onmousecenter,
3495 HTMLElement3_get_onmousecenter,
3496 HTMLElement3_put_onmouseleave,
3497 HTMLElement3_get_onmouseleave,
3498 HTMLElement3_put_onactivate,
3499 HTMLElement3_get_onactivate,
3500 HTMLElement3_put_ondeactivate,
3501 HTMLElement3_get_ondeactivate,
3502 HTMLElement3_dragDrop,
3503 HTMLElement3_get_glyphMode
3504 };
3505
3506 static inline HTMLElement *impl_from_IHTMLElement4(IHTMLElement4 *iface)
3507 {
3508 return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement4_iface);
3509 }
3510
3511 static HRESULT WINAPI HTMLElement4_QueryInterface(IHTMLElement4 *iface,
3512 REFIID riid, void **ppv)
3513 {
3514 HTMLElement *This = impl_from_IHTMLElement4(iface);
3515 return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
3516 }
3517
3518 static ULONG WINAPI HTMLElement4_AddRef(IHTMLElement4 *iface)
3519 {
3520 HTMLElement *This = impl_from_IHTMLElement4(iface);
3521 return IHTMLElement_AddRef(&This->IHTMLElement_iface);
3522 }
3523
3524 static ULONG WINAPI HTMLElement4_Release(IHTMLElement4 *iface)
3525 {
3526 HTMLElement *This = impl_from_IHTMLElement4(iface);
3527 return IHTMLElement_Release(&This->IHTMLElement_iface);
3528 }
3529
3530 static HRESULT WINAPI HTMLElement4_GetTypeInfoCount(IHTMLElement4 *iface, UINT *pctinfo)
3531 {
3532 HTMLElement *This = impl_from_IHTMLElement4(iface);
3533 return IDispatchEx_GetTypeInfoCount(&This->node.dispex.IDispatchEx_iface, pctinfo);
3534 }
3535
3536 static HRESULT WINAPI HTMLElement4_GetTypeInfo(IHTMLElement4 *iface, UINT iTInfo,
3537 LCID lcid, ITypeInfo **ppTInfo)
3538 {
3539 HTMLElement *This = impl_from_IHTMLElement4(iface);
3540 return IDispatchEx_GetTypeInfo(&This->node.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
3541 }
3542
3543 static HRESULT WINAPI HTMLElement4_GetIDsOfNames(IHTMLElement4 *iface, REFIID riid,
3544 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
3545 {
3546 HTMLElement *This = impl_from_IHTMLElement4(iface);
3547 return IDispatchEx_GetIDsOfNames(&This->node.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
3548 lcid, rgDispId);
3549 }
3550
3551 static HRESULT WINAPI HTMLElement4_Invoke(IHTMLElement4 *iface, DISPID dispIdMember, REFIID riid,
3552 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3553 {
3554 HTMLElement *This = impl_from_IHTMLElement4(iface);
3555 return IDispatchEx_Invoke(&This->node.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
3556 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3557 }
3558
3559 static HRESULT WINAPI HTMLElement4_put_onmousewheel(IHTMLElement4 *iface, VARIANT v)
3560 {
3561 HTMLElement *This = impl_from_IHTMLElement4(iface);
3562
3563 FIXME("(%p)->(%s) semi-stub\n", This, debugstr_variant(&v));
3564
3565 return set_node_event(&This->node, EVENTID_MOUSEWHEEL, &v);
3566 }
3567
3568 static HRESULT WINAPI HTMLElement4_get_onmousewheel(IHTMLElement4 *iface, VARIANT *p)
3569 {
3570 HTMLElement *This = impl_from_IHTMLElement4(iface);
3571
3572 TRACE("(%p)->(%p)\n", This, p);
3573
3574 return get_node_event(&This->node, EVENTID_MOUSEWHEEL, p);
3575 }
3576
3577 static HRESULT WINAPI HTMLElement4_normalize(IHTMLElement4 *iface)
3578 {
3579 HTMLElement *This = impl_from_IHTMLElement4(iface);
3580 FIXME("(%p)\n", This);
3581 return E_NOTIMPL;
3582 }
3583
3584 static HRESULT WINAPI HTMLElement4_getAttributeNode(IHTMLElement4 *iface, BSTR bstrname, IHTMLDOMAttribute **ppAttribute)
3585 {
3586 HTMLElement *This = impl_from_IHTMLElement4(iface);
3587 HTMLAttributeCollection *attrs;
3588 HRESULT hres;
3589
3590 TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrname), ppAttribute);
3591
3592 hres = HTMLElement_get_attr_col(&This->node, &attrs);
3593 if(FAILED(hres))
3594 return hres;
3595
3596 hres = IHTMLAttributeCollection2_getNamedItem(&attrs->IHTMLAttributeCollection2_iface, bstrname, ppAttribute);
3597 IHTMLAttributeCollection_Release(&attrs->IHTMLAttributeCollection_iface);
3598 return hres;
3599 }
3600
3601 static HRESULT WINAPI HTMLElement4_setAttributeNode(IHTMLElement4 *iface, IHTMLDOMAttribute *pattr,
3602 IHTMLDOMAttribute **ppretAttribute)
3603 {
3604 HTMLElement *This = impl_from_IHTMLElement4(iface);
3605 FIXME("(%p)->(%p %p)\n", This, pattr, ppretAttribute);
3606 return E_NOTIMPL;
3607 }
3608
3609 static HRESULT WINAPI HTMLElement4_removeAttributeNode(IHTMLElement4 *iface, IHTMLDOMAttribute *pattr,
3610 IHTMLDOMAttribute **ppretAttribute)
3611 {
3612 HTMLElement *This = impl_from_IHTMLElement4(iface);
3613 FIXME("(%p)->(%p %p)\n", This, pattr, ppretAttribute);
3614 return E_NOTIMPL;
3615 }
3616
3617 static HRESULT WINAPI HTMLElement4_put_onbeforeactivate(IHTMLElement4 *iface, VARIANT v)
3618 {
3619 HTMLElement *This = impl_from_IHTMLElement4(iface);
3620 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3621 return E_NOTIMPL;
3622 }
3623
3624 static HRESULT WINAPI HTMLElement4_get_onbeforeactivate(IHTMLElement4 *iface, VARIANT *p)
3625 {
3626 HTMLElement *This = impl_from_IHTMLElement4(iface);
3627 FIXME("(%p)->(%p)\n", This, p);
3628 return E_NOTIMPL;
3629 }
3630
3631 static HRESULT WINAPI HTMLElement4_put_onfocusin(IHTMLElement4 *iface, VARIANT v)
3632 {
3633 HTMLElement *This = impl_from_IHTMLElement4(iface);
3634 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3635 return E_NOTIMPL;
3636 }
3637
3638 static HRESULT WINAPI HTMLElement4_get_onfocusin(IHTMLElement4 *iface, VARIANT *p)
3639 {
3640 HTMLElement *This = impl_from_IHTMLElement4(iface);
3641 FIXME("(%p)->(%p)\n", This, p);
3642 return E_NOTIMPL;
3643 }
3644
3645 static HRESULT WINAPI HTMLElement4_put_onfocusout(IHTMLElement4 *iface, VARIANT v)
3646 {
3647 HTMLElement *This = impl_from_IHTMLElement4(iface);
3648 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3649 return E_NOTIMPL;
3650 }
3651
3652 static HRESULT WINAPI HTMLElement4_get_onfocusout(IHTMLElement4 *iface, VARIANT *p)
3653 {
3654 HTMLElement *This = impl_from_IHTMLElement4(iface);
3655 FIXME("(%p)->(%p)\n", This, p);
3656 return E_NOTIMPL;
3657 }
3658
3659 static const IHTMLElement4Vtbl HTMLElement4Vtbl = {
3660 HTMLElement4_QueryInterface,
3661 HTMLElement4_AddRef,
3662 HTMLElement4_Release,
3663 HTMLElement4_GetTypeInfoCount,
3664 HTMLElement4_GetTypeInfo,
3665 HTMLElement4_GetIDsOfNames,
3666 HTMLElement4_Invoke,
3667 HTMLElement4_put_onmousewheel,
3668 HTMLElement4_get_onmousewheel,
3669 HTMLElement4_normalize,
3670 HTMLElement4_getAttributeNode,
3671 HTMLElement4_setAttributeNode,
3672 HTMLElement4_removeAttributeNode,
3673 HTMLElement4_put_onbeforeactivate,
3674 HTMLElement4_get_onbeforeactivate,
3675 HTMLElement4_put_onfocusin,
3676 HTMLElement4_get_onfocusin,
3677 HTMLElement4_put_onfocusout,
3678 HTMLElement4_get_onfocusout
3679 };
3680
3681 static inline HTMLElement *impl_from_HTMLDOMNode(HTMLDOMNode *iface)
3682 {
3683 return CONTAINING_RECORD(iface, HTMLElement, node);
3684 }
3685
3686 HRESULT HTMLElement_QI(HTMLDOMNode *iface, REFIID riid, void **ppv)
3687 {
3688 HTMLElement *This = impl_from_HTMLDOMNode(iface);
3689
3690 if(IsEqualGUID(&IID_IUnknown, riid)) {
3691 *ppv = &This->IHTMLElement_iface;
3692 }else if(IsEqualGUID(&IID_IDispatch, riid)) {
3693 *ppv = &This->IHTMLElement_iface;
3694 }else if(IsEqualGUID(&IID_IHTMLElement, riid)) {
3695 *ppv = &This->IHTMLElement_iface;
3696 }else if(IsEqualGUID(&IID_IHTMLElement2, riid)) {
3697 *ppv = &This->IHTMLElement2_iface;
3698 }else if(IsEqualGUID(&IID_IHTMLElement3, riid)) {
3699 *ppv = &This->IHTMLElement3_iface;
3700 }else if(IsEqualGUID(&IID_IHTMLElement4, riid)) {
3701 *ppv = &This->IHTMLElement4_iface;
3702 }else if(IsEqualGUID(&IID_IConnectionPointContainer, riid)) {
3703 *ppv = &This->cp_container.IConnectionPointContainer_iface;
3704 }else {
3705 return HTMLDOMNode_QI(&This->node, riid, ppv);
3706 }
3707
3708 IUnknown_AddRef((IUnknown*)*ppv);
3709 return S_OK;
3710 }
3711
3712 void HTMLElement_destructor(HTMLDOMNode *iface)
3713 {
3714 HTMLElement *This = impl_from_HTMLDOMNode(iface);
3715
3716 ConnectionPointContainer_Destroy(&This->cp_container);
3717
3718 if(This->style) {
3719 This->style->elem = NULL;
3720 IHTMLStyle_Release(&This->style->IHTMLStyle_iface);
3721 }
3722 if(This->runtime_style) {
3723 This->runtime_style->elem = NULL;
3724 IHTMLStyle_Release(&This->runtime_style->IHTMLStyle_iface);
3725 }
3726 if(This->attrs) {
3727 HTMLDOMAttribute *attr;
3728
3729 LIST_FOR_EACH_ENTRY(attr, &This->attrs->attrs, HTMLDOMAttribute, entry)
3730 attr->elem = NULL;
3731
3732 This->attrs->elem = NULL;
3733 IHTMLAttributeCollection_Release(&This->attrs->IHTMLAttributeCollection_iface);
3734 }
3735
3736 heap_free(This->filter);
3737
3738 HTMLDOMNode_destructor(&This->node);
3739 }
3740
3741 HRESULT HTMLElement_clone(HTMLDOMNode *iface, nsIDOMNode *nsnode, HTMLDOMNode **ret)
3742 {
3743 HTMLElement *This = impl_from_HTMLDOMNode(iface);
3744 HTMLElement *new_elem;
3745 HRESULT hres;
3746
3747 hres = HTMLElement_Create(This->node.doc, nsnode, FALSE, &new_elem);
3748 if(FAILED(hres))
3749 return hres;
3750
3751 if(This->filter) {
3752 new_elem->filter = heap_strdupW(This->filter);
3753 if(!new_elem->filter) {
3754 IHTMLElement_Release(&This->IHTMLElement_iface);
3755 return E_OUTOFMEMORY;
3756 }
3757 }
3758
3759 *ret = &new_elem->node;
3760 return S_OK;
3761 }
3762
3763 HRESULT HTMLElement_handle_event(HTMLDOMNode *iface, DWORD eid, nsIDOMEvent *event, BOOL *prevent_default)
3764 {
3765 HTMLElement *This = impl_from_HTMLDOMNode(iface);
3766
3767 switch(eid) {
3768 case EVENTID_KEYDOWN: {
3769 nsIDOMKeyEvent *key_event;
3770 nsresult nsres;
3771
3772 nsres = nsIDOMEvent_QueryInterface(event, &IID_nsIDOMKeyEvent, (void**)&key_event);
3773 if(NS_SUCCEEDED(nsres)) {
3774 UINT32 code = 0;
3775
3776 nsIDOMKeyEvent_GetKeyCode(key_event, &code);
3777
3778 switch(code) {
3779 case VK_F1: /* DOM_VK_F1 */
3780 TRACE("F1 pressed\n");
3781 fire_event(This->node.doc, EVENTID_HELP, TRUE, This->node.nsnode, NULL, NULL);
3782 *prevent_default = TRUE;
3783 }
3784
3785 nsIDOMKeyEvent_Release(key_event);
3786 }
3787 }
3788 }
3789
3790 return S_OK;
3791 }
3792
3793 cp_static_data_t HTMLElementEvents2_data = { HTMLElementEvents2_tid, NULL /* FIXME */, TRUE };
3794
3795 const cpc_entry_t HTMLElement_cpc[] = {
3796 HTMLELEMENT_CPC,
3797 {NULL}
3798 };
3799
3800 static const NodeImplVtbl HTMLElementImplVtbl = {
3801 HTMLElement_QI,
3802 HTMLElement_destructor,
3803 HTMLElement_cpc,
3804 HTMLElement_clone,
3805 HTMLElement_handle_event,
3806 HTMLElement_get_attr_col
3807 };
3808
3809 static inline HTMLElement *impl_from_DispatchEx(DispatchEx *iface)
3810 {
3811 return CONTAINING_RECORD(iface, HTMLElement, node.dispex);
3812 }
3813
3814 static HRESULT HTMLElement_get_dispid(DispatchEx *dispex, BSTR name,
3815 DWORD grfdex, DISPID *pid)
3816 {
3817 HTMLElement *This = impl_from_DispatchEx(dispex);
3818
3819 if(This->node.vtbl->get_dispid)
3820 return This->node.vtbl->get_dispid(&This->node, name, grfdex, pid);
3821
3822 return DISP_E_UNKNOWNNAME;
3823 }
3824
3825 static HRESULT HTMLElement_invoke(DispatchEx *dispex, DISPID id, LCID lcid,
3826 WORD flags, DISPPARAMS *params, VARIANT *res, EXCEPINFO *ei,
3827 IServiceProvider *caller)
3828 {
3829 HTMLElement *This = impl_from_DispatchEx(dispex);
3830
3831 if(This->node.vtbl->invoke)
3832 return This->node.vtbl->invoke(&This->node, id, lcid, flags,
3833 params, res, ei, caller);
3834
3835 ERR("(%p): element has no invoke method\n", This);
3836 return E_NOTIMPL;
3837 }
3838
3839 static HRESULT HTMLElement_populate_props(DispatchEx *dispex)
3840 {
3841 HTMLElement *This = impl_from_DispatchEx(dispex);
3842 nsIDOMMozNamedAttrMap *attrs;
3843 nsIDOMAttr *attr;
3844 nsAString nsstr;
3845 const PRUnichar *str;
3846 BSTR name;
3847 VARIANT value;
3848 unsigned i;
3849 UINT32 len;
3850 DISPID id;
3851 nsresult nsres;
3852 HRESULT hres;
3853
3854 if(!This->nselem)
3855 return S_FALSE;
3856
3857 nsres = nsIDOMHTMLElement_GetAttributes(This->nselem, &attrs);
3858 if(NS_FAILED(nsres))
3859 return E_FAIL;
3860
3861 nsres = nsIDOMMozNamedAttrMap_GetLength(attrs, &len);
3862 if(NS_FAILED(nsres)) {
3863 nsIDOMMozNamedAttrMap_Release(attrs);
3864 return E_FAIL;
3865 }
3866
3867 nsAString_Init(&nsstr, NULL);
3868 for(i=0; i<len; i++) {
3869 nsres = nsIDOMMozNamedAttrMap_Item(attrs, i, &attr);
3870 if(NS_FAILED(nsres))
3871 continue;
3872
3873 nsres = nsIDOMAttr_GetNodeName(attr, &nsstr);
3874 if(NS_FAILED(nsres)) {
3875 nsIDOMAttr_Release(attr);
3876 continue;
3877 }
3878
3879 nsAString_GetData(&nsstr, &str);
3880 name = SysAllocString(str);
3881 if(!name) {
3882 nsIDOMAttr_Release(attr);
3883 continue;
3884 }
3885
3886 hres = IDispatchEx_GetDispID(&dispex->IDispatchEx_iface, name, fdexNameCaseInsensitive, &id);
3887 if(hres != DISP_E_UNKNOWNNAME) {
3888 nsIDOMAttr_Release(attr);
3889 SysFreeString(name);
3890 continue;
3891 }
3892
3893 nsres = nsIDOMAttr_GetNodeValue(attr, &nsstr);
3894 nsIDOMAttr_Release(attr);
3895 if(NS_FAILED(nsres)) {
3896 SysFreeString(name);
3897 continue;
3898 }
3899
3900 nsAString_GetData(&nsstr, &str);
3901 V_VT(&value) = VT_BSTR;
3902 if(*str) {
3903 V_BSTR(&value) = SysAllocString(str);
3904 if(!V_BSTR(&value)) {
3905 SysFreeString(name);
3906 continue;
3907 }
3908 } else
3909 V_BSTR(&value) = NULL;
3910
3911 IHTMLElement_setAttribute(&This->IHTMLElement_iface, name, value, 0);
3912 SysFreeString(name);
3913 VariantClear(&value);
3914 }
3915 nsAString_Finish(&nsstr);
3916
3917 nsIDOMMozNamedAttrMap_Release(attrs);
3918 return S_OK;
3919 }
3920
3921 static const tid_t HTMLElement_iface_tids[] = {
3922 HTMLELEMENT_TIDS,
3923 0
3924 };
3925
3926 static dispex_static_data_vtbl_t HTMLElement_dispex_vtbl = {
3927 NULL,
3928 HTMLElement_get_dispid,
3929 HTMLElement_invoke,
3930 HTMLElement_populate_props
3931 };
3932
3933 static dispex_static_data_t HTMLElement_dispex = {
3934 &HTMLElement_dispex_vtbl,
3935 DispHTMLUnknownElement_tid,
3936 NULL,
3937 HTMLElement_iface_tids
3938 };
3939
3940 void HTMLElement_Init(HTMLElement *This, HTMLDocumentNode *doc, nsIDOMHTMLElement *nselem, dispex_static_data_t *dispex_data)
3941 {
3942 This->IHTMLElement_iface.lpVtbl = &HTMLElementVtbl;
3943 This->IHTMLElement2_iface.lpVtbl = &HTMLElement2Vtbl;
3944 This->IHTMLElement3_iface.lpVtbl = &HTMLElement3Vtbl;
3945 This->IHTMLElement4_iface.lpVtbl = &HTMLElement4Vtbl;
3946
3947 if(dispex_data && !dispex_data->vtbl)
3948 dispex_data->vtbl = &HTMLElement_dispex_vtbl;
3949 init_dispex(&This->node.dispex, (IUnknown*)&This->IHTMLElement_iface,
3950 dispex_data ? dispex_data : &HTMLElement_dispex);
3951
3952 if(nselem) {
3953 HTMLDOMNode_Init(doc, &This->node, (nsIDOMNode*)nselem);
3954
3955 /* No AddRef, share reference with HTMLDOMNode */
3956 assert((nsIDOMNode*)nselem == This->node.nsnode);
3957 This->nselem = nselem;
3958 }
3959
3960 This->node.cp_container = &This->cp_container;
3961 ConnectionPointContainer_Init(&This->cp_container, (IUnknown*)&This->IHTMLElement_iface, This->node.vtbl->cpc_entries);
3962 }
3963
3964 HRESULT HTMLElement_Create(HTMLDocumentNode *doc, nsIDOMNode *nsnode, BOOL use_generic, HTMLElement **ret)
3965 {
3966 nsIDOMHTMLElement *nselem;
3967 nsAString class_name_str;
3968 const PRUnichar *class_name;
3969 const tag_desc_t *tag;
3970 HTMLElement *elem;
3971 nsresult nsres;
3972 HRESULT hres;
3973
3974 nsres = nsIDOMNode_QueryInterface(nsnode, &IID_nsIDOMHTMLElement, (void**)&nselem);
3975 if(NS_FAILED(nsres))
3976 return E_FAIL;
3977
3978 nsAString_Init(&class_name_str, NULL);
3979 nsIDOMHTMLElement_GetTagName(nselem, &class_name_str);
3980
3981 nsAString_GetData(&class_name_str, &class_name);
3982
3983 tag = get_tag_desc(class_name);
3984 if(tag) {
3985 hres = tag->constructor(doc, nselem, &elem);
3986 }else if(use_generic) {
3987 hres = HTMLGenericElement_Create(doc, nselem, &elem);
3988 }else {
3989 elem = heap_alloc_zero(sizeof(HTMLElement));
3990 if(elem) {
3991 elem->node.vtbl = &HTMLElementImplVtbl;
3992 HTMLElement_Init(elem, doc, nselem, &HTMLElement_dispex);
3993 hres = S_OK;
3994 }else {
3995 hres = E_OUTOFMEMORY;
3996 }
3997 }
3998
3999 TRACE("%s ret %p\n", debugstr_w(class_name), elem);
4000
4001 nsIDOMHTMLElement_Release(nselem);
4002 nsAString_Finish(&class_name_str);
4003 if(FAILED(hres))
4004 return hres;
4005
4006 *ret = elem;
4007 return S_OK;
4008 }
4009
4010 HRESULT get_elem(HTMLDocumentNode *doc, nsIDOMElement *nselem, HTMLElement **ret)
4011 {
4012 HTMLDOMNode *node;
4013 HRESULT hres;
4014
4015 hres = get_node(doc, (nsIDOMNode*)nselem, TRUE, &node);
4016 if(FAILED(hres))
4017 return hres;
4018
4019 *ret = impl_from_HTMLDOMNode(node);
4020 return S_OK;
4021 }
4022
4023 /* interface IHTMLFiltersCollection */
4024 static HRESULT WINAPI HTMLFiltersCollection_QueryInterface(IHTMLFiltersCollection *iface, REFIID riid, void **ppv)
4025 {
4026 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
4027
4028 TRACE("%p %s %p\n", This, debugstr_mshtml_guid(riid), ppv );
4029
4030 if(IsEqualGUID(&IID_IUnknown, riid)) {
4031 *ppv = &This->IHTMLFiltersCollection_iface;
4032 }else if(IsEqualGUID(&IID_IHTMLFiltersCollection, riid)) {
4033 TRACE("(%p)->(IID_IHTMLFiltersCollection %p)\n", This, ppv);
4034 *ppv = &This->IHTMLFiltersCollection_iface;
4035 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
4036 return *ppv ? S_OK : E_NOINTERFACE;
4037 }else {
4038 *ppv = NULL;
4039 FIXME("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
4040 return E_NOINTERFACE;
4041 }
4042
4043 IUnknown_AddRef((IUnknown*)*ppv);
4044 return S_OK;
4045 }
4046
4047 static ULONG WINAPI HTMLFiltersCollection_AddRef(IHTMLFiltersCollection *iface)
4048 {
4049 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
4050 LONG ref = InterlockedIncrement(&This->ref);
4051
4052 TRACE("(%p) ref=%d\n", This, ref);
4053
4054 return ref;
4055 }
4056
4057 static ULONG WINAPI HTMLFiltersCollection_Release(IHTMLFiltersCollection *iface)
4058 {
4059 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
4060 LONG ref = InterlockedDecrement(&This->ref);
4061
4062 TRACE("(%p) ref=%d\n", This, ref);
4063
4064 if(!ref)
4065 {
4066 heap_free(This);
4067 }
4068
4069 return ref;
4070 }
4071
4072 static HRESULT WINAPI HTMLFiltersCollection_GetTypeInfoCount(IHTMLFiltersCollection *iface, UINT *pctinfo)
4073 {
4074 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
4075 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
4076 }
4077
4078 static HRESULT WINAPI HTMLFiltersCollection_GetTypeInfo(IHTMLFiltersCollection *iface,
4079 UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
4080 {
4081 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
4082 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4083 }
4084
4085 static HRESULT WINAPI HTMLFiltersCollection_GetIDsOfNames(IHTMLFiltersCollection *iface,
4086 REFIID riid, LPOLESTR *rgszNames, UINT cNames,
4087 LCID lcid, DISPID *rgDispId)
4088 {
4089 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
4090 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
4091 lcid, rgDispId);
4092 }
4093
4094 static HRESULT WINAPI HTMLFiltersCollection_Invoke(IHTMLFiltersCollection *iface, DISPID dispIdMember, REFIID riid,
4095 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
4096 EXCEPINFO *pExcepInfo, UINT *puArgErr)
4097 {
4098 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
4099 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
4100 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4101 }
4102
4103 static HRESULT WINAPI HTMLFiltersCollection_get_length(IHTMLFiltersCollection *iface, LONG *p)
4104 {
4105 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
4106
4107 if(!p)
4108 return E_POINTER;
4109
4110 FIXME("(%p)->(%p) Always returning 0\n", This, p);
4111 *p = 0;
4112
4113 return S_OK;
4114 }
4115
4116 static HRESULT WINAPI HTMLFiltersCollection_get__newEnum(IHTMLFiltersCollection *iface, IUnknown **p)
4117 {
4118 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
4119 FIXME("(%p)->(%p)\n", This, p);
4120 return E_NOTIMPL;
4121 }
4122
4123 static HRESULT WINAPI HTMLFiltersCollection_item(IHTMLFiltersCollection *iface, VARIANT *pvarIndex, VARIANT *pvarResult)
4124 {
4125 HTMLFiltersCollection *This = impl_from_IHTMLFiltersCollection(iface);
4126 FIXME("(%p)->(%p, %p)\n", This, pvarIndex, pvarResult);
4127 return E_NOTIMPL;
4128 }
4129
4130 static const IHTMLFiltersCollectionVtbl HTMLFiltersCollectionVtbl = {
4131 HTMLFiltersCollection_QueryInterface,
4132 HTMLFiltersCollection_AddRef,
4133 HTMLFiltersCollection_Release,
4134 HTMLFiltersCollection_GetTypeInfoCount,
4135 HTMLFiltersCollection_GetTypeInfo,
4136 HTMLFiltersCollection_GetIDsOfNames,
4137 HTMLFiltersCollection_Invoke,
4138 HTMLFiltersCollection_get_length,
4139 HTMLFiltersCollection_get__newEnum,
4140 HTMLFiltersCollection_item
4141 };
4142
4143 static HRESULT HTMLFiltersCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
4144 {
4145 WCHAR *ptr;
4146 int idx = 0;
4147
4148 for(ptr = name; *ptr && isdigitW(*ptr); ptr++)
4149 idx = idx*10 + (*ptr-'0');
4150 if(*ptr)
4151 return DISP_E_UNKNOWNNAME;
4152
4153 *dispid = MSHTML_DISPID_CUSTOM_MIN + idx;
4154 TRACE("ret %x\n", *dispid);
4155 return S_OK;
4156 }
4157
4158 static HRESULT HTMLFiltersCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
4159 VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
4160 {
4161 TRACE("(%p)->(%x %x %x %p %p %p)\n", dispex, id, lcid, flags, params, res, ei);
4162
4163 V_VT(res) = VT_DISPATCH;
4164 V_DISPATCH(res) = NULL;
4165
4166 FIXME("always returning NULL\n");
4167
4168 return S_OK;
4169 }
4170
4171 static const dispex_static_data_vtbl_t HTMLFiltersCollection_dispex_vtbl = {
4172 NULL,
4173 HTMLFiltersCollection_get_dispid,
4174 HTMLFiltersCollection_invoke,
4175 NULL
4176 };
4177
4178 static const tid_t HTMLFiltersCollection_iface_tids[] = {
4179 IHTMLFiltersCollection_tid,
4180 0
4181 };
4182 static dispex_static_data_t HTMLFiltersCollection_dispex = {
4183 &HTMLFiltersCollection_dispex_vtbl,
4184 IHTMLFiltersCollection_tid,
4185 NULL,
4186 HTMLFiltersCollection_iface_tids
4187 };
4188
4189 static IHTMLFiltersCollection *HTMLFiltersCollection_Create(void)
4190 {
4191 HTMLFiltersCollection *ret = heap_alloc(sizeof(HTMLFiltersCollection));
4192
4193 ret->IHTMLFiltersCollection_iface.lpVtbl = &HTMLFiltersCollectionVtbl;
4194 ret->ref = 1;
4195
4196 init_dispex(&ret->dispex, (IUnknown*)&ret->IHTMLFiltersCollection_iface,
4197 &HTMLFiltersCollection_dispex);
4198
4199 return &ret->IHTMLFiltersCollection_iface;
4200 }
4201
4202 /* interface IHTMLAttributeCollection */
4203 static inline HTMLAttributeCollection *impl_from_IHTMLAttributeCollection(IHTMLAttributeCollection *iface)
4204 {
4205 return CONTAINING_RECORD(iface, HTMLAttributeCollection, IHTMLAttributeCollection_iface);
4206 }
4207
4208 static HRESULT WINAPI HTMLAttributeCollection_QueryInterface(IHTMLAttributeCollection *iface, REFIID riid, void **ppv)
4209 {
4210 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
4211
4212 if(IsEqualGUID(&IID_IUnknown, riid)) {
4213 *ppv = &This->IHTMLAttributeCollection_iface;
4214 }else if(IsEqualGUID(&IID_IHTMLAttributeCollection, riid)) {
4215 *ppv = &This->IHTMLAttributeCollection_iface;
4216 }else if(IsEqualGUID(&IID_IHTMLAttributeCollection2, riid)) {
4217 *ppv = &This->IHTMLAttributeCollection2_iface;
4218 }else if(IsEqualGUID(&IID_IHTMLAttributeCollection3, riid)) {
4219 *ppv = &This->IHTMLAttributeCollection3_iface;
4220 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
4221 return *ppv ? S_OK : E_NOINTERFACE;
4222 }else {
4223 *ppv = NULL;
4224 WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
4225 return E_NOINTERFACE;
4226 }
4227
4228 IUnknown_AddRef((IUnknown*)*ppv);
4229 return S_OK;
4230 }
4231
4232 static ULONG WINAPI HTMLAttributeCollection_AddRef(IHTMLAttributeCollection *iface)
4233 {
4234 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
4235 LONG ref = InterlockedIncrement(&This->ref);
4236
4237 TRACE("(%p) ref=%d\n", This, ref);
4238
4239 return ref;
4240 }
4241
4242 static ULONG WINAPI HTMLAttributeCollection_Release(IHTMLAttributeCollection *iface)
4243 {
4244 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
4245 LONG ref = InterlockedDecrement(&This->ref);
4246
4247 TRACE("(%p) ref=%d\n", This, ref);
4248
4249 if(!ref) {
4250 while(!list_empty(&This->attrs)) {
4251 HTMLDOMAttribute *attr = LIST_ENTRY(list_head(&This->attrs), HTMLDOMAttribute, entry);
4252
4253 list_remove(&attr->entry);
4254 attr->elem = NULL;
4255 IHTMLDOMAttribute_Release(&attr->IHTMLDOMAttribute_iface);
4256 }
4257
4258 heap_free(This);
4259 }
4260
4261 return ref;
4262 }
4263
4264 static HRESULT WINAPI HTMLAttributeCollection_GetTypeInfoCount(IHTMLAttributeCollection *iface, UINT *pctinfo)
4265 {
4266 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
4267 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
4268 }
4269
4270 static HRESULT WINAPI HTMLAttributeCollection_GetTypeInfo(IHTMLAttributeCollection *iface, UINT iTInfo,
4271 LCID lcid, ITypeInfo **ppTInfo)
4272 {
4273 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
4274 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4275 }
4276
4277 static HRESULT WINAPI HTMLAttributeCollection_GetIDsOfNames(IHTMLAttributeCollection *iface, REFIID riid,
4278 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4279 {
4280 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
4281 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
4282 lcid, rgDispId);
4283 }
4284
4285 static HRESULT WINAPI HTMLAttributeCollection_Invoke(IHTMLAttributeCollection *iface, DISPID dispIdMember,
4286 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
4287 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4288 {
4289 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
4290 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
4291 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4292 }
4293
4294 static HRESULT get_attr_dispid_by_idx(HTMLAttributeCollection *This, LONG *idx, DISPID *dispid)
4295 {
4296 IDispatchEx *dispex = &This->elem->node.dispex.IDispatchEx_iface;
4297 DISPID id = DISPID_STARTENUM;
4298 LONG len = -1;
4299 HRESULT hres;
4300
4301 FIXME("filter non-enumerable attributes out\n");
4302
4303 while(1) {
4304 hres = IDispatchEx_GetNextDispID(dispex, fdexEnumAll, id, &id);
4305 if(FAILED(hres))
4306 return hres;
4307 else if(hres == S_FALSE)
4308 break;
4309
4310 len++;
4311 if(len == *idx)
4312 break;
4313 }
4314
4315 if(dispid) {
4316 *dispid = id;
4317 return *idx==len ? S_OK : DISP_E_UNKNOWNNAME;
4318 }
4319
4320 *idx = len+1;
4321 return S_OK;
4322 }
4323
4324 static inline HRESULT get_attr_dispid_by_name(HTMLAttributeCollection *This, BSTR name, DISPID *id)
4325 {
4326 HRESULT hres;
4327
4328 if(name[0]>='0' && name[0]<='9') {
4329 WCHAR *end_ptr;
4330 LONG idx;
4331
4332 idx = strtoulW(name, &end_ptr, 10);
4333 if(!*end_ptr) {
4334 hres = get_attr_dispid_by_idx(This, &idx, id);
4335 if(SUCCEEDED(hres))
4336 return hres;
4337 }
4338 }
4339
4340 if(!This->elem) {
4341 WARN("NULL elem\n");
4342 return E_UNEXPECTED;
4343 }
4344
4345 hres = IDispatchEx_GetDispID(&This->elem->node.dispex.IDispatchEx_iface,
4346 name, fdexNameCaseInsensitive, id);
4347 return hres;
4348 }
4349
4350 static inline HRESULT get_domattr(HTMLAttributeCollection *This, DISPID id, LONG *list_pos, HTMLDOMAttribute **attr)
4351 {
4352 HTMLDOMAttribute *iter;
4353 LONG pos = 0;
4354 HRESULT hres;
4355
4356 *attr = NULL;
4357 LIST_FOR_EACH_ENTRY(iter, &This->attrs, HTMLDOMAttribute, entry) {
4358 if(iter->dispid == id) {
4359 *attr = iter;
4360 break;
4361 }
4362 pos++;
4363 }
4364
4365 if(!*attr) {
4366 if(!This->elem) {
4367 WARN("NULL elem\n");
4368 return E_UNEXPECTED;
4369 }
4370
4371 hres = HTMLDOMAttribute_Create(NULL, This->elem, id, attr);
4372 if(FAILED(hres))
4373 return hres;
4374 }
4375
4376 IHTMLDOMAttribute_AddRef(&(*attr)->IHTMLDOMAttribute_iface);
4377 if(list_pos)
4378 *list_pos = pos;
4379 return S_OK;
4380 }
4381
4382 static HRESULT WINAPI HTMLAttributeCollection_get_length(IHTMLAttributeCollection *iface, LONG *p)
4383 {
4384 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
4385 HRESULT hres;
4386
4387 TRACE("(%p)->(%p)\n", This, p);
4388
4389 *p = -1;
4390 hres = get_attr_dispid_by_idx(This, p, NULL);
4391 return hres;
4392 }
4393
4394 static HRESULT WINAPI HTMLAttributeCollection__newEnum(IHTMLAttributeCollection *iface, IUnknown **p)
4395 {
4396 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
4397 FIXME("(%p)->(%p)\n", This, p);
4398 return E_NOTIMPL;
4399 }
4400
4401 static HRESULT WINAPI HTMLAttributeCollection_item(IHTMLAttributeCollection *iface, VARIANT *name, IDispatch **ppItem)
4402 {
4403 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection(iface);
4404 HTMLDOMAttribute *attr;
4405 DISPID id;
4406 HRESULT hres;
4407
4408 TRACE("(%p)->(%s %p)\n", This, debugstr_variant(name), ppItem);
4409
4410 switch(V_VT(name)) {
4411 case VT_I4:
4412 hres = get_attr_dispid_by_idx(This, &V_I4(name), &id);
4413 break;
4414 case VT_BSTR:
4415 hres = get_attr_dispid_by_name(This, V_BSTR(name), &id);
4416 break;
4417 default:
4418 FIXME("unsupported name %s\n", debugstr_variant(name));
4419 hres = E_NOTIMPL;
4420 }
4421 if(hres == DISP_E_UNKNOWNNAME)
4422 return E_INVALIDARG;
4423 if(FAILED(hres))
4424 return hres;
4425
4426 hres = get_domattr(This, id, NULL, &attr);
4427 if(FAILED(hres))
4428 return hres;
4429
4430 *ppItem = (IDispatch*)&attr->IHTMLDOMAttribute_iface;
4431 return S_OK;
4432 }
4433
4434 static const IHTMLAttributeCollectionVtbl HTMLAttributeCollectionVtbl = {
4435 HTMLAttributeCollection_QueryInterface,
4436 HTMLAttributeCollection_AddRef,
4437 HTMLAttributeCollection_Release,
4438 HTMLAttributeCollection_GetTypeInfoCount,
4439 HTMLAttributeCollection_GetTypeInfo,
4440 HTMLAttributeCollection_GetIDsOfNames,
4441 HTMLAttributeCollection_Invoke,
4442 HTMLAttributeCollection_get_length,
4443 HTMLAttributeCollection__newEnum,
4444 HTMLAttributeCollection_item
4445 };
4446
4447 static inline HTMLAttributeCollection *impl_from_IHTMLAttributeCollection2(IHTMLAttributeCollection2 *iface)
4448 {
4449 return CONTAINING_RECORD(iface, HTMLAttributeCollection, IHTMLAttributeCollection2_iface);
4450 }
4451
4452 static HRESULT WINAPI HTMLAttributeCollection2_QueryInterface(IHTMLAttributeCollection2 *iface, REFIID riid, void **ppv)
4453 {
4454 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
4455 return IHTMLAttributeCollection_QueryInterface(&This->IHTMLAttributeCollection_iface, riid, ppv);
4456 }
4457
4458 static ULONG WINAPI HTMLAttributeCollection2_AddRef(IHTMLAttributeCollection2 *iface)
4459 {
4460 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
4461 return IHTMLAttributeCollection_AddRef(&This->IHTMLAttributeCollection_iface);
4462 }
4463
4464 static ULONG WINAPI HTMLAttributeCollection2_Release(IHTMLAttributeCollection2 *iface)
4465 {
4466 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
4467 return IHTMLAttributeCollection_Release(&This->IHTMLAttributeCollection_iface);
4468 }
4469
4470 static HRESULT WINAPI HTMLAttributeCollection2_GetTypeInfoCount(IHTMLAttributeCollection2 *iface, UINT *pctinfo)
4471 {
4472 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
4473 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
4474 }
4475
4476 static HRESULT WINAPI HTMLAttributeCollection2_GetTypeInfo(IHTMLAttributeCollection2 *iface, UINT iTInfo,
4477 LCID lcid, ITypeInfo **ppTInfo)
4478 {
4479 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
4480 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4481 }
4482
4483 static HRESULT WINAPI HTMLAttributeCollection2_GetIDsOfNames(IHTMLAttributeCollection2 *iface, REFIID riid,
4484 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4485 {
4486 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
4487 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
4488 lcid, rgDispId);
4489 }
4490
4491 static HRESULT WINAPI HTMLAttributeCollection2_Invoke(IHTMLAttributeCollection2 *iface, DISPID dispIdMember,
4492 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
4493 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4494 {
4495 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
4496 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
4497 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4498 }
4499
4500 static HRESULT WINAPI HTMLAttributeCollection2_getNamedItem(IHTMLAttributeCollection2 *iface, BSTR bstrName,
4501 IHTMLDOMAttribute **newretNode)
4502 {
4503 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
4504 HTMLDOMAttribute *attr;
4505 DISPID id;
4506 HRESULT hres;
4507
4508 TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrName), newretNode);
4509
4510 hres = get_attr_dispid_by_name(This, bstrName, &id);
4511 if(hres == DISP_E_UNKNOWNNAME) {
4512 *newretNode = NULL;
4513 return S_OK;
4514 } else if(FAILED(hres)) {
4515 return hres;
4516 }
4517
4518 hres = get_domattr(This, id, NULL, &attr);
4519 if(FAILED(hres))
4520 return hres;
4521
4522 *newretNode = &attr->IHTMLDOMAttribute_iface;
4523 return S_OK;
4524 }
4525
4526 static HRESULT WINAPI HTMLAttributeCollection2_setNamedItem(IHTMLAttributeCollection2 *iface,
4527 IHTMLDOMAttribute *ppNode, IHTMLDOMAttribute **newretNode)
4528 {
4529 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
4530 FIXME("(%p)->(%p %p)\n", This, ppNode, newretNode);
4531 return E_NOTIMPL;
4532 }
4533
4534 static HRESULT WINAPI HTMLAttributeCollection2_removeNamedItem(IHTMLAttributeCollection2 *iface,
4535 BSTR bstrName, IHTMLDOMAttribute **newretNode)
4536 {
4537 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection2(iface);
4538 FIXME("(%p)->(%s %p)\n", This, debugstr_w(bstrName), newretNode);
4539 return E_NOTIMPL;
4540 }
4541
4542 static const IHTMLAttributeCollection2Vtbl HTMLAttributeCollection2Vtbl = {
4543 HTMLAttributeCollection2_QueryInterface,
4544 HTMLAttributeCollection2_AddRef,
4545 HTMLAttributeCollection2_Release,
4546 HTMLAttributeCollection2_GetTypeInfoCount,
4547 HTMLAttributeCollection2_GetTypeInfo,
4548 HTMLAttributeCollection2_GetIDsOfNames,
4549 HTMLAttributeCollection2_Invoke,
4550 HTMLAttributeCollection2_getNamedItem,
4551 HTMLAttributeCollection2_setNamedItem,
4552 HTMLAttributeCollection2_removeNamedItem
4553 };
4554
4555 static inline HTMLAttributeCollection *impl_from_IHTMLAttributeCollection3(IHTMLAttributeCollection3 *iface)
4556 {
4557 return CONTAINING_RECORD(iface, HTMLAttributeCollection, IHTMLAttributeCollection3_iface);
4558 }
4559
4560 static HRESULT WINAPI HTMLAttributeCollection3_QueryInterface(IHTMLAttributeCollection3 *iface, REFIID riid, void **ppv)
4561 {
4562 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
4563 return IHTMLAttributeCollection_QueryInterface(&This->IHTMLAttributeCollection_iface, riid, ppv);
4564 }
4565
4566 static ULONG WINAPI HTMLAttributeCollection3_AddRef(IHTMLAttributeCollection3 *iface)
4567 {
4568 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
4569 return IHTMLAttributeCollection_AddRef(&This->IHTMLAttributeCollection_iface);
4570 }
4571
4572 static ULONG WINAPI HTMLAttributeCollection3_Release(IHTMLAttributeCollection3 *iface)
4573 {
4574 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
4575 return IHTMLAttributeCollection_Release(&This->IHTMLAttributeCollection_iface);
4576 }
4577
4578 static HRESULT WINAPI HTMLAttributeCollection3_GetTypeInfoCount(IHTMLAttributeCollection3 *iface, UINT *pctinfo)
4579 {
4580 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
4581 return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
4582 }
4583
4584 static HRESULT WINAPI HTMLAttributeCollection3_GetTypeInfo(IHTMLAttributeCollection3 *iface, UINT iTInfo,
4585 LCID lcid, ITypeInfo **ppTInfo)
4586 {
4587 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
4588 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
4589 }
4590
4591 static HRESULT WINAPI HTMLAttributeCollection3_GetIDsOfNames(IHTMLAttributeCollection3 *iface, REFIID riid,
4592 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
4593 {
4594 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
4595 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
4596 lcid, rgDispId);
4597 }
4598
4599 static HRESULT WINAPI HTMLAttributeCollection3_Invoke(IHTMLAttributeCollection3 *iface, DISPID dispIdMember,
4600 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
4601 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
4602 {
4603 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
4604 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
4605 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
4606 }
4607
4608 static HRESULT WINAPI HTMLAttributeCollection3_getNamedItem(IHTMLAttributeCollection3 *iface, BSTR bstrName,
4609 IHTMLDOMAttribute **ppNodeOut)
4610 {
4611 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
4612 return IHTMLAttributeCollection2_getNamedItem(&This->IHTMLAttributeCollection2_iface, bstrName, ppNodeOut);
4613 }
4614
4615 static HRESULT WINAPI HTMLAttributeCollection3_setNamedItem(IHTMLAttributeCollection3 *iface,
4616 IHTMLDOMAttribute *pNodeIn, IHTMLDOMAttribute **ppNodeOut)
4617 {
4618 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
4619 FIXME("(%p)->(%p %p)\n", This, pNodeIn, ppNodeOut);
4620 return E_NOTIMPL;
4621 }
4622
4623 static HRESULT WINAPI HTMLAttributeCollection3_removeNamedItem(IHTMLAttributeCollection3 *iface,
4624 BSTR bstrName, IHTMLDOMAttribute **ppNodeOut)
4625 {
4626 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
4627 FIXME("(%p)->(%s %p)\n", This, debugstr_w(bstrName), ppNodeOut);
4628 return E_NOTIMPL;
4629 }
4630
4631 static HRESULT WINAPI HTMLAttributeCollection3_item(IHTMLAttributeCollection3 *iface, LONG index, IHTMLDOMAttribute **ppNodeOut)
4632 {
4633 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
4634 HTMLDOMAttribute *attr;
4635 DISPID id;
4636 HRESULT hres;
4637
4638 TRACE("(%p)->(%d %p)\n", This, index, ppNodeOut);
4639
4640 hres = get_attr_dispid_by_idx(This, &index, &id);
4641 if(hres == DISP_E_UNKNOWNNAME)
4642 return E_INVALIDARG;
4643 if(FAILED(hres))
4644 return hres;
4645
4646 hres = get_domattr(This, id, NULL, &attr);
4647 if(FAILED(hres))
4648 return hres;
4649
4650 *ppNodeOut = &attr->IHTMLDOMAttribute_iface;
4651 return S_OK;
4652 }
4653
4654 static HRESULT WINAPI HTMLAttributeCollection3_get_length(IHTMLAttributeCollection3 *iface, LONG *p)
4655 {
4656 HTMLAttributeCollection *This = impl_from_IHTMLAttributeCollection3(iface);
4657 return IHTMLAttributeCollection_get_length(&This->IHTMLAttributeCollection_iface, p);
4658 }
4659
4660 static const IHTMLAttributeCollection3Vtbl HTMLAttributeCollection3Vtbl = {
4661 HTMLAttributeCollection3_QueryInterface,
4662 HTMLAttributeCollection3_AddRef,
4663 HTMLAttributeCollection3_Release,
4664 HTMLAttributeCollection3_GetTypeInfoCount,
4665 HTMLAttributeCollection3_GetTypeInfo,
4666 HTMLAttributeCollection3_GetIDsOfNames,
4667 HTMLAttributeCollection3_Invoke,
4668 HTMLAttributeCollection3_getNamedItem,
4669 HTMLAttributeCollection3_setNamedItem,
4670 HTMLAttributeCollection3_removeNamedItem,
4671 HTMLAttributeCollection3_item,
4672 HTMLAttributeCollection3_get_length
4673 };
4674
4675 static inline HTMLAttributeCollection *HTMLAttributeCollection_from_DispatchEx(DispatchEx *iface)
4676 {
4677 return CONTAINING_RECORD(iface, HTMLAttributeCollection, dispex);
4678 }
4679
4680 static HRESULT HTMLAttributeCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
4681 {
4682 HTMLAttributeCollection *This = HTMLAttributeCollection_from_DispatchEx(dispex);
4683 HTMLDOMAttribute *attr;
4684 LONG pos;
4685 HRESULT hres;
4686
4687 TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(name), flags, dispid);
4688
4689 hres = get_attr_dispid_by_name(This, name, dispid);
4690 if(FAILED(hres))
4691 return hres;
4692
4693 hres = get_domattr(This, *dispid, &pos, &attr);
4694 if(FAILED(hres))
4695 return hres;
4696 IHTMLDOMAttribute_Release(&attr->IHTMLDOMAttribute_iface);
4697
4698 *dispid = MSHTML_DISPID_CUSTOM_MIN+pos;
4699 return S_OK;
4700 }
4701
4702 static HRESULT HTMLAttributeCollection_invoke(DispatchEx *dispex, DISPID id, LCID lcid,
4703 WORD flags, DISPPARAMS *params, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
4704 {
4705 HTMLAttributeCollection *This = HTMLAttributeCollection_from_DispatchEx(dispex);
4706
4707 TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, flags, params, res, ei, caller);
4708
4709 switch(flags) {
4710 case DISPATCH_PROPERTYGET: {
4711 HTMLDOMAttribute *iter;
4712 DWORD pos;
4713
4714 pos = id-MSHTML_DISPID_CUSTOM_MIN;
4715
4716 LIST_FOR_EACH_ENTRY(iter, &This->attrs, HTMLDOMAttribute, entry) {
4717 if(!pos) {
4718 IHTMLDOMAttribute_AddRef(&iter->IHTMLDOMAttribute_iface);
4719 V_VT(res) = VT_DISPATCH;
4720 V_DISPATCH(res) = (IDispatch*)&iter->IHTMLDOMAttribute_iface;
4721 return S_OK;
4722 }
4723 pos--;
4724 }
4725
4726 WARN("invalid arg\n");
4727 return E_INVALIDARG;
4728 }
4729
4730 default:
4731 FIXME("unimplemented flags %x\n", flags);
4732 return E_NOTIMPL;
4733 }
4734 }
4735
4736 static const dispex_static_data_vtbl_t HTMLAttributeCollection_dispex_vtbl = {
4737 NULL,
4738 HTMLAttributeCollection_get_dispid,
4739 HTMLAttributeCollection_invoke,
4740 NULL
4741 };
4742
4743 static const tid_t HTMLAttributeCollection_iface_tids[] = {
4744 IHTMLAttributeCollection_tid,
4745 IHTMLAttributeCollection2_tid,
4746 IHTMLAttributeCollection3_tid,
4747 0
4748 };
4749
4750 static dispex_static_data_t HTMLAttributeCollection_dispex = {
4751 &HTMLAttributeCollection_dispex_vtbl,
4752 DispHTMLAttributeCollection_tid,
4753 NULL,
4754 HTMLAttributeCollection_iface_tids
4755 };
4756
4757 HRESULT HTMLElement_get_attr_col(HTMLDOMNode *iface, HTMLAttributeCollection **ac)
4758 {
4759 HTMLElement *This = impl_from_HTMLDOMNode(iface);
4760
4761 if(This->attrs) {
4762 IHTMLAttributeCollection_AddRef(&This->attrs->IHTMLAttributeCollection_iface);
4763 *ac = This->attrs;
4764 return S_OK;
4765 }
4766
4767 This->attrs = heap_alloc_zero(sizeof(HTMLAttributeCollection));
4768 if(!This->attrs)
4769 return E_OUTOFMEMORY;
4770
4771 This->attrs->IHTMLAttributeCollection_iface.lpVtbl = &HTMLAttributeCollectionVtbl;
4772 This->attrs->IHTMLAttributeCollection2_iface.lpVtbl = &HTMLAttributeCollection2Vtbl;
4773 This->attrs->IHTMLAttributeCollection3_iface.lpVtbl = &HTMLAttributeCollection3Vtbl;
4774 This->attrs->ref = 2;
4775
4776 This->attrs->elem = This;
4777 list_init(&This->attrs->attrs);
4778 init_dispex(&This->attrs->dispex, (IUnknown*)&This->attrs->IHTMLAttributeCollection_iface,
4779 &HTMLAttributeCollection_dispex);
4780
4781 *ac = This->attrs;
4782 return S_OK;
4783 }
Windows API implementation