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