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