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