ReactOS 0.4.15-dev-7906-g1b85a5f
htmlelem.c
Go to the documentation of this file.
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 "mshtml_private.h"
20
21static const WCHAR aW[] = {'A',0};
22static const WCHAR areaW[] = {'A','R','E','A',0};
23static const WCHAR bodyW[] = {'B','O','D','Y',0};
24static const WCHAR buttonW[] = {'B','U','T','T','O','N',0};
25static const WCHAR embedW[] = {'E','M','B','E','D',0};
26static const WCHAR formW[] = {'F','O','R','M',0};
27static const WCHAR frameW[] = {'F','R','A','M','E',0};
28static const WCHAR headW[] = {'H','E','A','D',0};
29static const WCHAR iframeW[] = {'I','F','R','A','M','E',0};
30static const WCHAR imgW[] = {'I','M','G',0};
31static const WCHAR inputW[] = {'I','N','P','U','T',0};
32static const WCHAR labelW[] = {'L','A','B','E','L',0};
33static const WCHAR linkW[] = {'L','I','N','K',0};
34static const WCHAR metaW[] = {'M','E','T','A',0};
35static const WCHAR objectW[] = {'O','B','J','E','C','T',0};
36static const WCHAR optionW[] = {'O','P','T','I','O','N',0};
37static const WCHAR scriptW[] = {'S','C','R','I','P','T',0};
38static const WCHAR selectW[] = {'S','E','L','E','C','T',0};
39static const WCHAR styleW[] = {'S','T','Y','L','E',0};
40static const WCHAR tableW[] = {'T','A','B','L','E',0};
41static const WCHAR tdW[] = {'T','D',0};
42static const WCHAR textareaW[] = {'T','E','X','T','A','R','E','A',0};
43static const WCHAR title_tagW[]= {'T','I','T','L','E',0};
44static const WCHAR trW[] = {'T','R',0};
45
46typedef struct {
47 const WCHAR *name;
50
51static const tag_desc_t tag_descs[] = {
76};
77
78static const tag_desc_t *get_tag_desc(const WCHAR *tag_name)
79{
80 DWORD min=0, max=sizeof(tag_descs)/sizeof(*tag_descs)-1, i;
81 int r;
82
83 while(min <= max) {
84 i = (min+max)/2;
85 r = strcmpW(tag_name, tag_descs[i].name);
86 if(!r)
87 return tag_descs+i;
88
89 if(r < 0)
90 max = i-1;
91 else
92 min = i+1;
93 }
94
95 return NULL;
96}
97
99{
100 nsIDOMDocumentFragment *nsfragment;
101 nsIDOMNode *nsparent;
104 nsresult nsres;
105 HRESULT hres = S_OK;
106
107 nsres = nsIDOMHTMLDocument_CreateRange(nsdoc, &range);
108 if(NS_FAILED(nsres)) {
109 ERR("CreateRange failed: %08x\n", nsres);
110 return E_FAIL;
111 }
112
114 nsIDOMRange_CreateContextualFragment(range, &html_str, &nsfragment);
115 nsIDOMRange_Release(range);
117 if(NS_FAILED(nsres)) {
118 ERR("CreateContextualFragment failed: %08x\n", nsres);
119 return E_FAIL;
120 }
121
122 nsres = nsIDOMNode_GetParentNode(nsnode, &nsparent);
123 if(NS_SUCCEEDED(nsres) && nsparent) {
124 nsIDOMNode *nstmp;
125
126 nsres = nsIDOMNode_ReplaceChild(nsparent, (nsIDOMNode*)nsfragment, nsnode, &nstmp);
127 nsIDOMNode_Release(nsparent);
128 if(NS_FAILED(nsres)) {
129 ERR("ReplaceChild failed: %08x\n", nsres);
130 hres = E_FAIL;
131 }else if(nstmp) {
132 nsIDOMNode_Release(nstmp);
133 }
134 }else {
135 ERR("GetParentNode failed: %08x\n", nsres);
136 hres = E_FAIL;
137 }
138
139 nsIDOMDocumentFragment_Release(nsfragment);
140 return hres;
141}
142
144{
145 nsAString name_str;
146 nsresult nsres;
147
148 nsAString_InitDepend(&name_str, name);
149 nsAString_Init(val_str, NULL);
150 nsres = nsIDOMHTMLElement_GetAttribute(nselem, &name_str, val_str);
151 nsAString_Finish(&name_str);
152 if(NS_FAILED(nsres)) {
153 ERR("GetAttribute(%s) failed: %08x\n", debugstr_w(name), nsres);
154 nsAString_Finish(val_str);
155 return nsres;
156 }
157
158 nsAString_GetData(val_str, val);
159 return NS_OK;
160}
161
163{
164 const PRUnichar *val;
165 nsAString val_str;
166 nsresult nsres;
167 HRESULT hres = S_OK;
168
169 nsres = get_elem_attr_value(elem->nselem, name, &val_str, &val);
170 if(NS_FAILED(nsres))
171 return E_FAIL;
172
173 TRACE("%s: returning %s\n", debugstr_w(name), debugstr_w(val));
174
175 if(*val || !use_null) {
176 *p = SysAllocString(val);
177 if(!*p)
179 }else {
180 *p = NULL;
181 }
182 nsAString_Finish(&val_str);
183 return hres;
184}
185
187{
188 nsAString name_str, val_str;
189 nsresult nsres;
190
191 nsAString_InitDepend(&name_str, name);
192 nsAString_InitDepend(&val_str, value);
193 nsres = nsIDOMHTMLElement_SetAttribute(elem->nselem, &name_str, &val_str);
194 nsAString_Finish(&name_str);
195 nsAString_Finish(&val_str);
196
197 if(NS_FAILED(nsres)) {
198 WARN("SetAttribute failed: %08x\n", nsres);
199 return E_FAIL;
200 }
201
202 return S_OK;
203}
204
205HRESULT get_readystate_string(READYSTATE readystate, BSTR *p)
206{
207 static const WCHAR uninitializedW[] = {'u','n','i','n','i','t','i','a','l','i','z','e','d',0};
208 static const WCHAR loadingW[] = {'l','o','a','d','i','n','g',0};
209 static const WCHAR loadedW[] = {'l','o','a','d','e','d',0};
210 static const WCHAR interactiveW[] = {'i','n','t','e','r','a','c','t','i','v','e',0};
211 static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
212
213 static const LPCWSTR readystate_strs[] = {
214 uninitializedW,
215 loadingW,
216 loadedW,
217 interactiveW,
218 completeW
219 };
220
221 assert(readystate <= READYSTATE_COMPLETE);
222 *p = SysAllocString(readystate_strs[readystate]);
223 return *p ? S_OK : E_OUTOFMEMORY;
224}
225
226typedef struct
227{
229 IHTMLFiltersCollection IHTMLFiltersCollection_iface;
230
233
234static inline HTMLFiltersCollection *impl_from_IHTMLFiltersCollection(IHTMLFiltersCollection *iface)
235{
236 return CONTAINING_RECORD(iface, HTMLFiltersCollection, IHTMLFiltersCollection_iface);
237}
238
239static IHTMLFiltersCollection *HTMLFiltersCollection_Create(void);
240
241static inline HTMLElement *impl_from_IHTMLElement(IHTMLElement *iface)
242{
243 return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement_iface);
244}
245
247{
248 nsIDOMElement *nselem;
249 nsAString tag_str;
250 nsresult nsres;
251
252 if(!doc->nsdoc) {
253 WARN("NULL nsdoc\n");
254 return E_UNEXPECTED;
255 }
256
257 nsAString_InitDepend(&tag_str, tag);
258 nsres = nsIDOMHTMLDocument_CreateElement(doc->nsdoc, &tag_str, &nselem);
259 nsAString_Finish(&tag_str);
260 if(NS_FAILED(nsres)) {
261 ERR("CreateElement failed: %08x\n", nsres);
262 return E_FAIL;
263 }
264
265 nsres = nsIDOMElement_QueryInterface(nselem, &IID_nsIDOMHTMLElement, (void**)ret);
266 nsIDOMElement_Release(nselem);
267 if(NS_FAILED(nsres)) {
268 ERR("Could not get nsIDOMHTMLElement iface: %08x\n", nsres);
269 return E_FAIL;
270 }
271
272 return S_OK;
273}
274
276{
277 nsIDOMHTMLElement *nselem;
279
280 /* Use owner doc if called on document fragment */
281 if(!doc->nsdoc)
282 doc = doc->node.doc;
283
284 hres = create_nselem(doc, tag, &nselem);
285 if(FAILED(hres))
286 return hres;
287
288 hres = HTMLElement_Create(doc, (nsIDOMNode*)nselem, TRUE, ret);
289 nsIDOMHTMLElement_Release(nselem);
290 return hres;
291}
292
293typedef struct {
296
298
300} HTMLRect;
301
302static inline HTMLRect *impl_from_IHTMLRect(IHTMLRect *iface)
303{
304 return CONTAINING_RECORD(iface, HTMLRect, IHTMLRect_iface);
305}
306
307static HRESULT WINAPI HTMLRect_QueryInterface(IHTMLRect *iface, REFIID riid, void **ppv)
308{
310
311 TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
312
314 *ppv = &This->IHTMLRect_iface;
315 }else if(IsEqualGUID(&IID_IHTMLRect, riid)) {
316 *ppv = &This->IHTMLRect_iface;
317 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
318 return *ppv ? S_OK : E_NOINTERFACE;
319 }else {
320 FIXME("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
321 *ppv = NULL;
322 return E_NOINTERFACE;
323 }
324
325 IUnknown_AddRef((IUnknown*)*ppv);
326 return S_OK;
327}
328
329static ULONG WINAPI HTMLRect_AddRef(IHTMLRect *iface)
330{
333
334 TRACE("(%p) ref=%d\n", This, ref);
335
336 return ref;
337}
338
339static ULONG WINAPI HTMLRect_Release(IHTMLRect *iface)
340{
343
344 TRACE("(%p) ref=%d\n", This, ref);
345
346 if(!ref) {
347 if(This->nsrect)
348 nsIDOMClientRect_Release(This->nsrect);
350 }
351
352 return ref;
353}
354
355static HRESULT WINAPI HTMLRect_GetTypeInfoCount(IHTMLRect *iface, UINT *pctinfo)
356{
358 FIXME("(%p)->(%p)\n", This, pctinfo);
359 return E_NOTIMPL;
360}
361
362static HRESULT WINAPI HTMLRect_GetTypeInfo(IHTMLRect *iface, UINT iTInfo,
363 LCID lcid, ITypeInfo **ppTInfo)
364{
366
367 return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
368}
369
371 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
372{
374
375 return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
376 lcid, rgDispId);
377}
378
379static HRESULT WINAPI HTMLRect_Invoke(IHTMLRect *iface, DISPID dispIdMember,
380 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
381 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
382{
384
385 return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
386 pDispParams, pVarResult, pExcepInfo, puArgErr);
387}
388
389static HRESULT WINAPI HTMLRect_put_left(IHTMLRect *iface, LONG v)
390{
392 FIXME("(%p)->(%d)\n", This, v);
393 return E_NOTIMPL;
394}
395
396static HRESULT WINAPI HTMLRect_get_left(IHTMLRect *iface, LONG *p)
397{
399 float left;
400 nsresult nsres;
401
402 TRACE("(%p)->(%p)\n", This, p);
403
404 nsres = nsIDOMClientRect_GetLeft(This->nsrect, &left);
405 if(NS_FAILED(nsres)) {
406 ERR("GetLeft failed: %08x\n", nsres);
407 return E_FAIL;
408 }
409
410 *p = floor(left+0.5);
411 return S_OK;
412}
413
414static HRESULT WINAPI HTMLRect_put_top(IHTMLRect *iface, LONG v)
415{
417 FIXME("(%p)->(%d)\n", This, v);
418 return E_NOTIMPL;
419}
420
421static HRESULT WINAPI HTMLRect_get_top(IHTMLRect *iface, LONG *p)
422{
424 float top;
425 nsresult nsres;
426
427 TRACE("(%p)->(%p)\n", This, p);
428
429 nsres = nsIDOMClientRect_GetTop(This->nsrect, &top);
430 if(NS_FAILED(nsres)) {
431 ERR("GetTop failed: %08x\n", nsres);
432 return E_FAIL;
433 }
434
435 *p = floor(top+0.5);
436 return S_OK;
437}
438
439static HRESULT WINAPI HTMLRect_put_right(IHTMLRect *iface, LONG v)
440{
442 FIXME("(%p)->(%d)\n", This, v);
443 return E_NOTIMPL;
444}
445
446static HRESULT WINAPI HTMLRect_get_right(IHTMLRect *iface, LONG *p)
447{
449 float right;
450 nsresult nsres;
451
452 TRACE("(%p)->(%p)\n", This, p);
453
454 nsres = nsIDOMClientRect_GetRight(This->nsrect, &right);
455 if(NS_FAILED(nsres)) {
456 ERR("GetRight failed: %08x\n", nsres);
457 return E_FAIL;
458 }
459
460 *p = floor(right+0.5);
461 return S_OK;
462}
463
464static HRESULT WINAPI HTMLRect_put_bottom(IHTMLRect *iface, LONG v)
465{
467 FIXME("(%p)->(%d)\n", This, v);
468 return E_NOTIMPL;
469}
470
471static HRESULT WINAPI HTMLRect_get_bottom(IHTMLRect *iface, LONG *p)
472{
474 float bottom;
475 nsresult nsres;
476
477 TRACE("(%p)->(%p)\n", This, p);
478
479 nsres = nsIDOMClientRect_GetBottom(This->nsrect, &bottom);
480 if(NS_FAILED(nsres)) {
481 ERR("GetBottom failed: %08x\n", nsres);
482 return E_FAIL;
483 }
484
485 *p = floor(bottom+0.5);
486 return S_OK;
487}
488
489static const IHTMLRectVtbl HTMLRectVtbl = {
505};
506
507static const tid_t HTMLRect_iface_tids[] = {
508 IHTMLRect_tid,
509 0
510};
512 NULL,
513 IHTMLRect_tid,
514 NULL,
516};
517
518static HRESULT create_html_rect(nsIDOMClientRect *nsrect, IHTMLRect **ret)
519{
520 HTMLRect *rect;
521
522 rect = heap_alloc_zero(sizeof(HTMLRect));
523 if(!rect)
524 return E_OUTOFMEMORY;
525
526 rect->IHTMLRect_iface.lpVtbl = &HTMLRectVtbl;
527 rect->ref = 1;
528
529 init_dispex(&rect->dispex, (IUnknown*)&rect->IHTMLRect_iface, &HTMLRect_dispex);
530
531 nsIDOMClientRect_AddRef(nsrect);
532 rect->nsrect = nsrect;
533
534 *ret = &rect->IHTMLRect_iface;
535 return S_OK;
536}
537
538static HRESULT WINAPI HTMLElement_QueryInterface(IHTMLElement *iface,
539 REFIID riid, void **ppv)
540{
542
543 return IHTMLDOMNode_QueryInterface(&This->node.IHTMLDOMNode_iface, riid, ppv);
544}
545
546static ULONG WINAPI HTMLElement_AddRef(IHTMLElement *iface)
547{
549
550 return IHTMLDOMNode_AddRef(&This->node.IHTMLDOMNode_iface);
551}
552
553static ULONG WINAPI HTMLElement_Release(IHTMLElement *iface)
554{
556
557 return IHTMLDOMNode_Release(&This->node.IHTMLDOMNode_iface);
558}
559
560static HRESULT WINAPI HTMLElement_GetTypeInfoCount(IHTMLElement *iface, UINT *pctinfo)
561{
563 return IDispatchEx_GetTypeInfoCount(&This->node.event_target.dispex.IDispatchEx_iface, pctinfo);
564}
565
566static HRESULT WINAPI HTMLElement_GetTypeInfo(IHTMLElement *iface, UINT iTInfo,
567 LCID lcid, ITypeInfo **ppTInfo)
568{
570 return IDispatchEx_GetTypeInfo(&This->node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
571}
572
574 LPOLESTR *rgszNames, UINT cNames,
575 LCID lcid, DISPID *rgDispId)
576{
578 return IDispatchEx_GetIDsOfNames(&This->node.event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
579 lcid, rgDispId);
580}
581
582static HRESULT WINAPI HTMLElement_Invoke(IHTMLElement *iface, DISPID dispIdMember,
583 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
584 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
585{
587 return IDispatchEx_Invoke(&This->node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
588 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
589}
590
591static HRESULT WINAPI HTMLElement_setAttribute(IHTMLElement *iface, BSTR strAttributeName,
592 VARIANT AttributeValue, LONG lFlags)
593{
596 DISPID dispid, dispidNamed = DISPID_PROPERTYPUT;
597 DISPPARAMS dispParams;
598 EXCEPINFO excep;
599
600 TRACE("(%p)->(%s %s %08x)\n", This, debugstr_w(strAttributeName), debugstr_variant(&AttributeValue), lFlags);
601
602 hres = IDispatchEx_GetDispID(&This->node.event_target.dispex.IDispatchEx_iface, strAttributeName,
603 (lFlags&ATTRFLAG_CASESENSITIVE ? fdexNameCaseSensitive : fdexNameCaseInsensitive) | fdexNameEnsure, &dispid);
604 if(FAILED(hres))
605 return hres;
606
607 if(dispid == DISPID_IHTMLELEMENT_STYLE) {
608 TRACE("Ignoring call on style attribute\n");
609 return S_OK;
610 }
611
612 dispParams.cArgs = 1;
613 dispParams.cNamedArgs = 1;
614 dispParams.rgdispidNamedArgs = &dispidNamed;
615 dispParams.rgvarg = &AttributeValue;
616
617 return IDispatchEx_InvokeEx(&This->node.event_target.dispex.IDispatchEx_iface, dispid,
618 LOCALE_SYSTEM_DEFAULT, DISPATCH_PROPERTYPUT, &dispParams, NULL, &excep, NULL);
619}
620
622{
623 DISPPARAMS dispParams = {NULL, NULL, 0, 0};
624 EXCEPINFO excep;
626
627 hres = IDispatchEx_InvokeEx(&elem->node.event_target.dispex.IDispatchEx_iface, dispid, LOCALE_SYSTEM_DEFAULT,
628 DISPATCH_PROPERTYGET, &dispParams, ret, &excep, NULL);
629 if(FAILED(hres))
630 return hres;
631
633 switch(V_VT(ret)) {
634 case VT_BSTR:
635 break;
636 case VT_DISPATCH:
637 IDispatch_Release(V_DISPATCH(ret));
638 V_VT(ret) = VT_BSTR;
640 break;
641 default:
643 if(FAILED(hres))
644 return hres;
645 }
646 }
647
648 return S_OK;
649}
650
651static HRESULT WINAPI HTMLElement_getAttribute(IHTMLElement *iface, BSTR strAttributeName,
652 LONG lFlags, VARIANT *AttributeValue)
653{
655 DISPID dispid;
657
658 TRACE("(%p)->(%s %08x %p)\n", This, debugstr_w(strAttributeName), lFlags, AttributeValue);
659
661 FIXME("Unsupported flags %x\n", lFlags);
662
663 hres = IDispatchEx_GetDispID(&This->node.event_target.dispex.IDispatchEx_iface, strAttributeName,
664 lFlags&ATTRFLAG_CASESENSITIVE ? fdexNameCaseSensitive : fdexNameCaseInsensitive, &dispid);
665 if(hres == DISP_E_UNKNOWNNAME) {
666 V_VT(AttributeValue) = VT_NULL;
667 return S_OK;
668 }
669
670 if(FAILED(hres)) {
671 V_VT(AttributeValue) = VT_NULL;
672 return hres;
673 }
674
675 return get_elem_attr_value_by_dispid(This, dispid, lFlags, AttributeValue);
676}
677
678static HRESULT WINAPI HTMLElement_removeAttribute(IHTMLElement *iface, BSTR strAttributeName,
679 LONG lFlags, VARIANT_BOOL *pfSuccess)
680{
682 DISPID id;
684
685 TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(strAttributeName), lFlags, pfSuccess);
686
687 hres = IDispatchEx_GetDispID(&This->node.event_target.dispex.IDispatchEx_iface, strAttributeName,
688 lFlags&ATTRFLAG_CASESENSITIVE ? fdexNameCaseSensitive : fdexNameCaseInsensitive, &id);
689 if(hres == DISP_E_UNKNOWNNAME) {
690 *pfSuccess = VARIANT_FALSE;
691 return S_OK;
692 }
693 if(FAILED(hres))
694 return hres;
695
696 if(id == DISPID_IHTMLELEMENT_STYLE) {
697 IHTMLStyle *style;
698
699 TRACE("Special case: style\n");
700
701 hres = IHTMLElement_get_style(&This->IHTMLElement_iface, &style);
702 if(FAILED(hres))
703 return hres;
704
705 hres = IHTMLStyle_put_cssText(style, NULL);
706 IHTMLStyle_Release(style);
707 if(FAILED(hres))
708 return hres;
709
710 *pfSuccess = VARIANT_TRUE;
711 return S_OK;
712 }
713
714 return remove_attribute(&This->node.event_target.dispex, id, pfSuccess);
715}
716
717static HRESULT WINAPI HTMLElement_put_className(IHTMLElement *iface, BSTR v)
718{
720 nsAString classname_str;
721 nsresult nsres;
722
723 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
724
725 if(!This->nselem) {
726 FIXME("NULL nselem\n");
727 return E_NOTIMPL;
728 }
729
730 nsAString_InitDepend(&classname_str, v);
731 nsres = nsIDOMHTMLElement_SetClassName(This->nselem, &classname_str);
732 nsAString_Finish(&classname_str);
733 if(NS_FAILED(nsres))
734 ERR("SetClassName failed: %08x\n", nsres);
735
736 return S_OK;
737}
738
739static HRESULT WINAPI HTMLElement_get_className(IHTMLElement *iface, BSTR *p)
740{
742 nsAString class_str;
743 nsresult nsres;
744
745 TRACE("(%p)->(%p)\n", This, p);
746
747 if(!This->nselem) {
748 FIXME("NULL nselem\n");
749 return E_NOTIMPL;
750 }
751
752 nsAString_Init(&class_str, NULL);
753 nsres = nsIDOMHTMLElement_GetClassName(This->nselem, &class_str);
754 return return_nsstr(nsres, &class_str, p);
755}
756
757static HRESULT WINAPI HTMLElement_put_id(IHTMLElement *iface, BSTR v)
758{
760 nsAString id_str;
761 nsresult nsres;
762
763 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
764
765 if(!This->nselem) {
766 FIXME("nselem == NULL\n");
767 return S_OK;
768 }
769
770 nsAString_InitDepend(&id_str, v);
771 nsres = nsIDOMHTMLElement_SetId(This->nselem, &id_str);
772 nsAString_Finish(&id_str);
773 if(NS_FAILED(nsres))
774 ERR("SetId failed: %08x\n", nsres);
775
776 return S_OK;
777}
778
779static HRESULT WINAPI HTMLElement_get_id(IHTMLElement *iface, BSTR *p)
780{
782 nsAString id_str;
783 nsresult nsres;
784
785 TRACE("(%p)->(%p)\n", This, p);
786
787 if(!This->nselem) {
788 *p = NULL;
789 return S_OK;
790 }
791
792 nsAString_Init(&id_str, NULL);
793 nsres = nsIDOMHTMLElement_GetId(This->nselem, &id_str);
794 return return_nsstr(nsres, &id_str, p);
795}
796
797static HRESULT WINAPI HTMLElement_get_tagName(IHTMLElement *iface, BSTR *p)
798{
800 nsAString tag_str;
801 nsresult nsres;
802
803 TRACE("(%p)->(%p)\n", This, p);
804
805 if(!This->nselem) {
806 static const WCHAR comment_tagW[] = {'!',0};
807
808 WARN("NULL nselem, assuming comment\n");
809
810 *p = SysAllocString(comment_tagW);
811 return *p ? S_OK : E_OUTOFMEMORY;
812 }
813
814 nsAString_Init(&tag_str, NULL);
815 nsres = nsIDOMHTMLElement_GetTagName(This->nselem, &tag_str);
816 return return_nsstr(nsres, &tag_str, p);
817}
818
819static HRESULT WINAPI HTMLElement_get_parentElement(IHTMLElement *iface, IHTMLElement **p)
820{
822 IHTMLDOMNode *node;
824
825 TRACE("(%p)->(%p)\n", This, p);
826
827 hres = IHTMLDOMNode_get_parentNode(&This->node.IHTMLDOMNode_iface, &node);
828 if(FAILED(hres))
829 return hres;
830
831 hres = IHTMLDOMNode_QueryInterface(node, &IID_IHTMLElement, (void**)p);
832 IHTMLDOMNode_Release(node);
833 if(FAILED(hres))
834 *p = NULL;
835
836 return S_OK;
837}
838
839static HRESULT WINAPI HTMLElement_get_style(IHTMLElement *iface, IHTMLStyle **p)
840{
842
843 TRACE("(%p)->(%p)\n", This, p);
844
845 if(!This->style) {
847
848 hres = HTMLStyle_Create(This, &This->style);
849 if(FAILED(hres))
850 return hres;
851 }
852
853 *p = &This->style->IHTMLStyle_iface;
854 IHTMLStyle_AddRef(*p);
855 return S_OK;
856}
857
858static HRESULT WINAPI HTMLElement_put_onhelp(IHTMLElement *iface, VARIANT v)
859{
861 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
862 return E_NOTIMPL;
863}
864
865static HRESULT WINAPI HTMLElement_get_onhelp(IHTMLElement *iface, VARIANT *p)
866{
868 FIXME("(%p)->(%p)\n", This, p);
869 return E_NOTIMPL;
870}
871
872static HRESULT WINAPI HTMLElement_put_onclick(IHTMLElement *iface, VARIANT v)
873{
875
876 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
877
878 return set_node_event(&This->node, EVENTID_CLICK, &v);
879}
880
881static HRESULT WINAPI HTMLElement_get_onclick(IHTMLElement *iface, VARIANT *p)
882{
884
885 TRACE("(%p)->(%p)\n", This, p);
886
887 return get_node_event(&This->node, EVENTID_CLICK, p);
888}
889
891{
893
894 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
895
896 return set_node_event(&This->node, EVENTID_DBLCLICK, &v);
897}
898
899static HRESULT WINAPI HTMLElement_get_ondblclick(IHTMLElement *iface, VARIANT *p)
900{
902
903 TRACE("(%p)->(%p)\n", This, p);
904
905 return get_node_event(&This->node, EVENTID_DBLCLICK, p);
906}
907
909{
911
912 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
913
914 return set_node_event(&This->node, EVENTID_KEYDOWN, &v);
915}
916
917static HRESULT WINAPI HTMLElement_get_onkeydown(IHTMLElement *iface, VARIANT *p)
918{
920
921 TRACE("(%p)->(%p)\n", This, p);
922
923 return get_node_event(&This->node, EVENTID_KEYDOWN, p);
924}
925
926static HRESULT WINAPI HTMLElement_put_onkeyup(IHTMLElement *iface, VARIANT v)
927{
929
930 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
931
932 return set_node_event(&This->node, EVENTID_KEYUP, &v);
933}
934
935static HRESULT WINAPI HTMLElement_get_onkeyup(IHTMLElement *iface, VARIANT *p)
936{
938 FIXME("(%p)->(%p)\n", This, p);
939 return E_NOTIMPL;
940}
941
943{
945
946 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
947
948 return set_node_event(&This->node, EVENTID_KEYPRESS, &v);
949}
950
951static HRESULT WINAPI HTMLElement_get_onkeypress(IHTMLElement *iface, VARIANT *p)
952{
954
955 TRACE("(%p)->(%p)\n", This, p);
956
957 return get_node_event(&This->node, EVENTID_KEYPRESS, p);
958}
959
961{
963
964 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
965
966 return set_node_event(&This->node, EVENTID_MOUSEOUT, &v);
967}
968
969static HRESULT WINAPI HTMLElement_get_onmouseout(IHTMLElement *iface, VARIANT *p)
970{
972
973 TRACE("(%p)->(%p)\n", This, p);
974
975 return get_node_event(&This->node, EVENTID_MOUSEOUT, p);
976}
977
979{
981
982 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
983
984 return set_node_event(&This->node, EVENTID_MOUSEOVER, &v);
985}
986
988{
990
991 TRACE("(%p)->(%p)\n", This, p);
992
993 return get_node_event(&This->node, EVENTID_MOUSEOVER, p);
994}
995
997{
999
1000 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1001
1002 return set_node_event(&This->node, EVENTID_MOUSEMOVE, &v);
1003}
1004
1006{
1008
1009 TRACE("(%p)->(%p)\n", This, p);
1010
1011 return get_node_event(&This->node, EVENTID_MOUSEMOVE, p);
1012}
1013
1015{
1017
1018 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1019
1020 return set_node_event(&This->node, EVENTID_MOUSEDOWN, &v);
1021}
1022
1024{
1026
1027 TRACE("(%p)->(%p)\n", This, p);
1028
1029 return get_node_event(&This->node, EVENTID_MOUSEDOWN, p);
1030}
1031
1033{
1035
1036 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1037
1038 return set_node_event(&This->node, EVENTID_MOUSEUP, &v);
1039}
1040
1041static HRESULT WINAPI HTMLElement_get_onmouseup(IHTMLElement *iface, VARIANT *p)
1042{
1044
1045 TRACE("(%p)->(%p)\n", This, p);
1046
1047 return get_node_event(&This->node, EVENTID_MOUSEUP, p);
1048}
1049
1050static HRESULT WINAPI HTMLElement_get_document(IHTMLElement *iface, IDispatch **p)
1051{
1053
1054 TRACE("(%p)->(%p)\n", This, p);
1055
1056 if(!p)
1057 return E_POINTER;
1058
1059 if(This->node.vtbl->get_document)
1060 return This->node.vtbl->get_document(&This->node, p);
1061
1062 *p = (IDispatch*)&This->node.doc->basedoc.IHTMLDocument2_iface;
1063 IDispatch_AddRef(*p);
1064 return S_OK;
1065}
1066
1067static const WCHAR titleW[] = {'t','i','t','l','e',0};
1068
1069static HRESULT WINAPI HTMLElement_put_title(IHTMLElement *iface, BSTR v)
1070{
1072 nsAString title_str;
1073 nsresult nsres;
1074
1075 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1076
1077 if(!This->nselem) {
1078 VARIANT *var;
1079 HRESULT hres;
1080
1081 hres = dispex_get_dprop_ref(&This->node.event_target.dispex, titleW, TRUE, &var);
1082 if(FAILED(hres))
1083 return hres;
1084
1086 V_VT(var) = VT_BSTR;
1087 V_BSTR(var) = v ? SysAllocString(v) : NULL;
1088 return S_OK;
1089 }
1090
1091 nsAString_InitDepend(&title_str, v);
1092 nsres = nsIDOMHTMLElement_SetTitle(This->nselem, &title_str);
1093 nsAString_Finish(&title_str);
1094 if(NS_FAILED(nsres))
1095 ERR("SetTitle failed: %08x\n", nsres);
1096
1097 return S_OK;
1098}
1099
1100static HRESULT WINAPI HTMLElement_get_title(IHTMLElement *iface, BSTR *p)
1101{
1103 nsAString title_str;
1104 nsresult nsres;
1105
1106 TRACE("(%p)->(%p)\n", This, p);
1107
1108 if(!This->nselem) {
1109 VARIANT *var;
1110 HRESULT hres;
1111
1112 hres = dispex_get_dprop_ref(&This->node.event_target.dispex, titleW, FALSE, &var);
1113 if(hres == DISP_E_UNKNOWNNAME) {
1114 *p = NULL;
1115 }else if(V_VT(var) != VT_BSTR) {
1116 FIXME("title = %s\n", debugstr_variant(var));
1117 return E_FAIL;
1118 }else {
1120 }
1121
1122 return S_OK;
1123 }
1124
1125 nsAString_Init(&title_str, NULL);
1126 nsres = nsIDOMHTMLElement_GetTitle(This->nselem, &title_str);
1127 return return_nsstr(nsres, &title_str, p);
1128}
1129
1130static const WCHAR languageW[] = {'l','a','n','g','u','a','g','e',0};
1131
1132static HRESULT WINAPI HTMLElement_put_language(IHTMLElement *iface, BSTR v)
1133{
1135
1136 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1137
1139}
1140
1141static HRESULT WINAPI HTMLElement_get_language(IHTMLElement *iface, BSTR *p)
1142{
1144
1145 TRACE("(%p)->(%p)\n", This, p);
1146
1148}
1149
1151{
1153
1154 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1155
1156 return set_node_event(&This->node, EVENTID_SELECTSTART, &v);
1157}
1158
1160{
1162
1163 TRACE("(%p)->(%p)\n", This, p);
1164
1165 return get_node_event(&This->node, EVENTID_SELECTSTART, p);
1166}
1167
1168static HRESULT WINAPI HTMLElement_scrollIntoView(IHTMLElement *iface, VARIANT varargStart)
1169{
1172 nsresult nsres;
1173
1174 TRACE("(%p)->(%s)\n", This, debugstr_variant(&varargStart));
1175
1176 switch(V_VT(&varargStart)) {
1177 case VT_EMPTY:
1178 case VT_ERROR:
1179 break;
1180 case VT_BOOL:
1181 start = V_BOOL(&varargStart) != VARIANT_FALSE;
1182 break;
1183 default:
1184 FIXME("Unsupported argument %s\n", debugstr_variant(&varargStart));
1185 }
1186
1187 if(!This->nselem) {
1188 FIXME("Unsupported for comments\n");
1189 return E_NOTIMPL;
1190 }
1191
1192 nsres = nsIDOMHTMLElement_ScrollIntoView(This->nselem, start, 1);
1193 assert(nsres == NS_OK);
1194
1195 return S_OK;
1196}
1197
1198static HRESULT WINAPI HTMLElement_contains(IHTMLElement *iface, IHTMLElement *pChild,
1199 VARIANT_BOOL *pfResult)
1200{
1203
1204 TRACE("(%p)->(%p %p)\n", This, pChild, pfResult);
1205
1206 if(pChild) {
1208 nsresult nsres;
1209
1211 if(!child) {
1212 ERR("not our element\n");
1213 return E_FAIL;
1214 }
1215
1216 nsres = nsIDOMNode_Contains(This->node.nsnode, child->node.nsnode, &result);
1217 assert(nsres == NS_OK);
1218 }
1219
1220 *pfResult = result ? VARIANT_TRUE : VARIANT_FALSE;
1221 return S_OK;
1222}
1223
1224static HRESULT WINAPI HTMLElement_get_sourceIndex(IHTMLElement *iface, LONG *p)
1225{
1227
1228 TRACE("(%p)->(%p)\n", This, p);
1229
1230 return get_elem_source_index(This, p);
1231}
1232
1234{
1236 FIXME("(%p)->(%p)\n", This, p);
1237 return E_NOTIMPL;
1238}
1239
1240static HRESULT WINAPI HTMLElement_put_lang(IHTMLElement *iface, BSTR v)
1241{
1243 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1244 return E_NOTIMPL;
1245}
1246
1247static HRESULT WINAPI HTMLElement_get_lang(IHTMLElement *iface, BSTR *p)
1248{
1250 FIXME("(%p)->(%p)\n", This, p);
1251 return E_NOTIMPL;
1252}
1253
1254static HRESULT WINAPI HTMLElement_get_offsetLeft(IHTMLElement *iface, LONG *p)
1255{
1257 nsresult nsres;
1258
1259 TRACE("(%p)->(%p)\n", This, p);
1260
1261 nsres = nsIDOMHTMLElement_GetOffsetLeft(This->nselem, p);
1262 if(NS_FAILED(nsres)) {
1263 ERR("GetOffsetLeft failed: %08x\n", nsres);
1264 return E_FAIL;
1265 }
1266
1267 return S_OK;
1268}
1269
1270static HRESULT WINAPI HTMLElement_get_offsetTop(IHTMLElement *iface, LONG *p)
1271{
1273 nsresult nsres;
1274
1275 TRACE("(%p)->(%p)\n", This, p);
1276
1277 nsres = nsIDOMHTMLElement_GetOffsetTop(This->nselem, p);
1278 if(NS_FAILED(nsres)) {
1279 ERR("GetOffsetTop failed: %08x\n", nsres);
1280 return E_FAIL;
1281 }
1282
1283 return S_OK;
1284}
1285
1286static HRESULT WINAPI HTMLElement_get_offsetWidth(IHTMLElement *iface, LONG *p)
1287{
1289 nsresult nsres;
1290
1291 TRACE("(%p)->(%p)\n", This, p);
1292
1293 nsres = nsIDOMHTMLElement_GetOffsetWidth(This->nselem, p);
1294 if(NS_FAILED(nsres)) {
1295 ERR("GetOffsetWidth failed: %08x\n", nsres);
1296 return E_FAIL;
1297 }
1298
1299 return S_OK;
1300}
1301
1302static HRESULT WINAPI HTMLElement_get_offsetHeight(IHTMLElement *iface, LONG *p)
1303{
1305 nsresult nsres;
1306
1307 TRACE("(%p)->(%p)\n", This, p);
1308
1309 nsres = nsIDOMHTMLElement_GetOffsetHeight(This->nselem, p);
1310 if(NS_FAILED(nsres)) {
1311 ERR("GetOffsetHeight failed: %08x\n", nsres);
1312 return E_FAIL;
1313 }
1314
1315 return S_OK;
1316}
1317
1318static HRESULT WINAPI HTMLElement_get_offsetParent(IHTMLElement *iface, IHTMLElement **p)
1319{
1321 nsIDOMElement *nsparent;
1322 nsresult nsres;
1323 HRESULT hres;
1324
1325 TRACE("(%p)->(%p)\n", This, p);
1326
1327 nsres = nsIDOMHTMLElement_GetOffsetParent(This->nselem, &nsparent);
1328 if(NS_FAILED(nsres)) {
1329 ERR("GetOffsetParent failed: %08x\n", nsres);
1330 return E_FAIL;
1331 }
1332
1333 if(nsparent) {
1335
1336 hres = get_node(This->node.doc, (nsIDOMNode*)nsparent, TRUE, &node);
1337 nsIDOMElement_Release(nsparent);
1338 if(FAILED(hres))
1339 return hres;
1340
1341 hres = IHTMLDOMNode_QueryInterface(&node->IHTMLDOMNode_iface, &IID_IHTMLElement, (void**)p);
1343 }else {
1344 *p = NULL;
1345 hres = S_OK;
1346 }
1347
1348 return hres;
1349}
1350
1351static HRESULT WINAPI HTMLElement_put_innerHTML(IHTMLElement *iface, BSTR v)
1352{
1355 nsresult nsres;
1356
1357 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1358
1359 if(!This->nselem) {
1360 FIXME("NULL nselem\n");
1361 return E_NOTIMPL;
1362 }
1363
1365 nsres = nsIDOMHTMLElement_SetInnerHTML(This->nselem, &html_str);
1367 if(NS_FAILED(nsres)) {
1368 FIXME("SetInnerHtml failed %08x\n", nsres);
1369 return E_FAIL;
1370 }
1371
1372 return S_OK;
1373}
1374
1375static HRESULT WINAPI HTMLElement_get_innerHTML(IHTMLElement *iface, BSTR *p)
1376{
1379 nsresult nsres;
1380
1381 TRACE("(%p)->(%p)\n", This, p);
1382
1383 if(!This->nselem) {
1384 FIXME("NULL nselem\n");
1385 return E_NOTIMPL;
1386 }
1387
1389 nsres = nsIDOMHTMLElement_GetInnerHTML(This->nselem, &html_str);
1390 return return_nsstr(nsres, &html_str, p);
1391}
1392
1393static HRESULT WINAPI HTMLElement_put_innerText(IHTMLElement *iface, BSTR v)
1394{
1396 nsIDOMNode *nschild, *tmp;
1397 nsIDOMText *text_node;
1398 nsAString text_str;
1399 nsresult nsres;
1400
1401 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1402
1403 while(1) {
1404 nsres = nsIDOMHTMLElement_GetLastChild(This->nselem, &nschild);
1405 if(NS_FAILED(nsres)) {
1406 ERR("GetLastChild failed: %08x\n", nsres);
1407 return E_FAIL;
1408 }
1409 if(!nschild)
1410 break;
1411
1412 nsres = nsIDOMHTMLElement_RemoveChild(This->nselem, nschild, &tmp);
1413 nsIDOMNode_Release(nschild);
1414 if(NS_FAILED(nsres)) {
1415 ERR("RemoveChild failed: %08x\n", nsres);
1416 return E_FAIL;
1417 }
1418 nsIDOMNode_Release(tmp);
1419 }
1420
1421 nsAString_InitDepend(&text_str, v);
1422 nsres = nsIDOMHTMLDocument_CreateTextNode(This->node.doc->nsdoc, &text_str, &text_node);
1423 nsAString_Finish(&text_str);
1424 if(NS_FAILED(nsres)) {
1425 ERR("CreateTextNode failed: %08x\n", nsres);
1426 return E_FAIL;
1427 }
1428
1429 nsres = nsIDOMHTMLElement_AppendChild(This->nselem, (nsIDOMNode*)text_node, &tmp);
1430 if(NS_FAILED(nsres)) {
1431 ERR("AppendChild failed: %08x\n", nsres);
1432 return E_FAIL;
1433 }
1434
1435 nsIDOMNode_Release(tmp);
1436 return S_OK;
1437}
1438
1439static HRESULT WINAPI HTMLElement_get_innerText(IHTMLElement *iface, BSTR *p)
1440{
1442
1443 TRACE("(%p)->(%p)\n", This, p);
1444
1445 return get_node_text(&This->node, p);
1446}
1447
1448static HRESULT WINAPI HTMLElement_put_outerHTML(IHTMLElement *iface, BSTR v)
1449{
1451
1452 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
1453
1454 return replace_node_by_html(This->node.doc->nsdoc, This->node.nsnode, v);
1455}
1456
1457static HRESULT WINAPI HTMLElement_get_outerHTML(IHTMLElement *iface, BSTR *p)
1458{
1461 HRESULT hres;
1462
1463 WARN("(%p)->(%p) semi-stub\n", This, p);
1464
1466 hres = nsnode_to_nsstring(This->node.nsnode, &html_str);
1467 if(SUCCEEDED(hres)) {
1468 const PRUnichar *html;
1469
1470 nsAString_GetData(&html_str, &html);
1471 *p = SysAllocString(html);
1472 if(!*p)
1474 }
1475
1477
1478 TRACE("ret %s\n", debugstr_w(*p));
1479 return hres;
1480}
1481
1482static HRESULT WINAPI HTMLElement_put_outerText(IHTMLElement *iface, BSTR v)
1483{
1485 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
1486 return E_NOTIMPL;
1487}
1488
1489static HRESULT WINAPI HTMLElement_get_outerText(IHTMLElement *iface, BSTR *p)
1490{
1492 FIXME("(%p)->(%p)\n", This, p);
1493 return E_NOTIMPL;
1494}
1495
1496static HRESULT insert_adjacent_node(HTMLElement *This, const WCHAR *where, nsIDOMNode *nsnode, HTMLDOMNode **ret_node)
1497{
1498 nsIDOMNode *ret_nsnode;
1499 nsresult nsres;
1500 HRESULT hres = S_OK;
1501
1502 static const WCHAR beforebeginW[] = {'b','e','f','o','r','e','b','e','g','i','n',0};
1503 static const WCHAR afterbeginW[] = {'a','f','t','e','r','b','e','g','i','n',0};
1504 static const WCHAR beforeendW[] = {'b','e','f','o','r','e','e','n','d',0};
1505 static const WCHAR afterendW[] = {'a','f','t','e','r','e','n','d',0};
1506
1507 if (!strcmpiW(where, beforebeginW)) {
1509
1510 nsres = nsIDOMNode_GetParentNode(This->node.nsnode, &parent);
1511 if(NS_FAILED(nsres))
1512 return E_FAIL;
1513
1514 if(!parent)
1515 return E_INVALIDARG;
1516
1517 nsres = nsIDOMNode_InsertBefore(parent, nsnode, This->node.nsnode, &ret_nsnode);
1518 nsIDOMNode_Release(parent);
1519 }else if(!strcmpiW(where, afterbeginW)) {
1520 nsIDOMNode *first_child;
1521
1522 nsres = nsIDOMNode_GetFirstChild(This->node.nsnode, &first_child);
1523 if(NS_FAILED(nsres))
1524 return E_FAIL;
1525
1526 nsres = nsIDOMNode_InsertBefore(This->node.nsnode, nsnode, first_child, &ret_nsnode);
1527 if(NS_FAILED(nsres))
1528 return E_FAIL;
1529
1530 if (first_child)
1531 nsIDOMNode_Release(first_child);
1532 }else if (!strcmpiW(where, beforeendW)) {
1533 nsres = nsIDOMNode_AppendChild(This->node.nsnode, nsnode, &ret_nsnode);
1534 }else if (!strcmpiW(where, afterendW)) {
1535 nsIDOMNode *next_sibling, *parent;
1536
1537 nsres = nsIDOMNode_GetParentNode(This->node.nsnode, &parent);
1538 if(NS_FAILED(nsres))
1539 return E_FAIL;
1540 if(!parent)
1541 return E_INVALIDARG;
1542
1543 nsres = nsIDOMNode_GetNextSibling(This->node.nsnode, &next_sibling);
1544 if(NS_SUCCEEDED(nsres)) {
1545 if(next_sibling) {
1546 nsres = nsIDOMNode_InsertBefore(parent, nsnode, next_sibling, &ret_nsnode);
1547 nsIDOMNode_Release(next_sibling);
1548 }else {
1549 nsres = nsIDOMNode_AppendChild(parent, nsnode, &ret_nsnode);
1550 }
1551 }
1552
1553 nsIDOMNode_Release(parent);
1554 }else {
1555 ERR("invalid where: %s\n", debugstr_w(where));
1556 return E_INVALIDARG;
1557 }
1558
1559 if (NS_FAILED(nsres))
1560 return E_FAIL;
1561
1562 if(ret_node)
1563 hres = get_node(This->node.doc, ret_nsnode, TRUE, ret_node);
1564 nsIDOMNode_Release(ret_nsnode);
1565 return hres;
1566}
1567
1568static HRESULT WINAPI HTMLElement_insertAdjacentHTML(IHTMLElement *iface, BSTR where,
1569 BSTR html)
1570{
1573 nsIDOMNode *nsnode;
1574 nsAString ns_html;
1575 nsresult nsres;
1576 HRESULT hr;
1577
1578 TRACE("(%p)->(%s %s)\n", This, debugstr_w(where), debugstr_w(html));
1579
1580 if(!This->node.doc->nsdoc) {
1581 WARN("NULL nsdoc\n");
1582 return E_UNEXPECTED;
1583 }
1584
1585 nsres = nsIDOMHTMLDocument_CreateRange(This->node.doc->nsdoc, &range);
1586 if(NS_FAILED(nsres))
1587 {
1588 ERR("CreateRange failed: %08x\n", nsres);
1589 return E_FAIL;
1590 }
1591
1592 nsIDOMRange_SetStartBefore(range, This->node.nsnode);
1593
1594 nsAString_InitDepend(&ns_html, html);
1595 nsres = nsIDOMRange_CreateContextualFragment(range, &ns_html, (nsIDOMDocumentFragment **)&nsnode);
1596 nsAString_Finish(&ns_html);
1597 nsIDOMRange_Release(range);
1598
1599 if(NS_FAILED(nsres) || !nsnode)
1600 {
1601 ERR("CreateTextNode failed: %08x\n", nsres);
1602 return E_FAIL;
1603 }
1604
1605 hr = insert_adjacent_node(This, where, nsnode, NULL);
1606 nsIDOMNode_Release(nsnode);
1607 return hr;
1608}
1609
1610static HRESULT WINAPI HTMLElement_insertAdjacentText(IHTMLElement *iface, BSTR where,
1611 BSTR text)
1612{
1614 nsIDOMNode *nsnode;
1615 nsAString ns_text;
1616 nsresult nsres;
1617 HRESULT hr;
1618
1619 TRACE("(%p)->(%s %s)\n", This, debugstr_w(where), debugstr_w(text));
1620
1621 if(!This->node.doc->nsdoc) {
1622 WARN("NULL nsdoc\n");
1623 return E_UNEXPECTED;
1624 }
1625
1626
1627 nsAString_InitDepend(&ns_text, text);
1628 nsres = nsIDOMHTMLDocument_CreateTextNode(This->node.doc->nsdoc, &ns_text, (nsIDOMText **)&nsnode);
1629 nsAString_Finish(&ns_text);
1630
1631 if(NS_FAILED(nsres) || !nsnode)
1632 {
1633 ERR("CreateTextNode failed: %08x\n", nsres);
1634 return E_FAIL;
1635 }
1636
1637 hr = insert_adjacent_node(This, where, nsnode, NULL);
1638 nsIDOMNode_Release(nsnode);
1639
1640 return hr;
1641}
1642
1643static HRESULT WINAPI HTMLElement_get_parentTextEdit(IHTMLElement *iface, IHTMLElement **p)
1644{
1646 FIXME("(%p)->(%p)\n", This, p);
1647 return E_NOTIMPL;
1648}
1649
1651{
1653
1654 TRACE("(%p)->(%p)\n", This, p);
1655
1656 *p = This->node.vtbl->is_text_edit && This->node.vtbl->is_text_edit(&This->node)
1657 ? VARIANT_TRUE : VARIANT_FALSE;
1658 return S_OK;
1659}
1660
1661static HRESULT WINAPI HTMLElement_click(IHTMLElement *iface)
1662{
1664
1665 TRACE("(%p)\n", This);
1666
1667 return call_fire_event(&This->node, EVENTID_CLICK);
1668}
1669
1670static HRESULT WINAPI HTMLElement_get_filters(IHTMLElement *iface,
1671 IHTMLFiltersCollection **p)
1672{
1674 TRACE("(%p)->(%p)\n", This, p);
1675
1676 if(!p)
1677 return E_POINTER;
1678
1680
1681 return S_OK;
1682}
1683
1685{
1687 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1688 return E_NOTIMPL;
1689}
1690
1692{
1694 FIXME("(%p)->(%p)\n", This, p);
1695 return E_NOTIMPL;
1696}
1697
1698static HRESULT WINAPI HTMLElement_toString(IHTMLElement *iface, BSTR *String)
1699{
1701 FIXME("(%p)->(%p)\n", This, String);
1702 return E_NOTIMPL;
1703}
1704
1706{
1708 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1709 return E_NOTIMPL;
1710}
1711
1713{
1715 FIXME("(%p)->(%p)\n", This, p);
1716 return E_NOTIMPL;
1717}
1718
1720{
1722 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1723 return E_NOTIMPL;
1724}
1725
1727{
1729 FIXME("(%p)->(%p)\n", This, p);
1730 return E_NOTIMPL;
1731}
1732
1734{
1736 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1737 return E_NOTIMPL;
1738}
1739
1741{
1743 FIXME("(%p)->(%p)\n", This, p);
1744 return E_NOTIMPL;
1745}
1746
1748{
1750 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1751 return E_NOTIMPL;
1752}
1753
1754static HRESULT WINAPI HTMLElement_get_onrowexit(IHTMLElement *iface, VARIANT *p)
1755{
1757 FIXME("(%p)->(%p)\n", This, p);
1758 return E_NOTIMPL;
1759}
1760
1762{
1764 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1765 return E_NOTIMPL;
1766}
1767
1769{
1771 FIXME("(%p)->(%p)\n", This, p);
1772 return E_NOTIMPL;
1773}
1774
1776{
1778 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1779 return E_NOTIMPL;
1780}
1781
1783{
1785 FIXME("(%p)->(%p)\n", This, p);
1786 return E_NOTIMPL;
1787}
1788
1790{
1792
1793 FIXME("(%p)->(%s) semi-stub\n", This, debugstr_variant(&v));
1794
1795 return set_node_event(&This->node, EVENTID_DATAAVAILABLE, &v);
1796}
1797
1799{
1801
1802 TRACE("(%p)->(%p)\n", This, p);
1803
1804 return get_node_event(&This->node, EVENTID_DATAAVAILABLE, p);
1805}
1806
1808{
1810 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1811 return E_NOTIMPL;
1812}
1813
1815{
1817 FIXME("(%p)->(%p)\n", This, p);
1818 return E_NOTIMPL;
1819}
1820
1822{
1824 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
1825 return E_NOTIMPL;
1826}
1827
1829{
1831 FIXME("(%p)->(%p)\n", This, p);
1832 return E_NOTIMPL;
1833}
1834
1835static HRESULT WINAPI HTMLElement_get_children(IHTMLElement *iface, IDispatch **p)
1836{
1838 nsIDOMNodeList *nsnode_list;
1839 nsresult nsres;
1840
1841 TRACE("(%p)->(%p)\n", This, p);
1842
1843 nsres = nsIDOMNode_GetChildNodes(This->node.nsnode, &nsnode_list);
1844 if(NS_FAILED(nsres)) {
1845 ERR("GetChildNodes failed: %08x\n", nsres);
1846 return E_FAIL;
1847 }
1848
1849 *p = (IDispatch*)create_collection_from_nodelist(This->node.doc, nsnode_list);
1850
1851 nsIDOMNodeList_Release(nsnode_list);
1852 return S_OK;
1853}
1854
1855static HRESULT WINAPI HTMLElement_get_all(IHTMLElement *iface, IDispatch **p)
1856{
1858
1859 TRACE("(%p)->(%p)\n", This, p);
1860
1862 return S_OK;
1863}
1864
1865static const IHTMLElementVtbl HTMLElementVtbl = {
1960};
1961
1963{
1964 return iface->lpVtbl == &HTMLElementVtbl ? impl_from_IHTMLElement(iface) : NULL;
1965}
1966
1967static inline HTMLElement *impl_from_IHTMLElement2(IHTMLElement2 *iface)
1968{
1969 return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement2_iface);
1970}
1971
1972static HRESULT WINAPI HTMLElement2_QueryInterface(IHTMLElement2 *iface,
1973 REFIID riid, void **ppv)
1974{
1976 return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
1977}
1978
1979static ULONG WINAPI HTMLElement2_AddRef(IHTMLElement2 *iface)
1980{
1982 return IHTMLElement_AddRef(&This->IHTMLElement_iface);
1983}
1984
1985static ULONG WINAPI HTMLElement2_Release(IHTMLElement2 *iface)
1986{
1988 return IHTMLElement_Release(&This->IHTMLElement_iface);
1989}
1990
1991static HRESULT WINAPI HTMLElement2_GetTypeInfoCount(IHTMLElement2 *iface, UINT *pctinfo)
1992{
1994 return IDispatchEx_GetTypeInfoCount(&This->node.event_target.dispex.IDispatchEx_iface, pctinfo);
1995}
1996
1997static HRESULT WINAPI HTMLElement2_GetTypeInfo(IHTMLElement2 *iface, UINT iTInfo,
1998 LCID lcid, ITypeInfo **ppTInfo)
1999{
2001 return IDispatchEx_GetTypeInfo(&This->node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2002}
2003
2005 LPOLESTR *rgszNames, UINT cNames,
2006 LCID lcid, DISPID *rgDispId)
2007{
2009 return IDispatchEx_GetIDsOfNames(&This->node.event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2010 lcid, rgDispId);
2011}
2012
2013static HRESULT WINAPI HTMLElement2_Invoke(IHTMLElement2 *iface, DISPID dispIdMember,
2014 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2015 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2016{
2018 return IDispatchEx_Invoke(&This->node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
2019 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
2020}
2021
2022static HRESULT WINAPI HTMLElement2_get_scopeName(IHTMLElement2 *iface, BSTR *p)
2023{
2025 FIXME("(%p)->(%p)\n", This, p);
2026 return E_NOTIMPL;
2027}
2028
2029static HRESULT WINAPI HTMLElement2_setCapture(IHTMLElement2 *iface, VARIANT_BOOL containerCapture)
2030{
2032 FIXME("(%p)->(%x)\n", This, containerCapture);
2033 return E_NOTIMPL;
2034}
2035
2036static HRESULT WINAPI HTMLElement2_releaseCapture(IHTMLElement2 *iface)
2037{
2039 FIXME("(%p)\n", This);
2040 return E_NOTIMPL;
2041}
2042
2044{
2046 FIXME("(%p)->()\n", This);
2047 return E_NOTIMPL;
2048}
2049
2051{
2053 FIXME("(%p)->(%p)\n", This, p);
2054 return E_NOTIMPL;
2055}
2056
2058 LONG x, LONG y, BSTR *component)
2059{
2061 FIXME("(%p)->(%d %d %p)\n", This, x, y, component);
2062 return E_NOTIMPL;
2063}
2064
2065static HRESULT WINAPI HTMLElement2_doScroll(IHTMLElement2 *iface, VARIANT component)
2066{
2068
2069 TRACE("(%p)->(%s)\n", This, debugstr_variant(&component));
2070
2071 if(!This->node.doc->content_ready
2072 || !This->node.doc->basedoc.doc_obj->in_place_active)
2073 return E_PENDING;
2074
2075 WARN("stub\n");
2076 return S_OK;
2077}
2078
2079static HRESULT WINAPI HTMLElement2_put_onscroll(IHTMLElement2 *iface, VARIANT v)
2080{
2082 FIXME("(%p)->()\n", This);
2083 return E_NOTIMPL;
2084}
2085
2086static HRESULT WINAPI HTMLElement2_get_onscroll(IHTMLElement2 *iface, VARIANT *p)
2087{
2089 FIXME("(%p)->(%p)\n", This, p);
2090 return E_NOTIMPL;
2091}
2092
2093static HRESULT WINAPI HTMLElement2_put_ondrag(IHTMLElement2 *iface, VARIANT v)
2094{
2096
2097 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2098
2099 return set_node_event(&This->node, EVENTID_DRAG, &v);
2100}
2101
2102static HRESULT WINAPI HTMLElement2_get_ondrag(IHTMLElement2 *iface, VARIANT *p)
2103{
2105
2106 TRACE("(%p)->(%p)\n", This, p);
2107
2108 return get_node_event(&This->node, EVENTID_DRAG, p);
2109}
2110
2112{
2114 FIXME("(%p)->()\n", This);
2115 return E_NOTIMPL;
2116}
2117
2118static HRESULT WINAPI HTMLElement2_get_ondragend(IHTMLElement2 *iface, VARIANT *p)
2119{
2121 FIXME("(%p)->(%p)\n", This, p);
2122 return E_NOTIMPL;
2123}
2124
2126{
2128 FIXME("(%p)->()\n", This);
2129 return E_NOTIMPL;
2130}
2131
2133{
2135 FIXME("(%p)->(%p)\n", This, p);
2136 return E_NOTIMPL;
2137}
2138
2140{
2142 FIXME("(%p)->()\n", This);
2143 return E_NOTIMPL;
2144}
2145
2147{
2149 FIXME("(%p)->(%p)\n", This, p);
2150 return E_NOTIMPL;
2151}
2152
2154{
2156 FIXME("(%p)->()\n", This);
2157 return E_NOTIMPL;
2158}
2159
2161{
2163 FIXME("(%p)->(%p)\n", This, p);
2164 return E_NOTIMPL;
2165}
2166
2167static HRESULT WINAPI HTMLElement2_put_ondrop(IHTMLElement2 *iface, VARIANT v)
2168{
2170 FIXME("(%p)->()\n", This);
2171 return E_NOTIMPL;
2172}
2173
2174static HRESULT WINAPI HTMLElement2_get_ondrop(IHTMLElement2 *iface, VARIANT *p)
2175{
2177 FIXME("(%p)->(%p)\n", This, p);
2178 return E_NOTIMPL;
2179}
2180
2182{
2184 FIXME("(%p)->()\n", This);
2185 return E_NOTIMPL;
2186}
2187
2189{
2191 FIXME("(%p)->(%p)\n", This, p);
2192 return E_NOTIMPL;
2193}
2194
2195static HRESULT WINAPI HTMLElement2_put_oncut(IHTMLElement2 *iface, VARIANT v)
2196{
2198 FIXME("(%p)->()\n", This);
2199 return E_NOTIMPL;
2200}
2201
2202static HRESULT WINAPI HTMLElement2_get_oncut(IHTMLElement2 *iface, VARIANT *p)
2203{
2205 FIXME("(%p)->(%p)\n", This, p);
2206 return E_NOTIMPL;
2207}
2208
2210{
2212 FIXME("(%p)->()\n", This);
2213 return E_NOTIMPL;
2214}
2215
2217{
2219 FIXME("(%p)->(%p)\n", This, p);
2220 return E_NOTIMPL;
2221}
2222
2223static HRESULT WINAPI HTMLElement2_put_oncopy(IHTMLElement2 *iface, VARIANT v)
2224{
2226 FIXME("(%p)->()\n", This);
2227 return E_NOTIMPL;
2228}
2229
2230static HRESULT WINAPI HTMLElement2_get_oncopy(IHTMLElement2 *iface, VARIANT *p)
2231{
2233 FIXME("(%p)->(%p)\n", This, p);
2234 return E_NOTIMPL;
2235}
2236
2238{
2240 FIXME("(%p)->()\n", This);
2241 return E_NOTIMPL;
2242}
2243
2245{
2247 FIXME("(%p)->(%p)\n", This, p);
2248 return E_NOTIMPL;
2249}
2250
2251static HRESULT WINAPI HTMLElement2_put_onpaste(IHTMLElement2 *iface, VARIANT v)
2252{
2254
2255 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2256
2257 return set_node_event(&This->node, EVENTID_PASTE, &v);
2258}
2259
2260static HRESULT WINAPI HTMLElement2_get_onpaste(IHTMLElement2 *iface, VARIANT *p)
2261{
2263
2264 TRACE("(%p)->(%p)\n", This, p);
2265
2266 return get_node_event(&This->node, EVENTID_PASTE, p);
2267}
2268
2269static HRESULT WINAPI HTMLElement2_get_currentStyle(IHTMLElement2 *iface, IHTMLCurrentStyle **p)
2270{
2272
2273 TRACE("(%p)->(%p)\n", This, p);
2274
2276}
2277
2279{
2281 FIXME("(%p)->()\n", This);
2282 return E_NOTIMPL;
2283}
2284
2286{
2288 FIXME("(%p)->(%p)\n", This, p);
2289 return E_NOTIMPL;
2290}
2291
2292static HRESULT WINAPI HTMLElement2_getClientRects(IHTMLElement2 *iface, IHTMLRectCollection **pRectCol)
2293{
2295 FIXME("(%p)->(%p)\n", This, pRectCol);
2296 return E_NOTIMPL;
2297}
2298
2299static HRESULT WINAPI HTMLElement2_getBoundingClientRect(IHTMLElement2 *iface, IHTMLRect **pRect)
2300{
2302 nsIDOMClientRect *nsrect;
2303 nsresult nsres;
2304 HRESULT hres;
2305
2306 TRACE("(%p)->(%p)\n", This, pRect);
2307
2308 nsres = nsIDOMHTMLElement_GetBoundingClientRect(This->nselem, &nsrect);
2309 if(NS_FAILED(nsres) || !nsrect) {
2310 ERR("GetBoindingClientRect failed: %08x\n", nsres);
2311 return E_FAIL;
2312 }
2313
2314 hres = create_html_rect(nsrect, pRect);
2315
2316 nsIDOMClientRect_Release(nsrect);
2317 return hres;
2318}
2319
2320static HRESULT WINAPI HTMLElement2_setExpression(IHTMLElement2 *iface, BSTR propname,
2321 BSTR expression, BSTR language)
2322{
2324 FIXME("(%p)->(%s %s %s)\n", This, debugstr_w(propname), debugstr_w(expression),
2325 debugstr_w(language));
2326 return E_NOTIMPL;
2327}
2328
2329static HRESULT WINAPI HTMLElement2_getExpression(IHTMLElement2 *iface, BSTR propname,
2330 VARIANT *expression)
2331{
2333 FIXME("(%p)->(%s %p)\n", This, debugstr_w(propname), expression);
2334 return E_NOTIMPL;
2335}
2336
2337static HRESULT WINAPI HTMLElement2_removeExpression(IHTMLElement2 *iface, BSTR propname,
2338 VARIANT_BOOL *pfSuccess)
2339{
2341 FIXME("(%p)->(%s %p)\n", This, debugstr_w(propname), pfSuccess);
2342 return E_NOTIMPL;
2343}
2344
2345static HRESULT WINAPI HTMLElement2_put_tabIndex(IHTMLElement2 *iface, short v)
2346{
2348 nsresult nsres;
2349
2350 TRACE("(%p)->(%d)\n", This, v);
2351
2352 nsres = nsIDOMHTMLElement_SetTabIndex(This->nselem, v);
2353 if(NS_FAILED(nsres))
2354 ERR("GetTabIndex failed: %08x\n", nsres);
2355
2356 return S_OK;
2357}
2358
2359static HRESULT WINAPI HTMLElement2_get_tabIndex(IHTMLElement2 *iface, short *p)
2360{
2362 LONG index;
2363 nsresult nsres;
2364
2365 TRACE("(%p)->(%p)\n", This, p);
2366
2367 nsres = nsIDOMHTMLElement_GetTabIndex(This->nselem, &index);
2368 if(NS_FAILED(nsres)) {
2369 ERR("GetTabIndex failed: %08x\n", nsres);
2370 return E_FAIL;
2371 }
2372
2373 *p = index;
2374 return S_OK;
2375}
2376
2377static HRESULT WINAPI HTMLElement2_focus(IHTMLElement2 *iface)
2378{
2380 nsresult nsres;
2381
2382 TRACE("(%p)\n", This);
2383
2384 nsres = nsIDOMHTMLElement_Focus(This->nselem);
2385 if(NS_FAILED(nsres))
2386 ERR("Focus failed: %08x\n", nsres);
2387
2388 return S_OK;
2389}
2390
2391static HRESULT WINAPI HTMLElement2_put_accessKey(IHTMLElement2 *iface, BSTR v)
2392{
2394 VARIANT var;
2395
2396 static WCHAR accessKeyW[] = {'a','c','c','e','s','s','K','e','y',0};
2397
2398 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2399
2400 V_VT(&var) = VT_BSTR;
2401 V_BSTR(&var) = v;
2402 return IHTMLElement_setAttribute(&This->IHTMLElement_iface, accessKeyW, var, 0);
2403}
2404
2405static HRESULT WINAPI HTMLElement2_get_accessKey(IHTMLElement2 *iface, BSTR *p)
2406{
2408 FIXME("(%p)->(%p)\n", This, p);
2409 return E_NOTIMPL;
2410}
2411
2412static HRESULT WINAPI HTMLElement2_put_onblur(IHTMLElement2 *iface, VARIANT v)
2413{
2415
2416 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2417
2418 return set_node_event(&This->node, EVENTID_BLUR, &v);
2419}
2420
2421static HRESULT WINAPI HTMLElement2_get_onblur(IHTMLElement2 *iface, VARIANT *p)
2422{
2424
2425 TRACE("(%p)->(%p)\n", This, p);
2426
2427 return get_node_event(&This->node, EVENTID_BLUR, p);
2428}
2429
2430static HRESULT WINAPI HTMLElement2_put_onfocus(IHTMLElement2 *iface, VARIANT v)
2431{
2433
2434 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2435
2436 return set_node_event(&This->node, EVENTID_FOCUS, &v);
2437}
2438
2439static HRESULT WINAPI HTMLElement2_get_onfocus(IHTMLElement2 *iface, VARIANT *p)
2440{
2442
2443 TRACE("(%p)->(%p)\n", This, p);
2444
2445 return get_node_event(&This->node, EVENTID_FOCUS, p);
2446}
2447
2448static HRESULT WINAPI HTMLElement2_put_onresize(IHTMLElement2 *iface, VARIANT v)
2449{
2451 FIXME("(%p)->()\n", This);
2452 return E_NOTIMPL;
2453}
2454
2455static HRESULT WINAPI HTMLElement2_get_onresize(IHTMLElement2 *iface, VARIANT *p)
2456{
2458 FIXME("(%p)->(%p)\n", This, p);
2459 return E_NOTIMPL;
2460}
2461
2462static HRESULT WINAPI HTMLElement2_blur(IHTMLElement2 *iface)
2463{
2465 nsresult nsres;
2466
2467 TRACE("(%p)\n", This);
2468
2469 nsres = nsIDOMHTMLElement_Blur(This->nselem);
2470 if(NS_FAILED(nsres)) {
2471 ERR("Blur failed: %08x\n", nsres);
2472 return E_FAIL;
2473 }
2474
2475 return S_OK;
2476}
2477
2478static HRESULT WINAPI HTMLElement2_addFilter(IHTMLElement2 *iface, IUnknown *pUnk)
2479{
2481 FIXME("(%p)->(%p)\n", This, pUnk);
2482 return E_NOTIMPL;
2483}
2484
2486{
2488 FIXME("(%p)->(%p)\n", This, pUnk);
2489 return E_NOTIMPL;
2490}
2491
2492static HRESULT WINAPI HTMLElement2_get_clientHeight(IHTMLElement2 *iface, LONG *p)
2493{
2495 nsresult nsres;
2496
2497 TRACE("(%p)->(%p)\n", This, p);
2498
2499 nsres = nsIDOMHTMLElement_GetClientHeight(This->nselem, p);
2500 assert(nsres == NS_OK);
2501 return S_OK;
2502}
2503
2504static HRESULT WINAPI HTMLElement2_get_clientWidth(IHTMLElement2 *iface, LONG *p)
2505{
2507 nsresult nsres;
2508
2509 TRACE("(%p)->(%p)\n", This, p);
2510
2511 nsres = nsIDOMHTMLElement_GetClientWidth(This->nselem, p);
2512 assert(nsres == NS_OK);
2513 return S_OK;
2514}
2515
2516static HRESULT WINAPI HTMLElement2_get_clientTop(IHTMLElement2 *iface, LONG *p)
2517{
2519 nsresult nsres;
2520
2521 TRACE("(%p)->(%p)\n", This, p);
2522
2523 nsres = nsIDOMHTMLElement_GetClientTop(This->nselem, p);
2524 assert(nsres == NS_OK);
2525
2526 TRACE("*p = %d\n", *p);
2527 return S_OK;
2528}
2529
2530static HRESULT WINAPI HTMLElement2_get_clientLeft(IHTMLElement2 *iface, LONG *p)
2531{
2533 nsresult nsres;
2534
2535 TRACE("(%p)->(%p)\n", This, p);
2536
2537 nsres = nsIDOMHTMLElement_GetClientLeft(This->nselem, p);
2538 assert(nsres == NS_OK);
2539
2540 TRACE("*p = %d\n", *p);
2541 return S_OK;
2542}
2543
2544static HRESULT WINAPI HTMLElement2_attachEvent(IHTMLElement2 *iface, BSTR event,
2545 IDispatch *pDisp, VARIANT_BOOL *pfResult)
2546{
2548
2549 TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(event), pDisp, pfResult);
2550
2551 return attach_event(&This->node.event_target, event, pDisp, pfResult);
2552}
2553
2554static HRESULT WINAPI HTMLElement2_detachEvent(IHTMLElement2 *iface, BSTR event, IDispatch *pDisp)
2555{
2557
2558 TRACE("(%p)->(%s %p)\n", This, debugstr_w(event), pDisp);
2559
2560 return detach_event(&This->node.event_target, event, pDisp);
2561}
2562
2564{
2566 BSTR str;
2567
2568 TRACE("(%p)->(%p)\n", This, p);
2569
2570 if(This->node.vtbl->get_readystate) {
2571 HRESULT hres;
2572
2573 hres = This->node.vtbl->get_readystate(&This->node, &str);
2574 if(FAILED(hres))
2575 return hres;
2576 }else {
2577 static const WCHAR completeW[] = {'c','o','m','p','l','e','t','e',0};
2578
2579 str = SysAllocString(completeW);
2580 if(!str)
2581 return E_OUTOFMEMORY;
2582 }
2583
2584 V_VT(p) = VT_BSTR;
2585 V_BSTR(p) = str;
2586 return S_OK;
2587}
2588
2590{
2592
2593 TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
2594
2596}
2597
2599{
2601
2602 TRACE("(%p)->(%p)\n", This, p);
2603
2605}
2606
2608{
2610 FIXME("(%p)->()\n", This);
2611 return E_NOTIMPL;
2612}
2613
2615{
2617 FIXME("(%p)->(%p)\n", This, p);
2618 return E_NOTIMPL;
2619}
2620
2622{
2624 FIXME("(%p)->()\n", This);
2625 return E_NOTIMPL;
2626}
2627
2629{
2631 FIXME("(%p)->(%p)\n", This, p);
2632 return E_NOTIMPL;
2633}
2634
2636{
2638 FIXME("(%p)->()\n", This);
2639 return E_NOTIMPL;
2640}
2641
2643{
2645 FIXME("(%p)->(%p)\n", This, p);
2646 return E_NOTIMPL;
2647}
2648
2649static HRESULT WINAPI HTMLElement2_put_dir(IHTMLElement2 *iface, BSTR v)
2650{
2652 nsAString nsstr;
2653 nsresult nsres;
2654
2655 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
2656
2657 if(!This->nselem) {
2658 FIXME("Unsupported for comment nodes.\n");
2659 return S_OK;
2660 }
2661
2662 nsAString_InitDepend(&nsstr, v);
2663 nsres = nsIDOMHTMLElement_SetDir(This->nselem, &nsstr);
2664 nsAString_Finish(&nsstr);
2665 if(NS_FAILED(nsres)) {
2666 ERR("SetDir failed: %08x\n", nsres);
2667 return E_FAIL;
2668 }
2669
2670 return S_OK;
2671}
2672
2673static HRESULT WINAPI HTMLElement2_get_dir(IHTMLElement2 *iface, BSTR *p)
2674{
2676 nsAString dir_str;
2677 nsresult nsres;
2678
2679 TRACE("(%p)->(%p)\n", This, p);
2680
2681 if(!This->nselem) {
2682 *p = NULL;
2683 return S_OK;
2684 }
2685
2686 nsAString_Init(&dir_str, NULL);
2687 nsres = nsIDOMHTMLElement_GetDir(This->nselem, &dir_str);
2688 return return_nsstr(nsres, &dir_str, p);
2689}
2690
2692{
2694 FIXME("(%p)->(%p)\n", This, range);
2695 return E_NOTIMPL;
2696}
2697
2698static HRESULT WINAPI HTMLElement2_get_scrollHeight(IHTMLElement2 *iface, LONG *p)
2699{
2701 nsresult nsres;
2702
2703 TRACE("(%p)->(%p)\n", This, p);
2704
2705 nsres = nsIDOMHTMLElement_GetScrollHeight(This->nselem, p);
2706 assert(nsres == NS_OK);
2707
2708 TRACE("*p = %d\n", *p);
2709 return S_OK;
2710}
2711
2712static HRESULT WINAPI HTMLElement2_get_scrollWidth(IHTMLElement2 *iface, LONG *p)
2713{
2715 nsresult nsres;
2716
2717 TRACE("(%p)->(%p)\n", This, p);
2718
2719 nsres = nsIDOMHTMLElement_GetScrollWidth(This->nselem, p);
2720 assert(nsres == NS_OK);
2721
2722 TRACE("*p = %d\n", *p);
2723 return S_OK;
2724}
2725
2726static HRESULT WINAPI HTMLElement2_put_scrollTop(IHTMLElement2 *iface, LONG v)
2727{
2729
2730 TRACE("(%p)->(%d)\n", This, v);
2731
2732 if(!This->nselem) {
2733 FIXME("NULL nselem\n");
2734 return E_NOTIMPL;
2735 }
2736
2737 nsIDOMHTMLElement_SetScrollTop(This->nselem, v);
2738 return S_OK;
2739}
2740
2741static HRESULT WINAPI HTMLElement2_get_scrollTop(IHTMLElement2 *iface, LONG *p)
2742{
2744 nsresult nsres;
2745
2746 TRACE("(%p)->(%p)\n", This, p);
2747
2748 nsres = nsIDOMHTMLElement_GetScrollTop(This->nselem, p);
2749 assert(nsres == NS_OK);
2750
2751 TRACE("*p = %d\n", *p);
2752 return S_OK;
2753}
2754
2755static HRESULT WINAPI HTMLElement2_put_scrollLeft(IHTMLElement2 *iface, LONG v)
2756{
2758
2759 TRACE("(%p)->(%d)\n", This, v);
2760
2761 if(!This->nselem) {
2762 FIXME("NULL nselem\n");
2763 return E_NOTIMPL;
2764 }
2765
2766 nsIDOMHTMLElement_SetScrollLeft(This->nselem, v);
2767 return S_OK;
2768}
2769
2770static HRESULT WINAPI HTMLElement2_get_scrollLeft(IHTMLElement2 *iface, LONG *p)
2771{
2773 nsresult nsres;
2774
2775 TRACE("(%p)->(%p)\n", This, p);
2776
2777 if(!p)
2778 return E_INVALIDARG;
2779
2780 if(!This->nselem)
2781 {
2782 FIXME("NULL nselem\n");
2783 return E_NOTIMPL;
2784 }
2785
2786 nsres = nsIDOMHTMLElement_GetScrollLeft(This->nselem, p);
2787 assert(nsres == NS_OK);
2788
2789 TRACE("*p = %d\n", *p);
2790 return S_OK;
2791}
2792
2793static HRESULT WINAPI HTMLElement2_clearAttributes(IHTMLElement2 *iface)
2794{
2796 FIXME("(%p)\n", This);
2797 return E_NOTIMPL;
2798}
2799
2800static HRESULT WINAPI HTMLElement2_mergeAttributes(IHTMLElement2 *iface, IHTMLElement *mergeThis)
2801{
2803 FIXME("(%p)->(%p)\n", This, mergeThis);
2804 return E_NOTIMPL;
2805}
2806
2808{
2810 FIXME("(%p)->()\n", This);
2811 return E_NOTIMPL;
2812}
2813
2815{
2817 FIXME("(%p)->(%p)\n", This, p);
2818 return E_NOTIMPL;
2819}
2820
2821static HRESULT WINAPI HTMLElement2_insertAdjacentElement(IHTMLElement2 *iface, BSTR where,
2822 IHTMLElement *insertedElement, IHTMLElement **inserted)
2823{
2825 HTMLDOMNode *ret_node;
2827 HRESULT hres;
2828
2829 TRACE("(%p)->(%s %p %p)\n", This, debugstr_w(where), insertedElement, inserted);
2830
2831 elem = unsafe_impl_from_IHTMLElement(insertedElement);
2832 if(!elem)
2833 return E_INVALIDARG;
2834
2835 hres = insert_adjacent_node(This, where, elem->node.nsnode, &ret_node);
2836 if(FAILED(hres))
2837 return hres;
2838
2839 hres = IHTMLDOMNode_QueryInterface(&ret_node->IHTMLDOMNode_iface, &IID_IHTMLElement, (void**)inserted);
2840 IHTMLDOMNode_Release(&ret_node->IHTMLDOMNode_iface);
2841 return hres;
2842}
2843
2844static HRESULT WINAPI HTMLElement2_applyElement(IHTMLElement2 *iface, IHTMLElement *apply,
2845 BSTR where, IHTMLElement **applied)
2846{
2848 FIXME("(%p)->(%p %s %p)\n", This, apply, debugstr_w(where), applied);
2849 return E_NOTIMPL;
2850}
2851
2852static HRESULT WINAPI HTMLElement2_getAdjacentText(IHTMLElement2 *iface, BSTR where, BSTR *text)
2853{
2855 FIXME("(%p)->(%s %p)\n", This, debugstr_w(where), text);
2856 return E_NOTIMPL;
2857}
2858
2859static HRESULT WINAPI HTMLElement2_replaceAdjacentText(IHTMLElement2 *iface, BSTR where,
2860 BSTR newText, BSTR *oldText)
2861{
2863 FIXME("(%p)->(%s %s %p)\n", This, debugstr_w(where), debugstr_w(newText), oldText);
2864 return E_NOTIMPL;
2865}
2866
2868{
2870 FIXME("(%p)->(%p)\n", This, p);
2871 return E_NOTIMPL;
2872}
2873
2874static HRESULT WINAPI HTMLElement2_addBehavior(IHTMLElement2 *iface, BSTR bstrUrl,
2875 VARIANT *pvarFactory, LONG *pCookie)
2876{
2878 FIXME("(%p)->(%s %p %p)\n", This, debugstr_w(bstrUrl), pvarFactory, pCookie);
2879 return E_NOTIMPL;
2880}
2881
2883 VARIANT_BOOL *pfResult)
2884{
2886 FIXME("(%p)->(%d %p)\n", This, cookie, pfResult);
2887 return E_NOTIMPL;
2888}
2889
2890static HRESULT WINAPI HTMLElement2_get_runtimeStyle(IHTMLElement2 *iface, IHTMLStyle **p)
2891{
2893
2894 FIXME("(%p)->(%p): hack\n", This, p);
2895
2896 /* We can't implement correct behavior on top of Gecko (although we could
2897 try a bit harder). Making runtimeStyle behave like regular style is
2898 enough for most use cases. */
2899 if(!This->runtime_style) {
2900 HRESULT hres;
2901
2902 hres = HTMLStyle_Create(This, &This->runtime_style);
2903 if(FAILED(hres))
2904 return hres;
2905 }
2906
2907 *p = &This->runtime_style->IHTMLStyle_iface;
2908 IHTMLStyle_AddRef(*p);
2909 return S_OK;
2910}
2911
2913{
2915 FIXME("(%p)->(%p)\n", This, p);
2916 return E_NOTIMPL;
2917}
2918
2919static HRESULT WINAPI HTMLElement2_put_tagUrn(IHTMLElement2 *iface, BSTR v)
2920{
2922 FIXME("(%p)->(%s)\n", This, debugstr_w(v));
2923 return E_NOTIMPL;
2924}
2925
2926static HRESULT WINAPI HTMLElement2_get_tagUrn(IHTMLElement2 *iface, BSTR *p)
2927{
2929 FIXME("(%p)->(%p)\n", This, p);
2930 return E_NOTIMPL;
2931}
2932
2934{
2936 FIXME("(%p)->()\n", This);
2937 return E_NOTIMPL;
2938}
2939
2941{
2943 FIXME("(%p)->(%p)\n", This, p);
2944 return E_NOTIMPL;
2945}
2946
2948{
2950 FIXME("(%p)->(%p)\n", This, p);
2951 return E_NOTIMPL;
2952}
2953
2955 IHTMLElementCollection **pelColl)
2956{
2958 nsIDOMHTMLCollection *nscol;
2959 nsAString tag_str;
2960 nsresult nsres;
2961
2962 TRACE("(%p)->(%s %p)\n", This, debugstr_w(v), pelColl);
2963
2964 nsAString_InitDepend(&tag_str, v);
2965 nsres = nsIDOMHTMLElement_GetElementsByTagName(This->nselem, &tag_str, &nscol);
2966 nsAString_Finish(&tag_str);
2967 if(NS_FAILED(nsres)) {
2968 ERR("GetElementByTagName failed: %08x\n", nsres);
2969 return E_FAIL;
2970 }
2971
2972 *pelColl = create_collection_from_htmlcol(This->node.doc, nscol);
2973 nsIDOMHTMLCollection_Release(nscol);
2974 return S_OK;
2975}
2976
2977static const IHTMLElement2Vtbl HTMLElement2Vtbl = {
3083};
3084
3085static inline HTMLElement *impl_from_IHTMLElement3(IHTMLElement3 *iface)
3086{
3087 return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement3_iface);
3088}
3089
3090static HRESULT WINAPI HTMLElement3_QueryInterface(IHTMLElement3 *iface,
3091 REFIID riid, void **ppv)
3092{
3094 return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
3095}
3096
3097static ULONG WINAPI HTMLElement3_AddRef(IHTMLElement3 *iface)
3098{
3100 return IHTMLElement_AddRef(&This->IHTMLElement_iface);
3101}
3102
3103static ULONG WINAPI HTMLElement3_Release(IHTMLElement3 *iface)
3104{
3106 return IHTMLElement_Release(&This->IHTMLElement_iface);
3107}
3108
3109static HRESULT WINAPI HTMLElement3_GetTypeInfoCount(IHTMLElement3 *iface, UINT *pctinfo)
3110{
3112 return IDispatchEx_GetTypeInfoCount(&This->node.event_target.dispex.IDispatchEx_iface, pctinfo);
3113}
3114
3115static HRESULT WINAPI HTMLElement3_GetTypeInfo(IHTMLElement3 *iface, UINT iTInfo,
3116 LCID lcid, ITypeInfo **ppTInfo)
3117{
3119 return IDispatchEx_GetTypeInfo(&This->node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
3120}
3121
3123 LPOLESTR *rgszNames, UINT cNames,
3124 LCID lcid, DISPID *rgDispId)
3125{
3127 return IDispatchEx_GetIDsOfNames(&This->node.event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
3128 lcid, rgDispId);
3129}
3130
3131static HRESULT WINAPI HTMLElement3_Invoke(IHTMLElement3 *iface, DISPID dispIdMember,
3132 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
3133 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3134{
3136 return IDispatchEx_Invoke(&This->node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
3137 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3138}
3139
3140static HRESULT WINAPI HTMLElement3_mergeAttributes(IHTMLElement3 *iface, IHTMLElement *mergeThis, VARIANT *pvarFlags)
3141{
3143 FIXME("(%p)->(%p %p)\n", This, mergeThis, pvarFlags);
3144 return E_NOTIMPL;
3145}
3146
3148{
3150 FIXME("(%p)->(%p)\n", This, p);
3151 return E_NOTIMPL;
3152}
3153
3155{
3157 FIXME("(%p)->(%p)\n", This, p);
3158 return E_NOTIMPL;
3159}
3160
3162{
3164 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3165 return E_NOTIMPL;
3166}
3167
3169{
3171 FIXME("(%p)->(%p)\n", This, p);
3172 return E_NOTIMPL;
3173}
3174
3175static HRESULT WINAPI HTMLElement3_put_onpage(IHTMLElement3 *iface, VARIANT v)
3176{
3178 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3179 return E_NOTIMPL;
3180}
3181
3182static HRESULT WINAPI HTMLElement3_get_onpage(IHTMLElement3 *iface, VARIANT *p)
3183{
3185 FIXME("(%p)->(%p)\n", This, p);
3186 return E_NOTIMPL;
3187}
3188
3190{
3192 FIXME("(%p)->(%x)\n", This, v);
3193 return E_NOTIMPL;
3194}
3195
3197{
3199 FIXME("(%p)->(%p)\n", This, p);
3200 return E_NOTIMPL;
3201}
3202
3204{
3206 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3207 return E_NOTIMPL;
3208}
3209
3211{
3213 FIXME("(%p)->(%p)\n", This, p);
3214 return E_NOTIMPL;
3215}
3216
3217static HRESULT WINAPI HTMLElement3_setActive(IHTMLElement3 *iface)
3218{
3220 FIXME("(%p)\n", This);
3221 return E_NOTIMPL;
3222}
3223
3225{
3227 nsresult nsres;
3228 nsAString str;
3229
3230 TRACE("(%p)->(%s)\n", This, debugstr_w(v));
3231
3233 nsres = nsIDOMHTMLElement_SetContentEditable(This->nselem, &str);
3235
3236 if (NS_FAILED(nsres)){
3237 ERR("SetContentEditable(%s) failed!\n", debugstr_w(v));
3238 return E_FAIL;
3239 }
3240
3241 return S_OK;
3242}
3243
3245{
3247 nsresult nsres;
3248 nsAString str;
3249
3250 TRACE("(%p)->(%p)\n", This, p);
3251
3253 nsres = nsIDOMHTMLElement_GetContentEditable(This->nselem, &str);
3254 return return_nsstr(nsres, &str, p);
3255}
3256
3258{
3260 FIXME("(%p)->(%p)\n", This, p);
3261 return E_NOTIMPL;
3262}
3263
3265{
3267 FIXME("(%p)->(%x)\n", This, v);
3268 return E_NOTIMPL;
3269}
3270
3272{
3274 FIXME("(%p)->(%p)\n", This, p);
3275 return E_NOTIMPL;
3276}
3277
3278static const WCHAR disabledW[] = {'d','i','s','a','b','l','e','d',0};
3279
3281{
3283 VARIANT *var;
3284 HRESULT hres;
3285
3286 TRACE("(%p)->(%x)\n", This, v);
3287
3288 if(This->node.vtbl->put_disabled)
3289 return This->node.vtbl->put_disabled(&This->node, v);
3290
3291 hres = dispex_get_dprop_ref(&This->node.event_target.dispex, disabledW, TRUE, &var);
3292 if(FAILED(hres))
3293 return hres;
3294
3296 V_VT(var) = VT_BOOL;
3297 V_BOOL(var) = v;
3298 return S_OK;
3299}
3300
3302{
3304 VARIANT *var;
3305 HRESULT hres;
3306
3307 TRACE("(%p)->(%p)\n", This, p);
3308
3309 if(This->node.vtbl->get_disabled)
3310 return This->node.vtbl->get_disabled(&This->node, p);
3311
3312 hres = dispex_get_dprop_ref(&This->node.event_target.dispex, disabledW, FALSE, &var);
3313 if(hres == DISP_E_UNKNOWNNAME) {
3314 *p = VARIANT_FALSE;
3315 return S_OK;
3316 }
3317 if(FAILED(hres))
3318 return hres;
3319
3320 if(V_VT(var) != VT_BOOL) {
3321 FIXME("value is %s\n", debugstr_variant(var));
3322 return E_NOTIMPL;
3323 }
3324
3325 *p = V_BOOL(var);
3326 return S_OK;
3327}
3328
3330{
3332 FIXME("(%p)->(%p)\n", This, p);
3333 return E_NOTIMPL;
3334}
3335
3336static HRESULT WINAPI HTMLElement3_put_onmove(IHTMLElement3 *iface, VARIANT v)
3337{
3339 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3340 return E_NOTIMPL;
3341}
3342
3343static HRESULT WINAPI HTMLElement3_get_onmove(IHTMLElement3 *iface, VARIANT *p)
3344{
3346 FIXME("(%p)->(%p)\n", This, p);
3347 return E_NOTIMPL;
3348}
3349
3351{
3353 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3354 return E_NOTIMPL;
3355}
3356
3358{
3360 FIXME("(%p)->(%p)\n", This, p);
3361 return E_NOTIMPL;
3362}
3363
3364static HRESULT WINAPI HTMLElement3_fireEvent(IHTMLElement3 *iface, BSTR bstrEventName,
3365 VARIANT *pvarEventObject, VARIANT_BOOL *pfCancelled)
3366{
3368
3369 TRACE("(%p)->(%s %s %p)\n", This, debugstr_w(bstrEventName), debugstr_variant(pvarEventObject),
3370 pfCancelled);
3371
3372 return dispatch_event(&This->node, bstrEventName, pvarEventObject, pfCancelled);
3373}
3374
3376{
3378 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3379 return E_NOTIMPL;
3380}
3381
3383{
3385 FIXME("(%p)->(%p)\n", This, p);
3386 return E_NOTIMPL;
3387}
3388
3390{
3392 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3393 return E_NOTIMPL;
3394}
3395
3397{
3399 FIXME("(%p)->(%p)\n", This, p);
3400 return E_NOTIMPL;
3401}
3402
3404{
3406 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3407 return E_NOTIMPL;
3408}
3409
3411{
3413 FIXME("(%p)->(%p)\n", This, p);
3414 return E_NOTIMPL;
3415}
3416
3418{
3420 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3421 return E_NOTIMPL;
3422}
3423
3424static HRESULT WINAPI HTMLElement3_get_onmoveend(IHTMLElement3 *iface, VARIANT *p)
3425{
3427 FIXME("(%p)->(%p)\n", This, p);
3428 return E_NOTIMPL;
3429}
3430
3432{
3434 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3435 return E_NOTIMPL;
3436}
3437
3439{
3441 FIXME("(%p)->(%p)\n", This, p);
3442 return E_NOTIMPL;
3443}
3444
3446{
3448 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3449 return E_NOTIMPL;
3450}
3451
3453{
3455 FIXME("(%p)->(%p)\n", This, p);
3456 return E_NOTIMPL;
3457}
3458
3460{
3462 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3463 return E_NOTIMPL;
3464}
3465
3467{
3469 FIXME("(%p)->(%p)\n", This, p);
3470 return E_NOTIMPL;
3471}
3472
3474{
3476 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3477 return E_NOTIMPL;
3478}
3479
3481{
3483 FIXME("(%p)->(%p)\n", This, p);
3484 return E_NOTIMPL;
3485}
3486
3487static HRESULT WINAPI HTMLElement3_dragDrop(IHTMLElement3 *iface, VARIANT_BOOL *pfRet)
3488{
3490 FIXME("(%p)->(%p)\n", This, pfRet);
3491 return E_NOTIMPL;
3492}
3493
3494static HRESULT WINAPI HTMLElement3_get_glyphMode(IHTMLElement3 *iface, LONG *p)
3495{
3497 FIXME("(%p)->(%p)\n", This, p);
3498 return E_NOTIMPL;
3499}
3500
3501static const IHTMLElement3Vtbl HTMLElement3Vtbl = {
3552};
3553
3554static inline HTMLElement *impl_from_IHTMLElement4(IHTMLElement4 *iface)
3555{
3556 return CONTAINING_RECORD(iface, HTMLElement, IHTMLElement4_iface);
3557}
3558
3559static HRESULT WINAPI HTMLElement4_QueryInterface(IHTMLElement4 *iface,
3560 REFIID riid, void **ppv)
3561{
3563 return IHTMLElement_QueryInterface(&This->IHTMLElement_iface, riid, ppv);
3564}
3565
3566static ULONG WINAPI HTMLElement4_AddRef(IHTMLElement4 *iface)
3567{
3569 return IHTMLElement_AddRef(&This->IHTMLElement_iface);
3570}
3571
3572static ULONG WINAPI HTMLElement4_Release(IHTMLElement4 *iface)
3573{
3575 return IHTMLElement_Release(&This->IHTMLElement_iface);
3576}
3577
3578static HRESULT WINAPI HTMLElement4_GetTypeInfoCount(IHTMLElement4 *iface, UINT *pctinfo)
3579{
3581 return IDispatchEx_GetTypeInfoCount(&This->node.event_target.dispex.IDispatchEx_iface, pctinfo);
3582}
3583
3584static HRESULT WINAPI HTMLElement4_GetTypeInfo(IHTMLElement4 *iface, UINT iTInfo,
3585 LCID lcid, ITypeInfo **ppTInfo)
3586{
3588 return IDispatchEx_GetTypeInfo(&This->node.event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
3589}
3590
3592 LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
3593{
3595 return IDispatchEx_GetIDsOfNames(&This->node.event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
3596 lcid, rgDispId);
3597}
3598
3599static HRESULT WINAPI HTMLElement4_Invoke(IHTMLElement4 *iface, DISPID dispIdMember, REFIID riid,
3600 LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
3601{
3603 return IDispatchEx_Invoke(&This->node.event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
3604 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3605}
3606
3608{
3610
3611 FIXME("(%p)->(%s) semi-stub\n", This, debugstr_variant(&v));
3612
3613 return set_node_event(&This->node, EVENTID_MOUSEWHEEL, &v);
3614}
3615
3617{
3619
3620 TRACE("(%p)->(%p)\n", This, p);
3621
3622 return get_node_event(&This->node, EVENTID_MOUSEWHEEL, p);
3623}
3624
3625static HRESULT WINAPI HTMLElement4_normalize(IHTMLElement4 *iface)
3626{
3628 FIXME("(%p)\n", This);
3629 return E_NOTIMPL;
3630}
3631
3632static HRESULT WINAPI HTMLElement4_getAttributeNode(IHTMLElement4 *iface, BSTR bstrname, IHTMLDOMAttribute **ppAttribute)
3633{
3636 HRESULT hres;
3637
3638 TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrname), ppAttribute);
3639
3640 hres = HTMLElement_get_attr_col(&This->node, &attrs);
3641 if(FAILED(hres))
3642 return hres;
3643
3644 hres = IHTMLAttributeCollection2_getNamedItem(&attrs->IHTMLAttributeCollection2_iface, bstrname, ppAttribute);
3645 IHTMLAttributeCollection_Release(&attrs->IHTMLAttributeCollection_iface);
3646 return hres;
3647}
3648
3649static HRESULT WINAPI HTMLElement4_setAttributeNode(IHTMLElement4 *iface, IHTMLDOMAttribute *pattr,
3650 IHTMLDOMAttribute **ppretAttribute)
3651{
3653 FIXME("(%p)->(%p %p)\n", This, pattr, ppretAttribute);
3654 return E_NOTIMPL;
3655}
3656
3657static HRESULT WINAPI HTMLElement4_removeAttributeNode(IHTMLElement4 *iface, IHTMLDOMAttribute *pattr,
3658 IHTMLDOMAttribute **ppretAttribute)
3659{
3661 FIXME("(%p)->(%p %p)\n", This, pattr, ppretAttribute);
3662 return E_NOTIMPL;
3663}
3664
3666{
3668 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3669 return E_NOTIMPL;
3670}
3671
3673{
3675 FIXME("(%p)->(%p)\n", This, p);
3676 return E_NOTIMPL;
3677}
3678
3680{
3682
3683 FIXME("(%p)->(%s) semi-stub\n", This, debugstr_variant(&v));
3684
3685 return set_node_event(&This->node, EVENTID_FOCUSIN, &v);
3686}
3687
3688static HRESULT WINAPI HTMLElement4_get_onfocusin(IHTMLElement4 *iface, VARIANT *p)
3689{
3691
3692 TRACE("(%p)->(%p)\n", This, p);
3693
3694 return get_node_event(&This->node, EVENTID_FOCUSIN, p);
3695}
3696
3698{
3700 FIXME("(%p)->(%s)\n", This, debugstr_variant(&v));
3701 return E_NOTIMPL;
3702}
3703
3705{
3707 FIXME("(%p)->(%p)\n", This, p);
3708 return E_NOTIMPL;
3709}
3710
3711static const IHTMLElement4Vtbl HTMLElement4Vtbl = {
3731};
3732
3734{
3735 return CONTAINING_RECORD(iface, HTMLElement, node);
3736}
3737
3739{
3741
3743 *ppv = &This->IHTMLElement_iface;
3744 }else if(IsEqualGUID(&IID_IDispatch, riid)) {
3745 *ppv = &This->IHTMLElement_iface;
3746 }else if(IsEqualGUID(&IID_IHTMLElement, riid)) {
3747 *ppv = &This->IHTMLElement_iface;
3748 }else if(IsEqualGUID(&IID_IHTMLElement2, riid)) {
3749 *ppv = &This->IHTMLElement2_iface;
3750 }else if(IsEqualGUID(&IID_IHTMLElement3, riid)) {
3751 *ppv = &This->IHTMLElement3_iface;
3752 }else if(IsEqualGUID(&IID_IHTMLElement4, riid)) {
3753 *