Source/WebCore/bindings/scripts/test/CPP/WebDOMTestObj.cpp

   1 /*
   2  * This file is part of the WebKit open source project.
   3  * This file has been generated by generate-bindings.pl. DO NOT MODIFY!
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public License
  16  * along with this library; see the file COPYING.LIB.  If not, write to
  17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 #include "config.h"
  22 #include "WebDOMTestObj.h"
  23
  24 #include "Dictionary.h"
  25 #include "Document.h"
  26 #include "HTMLNames.h"
  27 #include "IDBKey.h"
  28 #include "KURL.h"
  29 #include "SVGPoint.h"
  30 #include "SerializedScriptValue.h"
  31 #include "TestObj.h"
  32 #include "WebDOMDictionary.h"
  33 #include "WebDOMDocument.h"
  34 #include "WebDOMIDBKey.h"
  35 #include "WebDOMSVGPoint.h"
  36 #include "WebDOMString.h"
  37 #include "WebDOMa.h"
  38 #include "WebDOMb.h"
  39 #include "WebDOMbool.h"
  40 #include "WebDOMc.h"
  41 #include "WebDOMd.h"
  42 #include "WebDOMe.h"
  43 #include "WebExceptionHandler.h"
  44 #include "WebNativeEventListener.h"
  45 #include "a.h"
  46 #include "b.h"
  47 #include "bool.h"
  48 #include "c.h"
  49 #include "d.h"
  50 #include "e.h"
  51 #include "wtf/text/AtomicString.h"
  52 #include <wtf/GetPtr.h>
  53 #include <wtf/RefPtr.h>
  54
  55 struct WebDOMTestObj::WebDOMTestObjPrivate {
  56     WebDOMTestObjPrivate(WebCore::TestObj* object = 0)
  57         : impl(object)
  58     {
  59     }
  60
  61     RefPtr<WebCore::TestObj> impl;
  62 };
  63
  64 WebDOMTestObj::WebDOMTestObj()
  65     : WebDOMObject()
  66     , m_impl(0)
  67 {
  68 }
  69
  70 WebDOMTestObj::WebDOMTestObj(WebCore::TestObj* impl)
  71     : WebDOMObject()
  72     , m_impl(new WebDOMTestObjPrivate(impl))
  73 {
  74 }
  75
  76 WebDOMTestObj::WebDOMTestObj(const WebDOMTestObj& copy)
  77     : WebDOMObject()
  78 {
  79     m_impl = copy.impl() ? new WebDOMTestObjPrivate(copy.impl()) : 0;
  80 }
  81
  82 WebDOMTestObj& WebDOMTestObj::operator=(const WebDOMTestObj& copy)
  83 {
  84     delete m_impl;
  85     m_impl = copy.impl() ? new WebDOMTestObjPrivate(copy.impl()) : 0;
  86     return *this;
  87 }
  88
  89 WebCore::TestObj* WebDOMTestObj::impl() const
  90 {
  91     return m_impl ? WTF::getPtr(m_impl->impl) : 0;
  92 }
  93
  94 WebDOMTestObj::~WebDOMTestObj()
  95 {
  96     delete m_impl;
  97     m_impl = 0;
  98 }
  99
 100 int WebDOMTestObj::readOnlyIntAttr() const
 101 {
 102     if (!impl())
 103         return 0;
 104
 105     return impl()->readOnlyIntAttr();
 106 }
 107
 108 WebDOMString WebDOMTestObj::readOnlyStringAttr() const
 109 {
 110     if (!impl())
 111         return WebDOMString();
 112
 113     return static_cast<const WTF::String&>(impl()->readOnlyStringAttr());
 114 }
 115
 116 WebDOMTestObj WebDOMTestObj::readOnlyTestObjAttr() const
 117 {
 118     if (!impl())
 119         return WebDOMTestObj();
 120
 121     return toWebKit(WTF::getPtr(impl()->readOnlyTestObjAttr()));
 122 }
 123
 124 short WebDOMTestObj::shortAttr() const
 125 {
 126     if (!impl())
 127         return 0;
 128
 129     return impl()->shortAttr();
 130 }
 131
 132 void WebDOMTestObj::setShortAttr(short newShortAttr)
 133 {
 134     if (!impl())
 135         return;
 136
 137     impl()->setShortAttr(newShortAttr);
 138 }
 139
 140 unsigned short WebDOMTestObj::unsignedShortAttr() const
 141 {
 142     if (!impl())
 143         return 0;
 144
 145     return impl()->unsignedShortAttr();
 146 }
 147
 148 void WebDOMTestObj::setUnsignedShortAttr(unsigned short newUnsignedShortAttr)
 149 {
 150     if (!impl())
 151         return;
 152
 153     impl()->setUnsignedShortAttr(newUnsignedShortAttr);
 154 }
 155
 156 int WebDOMTestObj::intAttr() const
 157 {
 158     if (!impl())
 159         return 0;
 160
 161     return impl()->intAttr();
 162 }
 163
 164 void WebDOMTestObj::setIntAttr(int newIntAttr)
 165 {
 166     if (!impl())
 167         return;
 168
 169     impl()->setIntAttr(newIntAttr);
 170 }
 171
 172 long long WebDOMTestObj::longLongAttr() const
 173 {
 174     if (!impl())
 175         return 0;
 176
 177     return impl()->longLongAttr();
 178 }
 179
 180 void WebDOMTestObj::setLongLongAttr(long long newLongLongAttr)
 181 {
 182     if (!impl())
 183         return;
 184
 185     impl()->setLongLongAttr(newLongLongAttr);
 186 }
 187
 188 unsigned long long WebDOMTestObj::unsignedLongLongAttr() const
 189 {
 190     if (!impl())
 191         return 0;
 192
 193     return impl()->unsignedLongLongAttr();
 194 }
 195
 196 void WebDOMTestObj::setUnsignedLongLongAttr(unsigned long long newUnsignedLongLongAttr)
 197 {
 198     if (!impl())
 199         return;
 200
 201     impl()->setUnsignedLongLongAttr(newUnsignedLongLongAttr);
 202 }
 203
 204 WebDOMString WebDOMTestObj::stringAttr() const
 205 {
 206     if (!impl())
 207         return WebDOMString();
 208
 209     return static_cast<const WTF::String&>(impl()->stringAttr());
 210 }
 211
 212 void WebDOMTestObj::setStringAttr(const WebDOMString& newStringAttr)
 213 {
 214     if (!impl())
 215         return;
 216
 217     impl()->setStringAttr(newStringAttr);
 218 }
 219
 220 WebDOMTestObj WebDOMTestObj::testObjAttr() const
 221 {
 222     if (!impl())
 223         return WebDOMTestObj();
 224
 225     return toWebKit(WTF::getPtr(impl()->testObjAttr()));
 226 }
 227
 228 void WebDOMTestObj::setTestObjAttr(const WebDOMTestObj& newTestObjAttr)
 229 {
 230     if (!impl())
 231         return;
 232
 233     impl()->setTestObjAttr(toWebCore(newTestObjAttr));
 234 }
 235
 236 WebDOMTestObj WebDOMTestObj::XMLObjAttr() const
 237 {
 238     if (!impl())
 239         return WebDOMTestObj();
 240
 241     return toWebKit(WTF::getPtr(impl()->xmlObjAttr()));
 242 }
 243
 244 void WebDOMTestObj::setXMLObjAttr(const WebDOMTestObj& newXMLObjAttr)
 245 {
 246     if (!impl())
 247         return;
 248
 249     impl()->setXMLObjAttr(toWebCore(newXMLObjAttr));
 250 }
 251
 252 bool WebDOMTestObj::create() const
 253 {
 254     if (!impl())
 255         return false;
 256
 257     return impl()->isCreate();
 258 }
 259
 260 void WebDOMTestObj::setCreate(bool newCreate)
 261 {
 262     if (!impl())
 263         return;
 264
 265     impl()->setCreate(newCreate);
 266 }
 267
 268 WebDOMString WebDOMTestObj::reflectedStringAttr() const
 269 {
 270     if (!impl())
 271         return WebDOMString();
 272
 273     return static_cast<const WTF::String&>(impl()->getAttribute(WebCore::HTMLNames::reflectedstringattrAttr));
 274 }
 275
 276 void WebDOMTestObj::setReflectedStringAttr(const WebDOMString& newReflectedStringAttr)
 277 {
 278     if (!impl())
 279         return;
 280
 281     impl()->setAttribute(WebCore::HTMLNames::reflectedstringattrAttr, newReflectedStringAttr);
 282 }
 283
 284 int WebDOMTestObj::reflectedIntegralAttr() const
 285 {
 286     if (!impl())
 287         return 0;
 288
 289     return impl()->getIntegralAttribute(WebCore::HTMLNames::reflectedintegralattrAttr);
 290 }
 291
 292 void WebDOMTestObj::setReflectedIntegralAttr(int newReflectedIntegralAttr)
 293 {
 294     if (!impl())
 295         return;
 296
 297     impl()->setIntegralAttribute(WebCore::HTMLNames::reflectedintegralattrAttr, newReflectedIntegralAttr);
 298 }
 299
 300 unsigned WebDOMTestObj::reflectedUnsignedIntegralAttr() const
 301 {
 302     if (!impl())
 303         return unsigned();
 304
 305     return impl()->getUnsignedIntegralAttribute(WebCore::HTMLNames::reflectedunsignedintegralattrAttr);
 306 }
 307
 308 void WebDOMTestObj::setReflectedUnsignedIntegralAttr(unsigned newReflectedUnsignedIntegralAttr)
 309 {
 310     if (!impl())
 311         return;
 312
 313     impl()->setUnsignedIntegralAttribute(WebCore::HTMLNames::reflectedunsignedintegralattrAttr, newReflectedUnsignedIntegralAttr);
 314 }
 315
 316 bool WebDOMTestObj::reflectedBooleanAttr() const
 317 {
 318     if (!impl())
 319         return false;
 320
 321     return impl()->hasAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr);
 322 }
 323
 324 void WebDOMTestObj::setReflectedBooleanAttr(bool newReflectedBooleanAttr)
 325 {
 326     if (!impl())
 327         return;
 328
 329     impl()->setBooleanAttribute(WebCore::HTMLNames::reflectedbooleanattrAttr, newReflectedBooleanAttr);
 330 }
 331
 332 WebDOMString WebDOMTestObj::reflectedURLAttr() const
 333 {
 334     if (!impl())
 335         return WebDOMString();
 336
 337     return static_cast<const WTF::String&>(impl()->getURLAttribute(WebCore::HTMLNames::reflectedurlattrAttr));
 338 }
 339
 340 void WebDOMTestObj::setReflectedURLAttr(const WebDOMString& newReflectedURLAttr)
 341 {
 342     if (!impl())
 343         return;
 344
 345     impl()->setAttribute(WebCore::HTMLNames::reflectedurlattrAttr, newReflectedURLAttr);
 346 }
 347
 348 WebDOMString WebDOMTestObj::reflectedStringAttr() const
 349 {
 350     if (!impl())
 351         return WebDOMString();
 352
 353     return static_cast<const WTF::String&>(impl()->getAttribute(WebCore::HTMLNames::customContentStringAttrAttr));
 354 }
 355
 356 void WebDOMTestObj::setReflectedStringAttr(const WebDOMString& newReflectedStringAttr)
 357 {
 358     if (!impl())
 359         return;
 360
 361     impl()->setAttribute(WebCore::HTMLNames::customContentStringAttrAttr, newReflectedStringAttr);
 362 }
 363
 364 int WebDOMTestObj::reflectedCustomIntegralAttr() const
 365 {
 366     if (!impl())
 367         return 0;
 368
 369     return impl()->getIntegralAttribute(WebCore::HTMLNames::customContentIntegralAttrAttr);
 370 }
 371
 372 void WebDOMTestObj::setReflectedCustomIntegralAttr(int newReflectedCustomIntegralAttr)
 373 {
 374     if (!impl())
 375         return;
 376
 377     impl()->setIntegralAttribute(WebCore::HTMLNames::customContentIntegralAttrAttr, newReflectedCustomIntegralAttr);
 378 }
 379
 380 bool WebDOMTestObj::reflectedCustomBooleanAttr() const
 381 {
 382     if (!impl())
 383         return false;
 384
 385     return impl()->hasAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr);
 386 }
 387
 388 void WebDOMTestObj::setReflectedCustomBooleanAttr(bool newReflectedCustomBooleanAttr)
 389 {
 390     if (!impl())
 391         return;
 392
 393     impl()->setBooleanAttribute(WebCore::HTMLNames::customContentBooleanAttrAttr, newReflectedCustomBooleanAttr);
 394 }
 395
 396 WebDOMString WebDOMTestObj::reflectedCustomURLAttr() const
 397 {
 398     if (!impl())
 399         return WebDOMString();
 400
 401     return static_cast<const WTF::String&>(impl()->getURLAttribute(WebCore::HTMLNames::customContentURLAttrAttr));
 402 }
 403
 404 void WebDOMTestObj::setReflectedCustomURLAttr(const WebDOMString& newReflectedCustomURLAttr)
 405 {
 406     if (!impl())
 407         return;
 408
 409     impl()->setAttribute(WebCore::HTMLNames::customContentURLAttrAttr, newReflectedCustomURLAttr);
 410 }
 411
 412 int WebDOMTestObj::attrWithGetterException() const
 413 {
 414     if (!impl())
 415         return 0;
 416
 417     WebCore::ExceptionCode ec = 0;
 418     int result = impl()->attrWithGetterException(ec);
 419     webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
 420     return result;
 421 }
 422
 423 void WebDOMTestObj::setAttrWithGetterException(int newAttrWithGetterException)
 424 {
 425     if (!impl())
 426         return;
 427
 428     WebCore::ExceptionCode ec = 0;
 429     impl()->setAttrWithGetterException(newAttrWithGetterException, ec);
 430     webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
 431 }
 432
 433 int WebDOMTestObj::attrWithSetterException() const
 434 {
 435     if (!impl())
 436         return 0;
 437
 438     return impl()->attrWithSetterException();
 439 }
 440
 441 void WebDOMTestObj::setAttrWithSetterException(int newAttrWithSetterException)
 442 {
 443     if (!impl())
 444         return;
 445
 446     WebCore::ExceptionCode ec = 0;
 447     impl()->setAttrWithSetterException(newAttrWithSetterException, ec);
 448     webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
 449 }
 450
 451 WebDOMString WebDOMTestObj::stringAttrWithGetterException() const
 452 {
 453     if (!impl())
 454         return WebDOMString();
 455
 456     WebCore::ExceptionCode ec = 0;
 457     WebDOMString result = impl()->stringAttrWithGetterException(ec);
 458     webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
 459     return static_cast<const WTF::String&>(result);
 460 }
 461
 462 void WebDOMTestObj::setStringAttrWithGetterException(const WebDOMString& newStringAttrWithGetterException)
 463 {
 464     if (!impl())
 465         return;
 466
 467     WebCore::ExceptionCode ec = 0;
 468     impl()->setStringAttrWithGetterException(newStringAttrWithGetterException, ec);
 469     webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
 470 }
 471
 472 WebDOMString WebDOMTestObj::stringAttrWithSetterException() const
 473 {
 474     if (!impl())
 475         return WebDOMString();
 476
 477     return static_cast<const WTF::String&>(impl()->stringAttrWithSetterException());
 478 }
 479
 480 void WebDOMTestObj::setStringAttrWithSetterException(const WebDOMString& newStringAttrWithSetterException)
 481 {
 482     if (!impl())
 483         return;
 484
 485     WebCore::ExceptionCode ec = 0;
 486     impl()->setStringAttrWithSetterException(newStringAttrWithSetterException, ec);
 487     webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
 488 }
 489
 490 #if ENABLE(Condition1)
 491 int WebDOMTestObj::conditionalAttr1() const
 492 {
 493     if (!impl())
 494         return 0;
 495
 496     return impl()->conditionalAttr1();
 497 }
 498
 499 void WebDOMTestObj::setConditionalAttr1(int newConditionalAttr1)
 500 {
 501     if (!impl())
 502         return;
 503
 504     impl()->setConditionalAttr1(newConditionalAttr1);
 505 }
 506
 507 #endif
 508 #if ENABLE(Condition1) && ENABLE(Condition2)
 509 int WebDOMTestObj::conditionalAttr2() const
 510 {
 511     if (!impl())
 512         return 0;
 513
 514     return impl()->conditionalAttr2();
 515 }
 516
 517 void WebDOMTestObj::setConditionalAttr2(int newConditionalAttr2)
 518 {
 519     if (!impl())
 520         return;
 521
 522     impl()->setConditionalAttr2(newConditionalAttr2);
 523 }
 524
 525 #endif
 526 #if ENABLE(Condition1) || ENABLE(Condition2)
 527 int WebDOMTestObj::conditionalAttr3() const
 528 {
 529     if (!impl())
 530         return 0;
 531
 532     return impl()->conditionalAttr3();
 533 }
 534
 535 void WebDOMTestObj::setConditionalAttr3(int newConditionalAttr3)
 536 {
 537     if (!impl())
 538         return;
 539
 540     impl()->setConditionalAttr3(newConditionalAttr3);
 541 }
 542
 543 #endif
 544 WebDOMDocument WebDOMTestObj::contentDocument() const
 545 {
 546     if (!impl())
 547         return WebDOMDocument();
 548
 549     return toWebKit(WTF::getPtr(impl()->contentDocument()));
 550 }
 551
 552 WebDOMSVGPoint WebDOMTestObj::mutablePoint() const
 553 {
 554     if (!impl())
 555         return WebDOMSVGPoint();
 556
 557     return toWebKit(WTF::getPtr(impl()->mutablePoint()));
 558 }
 559
 560 void WebDOMTestObj::setMutablePoint(const WebDOMSVGPoint& newMutablePoint)
 561 {
 562     if (!impl())
 563         return;
 564
 565     impl()->setMutablePoint(toWebCore(newMutablePoint));
 566 }
 567
 568 WebDOMSVGPoint WebDOMTestObj::immutablePoint() const
 569 {
 570     if (!impl())
 571         return WebDOMSVGPoint();
 572
 573     return toWebKit(WTF::getPtr(impl()->immutablePoint()));
 574 }
 575
 576 void WebDOMTestObj::setImmutablePoint(const WebDOMSVGPoint& newImmutablePoint)
 577 {
 578     if (!impl())
 579         return;
 580
 581     impl()->setImmutablePoint(toWebCore(newImmutablePoint));
 582 }
 583
 584 float WebDOMTestObj::strictFloat() const
 585 {
 586     if (!impl())
 587         return 0;
 588
 589     return impl()->strictFloat();
 590 }
 591
 592 void WebDOMTestObj::setStrictFloat(float newStrictFloat)
 593 {
 594     if (!impl())
 595         return;
 596
 597     impl()->setStrictFloat(newStrictFloat);
 598 }
 599
 600 int WebDOMTestObj::description() const
 601 {
 602     if (!impl())
 603         return 0;
 604
 605     return impl()->description();
 606 }
 607
 608 int WebDOMTestObj::id() const
 609 {
 610     if (!impl())
 611         return 0;
 612
 613     return impl()->id();
 614 }
 615
 616 void WebDOMTestObj::setId(int newId)
 617 {
 618     if (!impl())
 619         return;
 620
 621     impl()->setId(newId);
 622 }
 623
 624 WebDOMString WebDOMTestObj::hash() const
 625 {
 626     if (!impl())
 627         return WebDOMString();
 628
 629     return static_cast<const WTF::String&>(impl()->hash());
 630 }
 631
 632 void WebDOMTestObj::voidMethod()
 633 {
 634     if (!impl())
 635         return;
 636
 637     impl()->voidMethod();
 638 }
 639
 640 void WebDOMTestObj::voidMethodWithArgs(int intArg, const WebDOMString& strArg, const WebDOMTestObj& objArg)
 641 {
 642     if (!impl())
 643         return;
 644
 645     impl()->voidMethodWithArgs(intArg, strArg, toWebCore(objArg));
 646 }
 647
 648 int WebDOMTestObj::intMethod()
 649 {
 650     if (!impl())
 651         return 0;
 652
 653     return impl()->intMethod();
 654 }
 655
 656 int WebDOMTestObj::intMethodWithArgs(int intArg, const WebDOMString& strArg, const WebDOMTestObj& objArg)
 657 {
 658     if (!impl())
 659         return 0;
 660
 661     return impl()->intMethodWithArgs(intArg, strArg, toWebCore(objArg));
 662 }
 663
 664 WebDOMTestObj WebDOMTestObj::objMethod()
 665 {
 666     if (!impl())
 667         return WebDOMTestObj();
 668
 669     return toWebKit(WTF::getPtr(impl()->objMethod()));
 670 }
 671
 672 WebDOMTestObj WebDOMTestObj::objMethodWithArgs(int intArg, const WebDOMString& strArg, const WebDOMTestObj& objArg)
 673 {
 674     if (!impl())
 675         return WebDOMTestObj();
 676
 677     return toWebKit(WTF::getPtr(impl()->objMethodWithArgs(intArg, strArg, toWebCore(objArg))));
 678 }
 679
 680 WebDOMTestObj WebDOMTestObj::methodThatRequiresAllArgsAndThrows(const WebDOMString& strArg, const WebDOMTestObj& objArg)
 681 {
 682     if (!impl())
 683         return WebDOMTestObj();
 684
 685     WebCore::ExceptionCode ec = 0;
 686     WebDOMTestObj result = toWebKit(WTF::getPtr(impl()->methodThatRequiresAllArgsAndThrows(strArg, toWebCore(objArg), ec)));
 687     webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
 688     return result;
 689 }
 690
 691 void WebDOMTestObj::serializedValue(const WebDOMString& serializedArg)
 692 {
 693     if (!impl())
 694         return;
 695
 696     impl()->serializedValue(WebCore::SerializedScriptValue::create(WTF::String(serializedArg)));
 697 }
 698
 699 void WebDOMTestObj::idbKey(const WebDOMIDBKey& key)
 700 {
 701     if (!impl())
 702         return;
 703
 704     impl()->idbKey(toWebCore(key));
 705 }
 706
 707 void WebDOMTestObj::optionsObject(const WebDOMDictionary& oo, const WebDOMDictionary& ooo)
 708 {
 709     if (!impl())
 710         return;
 711
 712     impl()->optionsObject(toWebCore(oo), toWebCore(ooo));
 713 }
 714
 715 void WebDOMTestObj::methodWithException()
 716 {
 717     if (!impl())
 718         return;
 719
 720     WebCore::ExceptionCode ec = 0;
 721     impl()->methodWithException(ec);
 722     webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
 723 }
 724
 725 void WebDOMTestObj::addEventListener(const WebDOMString& type, const WebDOMEventListener& listener, bool useCapture)
 726 {
 727     if (!impl())
 728         return;
 729
 730     impl()->addEventListener(type, toWebCore(listener), useCapture);
 731 }
 732
 733 void WebDOMTestObj::removeEventListener(const WebDOMString& type, const WebDOMEventListener& listener, bool useCapture)
 734 {
 735     if (!impl())
 736         return;
 737
 738     impl()->removeEventListener(type, toWebCore(listener), useCapture);
 739 }
 740
 741 void WebDOMTestObj::methodWithOptionalArg(int opt)
 742 {
 743     if (!impl())
 744         return;
 745
 746     impl()->methodWithOptionalArg(opt);
 747 }
 748
 749 void WebDOMTestObj::methodWithNonOptionalArgAndOptionalArg(int nonOpt, int opt)
 750 {
 751     if (!impl())
 752         return;
 753
 754     impl()->methodWithNonOptionalArgAndOptionalArg(nonOpt, opt);
 755 }
 756
 757 void WebDOMTestObj::methodWithNonOptionalArgAndTwoOptionalArgs(int nonOpt, int opt1, int opt2)
 758 {
 759     if (!impl())
 760         return;
 761
 762     impl()->methodWithNonOptionalArgAndTwoOptionalArgs(nonOpt, opt1, opt2);
 763 }
 764
 765 void WebDOMTestObj::methodWithOptionalString(const WebDOMString& str)
 766 {
 767     if (!impl())
 768         return;
 769
 770     impl()->methodWithOptionalString(str);
 771 }
 772
 773 void WebDOMTestObj::methodWithOptionalStringIsUndefined(const WebDOMString& str)
 774 {
 775     if (!impl())
 776         return;
 777
 778     impl()->methodWithOptionalStringIsUndefined(str);
 779 }
 780
 781 void WebDOMTestObj::methodWithOptionalStringIsNullString(const WebDOMString& str)
 782 {
 783     if (!impl())
 784         return;
 785
 786     impl()->methodWithOptionalStringIsNullString(str);
 787 }
 788
 789
 790 #if ENABLE(Condition1)
 791 WebDOMString WebDOMTestObj::conditionalMethod1()
 792 {
 793     if (!impl())
 794         return WebDOMString();
 795
 796     return impl()->conditionalMethod1();
 797 }
 798
 799 #endif
 800
 801
 802 #if ENABLE(Condition1) && ENABLE(Condition2)
 803 void WebDOMTestObj::conditionalMethod2()
 804 {
 805     if (!impl())
 806         return;
 807
 808     impl()->conditionalMethod2();
 809 }
 810
 811 #endif
 812
 813
 814 #if ENABLE(Condition1) || ENABLE(Condition2)
 815 void WebDOMTestObj::conditionalMethod3()
 816 {
 817     if (!impl())
 818         return;
 819
 820     impl()->conditionalMethod3();
 821 }
 822
 823 #endif
 824
 825 void WebDOMTestObj::classMethod()
 826 {
 827     if (!impl())
 828         return;
 829
 830     impl()->classMethod();
 831 }
 832
 833 int WebDOMTestObj::classMethodWithOptional(int arg)
 834 {
 835     if (!impl())
 836         return 0;
 837
 838     return impl()->classMethodWithOptional(arg);
 839 }
 840
 841
 842 #if ENABLE(Condition1)
 843 void WebDOMTestObj::overloadedMethod1(int arg)
 844 {
 845     if (!impl())
 846         return;
 847
 848     impl()->overloadedMethod1(arg);
 849 }
 850
 851 #endif
 852
 853
 854 #if ENABLE(Condition1)
 855 void WebDOMTestObj::overloadedMethod1(const WebDOMString& type)
 856 {
 857     if (!impl())
 858         return;
 859
 860     impl()->overloadedMethod1(type);
 861 }
 862
 863 #endif
 864
 865 void WebDOMTestObj::convert1(const WebDOMa& )
 866 {
 867     if (!impl())
 868         return;
 869
 870     impl()->convert1(toWebCore());
 871 }
 872
 873 void WebDOMTestObj::convert2(const WebDOMb& )
 874 {
 875     if (!impl())
 876         return;
 877
 878     impl()->convert2(toWebCore());
 879 }
 880
 881 void WebDOMTestObj::convert3(const WebDOMc& )
 882 {
 883     if (!impl())
 884         return;
 885
 886     impl()->convert3(toWebCore());
 887 }
 888
 889 void WebDOMTestObj::convert4(const WebDOMd& )
 890 {
 891     if (!impl())
 892         return;
 893
 894     impl()->convert4(toWebCore());
 895 }
 896
 897 void WebDOMTestObj::convert5(const WebDOMe& )
 898 {
 899     if (!impl())
 900         return;
 901
 902     impl()->convert5(toWebCore());
 903 }
 904
 905 WebDOMSVGPoint WebDOMTestObj::mutablePointFunction()
 906 {
 907     if (!impl())
 908         return WebDOMSVGPoint();
 909
 910     return toWebKit(WTF::getPtr(impl()->mutablePointFunction()));
 911 }
 912
 913 WebDOMSVGPoint WebDOMTestObj::immutablePointFunction()
 914 {
 915     if (!impl())
 916         return WebDOMSVGPoint();
 917
 918     return toWebKit(WTF::getPtr(impl()->immutablePointFunction()));
 919 }
 920
 921 void WebDOMTestObj::orange()
 922 {
 923     if (!impl())
 924         return;
 925
 926     impl()->orange();
 927 }
 928
 929 WebDOMbool WebDOMTestObj::strictFunction(const WebDOMString& str, float a, int b)
 930 {
 931     if (!impl())
 932         return WebDOMbool();
 933
 934     WebCore::ExceptionCode ec = 0;
 935     WebDOMbool result = toWebKit(WTF::getPtr(impl()->strictFunction(str, a, b, ec)));
 936     webDOMRaiseError(static_cast<WebDOMExceptionCode>(ec));
 937     return result;
 938 }
 939
 940 WebCore::TestObj* toWebCore(const WebDOMTestObj& wrapper)
 941 {
 942     return wrapper.impl();
 943 }
 944
 945 WebDOMTestObj toWebKit(WebCore::TestObj* value)
 946 {
 947     return WebDOMTestObj(value);
 948 }