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