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