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
50using namespace WebCore;
51using namespace HTMLNames;
52
53// DOMHTMLCollection
54
55DOMHTMLCollection::DOMHTMLCollection(WebCore::HTMLCollection* c)
56: m_collection(c)
57{
58}
59
60IDOMHTMLCollection* 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
77HRESULT 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
91HRESULT 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
102HRESULT 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
114HRESULT 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
124HRESULT 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
138DOMHTMLOptionsCollection::DOMHTMLOptionsCollection(WebCore::HTMLOptionsCollection* collection)
139    : m_collection(collection)
140{
141}
142
143IDOMHTMLOptionsCollection* 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
158HRESULT 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
168HRESULT STDMETHODCALLTYPE DOMHTMLOptionsCollection::setLength(
169    /* [in] */ unsigned int /*length*/)
170{
171    ASSERT_NOT_REACHED();
172    return E_NOTIMPL;
173}
174
175HRESULT 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
187HRESULT 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
197HRESULT 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
211HRESULT 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
226HRESULT STDMETHODCALLTYPE DOMHTMLDocument::setTitle(
227        /* [in] */ BSTR /*title*/)
228{
229    ASSERT_NOT_REACHED();
230    return E_NOTIMPL;
231}
232
233HRESULT STDMETHODCALLTYPE DOMHTMLDocument::referrer(
234        /* [retval][out] */ BSTR* /*result*/)
235{
236    ASSERT_NOT_REACHED();
237    return E_NOTIMPL;
238}
239
240HRESULT STDMETHODCALLTYPE DOMHTMLDocument::domain(
241        /* [retval][out] */ BSTR* /*result*/)
242{
243    ASSERT_NOT_REACHED();
244    return E_NOTIMPL;
245}
246
247HRESULT 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
257HRESULT 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
272HRESULT STDMETHODCALLTYPE DOMHTMLDocument::setBody(
273        /* [in] */ IDOMHTMLElement* /*body*/)
274{
275    ASSERT_NOT_REACHED();
276    return E_NOTIMPL;
277}
278
279HRESULT STDMETHODCALLTYPE DOMHTMLDocument::images(
280        /* [retval][out] */ IDOMHTMLCollection** /*collection*/)
281{
282    ASSERT_NOT_REACHED();
283    return E_NOTIMPL;
284}
285
286HRESULT STDMETHODCALLTYPE DOMHTMLDocument::applets(
287        /* [retval][out] */ IDOMHTMLCollection** /*collection*/)
288{
289    ASSERT_NOT_REACHED();
290    return E_NOTIMPL;
291}
292
293HRESULT STDMETHODCALLTYPE DOMHTMLDocument::links(
294        /* [retval][out] */ IDOMHTMLCollection** /*collection*/)
295{
296    ASSERT_NOT_REACHED();
297    return E_NOTIMPL;
298}
299
300HRESULT 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
313HRESULT STDMETHODCALLTYPE DOMHTMLDocument::anchors(
314        /* [retval][out] */ IDOMHTMLCollection** /*collection*/)
315{
316    ASSERT_NOT_REACHED();
317    return E_NOTIMPL;
318}
319
320HRESULT STDMETHODCALLTYPE DOMHTMLDocument::cookie(
321        /* [retval][out] */ BSTR* /*result*/)
322{
323    ASSERT_NOT_REACHED();
324    return E_NOTIMPL;
325}
326
327HRESULT STDMETHODCALLTYPE DOMHTMLDocument::setCookie(
328        /* [in] */ BSTR /*cookie*/)
329{
330    ASSERT_NOT_REACHED();
331    return E_NOTIMPL;
332}
333
334HRESULT STDMETHODCALLTYPE DOMHTMLDocument::open( void)
335{
336    ASSERT_NOT_REACHED();
337    return E_NOTIMPL;
338}
339
340HRESULT STDMETHODCALLTYPE DOMHTMLDocument::close( void)
341{
342    ASSERT_NOT_REACHED();
343    return E_NOTIMPL;
344}
345
346HRESULT STDMETHODCALLTYPE DOMHTMLDocument::write(
347        /* [in] */ BSTR /*text*/)
348{
349    ASSERT_NOT_REACHED();
350    return E_NOTIMPL;
351}
352
353HRESULT STDMETHODCALLTYPE DOMHTMLDocument::writeln(
354        /* [in] */ BSTR /*text*/)
355{
356    ASSERT_NOT_REACHED();
357    return E_NOTIMPL;
358}
359
360HRESULT STDMETHODCALLTYPE DOMHTMLDocument::getElementById_(
361        /* [in] */ BSTR /*elementId*/,
362        /* [retval][out] */ IDOMElement** /*element*/)
363{
364    ASSERT_NOT_REACHED();
365    return E_NOTIMPL;
366}
367
368HRESULT 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
378HRESULT 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
392HRESULT 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
404HRESULT STDMETHODCALLTYPE DOMHTMLElement::setIdName(
405        /* [in] */ BSTR /*idName*/)
406{
407    ASSERT_NOT_REACHED();
408    return E_NOTIMPL;
409}
410
411HRESULT STDMETHODCALLTYPE DOMHTMLElement::title(
412        /* [retval][out] */ BSTR* /*result*/)
413{
414    ASSERT_NOT_REACHED();
415    return E_NOTIMPL;
416}
417
418HRESULT STDMETHODCALLTYPE DOMHTMLElement::setTitle(
419        /* [in] */ BSTR /*title*/)
420{
421    ASSERT_NOT_REACHED();
422    return E_NOTIMPL;
423}
424
425HRESULT STDMETHODCALLTYPE DOMHTMLElement::lang(
426        /* [retval][out] */ BSTR* /*result*/)
427{
428    ASSERT_NOT_REACHED();
429    return E_NOTIMPL;
430}
431
432HRESULT STDMETHODCALLTYPE DOMHTMLElement::setLang(
433        /* [in] */ BSTR /*lang*/)
434{
435    ASSERT_NOT_REACHED();
436    return E_NOTIMPL;
437}
438
439HRESULT STDMETHODCALLTYPE DOMHTMLElement::dir(
440        /* [retval][out] */ BSTR* /*result*/)
441{
442    ASSERT_NOT_REACHED();
443    return E_NOTIMPL;
444}
445
446HRESULT STDMETHODCALLTYPE DOMHTMLElement::setDir(
447        /* [in] */ BSTR /*dir*/)
448{
449    ASSERT_NOT_REACHED();
450    return E_NOTIMPL;
451}
452
453HRESULT STDMETHODCALLTYPE DOMHTMLElement::className(
454        /* [retval][out] */ BSTR* /*result*/)
455{
456    ASSERT_NOT_REACHED();
457    return E_NOTIMPL;
458}
459
460HRESULT STDMETHODCALLTYPE DOMHTMLElement::setClassName(
461        /* [in] */ BSTR /*className*/)
462{
463    ASSERT_NOT_REACHED();
464    return E_NOTIMPL;
465}
466
467HRESULT STDMETHODCALLTYPE DOMHTMLElement::innerHTML(
468        /* [retval][out] */ BSTR* /*result*/)
469{
470    ASSERT_NOT_REACHED();
471    return E_NOTIMPL;
472}
473
474HRESULT STDMETHODCALLTYPE DOMHTMLElement::setInnerHTML(
475        /* [in] */ BSTR /*html*/)
476{
477    ASSERT_NOT_REACHED();
478    return E_NOTIMPL;
479}
480
481HRESULT 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
490HRESULT 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
503HRESULT 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
517HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::elements(
518        /* [retval][out] */ IDOMHTMLCollection** /*result*/)
519{
520    ASSERT_NOT_REACHED();
521    return E_NOTIMPL;
522}
523
524HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::length(
525        /* [retval][out] */ int* /*result*/)
526{
527    ASSERT_NOT_REACHED();
528    return E_NOTIMPL;
529}
530
531HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::name(
532        /* [retval][out] */ BSTR* /*result*/)
533{
534    ASSERT_NOT_REACHED();
535    return E_NOTIMPL;
536}
537
538HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::setName(
539        /* [in] */ BSTR /*name*/)
540{
541    ASSERT_NOT_REACHED();
542    return E_NOTIMPL;
543}
544
545HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::acceptCharset(
546        /* [retval][out] */ BSTR* /*result*/)
547{
548    ASSERT_NOT_REACHED();
549    return E_NOTIMPL;
550}
551
552HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::setAcceptCharset(
553        /* [in] */ BSTR /*acceptCharset*/)
554{
555    ASSERT_NOT_REACHED();
556    return E_NOTIMPL;
557}
558
559HRESULT 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
568HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::setAction(
569        /* [in] */ BSTR /*action*/)
570{
571    ASSERT_NOT_REACHED();
572    return E_NOTIMPL;
573}
574
575HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::encType(
576        /* [retval][out] */ BSTR* /*result*/)
577{
578    ASSERT_NOT_REACHED();
579    return E_NOTIMPL;
580}
581
582HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::setEnctype(
583        /* [retval][out] */ BSTR* /*encType*/)
584{
585    ASSERT_NOT_REACHED();
586    return E_NOTIMPL;
587}
588
589HRESULT 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
598HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::setMethod(
599        /* [in] */ BSTR /*method*/)
600{
601    ASSERT_NOT_REACHED();
602    return E_NOTIMPL;
603}
604
605HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::target(
606        /* [retval][out] */ BSTR* /*result*/)
607{
608    ASSERT_NOT_REACHED();
609    return E_NOTIMPL;
610}
611
612HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::setTarget(
613        /* [in] */ BSTR /*target*/)
614{
615    ASSERT_NOT_REACHED();
616    return E_NOTIMPL;
617}
618
619HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::submit( void)
620{
621    ASSERT_NOT_REACHED();
622    return E_NOTIMPL;
623}
624
625HRESULT STDMETHODCALLTYPE DOMHTMLFormElement::reset( void)
626{
627    ASSERT_NOT_REACHED();
628    return E_NOTIMPL;
629}
630
631// DOMHTMLSelectElement - IUnknown ----------------------------------------------
632
633HRESULT 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
649HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::type(
650        /* [retval][out] */ BSTR* /*result*/)
651{
652    ASSERT_NOT_REACHED();
653    return E_NOTIMPL;
654}
655
656HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::selectedIndex(
657        /* [retval][out] */ int* /*result*/)
658{
659    ASSERT_NOT_REACHED();
660    return E_NOTIMPL;
661}
662
663HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setSelectedIndx(
664        /* [in] */ int /*selectedIndex*/)
665{
666    ASSERT_NOT_REACHED();
667    return E_NOTIMPL;
668}
669
670HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::value(
671        /* [retval][out] */ BSTR* /*result*/)
672{
673    ASSERT_NOT_REACHED();
674    return E_NOTIMPL;
675}
676
677HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setValue(
678        /* [in] */ BSTR /*value*/)
679{
680    ASSERT_NOT_REACHED();
681    return E_NOTIMPL;
682}
683
684HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::length(
685        /* [retval][out] */ int* /*result*/)
686{
687    ASSERT_NOT_REACHED();
688    return E_NOTIMPL;
689}
690
691HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::form(
692        /* [retval][out] */ IDOMHTMLFormElement** /*result*/)
693{
694    ASSERT_NOT_REACHED();
695    return E_NOTIMPL;
696}
697
698HRESULT 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
716HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::disabled(
717        /* [retval][out] */ BOOL* /*result*/)
718{
719    ASSERT_NOT_REACHED();
720    return E_NOTIMPL;
721}
722
723HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setDisabled(
724        /* [in] */ BOOL /*disabled*/)
725{
726    ASSERT_NOT_REACHED();
727    return E_NOTIMPL;
728}
729
730HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::multiple(
731        /* [retval][out] */ BOOL* /*result*/)
732{
733    ASSERT_NOT_REACHED();
734    return E_NOTIMPL;
735}
736
737HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setMultiple(
738        /* [in] */ BOOL /*multiple*/)
739{
740    ASSERT_NOT_REACHED();
741    return E_NOTIMPL;
742}
743
744HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::name(
745        /* [retval][out] */ BSTR* /*result*/)
746{
747    ASSERT_NOT_REACHED();
748    return E_NOTIMPL;
749}
750
751HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setName(
752        /* [in] */ BSTR /*name*/)
753{
754    ASSERT_NOT_REACHED();
755    return E_NOTIMPL;
756}
757
758HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::size(
759        /* [retval][out] */ int* /*size*/)
760{
761    ASSERT_NOT_REACHED();
762    return E_NOTIMPL;
763}
764
765HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setSize(
766        /* [in] */ int /*size*/)
767{
768    ASSERT_NOT_REACHED();
769    return E_NOTIMPL;
770}
771
772HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::tabIndex(
773        /* [retval][out] */ int* /*result*/)
774{
775    ASSERT_NOT_REACHED();
776    return E_NOTIMPL;
777}
778
779HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setTabIndex(
780        /* [in] */ int /*tabIndex*/)
781{
782    ASSERT_NOT_REACHED();
783    return E_NOTIMPL;
784}
785
786HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::add(
787        /* [in] */ IDOMHTMLElement* /*element*/,
788        /* [in] */ IDOMHTMLElement* /*before*/)
789{
790    ASSERT_NOT_REACHED();
791    return E_NOTIMPL;
792}
793
794HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::remove(
795        /* [in] */ int /*index*/)
796{
797    ASSERT_NOT_REACHED();
798    return E_NOTIMPL;
799}
800
801// DOMHTMLSelectElement - IFormsAutoFillTransitionSelect ----------------------
802
803HRESULT 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
818HRESULT 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
832HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::form(
833        /* [retval][out] */ IDOMHTMLFormElement** /*result*/)
834{
835    ASSERT_NOT_REACHED();
836    return E_NOTIMPL;
837}
838
839HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::defaultSelected(
840        /* [retval][out] */ BOOL* /*result*/)
841{
842    ASSERT_NOT_REACHED();
843    return E_NOTIMPL;
844}
845
846HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setDefaultSelected(
847        /* [in] */ BOOL /*defaultSelected*/)
848{
849    ASSERT_NOT_REACHED();
850    return E_NOTIMPL;
851}
852
853HRESULT 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
869HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::index(
870        /* [retval][out] */ int* /*result*/)
871{
872    ASSERT_NOT_REACHED();
873    return E_NOTIMPL;
874}
875
876HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::disabled(
877        /* [retval][out] */ BOOL* /*result*/)
878{
879    ASSERT_NOT_REACHED();
880    return E_NOTIMPL;
881}
882
883HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setDisabled(
884        /* [in] */ BOOL /*disabled*/)
885{
886    ASSERT_NOT_REACHED();
887    return E_NOTIMPL;
888}
889
890HRESULT 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
906HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setLabel(
907        /* [in] */ BSTR /*label*/)
908{
909    ASSERT_NOT_REACHED();
910    return E_NOTIMPL;
911}
912
913HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::selected(
914        /* [retval][out] */ BOOL* /*result*/)
915{
916    ASSERT_NOT_REACHED();
917    return E_NOTIMPL;
918}
919
920HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setSelected(
921        /* [in] */ BOOL /*selected*/)
922{
923    ASSERT_NOT_REACHED();
924    return E_NOTIMPL;
925}
926
927HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::value(
928        /* [retval][out] */ BSTR* /*result*/)
929{
930    ASSERT_NOT_REACHED();
931    return E_NOTIMPL;
932}
933
934HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setValue(
935        /* [in] */ BSTR /*value*/)
936{
937    ASSERT_NOT_REACHED();
938    return E_NOTIMPL;
939}
940
941// DOMHTMLInputElement - IUnknown ----------------------------------------------
942
943HRESULT 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
961HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::defaultValue(
962        /* [retval][out] */ BSTR* /*result*/)
963{
964    ASSERT_NOT_REACHED();
965    return E_NOTIMPL;
966}
967
968HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setDefaultValue(
969        /* [in] */ BSTR /*val*/)
970{
971    ASSERT_NOT_REACHED();
972    return E_NOTIMPL;
973}
974
975HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::defaultChecked(
976        /* [retval][out] */ BOOL* /*result*/)
977{
978    ASSERT_NOT_REACHED();
979    return E_NOTIMPL;
980}
981
982HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setDefaultChecked(
983        /* [in] */ BSTR /*checked*/)
984{
985    ASSERT_NOT_REACHED();
986    return E_NOTIMPL;
987}
988
989HRESULT 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
1004HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::accept(
1005        /* [retval][out] */ BSTR* /*result*/)
1006{
1007    ASSERT_NOT_REACHED();
1008    return E_NOTIMPL;
1009}
1010
1011HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAccept(
1012        /* [in] */ BSTR /*accept*/)
1013{
1014    ASSERT_NOT_REACHED();
1015    return E_NOTIMPL;
1016}
1017
1018HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::accessKey(
1019        /* [retval][out] */ BSTR* /*result*/)
1020{
1021    ASSERT_NOT_REACHED();
1022    return E_NOTIMPL;
1023}
1024
1025HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAccessKey(
1026        /* [in] */ BSTR /*key*/)
1027{
1028    ASSERT_NOT_REACHED();
1029    return E_NOTIMPL;
1030}
1031
1032HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::align(
1033        /* [retval][out] */ BSTR* /*result*/)
1034{
1035    ASSERT_NOT_REACHED();
1036    return E_NOTIMPL;
1037}
1038
1039HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAlign(
1040        /* [in] */ BSTR /*align*/)
1041{
1042    ASSERT_NOT_REACHED();
1043    return E_NOTIMPL;
1044}
1045
1046HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::alt(
1047        /* [retval][out] */ BSTR* /*result*/)
1048{
1049    ASSERT_NOT_REACHED();
1050    return E_NOTIMPL;
1051}
1052
1053HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAlt(
1054        /* [in] */ BSTR /*alt*/)
1055{
1056    ASSERT_NOT_REACHED();
1057    return E_NOTIMPL;
1058}
1059
1060HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::checked(
1061        /* [retval][out] */ BOOL* /*result*/)
1062{
1063    ASSERT_NOT_REACHED();
1064    return E_NOTIMPL;
1065}
1066
1067HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setChecked(
1068        /* [in] */ BOOL /*checked*/)
1069{
1070    ASSERT_NOT_REACHED();
1071    return E_NOTIMPL;
1072}
1073
1074HRESULT 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
1083HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setDisabled(
1084        /* [in] */ BOOL /*disabled*/)
1085{
1086    ASSERT_NOT_REACHED();
1087    return E_NOTIMPL;
1088}
1089
1090HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::maxLength(
1091        /* [retval][out] */ int* /*result*/)
1092{
1093    ASSERT_NOT_REACHED();
1094    return E_NOTIMPL;
1095}
1096
1097HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setMaxLength(
1098        /* [in] */ int /*maxLength*/)
1099{
1100    ASSERT_NOT_REACHED();
1101    return E_NOTIMPL;
1102}
1103
1104HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::name(
1105        /* [retval][out] */ BSTR* /*name*/)
1106{
1107    ASSERT_NOT_REACHED();
1108    return E_NOTIMPL;
1109}
1110
1111HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setName(
1112        /* [in] */ BSTR /*name*/)
1113{
1114    ASSERT_NOT_REACHED();
1115    return E_NOTIMPL;
1116}
1117
1118HRESULT 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
1127HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setReadOnly(
1128        /* [in] */ BOOL /*readOnly*/)
1129{
1130    ASSERT_NOT_REACHED();
1131    return E_NOTIMPL;
1132}
1133
1134HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::size(
1135        /* [retval][out] */ unsigned int* /*result*/)
1136{
1137    ASSERT_NOT_REACHED();
1138    return E_NOTIMPL;
1139}
1140
1141HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setSize(
1142        /* [in] */ unsigned int /*size*/)
1143{
1144    ASSERT_NOT_REACHED();
1145    return E_NOTIMPL;
1146}
1147
1148HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::src(
1149        /* [retval][out] */ BSTR* /*result*/)
1150{
1151    ASSERT_NOT_REACHED();
1152    return E_NOTIMPL;
1153}
1154
1155HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setSrc(
1156        /* [in] */ BSTR /*src*/)
1157{
1158    ASSERT_NOT_REACHED();
1159    return E_NOTIMPL;
1160}
1161
1162HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::tabIndex(
1163        /* [retval][out] */ int* /*result*/)
1164{
1165    ASSERT_NOT_REACHED();
1166    return E_NOTIMPL;
1167}
1168
1169HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setTabIndex(
1170        /* [in] */ int /*tabIndex*/)
1171{
1172    ASSERT_NOT_REACHED();
1173    return E_NOTIMPL;
1174}
1175
1176HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::type(
1177        /* [retval][out] */ BSTR* /*result*/)
1178{
1179    ASSERT_NOT_REACHED();
1180    return E_NOTIMPL;
1181}
1182
1183HRESULT 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
1193HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::useMap(
1194        /* [retval][out] */ BSTR* /*result*/)
1195{
1196    ASSERT_NOT_REACHED();
1197    return E_NOTIMPL;
1198}
1199
1200HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setUseMap(
1201        /* [in] */ BSTR /*useMap*/)
1202{
1203    ASSERT_NOT_REACHED();
1204    return E_NOTIMPL;
1205}
1206
1207HRESULT 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
1219HRESULT 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
1228HRESULT 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
1238HRESULT 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
1246HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::click( void)
1247{
1248    ASSERT_NOT_REACHED();
1249    return E_NOTIMPL;
1250}
1251
1252HRESULT 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
1261HRESULT 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
1270HRESULT 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
1279HRESULT 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
1290HRESULT 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
1300HRESULT 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
1320HRESULT 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
1342HRESULT 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
1354HRESULT 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
1364HRESULT 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
1376HRESULT 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
1394HRESULT 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
1410HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::defaultValue(
1411        /* [retval][out] */ BSTR* /*result*/)
1412{
1413    ASSERT_NOT_REACHED();
1414    return E_NOTIMPL;
1415}
1416
1417HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setDefaultValue(
1418        /* [in] */ BSTR /*val*/)
1419{
1420    ASSERT_NOT_REACHED();
1421    return E_NOTIMPL;
1422}
1423
1424HRESULT 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
1439HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::accessKey(
1440        /* [retval][out] */ BSTR* /*result*/)
1441{
1442    ASSERT_NOT_REACHED();
1443    return E_NOTIMPL;
1444}
1445
1446HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setAccessKey(
1447        /* [in] */ BSTR /*key*/)
1448{
1449    ASSERT_NOT_REACHED();
1450    return E_NOTIMPL;
1451}
1452
1453HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::cols(
1454        /* [retval][out] */ int* /*result*/)
1455{
1456    ASSERT_NOT_REACHED();
1457    return E_NOTIMPL;
1458}
1459
1460HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setCols(
1461        /* [in] */ int /*cols*/)
1462{
1463    ASSERT_NOT_REACHED();
1464    return E_NOTIMPL;
1465}
1466
1467HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::disabled(
1468        /* [retval][out] */ BOOL* /*result*/)
1469{
1470    ASSERT_NOT_REACHED();
1471    return E_NOTIMPL;
1472}
1473
1474HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setDisabled(
1475        /* [in] */ BOOL /*disabled*/)
1476{
1477    ASSERT_NOT_REACHED();
1478    return E_NOTIMPL;
1479}
1480
1481HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::name(
1482        /* [retval][out] */ BSTR* /*name*/)
1483{
1484    ASSERT_NOT_REACHED();
1485    return E_NOTIMPL;
1486}
1487
1488HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setName(
1489        /* [in] */ BSTR /*name*/)
1490{
1491    ASSERT_NOT_REACHED();
1492    return E_NOTIMPL;
1493}
1494
1495HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::readOnly(
1496        /* [retval][out] */ BOOL* /*result*/)
1497{
1498    ASSERT_NOT_REACHED();
1499    return E_NOTIMPL;
1500}
1501
1502HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setReadOnly(
1503        /* [in] */ BOOL /*readOnly*/)
1504{
1505    ASSERT_NOT_REACHED();
1506    return E_NOTIMPL;
1507}
1508
1509HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::rows(
1510        /* [retval][out] */ int* /*result*/)
1511{
1512    ASSERT_NOT_REACHED();
1513    return E_NOTIMPL;
1514}
1515
1516HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setRows(
1517        /* [in] */ int /*rows*/)
1518{
1519    ASSERT_NOT_REACHED();
1520    return E_NOTIMPL;
1521}
1522
1523HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::tabIndex(
1524        /* [retval][out] */ int* /*result*/)
1525{
1526    ASSERT_NOT_REACHED();
1527    return E_NOTIMPL;
1528}
1529
1530HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setTabIndex(
1531        /* [in] */ int /*tabIndex*/)
1532{
1533    ASSERT_NOT_REACHED();
1534    return E_NOTIMPL;
1535}
1536
1537HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::type(
1538        /* [retval][out] */ BSTR* /*result*/)
1539{
1540    ASSERT_NOT_REACHED();
1541    return E_NOTIMPL;
1542}
1543
1544HRESULT 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
1556HRESULT 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
1565HRESULT 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
1575HRESULT 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
1590HRESULT 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
1604HRESULT 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}
1617