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(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.characters(), innerTextString.length()).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 && 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 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 && 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 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 *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 718HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::disabled( 719 /* [retval][out] */ BOOL* /*result*/) 720{ 721 ASSERT_NOT_REACHED(); 722 return E_NOTIMPL; 723} 724 725HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setDisabled( 726 /* [in] */ BOOL /*disabled*/) 727{ 728 ASSERT_NOT_REACHED(); 729 return E_NOTIMPL; 730} 731 732HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::multiple( 733 /* [retval][out] */ BOOL* /*result*/) 734{ 735 ASSERT_NOT_REACHED(); 736 return E_NOTIMPL; 737} 738 739HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setMultiple( 740 /* [in] */ BOOL /*multiple*/) 741{ 742 ASSERT_NOT_REACHED(); 743 return E_NOTIMPL; 744} 745 746HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::name( 747 /* [retval][out] */ BSTR* /*result*/) 748{ 749 ASSERT_NOT_REACHED(); 750 return E_NOTIMPL; 751} 752 753HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setName( 754 /* [in] */ BSTR /*name*/) 755{ 756 ASSERT_NOT_REACHED(); 757 return E_NOTIMPL; 758} 759 760HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::size( 761 /* [retval][out] */ int* /*size*/) 762{ 763 ASSERT_NOT_REACHED(); 764 return E_NOTIMPL; 765} 766 767HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setSize( 768 /* [in] */ int /*size*/) 769{ 770 ASSERT_NOT_REACHED(); 771 return E_NOTIMPL; 772} 773 774HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::tabIndex( 775 /* [retval][out] */ int* /*result*/) 776{ 777 ASSERT_NOT_REACHED(); 778 return E_NOTIMPL; 779} 780 781HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::setTabIndex( 782 /* [in] */ int /*tabIndex*/) 783{ 784 ASSERT_NOT_REACHED(); 785 return E_NOTIMPL; 786} 787 788HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::add( 789 /* [in] */ IDOMHTMLElement* /*element*/, 790 /* [in] */ IDOMHTMLElement* /*before*/) 791{ 792 ASSERT_NOT_REACHED(); 793 return E_NOTIMPL; 794} 795 796HRESULT STDMETHODCALLTYPE DOMHTMLSelectElement::remove( 797 /* [in] */ int /*index*/) 798{ 799 ASSERT_NOT_REACHED(); 800 return E_NOTIMPL; 801} 802 803// DOMHTMLSelectElement - IFormsAutoFillTransitionSelect ---------------------- 804 805HRESULT 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 821HRESULT 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 835HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::form( 836 /* [retval][out] */ IDOMHTMLFormElement** /*result*/) 837{ 838 ASSERT_NOT_REACHED(); 839 return E_NOTIMPL; 840} 841 842HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::defaultSelected( 843 /* [retval][out] */ BOOL* /*result*/) 844{ 845 ASSERT_NOT_REACHED(); 846 return E_NOTIMPL; 847} 848 849HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setDefaultSelected( 850 /* [in] */ BOOL /*defaultSelected*/) 851{ 852 ASSERT_NOT_REACHED(); 853 return E_NOTIMPL; 854} 855 856HRESULT 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 872HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::index( 873 /* [retval][out] */ int* /*result*/) 874{ 875 ASSERT_NOT_REACHED(); 876 return E_NOTIMPL; 877} 878 879HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::disabled( 880 /* [retval][out] */ BOOL* /*result*/) 881{ 882 ASSERT_NOT_REACHED(); 883 return E_NOTIMPL; 884} 885 886HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setDisabled( 887 /* [in] */ BOOL /*disabled*/) 888{ 889 ASSERT_NOT_REACHED(); 890 return E_NOTIMPL; 891} 892 893HRESULT 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 909HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setLabel( 910 /* [in] */ BSTR /*label*/) 911{ 912 ASSERT_NOT_REACHED(); 913 return E_NOTIMPL; 914} 915 916HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::selected( 917 /* [retval][out] */ BOOL* /*result*/) 918{ 919 ASSERT_NOT_REACHED(); 920 return E_NOTIMPL; 921} 922 923HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setSelected( 924 /* [in] */ BOOL /*selected*/) 925{ 926 ASSERT_NOT_REACHED(); 927 return E_NOTIMPL; 928} 929 930HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::value( 931 /* [retval][out] */ BSTR* /*result*/) 932{ 933 ASSERT_NOT_REACHED(); 934 return E_NOTIMPL; 935} 936 937HRESULT STDMETHODCALLTYPE DOMHTMLOptionElement::setValue( 938 /* [in] */ BSTR /*value*/) 939{ 940 ASSERT_NOT_REACHED(); 941 return E_NOTIMPL; 942} 943 944// DOMHTMLInputElement - IUnknown ---------------------------------------------- 945 946HRESULT 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 964HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::defaultValue( 965 /* [retval][out] */ BSTR* /*result*/) 966{ 967 ASSERT_NOT_REACHED(); 968 return E_NOTIMPL; 969} 970 971HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setDefaultValue( 972 /* [in] */ BSTR /*val*/) 973{ 974 ASSERT_NOT_REACHED(); 975 return E_NOTIMPL; 976} 977 978HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::defaultChecked( 979 /* [retval][out] */ BOOL* /*result*/) 980{ 981 ASSERT_NOT_REACHED(); 982 return E_NOTIMPL; 983} 984 985HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setDefaultChecked( 986 /* [in] */ BSTR /*checked*/) 987{ 988 ASSERT_NOT_REACHED(); 989 return E_NOTIMPL; 990} 991 992HRESULT 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 1007HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::accept( 1008 /* [retval][out] */ BSTR* /*result*/) 1009{ 1010 ASSERT_NOT_REACHED(); 1011 return E_NOTIMPL; 1012} 1013 1014HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAccept( 1015 /* [in] */ BSTR /*accept*/) 1016{ 1017 ASSERT_NOT_REACHED(); 1018 return E_NOTIMPL; 1019} 1020 1021HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::accessKey( 1022 /* [retval][out] */ BSTR* /*result*/) 1023{ 1024 ASSERT_NOT_REACHED(); 1025 return E_NOTIMPL; 1026} 1027 1028HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAccessKey( 1029 /* [in] */ BSTR /*key*/) 1030{ 1031 ASSERT_NOT_REACHED(); 1032 return E_NOTIMPL; 1033} 1034 1035HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::align( 1036 /* [retval][out] */ BSTR* /*result*/) 1037{ 1038 ASSERT_NOT_REACHED(); 1039 return E_NOTIMPL; 1040} 1041 1042HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAlign( 1043 /* [in] */ BSTR /*align*/) 1044{ 1045 ASSERT_NOT_REACHED(); 1046 return E_NOTIMPL; 1047} 1048 1049HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::alt( 1050 /* [retval][out] */ BSTR* /*result*/) 1051{ 1052 ASSERT_NOT_REACHED(); 1053 return E_NOTIMPL; 1054} 1055 1056HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setAlt( 1057 /* [in] */ BSTR /*alt*/) 1058{ 1059 ASSERT_NOT_REACHED(); 1060 return E_NOTIMPL; 1061} 1062 1063HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::checked( 1064 /* [retval][out] */ BOOL* /*result*/) 1065{ 1066 ASSERT_NOT_REACHED(); 1067 return E_NOTIMPL; 1068} 1069 1070HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setChecked( 1071 /* [in] */ BOOL /*checked*/) 1072{ 1073 ASSERT_NOT_REACHED(); 1074 return E_NOTIMPL; 1075} 1076 1077HRESULT 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->isDisabledFormControl() ? TRUE : FALSE; 1083 return S_OK; 1084} 1085 1086HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setDisabled( 1087 /* [in] */ BOOL /*disabled*/) 1088{ 1089 ASSERT_NOT_REACHED(); 1090 return E_NOTIMPL; 1091} 1092 1093HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::maxLength( 1094 /* [retval][out] */ int* /*result*/) 1095{ 1096 ASSERT_NOT_REACHED(); 1097 return E_NOTIMPL; 1098} 1099 1100HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setMaxLength( 1101 /* [in] */ int /*maxLength*/) 1102{ 1103 ASSERT_NOT_REACHED(); 1104 return E_NOTIMPL; 1105} 1106 1107HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::name( 1108 /* [retval][out] */ BSTR* /*name*/) 1109{ 1110 ASSERT_NOT_REACHED(); 1111 return E_NOTIMPL; 1112} 1113 1114HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setName( 1115 /* [in] */ BSTR /*name*/) 1116{ 1117 ASSERT_NOT_REACHED(); 1118 return E_NOTIMPL; 1119} 1120 1121HRESULT 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->isReadOnly() ? TRUE : FALSE; 1127 return S_OK; 1128} 1129 1130HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setReadOnly( 1131 /* [in] */ BOOL /*readOnly*/) 1132{ 1133 ASSERT_NOT_REACHED(); 1134 return E_NOTIMPL; 1135} 1136 1137HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::size( 1138 /* [retval][out] */ unsigned int* /*result*/) 1139{ 1140 ASSERT_NOT_REACHED(); 1141 return E_NOTIMPL; 1142} 1143 1144HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setSize( 1145 /* [in] */ unsigned int /*size*/) 1146{ 1147 ASSERT_NOT_REACHED(); 1148 return E_NOTIMPL; 1149} 1150 1151HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::src( 1152 /* [retval][out] */ BSTR* /*result*/) 1153{ 1154 ASSERT_NOT_REACHED(); 1155 return E_NOTIMPL; 1156} 1157 1158HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setSrc( 1159 /* [in] */ BSTR /*src*/) 1160{ 1161 ASSERT_NOT_REACHED(); 1162 return E_NOTIMPL; 1163} 1164 1165HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::tabIndex( 1166 /* [retval][out] */ int* /*result*/) 1167{ 1168 ASSERT_NOT_REACHED(); 1169 return E_NOTIMPL; 1170} 1171 1172HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setTabIndex( 1173 /* [in] */ int /*tabIndex*/) 1174{ 1175 ASSERT_NOT_REACHED(); 1176 return E_NOTIMPL; 1177} 1178 1179HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::type( 1180 /* [retval][out] */ BSTR* /*result*/) 1181{ 1182 ASSERT_NOT_REACHED(); 1183 return E_NOTIMPL; 1184} 1185 1186HRESULT 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 1196HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::useMap( 1197 /* [retval][out] */ BSTR* /*result*/) 1198{ 1199 ASSERT_NOT_REACHED(); 1200 return E_NOTIMPL; 1201} 1202 1203HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::setUseMap( 1204 /* [in] */ BSTR /*useMap*/) 1205{ 1206 ASSERT_NOT_REACHED(); 1207 return E_NOTIMPL; 1208} 1209 1210HRESULT 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 1222HRESULT 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 1231HRESULT 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 1241HRESULT 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 1249HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::click( void) 1250{ 1251 ASSERT_NOT_REACHED(); 1252 return E_NOTIMPL; 1253} 1254 1255HRESULT 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 1264HRESULT 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 1273HRESULT 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 1282HRESULT 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 1293HRESULT 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 1303HRESULT 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 1323HRESULT 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 1345HRESULT 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 1357HRESULT 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 1367HRESULT 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 1379HRESULT 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 1397HRESULT 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 1413HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::defaultValue( 1414 /* [retval][out] */ BSTR* /*result*/) 1415{ 1416 ASSERT_NOT_REACHED(); 1417 return E_NOTIMPL; 1418} 1419 1420HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setDefaultValue( 1421 /* [in] */ BSTR /*val*/) 1422{ 1423 ASSERT_NOT_REACHED(); 1424 return E_NOTIMPL; 1425} 1426 1427HRESULT 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 1442HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::accessKey( 1443 /* [retval][out] */ BSTR* /*result*/) 1444{ 1445 ASSERT_NOT_REACHED(); 1446 return E_NOTIMPL; 1447} 1448 1449HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setAccessKey( 1450 /* [in] */ BSTR /*key*/) 1451{ 1452 ASSERT_NOT_REACHED(); 1453 return E_NOTIMPL; 1454} 1455 1456HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::cols( 1457 /* [retval][out] */ int* /*result*/) 1458{ 1459 ASSERT_NOT_REACHED(); 1460 return E_NOTIMPL; 1461} 1462 1463HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setCols( 1464 /* [in] */ int /*cols*/) 1465{ 1466 ASSERT_NOT_REACHED(); 1467 return E_NOTIMPL; 1468} 1469 1470HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::disabled( 1471 /* [retval][out] */ BOOL* /*result*/) 1472{ 1473 ASSERT_NOT_REACHED(); 1474 return E_NOTIMPL; 1475} 1476 1477HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setDisabled( 1478 /* [in] */ BOOL /*disabled*/) 1479{ 1480 ASSERT_NOT_REACHED(); 1481 return E_NOTIMPL; 1482} 1483 1484HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::name( 1485 /* [retval][out] */ BSTR* /*name*/) 1486{ 1487 ASSERT_NOT_REACHED(); 1488 return E_NOTIMPL; 1489} 1490 1491HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setName( 1492 /* [in] */ BSTR /*name*/) 1493{ 1494 ASSERT_NOT_REACHED(); 1495 return E_NOTIMPL; 1496} 1497 1498HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::readOnly( 1499 /* [retval][out] */ BOOL* /*result*/) 1500{ 1501 ASSERT_NOT_REACHED(); 1502 return E_NOTIMPL; 1503} 1504 1505HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setReadOnly( 1506 /* [in] */ BOOL /*readOnly*/) 1507{ 1508 ASSERT_NOT_REACHED(); 1509 return E_NOTIMPL; 1510} 1511 1512HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::rows( 1513 /* [retval][out] */ int* /*result*/) 1514{ 1515 ASSERT_NOT_REACHED(); 1516 return E_NOTIMPL; 1517} 1518 1519HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setRows( 1520 /* [in] */ int /*rows*/) 1521{ 1522 ASSERT_NOT_REACHED(); 1523 return E_NOTIMPL; 1524} 1525 1526HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::tabIndex( 1527 /* [retval][out] */ int* /*result*/) 1528{ 1529 ASSERT_NOT_REACHED(); 1530 return E_NOTIMPL; 1531} 1532 1533HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::setTabIndex( 1534 /* [in] */ int /*tabIndex*/) 1535{ 1536 ASSERT_NOT_REACHED(); 1537 return E_NOTIMPL; 1538} 1539 1540HRESULT STDMETHODCALLTYPE DOMHTMLTextAreaElement::type( 1541 /* [retval][out] */ BSTR* /*result*/) 1542{ 1543 ASSERT_NOT_REACHED(); 1544 return E_NOTIMPL; 1545} 1546 1547HRESULT 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 1559HRESULT 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 1568HRESULT 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 1578HRESULT 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 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); 1614 HTMLIFrameElement* iFrameElement = toHTMLIFrameElement(m_element); 1615 COMPtr<IWebFrame> webFrame = kit(iFrameElement->contentFrame()); 1616 if (!webFrame) 1617 return E_FAIL; 1618 return webFrame.copyRefTo(result); 1619} 1620