b38c77a6e6f633035a6d5930d9b7182076a09796
[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 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 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(toHTMLDocument(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 = toHTMLDocument(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 = toHTMLDocument(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 = toHTMLElement(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 = toHTMLElement(m_element)->innerText();
486     *result = BString(innerTextString).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 = toHTMLElement(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 && isHTMLFormElement(m_element));
563     WTF::String actionString = toHTMLFormElement(m_element)->action();
564     *result = BString(actionString).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 && isHTMLFormElement(m_element));
593     WTF::String methodString = toHTMLFormElement(m_element)->method();
594     *result = BString(methodString).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     ASSERT(m_element);
705     HTMLSelectElement* selectElement = toHTMLSelectElement(m_element);
706
707     if (!selectElement->options())
708         return E_FAIL;
709
710     *result = 0;
711     RefPtr<HTMLOptionsCollection> options = selectElement->options();
712     *result = DOMHTMLOptionsCollection::createInstance(options.get());
713     return S_OK;
714 }
715     
716 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::disabled( 
717         /* [retval][out] */ BOOL* /*result*/)
718 {
719     ASSERT_NOT_REACHED();
720     return E_NOTIMPL;
721 }
722     
723 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setDisabled( 
724         /* [in] */ BOOL /*disabled*/)
725 {
726     ASSERT_NOT_REACHED();
727     return E_NOTIMPL;
728 }
729     
730 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::multiple( 
731         /* [retval][out] */ BOOL* /*result*/)
732 {
733     ASSERT_NOT_REACHED();
734     return E_NOTIMPL;
735 }
736     
737 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setMultiple( 
738         /* [in] */ BOOL /*multiple*/)
739 {
740     ASSERT_NOT_REACHED();
741     return E_NOTIMPL;
742 }
743     
744 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::name( 
745         /* [retval][out] */ BSTR* /*result*/)
746 {
747     ASSERT_NOT_REACHED();
748     return E_NOTIMPL;
749 }
750     
751 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setName( 
752         /* [in] */ BSTR /*name*/)
753 {
754     ASSERT_NOT_REACHED();
755     return E_NOTIMPL;
756 }
757     
758 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::size( 
759         /* [retval][out] */ int* /*size*/)
760 {
761     ASSERT_NOT_REACHED();
762     return E_NOTIMPL;
763 }
764     
765 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setSize( 
766         /* [in] */ int /*size*/)
767 {
768     ASSERT_NOT_REACHED();
769     return E_NOTIMPL;
770 }
771     
772 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::tabIndex( 
773         /* [retval][out] */ int* /*result*/)
774 {
775     ASSERT_NOT_REACHED();
776     return E_NOTIMPL;
777 }
778     
779 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setTabIndex( 
780         /* [in] */ int /*tabIndex*/)
781 {
782     ASSERT_NOT_REACHED();
783     return E_NOTIMPL;
784 }
785     
786 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::add( 
787         /* [in] */ IDOMHTMLElement* /*element*/,
788         /* [in] */ IDOMHTMLElement* /*before*/)
789 {
790     ASSERT_NOT_REACHED();
791     return E_NOTIMPL;
792 }
793     
794 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::remove( 
795         /* [in] */ int /*index*/)
796 {
797     ASSERT_NOT_REACHED();
798     return E_NOTIMPL;
799 }
800     
801 // DOMHTMLSelectElement - IFormsAutoFillTransitionSelect ----------------------
802
803 HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::activateItemAtIndex( 
804     /* [in] */ int index)
805 {
806     ASSERT(m_element);
807     HTMLSelectElement* selectElement = toHTMLSelectElement(m_element);
808
809     if (index >= selectElement->length())
810         return E_FAIL;
811
812     selectElement->setSelectedIndex(index);
813     return S_OK;
814 }
815
816 // DOMHTMLOptionElement - IUnknown --------------------------------------------
817
818 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::QueryInterface(REFIID riid, void** ppvObject)
819 {
820     *ppvObject = 0;
821     if (IsEqualGUID(riid, IID_IDOMHTMLOptionElement))
822         *ppvObject = static_cast<IDOMHTMLOptionElement*>(this);
823     else
824         return DOMHTMLElement::QueryInterface(riid, ppvObject);
825
826     AddRef();
827     return S_OK;
828 }
829
830 // DOMHTMLOptionElement -------------------------------------------------------
831
832 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::form( 
833         /* [retval][out] */ IDOMHTMLFormElement** /*result*/)
834 {
835     ASSERT_NOT_REACHED();
836     return E_NOTIMPL;
837 }
838     
839 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::defaultSelected( 
840         /* [retval][out] */ BOOL* /*result*/)
841 {
842     ASSERT_NOT_REACHED();
843     return E_NOTIMPL;
844 }
845     
846 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setDefaultSelected( 
847         /* [in] */ BOOL /*defaultSelected*/)
848 {
849     ASSERT_NOT_REACHED();
850     return E_NOTIMPL;
851 }
852     
853 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::text( 
854         /* [retval][out] */ BSTR* result)
855 {
856     if (!result)
857         return E_POINTER;
858
859     *result = 0;
860
861     ASSERT(m_element);
862     ASSERT(isHTMLOptionElement(m_element));
863     HTMLOptionElement* optionElement = toHTMLOptionElement(m_element);
864
865     *result = BString(optionElement->text()).release();
866     return S_OK;
867 }
868     
869 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::index( 
870         /* [retval][out] */ int* /*result*/)
871 {
872     ASSERT_NOT_REACHED();
873     return E_NOTIMPL;
874 }
875     
876 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::disabled( 
877         /* [retval][out] */ BOOL* /*result*/)
878 {
879     ASSERT_NOT_REACHED();
880     return E_NOTIMPL;
881 }
882     
883 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setDisabled( 
884         /* [in] */ BOOL /*disabled*/)
885 {
886     ASSERT_NOT_REACHED();
887     return E_NOTIMPL;
888 }
889     
890 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::label( 
891         /* [retval][out] */ BSTR* result)
892 {
893     if (!result)
894         return E_POINTER;
895
896     *result = 0;
897
898     ASSERT(m_element);
899     ASSERT(isHTMLOptionElement(m_element));
900     HTMLOptionElement* optionElement = toHTMLOptionElement(m_element);
901
902     *result = BString(optionElement->label()).release();
903     return S_OK;
904 }
905     
906 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setLabel( 
907         /* [in] */ BSTR /*label*/)
908 {
909     ASSERT_NOT_REACHED();
910     return E_NOTIMPL;
911 }
912     
913 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::selected( 
914         /* [retval][out] */ BOOL* /*result*/)
915 {
916     ASSERT_NOT_REACHED();
917     return E_NOTIMPL;
918 }
919     
920 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setSelected( 
921         /* [in] */ BOOL /*selected*/)
922 {
923     ASSERT_NOT_REACHED();
924     return E_NOTIMPL;
925 }
926     
927 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::value( 
928         /* [retval][out] */ BSTR* /*result*/)
929 {
930     ASSERT_NOT_REACHED();
931     return E_NOTIMPL;
932 }
933     
934 HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setValue( 
935         /* [in] */ BSTR /*value*/)
936 {
937     ASSERT_NOT_REACHED();
938     return E_NOTIMPL;
939 }
940
941 // DOMHTMLInputElement - IUnknown ----------------------------------------------
942
943 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::QueryInterface(REFIID riid, void** ppvObject)
944 {
945     *ppvObject = 0;
946     if (IsEqualGUID(riid, IID_IDOMHTMLInputElement))
947         *ppvObject = static_cast<IDOMHTMLInputElement*>(this);
948     else if (IsEqualGUID(riid, IID_IFormsAutoFillTransition))
949         *ppvObject = static_cast<IFormsAutoFillTransition*>(this);
950     else if (IsEqualGUID(riid, IID_IFormPromptAdditions))
951         *ppvObject = static_cast<IFormPromptAdditions*>(this);    
952     else
953         return DOMHTMLElement::QueryInterface(riid, ppvObject);
954
955     AddRef();
956     return S_OK;
957 }
958
959 // DOMHTMLInputElement --------------------------------------------------------
960
961 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::defaultValue( 
962         /* [retval][out] */ BSTR* /*result*/)
963 {
964     ASSERT_NOT_REACHED();
965     return E_NOTIMPL;
966 }
967     
968 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setDefaultValue( 
969         /* [in] */ BSTR /*val*/)
970 {
971     ASSERT_NOT_REACHED();
972     return E_NOTIMPL;
973 }
974     
975 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::defaultChecked( 
976         /* [retval][out] */ BOOL* /*result*/)
977 {
978     ASSERT_NOT_REACHED();
979     return E_NOTIMPL;
980 }
981     
982 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setDefaultChecked( 
983         /* [in] */ BSTR /*checked*/)
984 {
985     ASSERT_NOT_REACHED();
986     return E_NOTIMPL;
987 }
988     
989 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::form( 
990         /* [retval][out] */ IDOMHTMLElement** result)
991 {
992     if (!result)
993         return E_POINTER;
994     *result = 0;
995     ASSERT(m_element && isHTMLInputElement(m_element));
996     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
997     COMPtr<IDOMElement> domElement;
998     domElement.adoptRef(DOMHTMLElement::createInstance(inputElement->form()));
999     if (domElement)
1000         return domElement->QueryInterface(IID_IDOMHTMLElement, (void**) result);
1001     return E_FAIL;
1002 }
1003     
1004 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::accept( 
1005         /* [retval][out] */ BSTR* /*result*/)
1006 {
1007     ASSERT_NOT_REACHED();
1008     return E_NOTIMPL;
1009 }
1010     
1011 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAccept( 
1012         /* [in] */ BSTR /*accept*/)
1013 {
1014     ASSERT_NOT_REACHED();
1015     return E_NOTIMPL;
1016 }
1017     
1018 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::accessKey( 
1019         /* [retval][out] */ BSTR* /*result*/)
1020 {
1021     ASSERT_NOT_REACHED();
1022     return E_NOTIMPL;
1023 }
1024     
1025 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAccessKey( 
1026         /* [in] */ BSTR /*key*/)
1027 {
1028     ASSERT_NOT_REACHED();
1029     return E_NOTIMPL;
1030 }
1031     
1032 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::align( 
1033         /* [retval][out] */ BSTR* /*result*/)
1034 {
1035     ASSERT_NOT_REACHED();
1036     return E_NOTIMPL;
1037 }
1038     
1039 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAlign( 
1040         /* [in] */ BSTR /*align*/)
1041 {
1042     ASSERT_NOT_REACHED();
1043     return E_NOTIMPL;
1044 }
1045     
1046 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::alt( 
1047         /* [retval][out] */ BSTR* /*result*/)
1048 {
1049     ASSERT_NOT_REACHED();
1050     return E_NOTIMPL;
1051 }
1052     
1053 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAlt( 
1054         /* [in] */ BSTR /*alt*/)
1055 {
1056     ASSERT_NOT_REACHED();
1057     return E_NOTIMPL;
1058 }
1059     
1060 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::checked( 
1061         /* [retval][out] */ BOOL* /*result*/)
1062 {
1063     ASSERT_NOT_REACHED();
1064     return E_NOTIMPL;
1065 }
1066     
1067 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setChecked( 
1068         /* [in] */ BOOL /*checked*/)
1069 {
1070     ASSERT_NOT_REACHED();
1071     return E_NOTIMPL;
1072 }
1073     
1074 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::disabled( 
1075         /* [retval][out] */ BOOL* result)
1076 {
1077     ASSERT(m_element && isHTMLInputElement(m_element));
1078     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1079     *result = inputElement->isDisabledFormControl() ? TRUE : FALSE;
1080     return S_OK;
1081 }
1082     
1083 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setDisabled( 
1084         /* [in] */ BOOL /*disabled*/)
1085 {
1086     ASSERT_NOT_REACHED();
1087     return E_NOTIMPL;
1088 }
1089     
1090 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::maxLength( 
1091         /* [retval][out] */ int* /*result*/)
1092 {
1093     ASSERT_NOT_REACHED();
1094     return E_NOTIMPL;
1095 }
1096     
1097 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setMaxLength( 
1098         /* [in] */ int /*maxLength*/)
1099 {
1100     ASSERT_NOT_REACHED();
1101     return E_NOTIMPL;
1102 }
1103     
1104 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::name( 
1105         /* [retval][out] */ BSTR* /*name*/)
1106 {
1107     ASSERT_NOT_REACHED();
1108     return E_NOTIMPL;
1109 }
1110     
1111 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setName( 
1112         /* [in] */ BSTR /*name*/)
1113 {
1114     ASSERT_NOT_REACHED();
1115     return E_NOTIMPL;
1116 }
1117     
1118 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::readOnly( 
1119         /* [retval][out] */ BOOL* result)
1120 {
1121     ASSERT(m_element && isHTMLInputElement(m_element));
1122     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1123     *result = inputElement->isReadOnly() ? TRUE : FALSE;
1124     return S_OK;
1125 }
1126     
1127 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setReadOnly( 
1128         /* [in] */ BOOL /*readOnly*/)
1129 {
1130     ASSERT_NOT_REACHED();
1131     return E_NOTIMPL;
1132 }
1133     
1134 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::size( 
1135         /* [retval][out] */ unsigned int* /*result*/)
1136 {
1137     ASSERT_NOT_REACHED();
1138     return E_NOTIMPL;
1139 }
1140     
1141 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setSize( 
1142         /* [in] */ unsigned int /*size*/)
1143 {
1144     ASSERT_NOT_REACHED();
1145     return E_NOTIMPL;
1146 }
1147     
1148 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::src( 
1149         /* [retval][out] */ BSTR* /*result*/)
1150 {
1151     ASSERT_NOT_REACHED();
1152     return E_NOTIMPL;
1153 }
1154     
1155 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setSrc( 
1156         /* [in] */ BSTR /*src*/)
1157 {
1158     ASSERT_NOT_REACHED();
1159     return E_NOTIMPL;
1160 }
1161     
1162 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::tabIndex( 
1163         /* [retval][out] */ int* /*result*/)
1164 {
1165     ASSERT_NOT_REACHED();
1166     return E_NOTIMPL;
1167 }
1168     
1169 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setTabIndex( 
1170         /* [in] */ int /*tabIndex*/)
1171 {
1172     ASSERT_NOT_REACHED();
1173     return E_NOTIMPL;
1174 }
1175     
1176 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::type( 
1177         /* [retval][out] */ BSTR* /*result*/)
1178 {
1179     ASSERT_NOT_REACHED();
1180     return E_NOTIMPL;
1181 }
1182     
1183 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setType( 
1184         /* [in] */ BSTR type)
1185 {
1186     ASSERT(m_element && isHTMLInputElement(m_element));
1187     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1188     WTF::String typeString(type, SysStringLen(type));
1189     inputElement->setType(typeString);
1190     return S_OK;
1191 }
1192     
1193 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::useMap( 
1194         /* [retval][out] */ BSTR* /*result*/)
1195 {
1196     ASSERT_NOT_REACHED();
1197     return E_NOTIMPL;
1198 }
1199     
1200 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setUseMap( 
1201         /* [in] */ BSTR /*useMap*/)
1202 {
1203     ASSERT_NOT_REACHED();
1204     return E_NOTIMPL;
1205 }
1206     
1207 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::value( 
1208         /* [retval][out] */ BSTR* result)
1209 {
1210     ASSERT(m_element && isHTMLInputElement(m_element));
1211     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1212     WTF::String valueString = inputElement->value();
1213     *result = BString(valueString).release();
1214     if (valueString.length() && !*result)
1215         return E_OUTOFMEMORY;
1216     return S_OK;
1217 }
1218     
1219 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setValue( 
1220         /* [in] */ BSTR value)
1221 {
1222     ASSERT(m_element && isHTMLInputElement(m_element));
1223     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1224     inputElement->setValue(String((UChar*) value, SysStringLen(value)));
1225     return S_OK;
1226 }
1227
1228 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setValueForUser(
1229         /* [in] */ BSTR value)
1230 {
1231     ASSERT(m_element);
1232     ASSERT(isHTMLInputElement(m_element));
1233     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1234     inputElement->setValueForUser(String(static_cast<UChar*>(value), SysStringLen(value)));
1235     return S_OK;
1236 }
1237
1238 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::select( void)
1239 {
1240     ASSERT(m_element && isHTMLInputElement(m_element));
1241     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1242     inputElement->select();
1243     return S_OK;
1244 }
1245     
1246 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::click( void)
1247 {
1248     ASSERT_NOT_REACHED();
1249     return E_NOTIMPL;
1250 }
1251
1252 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setSelectionStart( 
1253     /* [in] */ long start)
1254 {
1255     ASSERT(m_element && isHTMLInputElement(m_element));
1256     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1257     inputElement->setSelectionStart(start);
1258     return S_OK;
1259 }
1260
1261 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::selectionStart( 
1262     /* [retval][out] */ long *start)
1263 {
1264     ASSERT(m_element && isHTMLInputElement(m_element));
1265     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1266     *start = inputElement->selectionStart();
1267     return S_OK;
1268 }
1269
1270 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setSelectionEnd( 
1271     /* [in] */ long end)
1272 {
1273     ASSERT(m_element && isHTMLInputElement(m_element));
1274     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1275     inputElement->setSelectionEnd(end);
1276     return S_OK;
1277 }
1278
1279 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::selectionEnd( 
1280     /* [retval][out] */ long *end)
1281 {
1282     ASSERT(m_element && isHTMLInputElement(m_element));
1283     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1284     *end = inputElement->selectionEnd();
1285     return S_OK;
1286 }
1287
1288 // DOMHTMLInputElement -- IFormsAutoFillTransition ----------------------------
1289
1290 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::isTextField(
1291     /* [retval][out] */ BOOL* result)
1292 {
1293     ASSERT(m_element);
1294     ASSERT(isHTMLInputElement(m_element));
1295     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1296     *result = inputElement->isTextField() ? TRUE : FALSE;
1297     return S_OK;
1298 }
1299
1300 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::rectOnScreen( 
1301     /* [retval][out] */ LPRECT rect)
1302 {
1303     ASSERT(m_element);
1304     ASSERT(isHTMLInputElement(m_element));
1305     rect->left = rect->top = rect->right = rect->bottom = 0;
1306     RenderObject* renderer = m_element->renderer();
1307     FrameView* view = m_element->document().view();
1308     if (!renderer || !view)
1309         return E_FAIL;
1310
1311     IntRect coreRect = view->contentsToScreen(renderer->absoluteBoundingBoxRect());
1312     rect->left = coreRect.x();
1313     rect->top = coreRect.y();
1314     rect->right = coreRect.maxX();
1315     rect->bottom = coreRect.maxY();
1316
1317     return S_OK;
1318 }
1319
1320 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::replaceCharactersInRange( 
1321     /* [in] */ int startTarget,
1322     /* [in] */ int endTarget,
1323     /* [in] */ BSTR replacementString,
1324     /* [in] */ int index)
1325 {
1326     if (!replacementString)
1327         return E_POINTER;
1328
1329     ASSERT(m_element);
1330     ASSERT(isHTMLInputElement(m_element));
1331     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1332
1333     String newValue = inputElement->value();
1334     String webCoreReplacementString(static_cast<UChar*>(replacementString), SysStringLen(replacementString));
1335     newValue.replace(startTarget, endTarget - startTarget, webCoreReplacementString);
1336     inputElement->setValue(newValue);
1337     inputElement->setSelectionRange(index, newValue.length());
1338
1339     return S_OK;
1340 }
1341
1342 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::selectedRange( 
1343     /* [out] */ int* start,
1344     /* [out] */ int* end)
1345 {
1346     ASSERT(m_element);
1347     ASSERT(isHTMLInputElement(m_element));
1348     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1349     *start = inputElement->selectionStart();
1350     *end = inputElement->selectionEnd();
1351     return S_OK;
1352 }
1353
1354 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAutofilled( 
1355     /* [in] */ BOOL filled)
1356 {
1357     ASSERT(m_element);
1358     ASSERT(isHTMLInputElement(m_element));
1359     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1360     inputElement->setAutofilled(!!filled);
1361     return S_OK;
1362 }
1363
1364 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::isAutofilled(
1365     /* [retval][out] */ BOOL* result)
1366 {
1367     ASSERT(m_element);
1368     ASSERT(isHTMLInputElement(m_element));
1369     HTMLInputElement* inputElement = toHTMLInputElement(m_element);
1370     *result = inputElement->isAutofilled() ? TRUE : FALSE;
1371     return S_OK;
1372 }
1373
1374 // DOMHTMLInputElement -- IFormPromptAdditions ------------------------------------
1375
1376 HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::isUserEdited( 
1377     /* [retval][out] */ BOOL *result)
1378 {
1379     if (!result)
1380         return E_POINTER;
1381
1382     *result = FALSE;
1383     ASSERT(m_element && isHTMLInputElement(m_element));
1384     BOOL textField = FALSE;
1385     if (FAILED(isTextField(&textField)) || !textField)
1386         return S_OK;
1387     if (toHTMLInputElement(m_element)->lastChangeWasUserEdit())
1388         *result = TRUE;
1389     return S_OK;
1390 }
1391
1392 // DOMHTMLTextAreaElement - IUnknown ----------------------------------------------
1393
1394 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::QueryInterface(REFIID riid, void** ppvObject)
1395 {
1396     *ppvObject = 0;
1397     if (IsEqualGUID(riid, IID_IDOMHTMLTextAreaElement))
1398         *ppvObject = static_cast<IDOMHTMLTextAreaElement*>(this);
1399     else if (IsEqualGUID(riid, IID_IFormPromptAdditions))
1400         *ppvObject = static_cast<IFormPromptAdditions*>(this);    
1401     else
1402         return DOMHTMLElement::QueryInterface(riid, ppvObject);
1403
1404     AddRef();
1405     return S_OK;
1406 }
1407
1408 // DOMHTMLTextAreaElement -----------------------------------------------------
1409
1410 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::defaultValue( 
1411         /* [retval][out] */ BSTR* /*result*/)
1412 {
1413     ASSERT_NOT_REACHED();
1414     return E_NOTIMPL;
1415 }
1416     
1417 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setDefaultValue( 
1418         /* [in] */ BSTR /*val*/)
1419 {
1420     ASSERT_NOT_REACHED();
1421     return E_NOTIMPL;
1422 }
1423     
1424 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::form( 
1425         /* [retval][out] */ IDOMHTMLElement** result)
1426 {
1427     if (!result)
1428         return E_POINTER;
1429     *result = 0;
1430     ASSERT(m_element && isHTMLTextAreaElement(m_element));
1431     HTMLTextAreaElement* textareaElement = toHTMLTextAreaElement(m_element);
1432     COMPtr<IDOMElement> domElement;
1433     domElement.adoptRef(DOMHTMLElement::createInstance(textareaElement->form()));
1434     if (domElement)
1435         return domElement->QueryInterface(IID_IDOMHTMLElement, (void**) result);
1436     return E_FAIL;
1437 }
1438     
1439 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::accessKey( 
1440         /* [retval][out] */ BSTR* /*result*/)
1441 {
1442     ASSERT_NOT_REACHED();
1443     return E_NOTIMPL;
1444 }
1445     
1446 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setAccessKey( 
1447         /* [in] */ BSTR /*key*/)
1448 {
1449     ASSERT_NOT_REACHED();
1450     return E_NOTIMPL;
1451 }
1452     
1453 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::cols( 
1454         /* [retval][out] */ int* /*result*/)
1455 {
1456     ASSERT_NOT_REACHED();
1457     return E_NOTIMPL;
1458 }
1459     
1460 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setCols( 
1461         /* [in] */ int /*cols*/)
1462 {
1463     ASSERT_NOT_REACHED();
1464     return E_NOTIMPL;
1465 }
1466     
1467 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::disabled( 
1468         /* [retval][out] */ BOOL* /*result*/)
1469 {
1470     ASSERT_NOT_REACHED();
1471     return E_NOTIMPL;
1472 }
1473     
1474 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setDisabled( 
1475         /* [in] */ BOOL /*disabled*/)
1476 {
1477     ASSERT_NOT_REACHED();
1478     return E_NOTIMPL;
1479 }
1480     
1481 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::name( 
1482         /* [retval][out] */ BSTR* /*name*/)
1483 {
1484     ASSERT_NOT_REACHED();
1485     return E_NOTIMPL;
1486 }
1487     
1488 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setName( 
1489         /* [in] */ BSTR /*name*/)
1490 {
1491     ASSERT_NOT_REACHED();
1492     return E_NOTIMPL;
1493 }
1494     
1495 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::readOnly( 
1496         /* [retval][out] */ BOOL* /*result*/)
1497 {
1498     ASSERT_NOT_REACHED();
1499     return E_NOTIMPL;
1500 }
1501     
1502 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setReadOnly( 
1503         /* [in] */ BOOL /*readOnly*/)
1504 {
1505     ASSERT_NOT_REACHED();
1506     return E_NOTIMPL;
1507 }
1508     
1509 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::rows( 
1510         /* [retval][out] */ int* /*result*/)
1511 {
1512     ASSERT_NOT_REACHED();
1513     return E_NOTIMPL;
1514 }
1515     
1516 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setRows( 
1517         /* [in] */ int /*rows*/)
1518 {
1519     ASSERT_NOT_REACHED();
1520     return E_NOTIMPL;
1521 }
1522     
1523 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::tabIndex( 
1524         /* [retval][out] */ int* /*result*/)
1525 {
1526     ASSERT_NOT_REACHED();
1527     return E_NOTIMPL;
1528 }
1529     
1530 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setTabIndex( 
1531         /* [in] */ int /*tabIndex*/)
1532 {
1533     ASSERT_NOT_REACHED();
1534     return E_NOTIMPL;
1535 }
1536     
1537 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::type( 
1538         /* [retval][out] */ BSTR* /*result*/)
1539 {
1540     ASSERT_NOT_REACHED();
1541     return E_NOTIMPL;
1542 }
1543     
1544 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::value( 
1545         /* [retval][out] */ BSTR* result)
1546 {
1547     ASSERT(m_element && isHTMLTextAreaElement(m_element));
1548     HTMLTextAreaElement* textareaElement = toHTMLTextAreaElement(m_element);
1549     WTF::String valueString = textareaElement->value();
1550     *result = BString(valueString).release();
1551     if (valueString.length() && !*result)
1552         return E_OUTOFMEMORY;
1553     return S_OK;
1554 }
1555     
1556 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setValue( 
1557         /* [in] */ BSTR value)
1558 {
1559     ASSERT(m_element && isHTMLTextAreaElement(m_element));
1560     HTMLTextAreaElement* textareaElement = toHTMLTextAreaElement(m_element);
1561     textareaElement->setValue(String((UChar*) value, SysStringLen(value)));
1562     return S_OK;
1563 }
1564     
1565 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::select( void)
1566 {
1567     ASSERT(m_element && isHTMLTextAreaElement(m_element));
1568     HTMLTextAreaElement* textareaElement = toHTMLTextAreaElement(m_element);
1569     textareaElement->select();
1570     return S_OK;
1571 }
1572
1573 // DOMHTMLTextAreaElement -- IFormPromptAdditions ------------------------------------
1574
1575 HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::isUserEdited( 
1576     /* [retval][out] */ BOOL *result)
1577 {
1578     if (!result)
1579         return E_POINTER;
1580
1581     *result = FALSE;
1582     ASSERT(m_element && isHTMLTextAreaElement(m_element));
1583     if (toHTMLTextAreaElement(m_element)->lastChangeWasUserEdit())
1584         *result = TRUE;
1585     return S_OK;
1586 }
1587
1588 // DOMHTMLIFrameElement - IUnknown --------------------------------------------------
1589
1590 HRESULT STDMETHODCALLTYPE DOMHTMLIFrameElement::QueryInterface(REFIID riid, void** ppvObject)
1591 {
1592     *ppvObject = 0;
1593     if (IsEqualGUID(riid, IID_IDOMHTMLIFrameElement))
1594         *ppvObject = static_cast<IDOMHTMLIFrameElement*>(this);
1595     else
1596         return DOMHTMLElement::QueryInterface(riid, ppvObject);
1597
1598     AddRef();
1599     return S_OK;
1600 }
1601
1602 // DOMHTMLIFrameElement -------------------------------------------------------------
1603
1604 HRESULT STDMETHODCALLTYPE DOMHTMLIFrameElement::contentFrame( 
1605     /* [retval][out] */ IWebFrame **result)
1606 {
1607     if (!result)
1608         return E_POINTER;
1609     *result = 0;
1610     ASSERT(m_element);
1611     HTMLIFrameElement* iFrameElement = toHTMLIFrameElement(m_element);
1612     COMPtr<IWebFrame> webFrame = kit(iFrameElement->contentFrame());
1613     if (!webFrame)
1614         return E_FAIL;
1615     return webFrame.copyRefTo(result);
1616 }