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