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