Source/WebKit/win/DOMHTMLClasses.cpp

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