WebKit/win/DOMHTMLClasses.cpp

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