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