d58fc691024d01919e9345a36d94e6e0146d9cf2
[WebKit-https.git] / Source / WebKit / win / DOMHTMLClasses.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2009 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "WebKitDLL.h"
28 #include "DOMHTMLClasses.h"
29 #include "WebFrame.h"
30
31 #include <WebCore/BString.h>
32 #include <WebCore/COMPtr.h>
33 #include <WebCore/Document.h>
34 #include <WebCore/Element.h>
35 #include <WebCore/FrameView.h>
36 #include <WebCore/HTMLCollection.h>
37 #include <WebCore/HTMLDocument.h>
38 #include <WebCore/HTMLFormElement.h>
39 #include <WebCore/HTMLIFrameElement.h>
40 #include <WebCore/HTMLInputElement.h>
41 #include <WebCore/HTMLNames.h>
42 #include <WebCore/HTMLOptionElement.h>
43 #include <WebCore/HTMLOptionsCollection.h>
44 #include <WebCore/HTMLSelectElement.h>
45 #include <WebCore/HTMLTextAreaElement.h>
46 #include <WebCore/IntRect.h>
47 #include <WebCore/RenderObject.h>
48 #include <WebCore/RenderTextControl.h>
49
50 using namespace WebCore;
51 using namespace HTMLNames;
52
53 // DOMHTMLCollection
54
55 DOMHTMLCollection::DOMHTMLCollection(WebCore::HTMLCollection* c)
56 : m_collection(c)
57 {
58 }
59
60 IDOMHTMLCollection* DOMHTMLCollection::createInstance(WebCore::HTMLCollection* c)
61 {
62     if (!c)
63         return 0;
64
65     IDOMHTMLCollection* htmlCollection = 0;
66     DOMHTMLCollection* newCollection = new DOMHTMLCollection(c);
67     if (FAILED(newCollection->QueryInterface(IID_IDOMHTMLCollection, (void**)&htmlCollection))) {
68         delete newCollection;
69         return 0;
70     }
71
72     return htmlCollection;
73 }
74
75 // DOMHTMLCollection - IUnknown -----------------------------------------------
76
77 HRESULT STDMETHODCALLTYPE DOMHTMLCollection::QueryInterface(REFIID riid, void** ppvObject)
78 {
79     *ppvObject = 0;
80     if (IsEqualGUID(riid, IID_IDOMHTMLCollection))
81         *ppvObject = static_cast<IDOMHTMLCollection*>(this);
82     else
83         return DOMObject::QueryInterface(riid, ppvObject);
84
85     AddRef();
86     return S_OK;
87 }
88
89 // DOMHTMLCollection ----------------------------------------------------------
90
91 HRESULT STDMETHODCALLTYPE DOMHTMLCollection::length( 
92     /* [retval][out] */ UINT* result)
93 {
94     *result = 0;
95     if (!m_collection)
96         return E_POINTER;
97
98     *result = m_collection->length();
99     return S_OK;
100 }
101
102 HRESULT STDMETHODCALLTYPE DOMHTMLCollection::item( 
103     /* [in] */ UINT index,
104     /* [retval][out] */ IDOMNode** node)
105 {
106     *node = 0;
107     if (!m_collection)
108         return E_POINTER;
109
110     *node = DOMNode::createInstance(m_collection->item(index));
111     return *node ? S_OK : E_FAIL;
112 }
113
114 HRESULT STDMETHODCALLTYPE DOMHTMLCollection::namedItem( 
115     /* [in] */ BSTR /*name*/,
116     /* [retval][out] */ IDOMNode** /*node*/)
117 {
118     ASSERT_NOT_REACHED();
119     return E_NOTIMPL;
120 }
121
122 // DOMHTMLOptionsCollection - IUnknown ----------------------------------------
123
124 HRESULT STDMETHODCALLTYPE DOMHTMLOptionsCollection::QueryInterface(REFIID riid, void** ppvObject)
125 {
126     *ppvObject = 0;
127     if (IsEqualGUID(riid, IID_IDOMHTMLOptionsCollection))
128         *ppvObject = static_cast<IDOMHTMLOptionsCollection*>(this);
129     else
130         return DOMObject::QueryInterface(riid, ppvObject);
131
132     AddRef();
133     return S_OK;
134 }
135
136 // DOMHTMLOptionsCollection ---------------------------------------------------
137
138 DOMHTMLOptionsCollection::DOMHTMLOptionsCollection(WebCore::HTMLOptionsCollection* collection)
139     : m_collection(collection)
140 {
141 }
142
143 IDOMHTMLOptionsCollection* DOMHTMLOptionsCollection::createInstance(WebCore::HTMLOptionsCollection* collection)
144 {
145     if (!collection)
146         return 0;
147
148     IDOMHTMLOptionsCollection* optionsCollection = 0;
149     DOMHTMLOptionsCollection* newCollection = new DOMHTMLOptionsCollection(collection);
150     if (FAILED(newCollection->QueryInterface(IID_IDOMHTMLOptionsCollection, (void**)&optionsCollection))) {
151         delete newCollection;
152         return 0;
153     }
154
155     return optionsCollection;
156 }
157
158 HRESULT STDMETHODCALLTYPE DOMHTMLOptionsCollection::length( 
159     /* [retval][out] */ unsigned int* result)
160 {
161     if (!result)
162         return E_POINTER;
163
164     *result = m_collection->length();
165     return S_OK;
166 }
167
168 HRESULT STDMETHODCALLTYPE DOMHTMLOptionsCollection::setLength( 
169     /* [in] */ unsigned int /*length*/)
170 {
171     ASSERT_NOT_REACHED();
172     return E_NOTIMPL;
173 }
174
175 HRESULT STDMETHODCALLTYPE DOMHTMLOptionsCollection::item( 
176     /* [in] */ unsigned int index,
177     /* [retval][out] */ IDOMNode** result)
178 {
179     if (!result)
180         return E_POINTER;
181
182     *result = DOMNode::createInstance(m_collection->item(index));
183
184     return *result ? S_OK : E_FAIL;
185 }
186
187 HRESULT STDMETHODCALLTYPE DOMHTMLOptionsCollection::namedItem( 
188     /* [in] */ BSTR /*name*/,
189     /* [retval][out] */ IDOMNode** /*result*/)
190 {
191     ASSERT_NOT_REACHED();
192     return E_NOTIMPL;
193 }
194
195 // DOMHTMLDocument - IUnknown -------------------------------------------------
196
197 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::QueryInterface(REFIID riid, void** ppvObject)
198 {
199     *ppvObject = 0;
200     if (IsEqualGUID(riid, IID_IDOMHTMLDocument))
201         *ppvObject = static_cast<IDOMHTMLDocument*>(this);
202     else
203         return DOMDocument::QueryInterface(riid, ppvObject);
204
205     AddRef();
206     return S_OK;
207 }
208
209 // DOMHTMLDocument ------------------------------------------------------------
210
211 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::title( 
212         /* [retval][out] */ BSTR* result)
213 {
214     if (!result)
215         return E_POINTER;
216
217     *result = 0;
218
219     if (!m_document || !m_document->isHTMLDocument())
220         return E_FAIL;
221
222     *result = BString(m_document->title()).release();
223     return S_OK;
224 }
225     
226 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::setTitle( 
227         /* [in] */ BSTR /*title*/)
228 {
229     ASSERT_NOT_REACHED();
230     return E_NOTIMPL;
231 }
232     
233 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::referrer( 
234         /* [retval][out] */ BSTR* /*result*/)
235 {
236     ASSERT_NOT_REACHED();
237     return E_NOTIMPL;
238 }
239     
240 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::domain( 
241         /* [retval][out] */ BSTR* /*result*/)
242 {
243     ASSERT_NOT_REACHED();
244     return E_NOTIMPL;
245 }
246     
247 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::URL( 
248         /* [retval][out] */ BSTR* result)
249 {
250     if (!result)
251         return E_POINTER;
252
253     *result = BString(static_cast<HTMLDocument*>(m_document)->url()).release();
254     return S_OK;
255 }
256     
257 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::body( 
258         /* [retval][out] */ IDOMHTMLElement** bodyElement)
259 {
260     *bodyElement = 0;
261     if (!m_document || !m_document->isHTMLDocument())
262         return E_FAIL;
263
264     HTMLDocument* htmlDoc = static_cast<HTMLDocument*>(m_document);
265     COMPtr<IDOMElement> domElement;
266     domElement.adoptRef(DOMHTMLElement::createInstance(htmlDoc->body()));
267     if (domElement)
268         return domElement->QueryInterface(IID_IDOMHTMLElement, (void**) bodyElement);
269     return E_FAIL;
270 }
271     
272 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::setBody( 
273         /* [in] */ IDOMHTMLElement* /*body*/)
274 {
275     ASSERT_NOT_REACHED();
276     return E_NOTIMPL;
277 }
278     
279 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::images( 
280         /* [retval][out] */ IDOMHTMLCollection** /*collection*/)
281 {
282     ASSERT_NOT_REACHED();
283     return E_NOTIMPL;
284 }
285     
286 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::applets( 
287         /* [retval][out] */ IDOMHTMLCollection** /*collection*/)
288 {
289     ASSERT_NOT_REACHED();
290     return E_NOTIMPL;
291 }
292     
293 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::links( 
294         /* [retval][out] */ IDOMHTMLCollection** /*collection*/)
295 {
296     ASSERT_NOT_REACHED();
297     return E_NOTIMPL;
298 }
299     
300 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::forms( 
301         /* [retval][out] */ IDOMHTMLCollection** collection)
302 {
303     *collection = 0;
304     if (!m_document || !m_document->isHTMLDocument())
305         return E_FAIL;
306
307     HTMLDocument* htmlDoc = static_cast<HTMLDocument*>(m_document);
308     RefPtr<HTMLCollection> forms = htmlDoc->forms();
309     *collection = DOMHTMLCollection::createInstance(forms.get());
310     return S_OK;
311 }
312     
313 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::anchors( 
314         /* [retval][out] */ IDOMHTMLCollection** /*collection*/)
315 {
316     ASSERT_NOT_REACHED();
317     return E_NOTIMPL;
318 }
319     
320 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::cookie( 
321         /* [retval][out] */ BSTR* /*result*/)
322 {
323     ASSERT_NOT_REACHED();
324     return E_NOTIMPL;
325 }
326     
327 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::setCookie( 
328         /* [in] */ BSTR /*cookie*/)
329 {
330     ASSERT_NOT_REACHED();
331     return E_NOTIMPL;
332 }
333     
334 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::open( void)
335 {
336     ASSERT_NOT_REACHED();
337     return E_NOTIMPL;
338 }
339     
340 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::close( void)
341 {
342     ASSERT_NOT_REACHED();
343     return E_NOTIMPL;
344 }
345     
346 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::write( 
347         /* [in] */ BSTR /*text*/)
348 {
349     ASSERT_NOT_REACHED();
350     return E_NOTIMPL;
351 }
352     
353 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::writeln( 
354         /* [in] */ BSTR /*text*/)
355 {
356     ASSERT_NOT_REACHED();
357     return E_NOTIMPL;
358 }
359     
360 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::getElementById_( 
361         /* [in] */ BSTR /*elementId*/,
362         /* [retval][out] */ IDOMElement** /*element*/)
363 {
364     ASSERT_NOT_REACHED();
365     return E_NOTIMPL;
366 }
367     
368 HRESULT STDMETHODCALLTYPE DOMHTMLDocument::getElementsByName( 
369         /* [in] */ BSTR /*elementName*/,
370         /* [retval][out] */ IDOMNodeList** /*nodeList*/)
371 {
372     ASSERT_NOT_REACHED();
373     return E_NOTIMPL;
374 }
375
376 // DOMHTMLElement - IUnknown --------------------------------------------------
377
378 HRESULT STDMETHODCALLTYPE DOMHTMLElement::QueryInterface(REFIID riid, void** ppvObject)
379 {
380     *ppvObject = 0;
381     if (IsEqualGUID(riid, IID_IDOMHTMLElement))
382         *ppvObject = static_cast<IDOMHTMLElement*>(this);
383     else
384         return DOMElement::QueryInterface(riid, ppvObject);
385
386     AddRef();
387     return S_OK;
388 }
389
390 // DOMHTMLElement -------------------------------------------------------------
391
392 HRESULT STDMETHODCALLTYPE DOMHTMLElement::idName( 
393         /* [retval][out] */ BSTR* result)
394 {
395     if (!result)
396         return E_POINTER;
397
398     ASSERT(m_element && m_element->isHTMLElement());
399     String idString = static_cast<HTMLElement*>(m_element)->getAttribute(idAttr);
400     *result = BString(idString).release();
401     return S_OK;
402 }
403     
404 HRESULT STDMETHODCALLTYPE DOMHTMLElement::setIdName( 
405         /* [in] */ BSTR /*idName*/)
406 {
407     ASSERT_NOT_REACHED();
408     return E_NOTIMPL;
409 }
410     
411 HRESULT STDMETHODCALLTYPE DOMHTMLElement::title( 
412         /* [retval][out] */ BSTR* /*result*/)
413 {
414     ASSERT_NOT_REACHED();
415     return E_NOTIMPL;
416 }
417     
418 HRESULT STDMETHODCALLTYPE DOMHTMLElement::setTitle( 
419         /* [in] */ BSTR /*title*/)
420 {
421     ASSERT_NOT_REACHED();
422     return E_NOTIMPL;
423 }
424     
425 HRESULT STDMETHODCALLTYPE DOMHTMLElement::lang( 
426         /* [retval][out] */ BSTR* /*result*/)
427 {
428     ASSERT_NOT_REACHED();
429     return E_NOTIMPL;
430 }
431     
432 HRESULT STDMETHODCALLTYPE DOMHTMLElement::setLang( 
433         /* [in] */ BSTR /*lang*/)
434 {
435     ASSERT_NOT_REACHED();
436     return E_NOTIMPL;
437 }
438     
439 HRESULT STDMETHODCALLTYPE DOMHTMLElement::dir( 
440         /* [retval][out] */ BSTR* /*result*/)
441 {
442     ASSERT_NOT_REACHED();
443     return E_NOTIMPL;
444 }
445     
446 HRESULT STDMETHODCALLTYPE DOMHTMLElement::setDir( 
447         /* [in] */ BSTR /*dir*/)
448 {
449     ASSERT_NOT_REACHED();
450     return E_NOTIMPL;
451 }
452     
453 HRESULT STDMETHODCALLTYPE DOMHTMLElement::className( 
454         /* [retval][out] */ BSTR* /*result*/)
455 {
456     ASSERT_NOT_REACHED();
457     return E_NOTIMPL;
458 }
459     
460 HRESULT STDMETHODCALLTYPE DOMHTMLElement::setClassName( 
461         /* [in] */ BSTR /*className*/)
462 {
463     ASSERT_NOT_REACHED();
464     return E_NOTIMPL;
465 }
466
467 HRESULT STDMETHODCALLTYPE DOMHTMLElement::innerHTML( 
468         /* [retval][out] */ BSTR* /*result*/)
469 {
470     ASSERT_NOT_REACHED();
471     return E_NOTIMPL;
472 }
473         
474 HRESULT STDMETHODCALLTYPE DOMHTMLElement::setInnerHTML( 
475         /* [in] */ BSTR /*html*/)
476 {
477     ASSERT_NOT_REACHED();
478     return E_NOTIMPL;
479 }
480         
481 HRESULT STDMETHODCALLTYPE DOMHTMLElement::innerText( 
482         /* [retval][out] */ BSTR* result)
483 {
484     ASSERT(m_element && m_element->isHTMLElement());
485     WTF::String innerTextString = static_cast<HTMLElement*>(m_element)->innerText();
486     *result = BString(innerTextString.characters(), innerTextString.length()).release();
487     return S_OK;
488 }
489         
490 HRESULT STDMETHODCALLTYPE DOMHTMLElement::setInnerText( 
491         /* [in] */ BSTR text)
492 {
493     ASSERT(m_element && m_element->isHTMLElement());
494     HTMLElement* htmlEle = static_cast<HTMLElement*>(m_element);
495     WTF::String textString(text, SysStringLen(text));
496     WebCore::ExceptionCode ec = 0;
497     htmlEle->setInnerText(textString, ec);
498     return S_OK;
499 }
500
501 // DOMHTMLFormElement - IUnknown ----------------------------------------------
502
503 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::QueryInterface(REFIID riid, void** ppvObject)
504 {
505     *ppvObject = 0;
506     if (IsEqualGUID(riid, IID_IDOMHTMLFormElement))
507         *ppvObject = static_cast<IDOMHTMLFormElement*>(this);
508     else
509         return DOMHTMLElement::QueryInterface(riid, ppvObject);
510
511     AddRef();
512     return S_OK;
513 }
514
515 // DOMHTMLFormElement ---------------------------------------------------------
516
517 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::elements( 
518         /* [retval][out] */ IDOMHTMLCollection** /*result*/)
519 {
520     ASSERT_NOT_REACHED();
521     return E_NOTIMPL;
522 }
523     
524 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::length( 
525         /* [retval][out] */ int* /*result*/)
526 {
527     ASSERT_NOT_REACHED();
528     return E_NOTIMPL;
529 }
530     
531 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::name( 
532         /* [retval][out] */ BSTR* /*result*/)
533 {
534     ASSERT_NOT_REACHED();
535     return E_NOTIMPL;
536 }
537     
538 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::setName( 
539         /* [in] */ BSTR /*name*/)
540 {
541     ASSERT_NOT_REACHED();
542     return E_NOTIMPL;
543 }
544     
545 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::acceptCharset( 
546         /* [retval][out] */ BSTR* /*result*/)
547 {
548     ASSERT_NOT_REACHED();
549     return E_NOTIMPL;
550 }
551     
552 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::setAcceptCharset( 
553         /* [in] */ BSTR /*acceptCharset*/)
554 {
555     ASSERT_NOT_REACHED();
556     return E_NOTIMPL;
557 }
558     
559 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::action( 
560         /* [retval][out] */ BSTR* result)
561 {
562     ASSERT(m_element && m_element->hasTagName(formTag));
563     WTF::String actionString = static_cast<HTMLFormElement*>(m_element)->action();
564     *result = BString(actionString.characters(), actionString.length()).release();
565     return S_OK;
566 }
567     
568 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::setAction( 
569         /* [in] */ BSTR /*action*/)
570 {
571     ASSERT_NOT_REACHED();
572     return E_NOTIMPL;
573 }
574     
575 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::encType( 
576         /* [retval][out] */ BSTR* /*result*/)
577 {
578     ASSERT_NOT_REACHED();
579     return E_NOTIMPL;
580 }
581     
582 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::setEnctype( 
583         /* [retval][out] */ BSTR* /*encType*/)
584 {
585     ASSERT_NOT_REACHED();
586     return E_NOTIMPL;
587 }
588     
589 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::method( 
590         /* [retval][out] */ BSTR* result)
591 {
592     ASSERT(m_element && m_element->hasTagName(formTag));
593     WTF::String methodString = static_cast<HTMLFormElement*>(m_element)->method();
594     *result = BString(methodString.characters(), methodString.length()).release();
595     return S_OK;
596 }
597     
598 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::setMethod( 
599         /* [in] */ BSTR /*method*/)
600 {
601     ASSERT_NOT_REACHED();
602     return E_NOTIMPL;
603 }
604     
605 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::target( 
606         /* [retval][out] */ BSTR* /*result*/)
607 {
608     ASSERT_NOT_REACHED();
609     return E_NOTIMPL;
610 }
611     
612 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::setTarget( 
613         /* [in] */ BSTR /*target*/)
614 {
615     ASSERT_NOT_REACHED();
616     return E_NOTIMPL;
617 }
618     
619 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::submit( void)
620 {
621     ASSERT_NOT_REACHED();
622     return E_NOTIMPL;
623 }
624     
625 HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::reset( void)
626 {
627     ASSERT_NOT_REACHED();
628     return E_NOTIMPL;
629 }
630
631 // DOMHTMLSelectElement - IUnknown ----------------------------------------------
632
633 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::QueryInterface(REFIID riid, void** ppvObject)
634 {
635     *ppvObject = 0;
636     if (IsEqualGUID(riid, IID_IDOMHTMLSelectElement))
637         *ppvObject = static_cast<IDOMHTMLSelectElement*>(this);
638     else if (IsEqualGUID(riid, IID_IFormsAutoFillTransitionSelect))
639         *ppvObject = static_cast<IFormsAutoFillTransitionSelect*>(this);
640     else
641         return DOMHTMLElement::QueryInterface(riid, ppvObject);
642
643     AddRef();
644     return S_OK;
645 }
646
647 // DOMHTMLSelectElement -------------------------------------------------------
648
649 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::type( 
650         /* [retval][out] */ BSTR* /*result*/)
651 {
652     ASSERT_NOT_REACHED();
653     return E_NOTIMPL;
654 }
655     
656 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::selectedIndex( 
657         /* [retval][out] */ int* /*result*/)
658 {
659     ASSERT_NOT_REACHED();
660     return E_NOTIMPL;
661 }
662     
663 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setSelectedIndx( 
664         /* [in] */ int /*selectedIndex*/)
665 {
666     ASSERT_NOT_REACHED();
667     return E_NOTIMPL;
668 }
669     
670 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::value( 
671         /* [retval][out] */ BSTR* /*result*/)
672 {
673     ASSERT_NOT_REACHED();
674     return E_NOTIMPL;
675 }
676     
677 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setValue( 
678         /* [in] */ BSTR /*value*/)
679 {
680     ASSERT_NOT_REACHED();
681     return E_NOTIMPL;
682 }
683     
684 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::length( 
685         /* [retval][out] */ int* /*result*/)
686 {
687     ASSERT_NOT_REACHED();
688     return E_NOTIMPL;
689 }
690     
691 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::form( 
692         /* [retval][out] */ IDOMHTMLFormElement** /*result*/)
693 {
694     ASSERT_NOT_REACHED();
695     return E_NOTIMPL;
696 }
697     
698 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::options( 
699         /* [retval][out] */ IDOMHTMLOptionsCollection** result)
700 {
701     if (!result)
702         return E_POINTER;
703
704     *result = 0;
705
706     ASSERT(m_element);
707     ASSERT(m_element->hasTagName(selectTag));
708     HTMLSelectElement* selectElement = static_cast<HTMLSelectElement*>(m_element);
709
710     if (!selectElement->options())
711         return E_FAIL;
712
713     RefPtr<HTMLOptionsCollection> options = selectElement->options();
714     *result = DOMHTMLOptionsCollection::createInstance(options.get());
715     return S_OK;
716 }
717     
718 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::disabled( 
719         /* [retval][out] */ BOOL* /*result*/)
720 {
721     ASSERT_NOT_REACHED();
722     return E_NOTIMPL;
723 }
724     
725 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setDisabled( 
726         /* [in] */ BOOL /*disabled*/)
727 {
728     ASSERT_NOT_REACHED();
729     return E_NOTIMPL;
730 }
731     
732 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::multiple( 
733         /* [retval][out] */ BOOL* /*result*/)
734 {
735     ASSERT_NOT_REACHED();
736     return E_NOTIMPL;
737 }
738     
739 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setMultiple( 
740         /* [in] */ BOOL /*multiple*/)
741 {
742     ASSERT_NOT_REACHED();
743     return E_NOTIMPL;
744 }
745     
746 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::name( 
747         /* [retval][out] */ BSTR* /*result*/)
748 {
749     ASSERT_NOT_REACHED();
750     return E_NOTIMPL;
751 }
752     
753 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setName( 
754         /* [in] */ BSTR /*name*/)
755 {
756     ASSERT_NOT_REACHED();
757     return E_NOTIMPL;
758 }
759     
760 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::size( 
761         /* [retval][out] */ int* /*size*/)
762 {
763     ASSERT_NOT_REACHED();
764     return E_NOTIMPL;
765 }
766     
767 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setSize( 
768         /* [in] */ int /*size*/)
769 {
770     ASSERT_NOT_REACHED();
771     return E_NOTIMPL;
772 }
773     
774 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::tabIndex( 
775         /* [retval][out] */ int* /*result*/)
776 {
777     ASSERT_NOT_REACHED();
778     return E_NOTIMPL;
779 }
780     
781 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setTabIndex( 
782         /* [in] */ int /*tabIndex*/)
783 {
784     ASSERT_NOT_REACHED();
785     return E_NOTIMPL;
786 }
787     
788 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::add( 
789         /* [in] */ IDOMHTMLElement* /*element*/,
790         /* [in] */ IDOMHTMLElement* /*before*/)
791 {
792     ASSERT_NOT_REACHED();
793     return E_NOTIMPL;
794 }
795     
796 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::remove( 
797         /* [in] */ int /*index*/)
798 {
799     ASSERT_NOT_REACHED();
800     return E_NOTIMPL;
801 }
802     
803 // DOMHTMLSelectElement - IFormsAutoFillTransitionSelect ----------------------
804
805 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::activateItemAtIndex( 
806     /* [in] */ int index)
807 {
808     ASSERT(m_element);
809     ASSERT(m_element->hasTagName(selectTag));
810     HTMLSelectElement* selectElement = static_cast<HTMLSelectElement*>(m_element);
811
812     if (index >= selectElement->length())
813         return E_FAIL;
814
815     selectElement->setSelectedIndex(index);
816     return S_OK;
817 }
818
819 // DOMHTMLOptionElement - IUnknown --------------------------------------------
820
821 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::QueryInterface(REFIID riid, void** ppvObject)
822 {
823     *ppvObject = 0;
824     if (IsEqualGUID(riid, IID_IDOMHTMLOptionElement))
825         *ppvObject = static_cast<IDOMHTMLOptionElement*>(this);
826     else
827         return DOMHTMLElement::QueryInterface(riid, ppvObject);
828
829     AddRef();
830     return S_OK;
831 }
832
833 // DOMHTMLOptionElement -------------------------------------------------------
834
835 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::form( 
836         /* [retval][out] */ IDOMHTMLFormElement** /*result*/)
837 {
838     ASSERT_NOT_REACHED();
839     return E_NOTIMPL;
840 }
841     
842 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::defaultSelected( 
843         /* [retval][out] */ BOOL* /*result*/)
844 {
845     ASSERT_NOT_REACHED();
846     return E_NOTIMPL;
847 }
848     
849 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setDefaultSelected( 
850         /* [in] */ BOOL /*defaultSelected*/)
851 {
852     ASSERT_NOT_REACHED();
853     return E_NOTIMPL;
854 }
855     
856 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::text( 
857         /* [retval][out] */ BSTR* result)
858 {
859     if (!result)
860         return E_POINTER;
861
862     *result = 0;
863
864     ASSERT(m_element);
865     ASSERT(m_element->hasTagName(optionTag));
866     HTMLOptionElement* optionElement = static_cast<HTMLOptionElement*>(m_element);
867
868     *result = BString(optionElement->text()).release();
869     return S_OK;
870 }
871     
872 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::index( 
873         /* [retval][out] */ int* /*result*/)
874 {
875     ASSERT_NOT_REACHED();
876     return E_NOTIMPL;
877 }
878     
879 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::disabled( 
880         /* [retval][out] */ BOOL* /*result*/)
881 {
882     ASSERT_NOT_REACHED();
883     return E_NOTIMPL;
884 }
885     
886 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setDisabled( 
887         /* [in] */ BOOL /*disabled*/)
888 {
889     ASSERT_NOT_REACHED();
890     return E_NOTIMPL;
891 }
892     
893 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::label( 
894         /* [retval][out] */ BSTR* result)
895 {
896     if (!result)
897         return E_POINTER;
898
899     *result = 0;
900
901     ASSERT(m_element);
902     ASSERT(m_element->hasTagName(optionTag));
903     HTMLOptionElement* optionElement = static_cast<HTMLOptionElement*>(m_element);
904
905     *result = BString(optionElement->label()).release();
906     return S_OK;
907 }
908     
909 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setLabel( 
910         /* [in] */ BSTR /*label*/)
911 {
912     ASSERT_NOT_REACHED();
913     return E_NOTIMPL;
914 }
915     
916 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::selected( 
917         /* [retval][out] */ BOOL* /*result*/)
918 {
919     ASSERT_NOT_REACHED();
920     return E_NOTIMPL;
921 }
922     
923 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setSelected( 
924         /* [in] */ BOOL /*selected*/)
925 {
926     ASSERT_NOT_REACHED();
927     return E_NOTIMPL;
928 }
929     
930 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::value( 
931         /* [retval][out] */ BSTR* /*result*/)
932 {
933     ASSERT_NOT_REACHED();
934     return E_NOTIMPL;
935 }
936     
937 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setValue( 
938         /* [in] */ BSTR /*value*/)
939 {
940     ASSERT_NOT_REACHED();
941     return E_NOTIMPL;
942 }
943
944 // DOMHTMLInputElement - IUnknown ----------------------------------------------
945
946 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::QueryInterface(REFIID riid, void** ppvObject)
947 {
948     *ppvObject = 0;
949     if (IsEqualGUID(riid, IID_IDOMHTMLInputElement))
950         *ppvObject = static_cast<IDOMHTMLInputElement*>(this);
951     else if (IsEqualGUID(riid, IID_IFormsAutoFillTransition))
952         *ppvObject = static_cast<IFormsAutoFillTransition*>(this);
953     else if (IsEqualGUID(riid, IID_IFormPromptAdditions))
954         *ppvObject = static_cast<IFormPromptAdditions*>(this);    
955     else
956         return DOMHTMLElement::QueryInterface(riid, ppvObject);
957
958     AddRef();
959     return S_OK;
960 }
961
962 // DOMHTMLInputElement --------------------------------------------------------
963
964 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::defaultValue( 
965         /* [retval][out] */ BSTR* /*result*/)
966 {
967     ASSERT_NOT_REACHED();
968     return E_NOTIMPL;
969 }
970     
971 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setDefaultValue( 
972         /* [in] */ BSTR /*val*/)
973 {
974     ASSERT_NOT_REACHED();
975     return E_NOTIMPL;
976 }
977     
978 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::defaultChecked( 
979         /* [retval][out] */ BOOL* /*result*/)
980 {
981     ASSERT_NOT_REACHED();
982     return E_NOTIMPL;
983 }
984     
985 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setDefaultChecked( 
986         /* [in] */ BSTR /*checked*/)
987 {
988     ASSERT_NOT_REACHED();
989     return E_NOTIMPL;
990 }
991     
992 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::form( 
993         /* [retval][out] */ IDOMHTMLElement** result)
994 {
995     if (!result)
996         return E_POINTER;
997     *result = 0;
998     ASSERT(m_element && m_element->hasTagName(inputTag));
999     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1000     COMPtr<IDOMElement> domElement;
1001     domElement.adoptRef(DOMHTMLElement::createInstance(inputElement->form()));
1002     if (domElement)
1003         return domElement->QueryInterface(IID_IDOMHTMLElement, (void**) result);
1004     return E_FAIL;
1005 }
1006     
1007 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::accept( 
1008         /* [retval][out] */ BSTR* /*result*/)
1009 {
1010     ASSERT_NOT_REACHED();
1011     return E_NOTIMPL;
1012 }
1013     
1014 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAccept( 
1015         /* [in] */ BSTR /*accept*/)
1016 {
1017     ASSERT_NOT_REACHED();
1018     return E_NOTIMPL;
1019 }
1020     
1021 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::accessKey( 
1022         /* [retval][out] */ BSTR* /*result*/)
1023 {
1024     ASSERT_NOT_REACHED();
1025     return E_NOTIMPL;
1026 }
1027     
1028 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAccessKey( 
1029         /* [in] */ BSTR /*key*/)
1030 {
1031     ASSERT_NOT_REACHED();
1032     return E_NOTIMPL;
1033 }
1034     
1035 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::align( 
1036         /* [retval][out] */ BSTR* /*result*/)
1037 {
1038     ASSERT_NOT_REACHED();
1039     return E_NOTIMPL;
1040 }
1041     
1042 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAlign( 
1043         /* [in] */ BSTR /*align*/)
1044 {
1045     ASSERT_NOT_REACHED();
1046     return E_NOTIMPL;
1047 }
1048     
1049 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::alt( 
1050         /* [retval][out] */ BSTR* /*result*/)
1051 {
1052     ASSERT_NOT_REACHED();
1053     return E_NOTIMPL;
1054 }
1055     
1056 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAlt( 
1057         /* [in] */ BSTR /*alt*/)
1058 {
1059     ASSERT_NOT_REACHED();
1060     return E_NOTIMPL;
1061 }
1062     
1063 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::checked( 
1064         /* [retval][out] */ BOOL* /*result*/)
1065 {
1066     ASSERT_NOT_REACHED();
1067     return E_NOTIMPL;
1068 }
1069     
1070 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setChecked( 
1071         /* [in] */ BOOL /*checked*/)
1072 {
1073     ASSERT_NOT_REACHED();
1074     return E_NOTIMPL;
1075 }
1076     
1077 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::disabled( 
1078         /* [retval][out] */ BOOL* result)
1079 {
1080     ASSERT(m_element && m_element->hasTagName(inputTag));
1081     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1082     *result = inputElement->disabled() ? TRUE : FALSE;
1083     return S_OK;
1084 }
1085     
1086 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setDisabled( 
1087         /* [in] */ BOOL /*disabled*/)
1088 {
1089     ASSERT_NOT_REACHED();
1090     return E_NOTIMPL;
1091 }
1092     
1093 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::maxLength( 
1094         /* [retval][out] */ int* /*result*/)
1095 {
1096     ASSERT_NOT_REACHED();
1097     return E_NOTIMPL;
1098 }
1099     
1100 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setMaxLength( 
1101         /* [in] */ int /*maxLength*/)
1102 {
1103     ASSERT_NOT_REACHED();
1104     return E_NOTIMPL;
1105 }
1106     
1107 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::name( 
1108         /* [retval][out] */ BSTR* /*name*/)
1109 {
1110     ASSERT_NOT_REACHED();
1111     return E_NOTIMPL;
1112 }
1113     
1114 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setName( 
1115         /* [in] */ BSTR /*name*/)
1116 {
1117     ASSERT_NOT_REACHED();
1118     return E_NOTIMPL;
1119 }
1120     
1121 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::readOnly( 
1122         /* [retval][out] */ BOOL* result)
1123 {
1124     ASSERT(m_element && m_element->hasTagName(inputTag));
1125     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1126     *result = inputElement->readOnly() ? TRUE : FALSE;
1127     return S_OK;
1128 }
1129     
1130 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setReadOnly( 
1131         /* [in] */ BOOL /*readOnly*/)
1132 {
1133     ASSERT_NOT_REACHED();
1134     return E_NOTIMPL;
1135 }
1136     
1137 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::size( 
1138         /* [retval][out] */ unsigned int* /*result*/)
1139 {
1140     ASSERT_NOT_REACHED();
1141     return E_NOTIMPL;
1142 }
1143     
1144 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setSize( 
1145         /* [in] */ unsigned int /*size*/)
1146 {
1147     ASSERT_NOT_REACHED();
1148     return E_NOTIMPL;
1149 }
1150     
1151 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::src( 
1152         /* [retval][out] */ BSTR* /*result*/)
1153 {
1154     ASSERT_NOT_REACHED();
1155     return E_NOTIMPL;
1156 }
1157     
1158 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setSrc( 
1159         /* [in] */ BSTR /*src*/)
1160 {
1161     ASSERT_NOT_REACHED();
1162     return E_NOTIMPL;
1163 }
1164     
1165 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::tabIndex( 
1166         /* [retval][out] */ int* /*result*/)
1167 {
1168     ASSERT_NOT_REACHED();
1169     return E_NOTIMPL;
1170 }
1171     
1172 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setTabIndex( 
1173         /* [in] */ int /*tabIndex*/)
1174 {
1175     ASSERT_NOT_REACHED();
1176     return E_NOTIMPL;
1177 }
1178     
1179 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::type( 
1180         /* [retval][out] */ BSTR* /*result*/)
1181 {
1182     ASSERT_NOT_REACHED();
1183     return E_NOTIMPL;
1184 }
1185     
1186 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setType( 
1187         /* [in] */ BSTR type)
1188 {
1189     ASSERT(m_element && m_element->hasTagName(inputTag));
1190     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1191     WTF::String typeString(type, SysStringLen(type));
1192     inputElement->setType(typeString);
1193     return S_OK;
1194 }
1195     
1196 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::useMap( 
1197         /* [retval][out] */ BSTR* /*result*/)
1198 {
1199     ASSERT_NOT_REACHED();
1200     return E_NOTIMPL;
1201 }
1202     
1203 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setUseMap( 
1204         /* [in] */ BSTR /*useMap*/)
1205 {
1206     ASSERT_NOT_REACHED();
1207     return E_NOTIMPL;
1208 }
1209     
1210 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::value( 
1211         /* [retval][out] */ BSTR* result)
1212 {
1213     ASSERT(m_element && m_element->hasTagName(inputTag));
1214     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1215     WTF::String valueString = inputElement->value();
1216     *result = BString(valueString.characters(), valueString.length()).release();
1217     if (valueString.length() && !*result)
1218         return E_OUTOFMEMORY;
1219     return S_OK;
1220 }
1221     
1222 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setValue( 
1223         /* [in] */ BSTR value)
1224 {
1225     ASSERT(m_element && m_element->hasTagName(inputTag));
1226     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1227     inputElement->setValue(String((UChar*) value, SysStringLen(value)));
1228     return S_OK;
1229 }
1230
1231 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setValueForUser(
1232         /* [in] */ BSTR value)
1233 {
1234     ASSERT(m_element);
1235     ASSERT(m_element->hasTagName(inputTag));
1236     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1237     inputElement->setValueForUser(String(static_cast<UChar*>(value), SysStringLen(value)));
1238     return S_OK;
1239 }
1240
1241 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::select( void)
1242 {
1243     ASSERT(m_element && m_element->hasTagName(inputTag));
1244     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1245     inputElement->select();
1246     return S_OK;
1247 }
1248     
1249 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::click( void)
1250 {
1251     ASSERT_NOT_REACHED();
1252     return E_NOTIMPL;
1253 }
1254
1255 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setSelectionStart( 
1256     /* [in] */ long start)
1257 {
1258     ASSERT(m_element && m_element->hasTagName(inputTag));
1259     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1260     inputElement->setSelectionStart(start);
1261     return S_OK;
1262 }
1263
1264 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::selectionStart( 
1265     /* [retval][out] */ long *start)
1266 {
1267     ASSERT(m_element && m_element->hasTagName(inputTag));
1268     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1269     *start = inputElement->selectionStart();
1270     return S_OK;
1271 }
1272
1273 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setSelectionEnd( 
1274     /* [in] */ long end)
1275 {
1276     ASSERT(m_element && m_element->hasTagName(inputTag));
1277     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1278     inputElement->setSelectionEnd(end);
1279     return S_OK;
1280 }
1281
1282 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::selectionEnd( 
1283     /* [retval][out] */ long *end)
1284 {
1285     ASSERT(m_element && m_element->hasTagName(inputTag));
1286     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1287     *end = inputElement->selectionEnd();
1288     return S_OK;
1289 }
1290
1291 // DOMHTMLInputElement -- IFormsAutoFillTransition ----------------------------
1292
1293 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::isTextField(
1294     /* [retval][out] */ BOOL* result)
1295 {
1296     ASSERT(m_element);
1297     ASSERT(m_element->hasTagName(inputTag));
1298     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1299     *result = inputElement->isTextField() ? TRUE : FALSE;
1300     return S_OK;
1301 }
1302
1303 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::rectOnScreen( 
1304     /* [retval][out] */ LPRECT rect)
1305 {
1306     ASSERT(m_element);
1307     ASSERT(m_element->hasTagName(inputTag));
1308     rect->left = rect->top = rect->right = rect->bottom = 0;
1309     RenderObject* renderer = m_element->renderer();
1310     FrameView* view = m_element->document()->view();
1311     if (!renderer || !view)
1312         return E_FAIL;
1313
1314     IntRect coreRect = view->contentsToScreen(renderer->absoluteBoundingBoxRect());
1315     rect->left = coreRect.x();
1316     rect->top = coreRect.y();
1317     rect->right = coreRect.maxX();
1318     rect->bottom = coreRect.maxY();
1319
1320     return S_OK;
1321 }
1322
1323 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::replaceCharactersInRange( 
1324     /* [in] */ int startTarget,
1325     /* [in] */ int endTarget,
1326     /* [in] */ BSTR replacementString,
1327     /* [in] */ int index)
1328 {
1329     if (!replacementString)
1330         return E_POINTER;
1331
1332     ASSERT(m_element);
1333     ASSERT(m_element->hasTagName(inputTag));
1334     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1335
1336     String newValue = inputElement->value();
1337     String webCoreReplacementString(static_cast<UChar*>(replacementString), SysStringLen(replacementString));
1338     newValue.replace(startTarget, endTarget - startTarget, webCoreReplacementString);
1339     inputElement->setValue(newValue);
1340     inputElement->setSelectionRange(index, newValue.length());
1341
1342     return S_OK;
1343 }
1344
1345 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::selectedRange( 
1346     /* [out] */ int* start,
1347     /* [out] */ int* end)
1348 {
1349     ASSERT(m_element);
1350     ASSERT(m_element->hasTagName(inputTag));
1351     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1352     *start = inputElement->selectionStart();
1353     *end = inputElement->selectionEnd();
1354     return S_OK;
1355 }
1356
1357 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAutofilled( 
1358     /* [in] */ BOOL filled)
1359 {
1360     ASSERT(m_element);
1361     ASSERT(m_element->hasTagName(inputTag));
1362     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1363     inputElement->setAutofilled(!!filled);
1364     return S_OK;
1365 }
1366
1367 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::isAutofilled(
1368     /* [retval][out] */ BOOL* result)
1369 {
1370     ASSERT(m_element);
1371     ASSERT(m_element->hasTagName(inputTag));
1372     HTMLInputElement* inputElement = static_cast<HTMLInputElement*>(m_element);
1373     *result = inputElement->isAutofilled() ? TRUE : FALSE;
1374     return S_OK;
1375 }
1376
1377 // DOMHTMLInputElement -- IFormPromptAdditions ------------------------------------
1378
1379 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::isUserEdited( 
1380     /* [retval][out] */ BOOL *result)
1381 {
1382     if (!result)
1383         return E_POINTER;
1384
1385     *result = FALSE;
1386     ASSERT(m_element && m_element->hasTagName(inputTag));
1387     BOOL textField = FALSE;
1388     if (FAILED(isTextField(&textField)) || !textField)
1389         return S_OK;
1390     if (static_cast<HTMLInputElement*>(m_element)->lastChangeWasUserEdit())
1391         *result = TRUE;
1392     return S_OK;
1393 }
1394
1395 // DOMHTMLTextAreaElement - IUnknown ----------------------------------------------
1396
1397 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::QueryInterface(REFIID riid, void** ppvObject)
1398 {
1399     *ppvObject = 0;
1400     if (IsEqualGUID(riid, IID_IDOMHTMLTextAreaElement))
1401         *ppvObject = static_cast<IDOMHTMLTextAreaElement*>(this);
1402     else if (IsEqualGUID(riid, IID_IFormPromptAdditions))
1403         *ppvObject = static_cast<IFormPromptAdditions*>(this);    
1404     else
1405         return DOMHTMLElement::QueryInterface(riid, ppvObject);
1406
1407     AddRef();
1408     return S_OK;
1409 }
1410
1411 // DOMHTMLTextAreaElement -----------------------------------------------------
1412
1413 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::defaultValue( 
1414         /* [retval][out] */ BSTR* /*result*/)
1415 {
1416     ASSERT_NOT_REACHED();
1417     return E_NOTIMPL;
1418 }
1419     
1420 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setDefaultValue( 
1421         /* [in] */ BSTR /*val*/)
1422 {
1423     ASSERT_NOT_REACHED();
1424     return E_NOTIMPL;
1425 }
1426     
1427 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::form( 
1428         /* [retval][out] */ IDOMHTMLElement** result)
1429 {
1430     if (!result)
1431         return E_POINTER;
1432     *result = 0;
1433     ASSERT(m_element && m_element->hasTagName(textareaTag));
1434     HTMLTextAreaElement* textareaElement = static_cast<HTMLTextAreaElement*>(m_element);
1435     COMPtr<IDOMElement> domElement;
1436     domElement.adoptRef(DOMHTMLElement::createInstance(textareaElement->form()));
1437     if (domElement)
1438         return domElement->QueryInterface(IID_IDOMHTMLElement, (void**) result);
1439     return E_FAIL;
1440 }
1441     
1442 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::accessKey( 
1443         /* [retval][out] */ BSTR* /*result*/)
1444 {
1445     ASSERT_NOT_REACHED();
1446     return E_NOTIMPL;
1447 }
1448     
1449 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setAccessKey( 
1450         /* [in] */ BSTR /*key*/)
1451 {
1452     ASSERT_NOT_REACHED();
1453     return E_NOTIMPL;
1454 }
1455     
1456 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::cols( 
1457         /* [retval][out] */ int* /*result*/)
1458 {
1459     ASSERT_NOT_REACHED();
1460     return E_NOTIMPL;
1461 }
1462     
1463 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setCols( 
1464         /* [in] */ int /*cols*/)
1465 {
1466     ASSERT_NOT_REACHED();
1467     return E_NOTIMPL;
1468 }
1469     
1470 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::disabled( 
1471         /* [retval][out] */ BOOL* /*result*/)
1472 {
1473     ASSERT_NOT_REACHED();
1474     return E_NOTIMPL;
1475 }
1476     
1477 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setDisabled( 
1478         /* [in] */ BOOL /*disabled*/)
1479 {
1480     ASSERT_NOT_REACHED();
1481     return E_NOTIMPL;
1482 }
1483     
1484 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::name( 
1485         /* [retval][out] */ BSTR* /*name*/)
1486 {
1487     ASSERT_NOT_REACHED();
1488     return E_NOTIMPL;
1489 }
1490     
1491 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setName( 
1492         /* [in] */ BSTR /*name*/)
1493 {
1494     ASSERT_NOT_REACHED();
1495     return E_NOTIMPL;
1496 }
1497     
1498 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::readOnly( 
1499         /* [retval][out] */ BOOL* /*result*/)
1500 {
1501     ASSERT_NOT_REACHED();
1502     return E_NOTIMPL;
1503 }
1504     
1505 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setReadOnly( 
1506         /* [in] */ BOOL /*readOnly*/)
1507 {
1508     ASSERT_NOT_REACHED();
1509     return E_NOTIMPL;
1510 }
1511     
1512 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::rows( 
1513         /* [retval][out] */ int* /*result*/)
1514 {
1515     ASSERT_NOT_REACHED();
1516     return E_NOTIMPL;
1517 }
1518     
1519 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setRows( 
1520         /* [in] */ int /*rows*/)
1521 {
1522     ASSERT_NOT_REACHED();
1523     return E_NOTIMPL;
1524 }
1525     
1526 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::tabIndex( 
1527         /* [retval][out] */ int* /*result*/)
1528 {
1529     ASSERT_NOT_REACHED();
1530     return E_NOTIMPL;
1531 }
1532     
1533 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setTabIndex( 
1534         /* [in] */ int /*tabIndex*/)
1535 {
1536     ASSERT_NOT_REACHED();
1537     return E_NOTIMPL;
1538 }
1539     
1540 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::type( 
1541         /* [retval][out] */ BSTR* /*result*/)
1542 {
1543     ASSERT_NOT_REACHED();
1544     return E_NOTIMPL;
1545 }
1546     
1547 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::value( 
1548         /* [retval][out] */ BSTR* result)
1549 {
1550     ASSERT(m_element && m_element->hasTagName(textareaTag));
1551     HTMLTextAreaElement* textareaElement = static_cast<HTMLTextAreaElement*>(m_element);
1552     WTF::String valueString = textareaElement->value();
1553     *result = BString(valueString.characters(), valueString.length()).release();
1554     if (valueString.length() && !*result)
1555         return E_OUTOFMEMORY;
1556     return S_OK;
1557 }
1558     
1559 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setValue( 
1560         /* [in] */ BSTR value)
1561 {
1562     ASSERT(m_element && m_element->hasTagName(textareaTag));
1563     HTMLTextAreaElement* textareaElement = static_cast<HTMLTextAreaElement*>(m_element);
1564     textareaElement->setValue(String((UChar*) value, SysStringLen(value)));
1565     return S_OK;
1566 }
1567     
1568 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::select( void)
1569 {
1570     ASSERT(m_element && m_element->hasTagName(textareaTag));
1571     HTMLTextAreaElement* textareaElement = static_cast<HTMLTextAreaElement*>(m_element);
1572     textareaElement->select();
1573     return S_OK;
1574 }
1575
1576 // DOMHTMLTextAreaElement -- IFormPromptAdditions ------------------------------------
1577
1578 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::isUserEdited( 
1579     /* [retval][out] */ BOOL *result)
1580 {
1581     if (!result)
1582         return E_POINTER;
1583
1584     *result = FALSE;
1585     ASSERT(m_element && m_element->hasTagName(textareaTag));
1586     if (static_cast<HTMLTextAreaElement*>(m_element)->lastChangeWasUserEdit())
1587         *result = TRUE;
1588     return S_OK;
1589 }
1590
1591 // DOMHTMLIFrameElement - IUnknown --------------------------------------------------
1592
1593 HRESULT STDMETHODCALLTYPE DOMHTMLIFrameElement::QueryInterface(REFIID riid, void** ppvObject)
1594 {
1595     *ppvObject = 0;
1596     if (IsEqualGUID(riid, IID_IDOMHTMLIFrameElement))
1597         *ppvObject = static_cast<IDOMHTMLIFrameElement*>(this);
1598     else
1599         return DOMHTMLElement::QueryInterface(riid, ppvObject);
1600
1601     AddRef();
1602     return S_OK;
1603 }
1604
1605 // DOMHTMLIFrameElement -------------------------------------------------------------
1606
1607 HRESULT STDMETHODCALLTYPE DOMHTMLIFrameElement::contentFrame( 
1608     /* [retval][out] */ IWebFrame **result)
1609 {
1610     if (!result)
1611         return E_POINTER;
1612     *result = 0;
1613     ASSERT(m_element && m_element->hasTagName(iframeTag));
1614     HTMLIFrameElement* iFrameElement = static_cast<HTMLIFrameElement*>(m_element);
1615     COMPtr<IWebFrame> webFrame = kit(iFrameElement->contentFrame());
1616     if (!webFrame)
1617         return E_FAIL;
1618     return webFrame.copyRefTo(result);
1619 }