00001
00022
00023
00024
#include "dom/html_form.h"
00025
#include "dom/dom_exception.h"
00026
#include "dom/dom_doc.h"
00027
00028
#include "html/html_formimpl.h"
00029
#include "html/html_miscimpl.h"
00030
00031
#include "xml/dom_docimpl.h"
00032
#include "misc/htmlhashes.h"
00033
00034
using namespace DOM;
00035
00036 HTMLButtonElement::HTMLButtonElement() :
HTMLElement()
00037 {
00038 }
00039
00040 HTMLButtonElement::HTMLButtonElement(
const HTMLButtonElement &other) :
HTMLElement(other)
00041 {
00042 }
00043
00044 HTMLButtonElement::HTMLButtonElement(HTMLButtonElementImpl *impl) :
HTMLElement(impl)
00045 {
00046 }
00047
00048
HTMLButtonElement &HTMLButtonElement::operator = (
const Node &other)
00049 {
00050 assignOther( other, ID_BUTTON );
00051
return *
this;
00052 }
00053
00054
HTMLButtonElement &HTMLButtonElement::operator = (
const HTMLButtonElement &other)
00055 {
00056 HTMLElement::operator = (other);
00057
return *
this;
00058 }
00059
00060 HTMLButtonElement::~HTMLButtonElement()
00061 {
00062 }
00063
00064 HTMLFormElement HTMLButtonElement::form()
const
00065
{
00066
return Element::form();
00067 }
00068
00069 DOMString HTMLButtonElement::accessKey()
const
00070
{
00071
if(!impl)
return DOMString();
00072
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ACCESSKEY);
00073 }
00074
00075 void HTMLButtonElement::setAccessKey(
const DOMString &value )
00076 {
00077
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ACCESSKEY, value);
00078 }
00079
00080 bool HTMLButtonElement::disabled()
const
00081
{
00082
if(!impl)
return 0;
00083
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_DISABLED).isNull();
00084 }
00085
00086 void HTMLButtonElement::setDisabled(
bool _disabled )
00087 {
00088
if (impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_DISABLED, _disabled ?
"" : 0);
00089 }
00090
00091 DOMString HTMLButtonElement::name()
const
00092
{
00093
if(!impl)
return DOMString();
00094
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_NAME);
00095 }
00096
00097 void HTMLButtonElement::setName(
const DOMString &value )
00098 {
00099
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_NAME, value);
00100 }
00101
00102 long HTMLButtonElement::tabIndex()
const
00103
{
00104
if(!impl)
return 0;
00105
return static_cast<ElementImpl*>(impl)->tabIndex();
00106 }
00107
00108 void HTMLButtonElement::setTabIndex(
long _tabIndex )
00109 {
00110
if (!impl)
return;
00111 static_cast<ElementImpl*>(impl)->setTabIndex(_tabIndex);
00112 }
00113
00114 DOMString HTMLButtonElement::type()
const
00115
{
00116
if(!impl)
return DOMString();
00117
return static_cast<HTMLButtonElementImpl*>(impl)->type();
00118 }
00119
00120 DOMString HTMLButtonElement::value()
const
00121
{
00122
if(!impl)
return DOMString();
00123
DOMString s = static_cast<ElementImpl*>(impl)->getAttribute(ATTR_VALUE);
00124
if (s.
isNull())
return DOMString(
"");
00125
return s;
00126 }
00127
00128 void HTMLButtonElement::setValue(
const DOMString &value )
00129 {
00130
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_VALUE, value);
00131 }
00132
00133
00134
00135 HTMLFieldSetElement::HTMLFieldSetElement() :
HTMLElement()
00136 {
00137 }
00138
00139 HTMLFieldSetElement::HTMLFieldSetElement(
const HTMLFieldSetElement &other) :
HTMLElement(other)
00140 {
00141 }
00142
00143 HTMLFieldSetElement::HTMLFieldSetElement(HTMLFieldSetElementImpl *impl) :
HTMLElement(impl)
00144 {
00145 }
00146
00147
HTMLFieldSetElement &HTMLFieldSetElement::operator = (
const Node &other)
00148 {
00149 assignOther( other, ID_FIELDSET );
00150
return *
this;
00151 }
00152
00153
HTMLFieldSetElement &HTMLFieldSetElement::operator = (
const HTMLFieldSetElement &other)
00154 {
00155 HTMLElement::operator = (other);
00156
return *
this;
00157 }
00158
00159 HTMLFieldSetElement::~HTMLFieldSetElement()
00160 {
00161 }
00162
00163 HTMLFormElement HTMLFieldSetElement::form()
const
00164
{
00165
return Element::form();
00166 }
00167
00168
00169
00170 HTMLFormElement::HTMLFormElement() :
HTMLElement()
00171 {
00172 }
00173
00174 HTMLFormElement::HTMLFormElement(
const HTMLFormElement &other) :
HTMLElement(other)
00175 {
00176 }
00177
00178 HTMLFormElement::HTMLFormElement(HTMLFormElementImpl *impl) :
HTMLElement(impl)
00179 {
00180 }
00181
00182
HTMLFormElement &HTMLFormElement::operator = (
const Node &other)
00183 {
00184 assignOther( other, ID_FORM );
00185
return *
this;
00186 }
00187
00188
HTMLFormElement &HTMLFormElement::operator = (
const HTMLFormElement &other)
00189 {
00190 HTMLElement::operator = (other);
00191
return *
this;
00192 }
00193
00194 HTMLFormElement::~HTMLFormElement()
00195 {
00196 }
00197
00198 HTMLCollection HTMLFormElement::elements()
const
00199
{
00200
if(!impl)
return HTMLCollection();
00201
return HTMLFormCollection(impl);
00202 }
00203
00204 long HTMLFormElement::length()
const
00205
{
00206
if(!impl)
return 0;
00207
return static_cast<HTMLFormElementImpl*>(impl)->length();
00208 }
00209
00210 DOMString HTMLFormElement::name()
const
00211
{
00212
if(!impl)
return DOMString();
00213
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_NAME);
00214 }
00215
00216 void HTMLFormElement::setName(
const DOMString &value )
00217 {
00218
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_NAME, value);
00219 }
00220
00221 DOMString HTMLFormElement::acceptCharset()
const
00222
{
00223
if(!impl)
return DOMString();
00224
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ACCEPT_CHARSET);
00225 }
00226
00227 void HTMLFormElement::setAcceptCharset(
const DOMString &value )
00228 {
00229
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ACCEPT_CHARSET, value);
00230 }
00231
00232 DOMString HTMLFormElement::action()
const
00233
{
00234
if(!impl)
return DOMString();
00235
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ACTION);
00236 }
00237
00238 void HTMLFormElement::setAction(
const DOMString &value )
00239 {
00240
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ACTION, value);
00241 }
00242
00243 DOMString HTMLFormElement::enctype()
const
00244
{
00245
if(!impl)
return DOMString();
00246
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ENCTYPE);
00247 }
00248
00249 void HTMLFormElement::setEnctype(
const DOMString &value )
00250 {
00251
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ENCTYPE, value);
00252 }
00253
00254 DOMString HTMLFormElement::method()
const
00255
{
00256
if(!impl)
return DOMString();
00257
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_METHOD);
00258 }
00259
00260 void HTMLFormElement::setMethod(
const DOMString &value )
00261 {
00262
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_METHOD, value);
00263 }
00264
00265 DOMString HTMLFormElement::target()
const
00266
{
00267
if(!impl)
return DOMString();
00268
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_TARGET);
00269 }
00270
00271 void HTMLFormElement::setTarget(
const DOMString &value )
00272 {
00273
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_TARGET, value);
00274 }
00275
00276 void HTMLFormElement::submit( )
00277 {
00278
if(impl) static_cast<HTMLFormElementImpl*>(impl)->submit( );
00279 }
00280
00281 void HTMLFormElement::reset( )
00282 {
00283
if(impl) static_cast<HTMLFormElementImpl*>(impl)->reset( );
00284 }
00285
00286
00287
00288 HTMLInputElement::HTMLInputElement() :
HTMLElement()
00289 {
00290 }
00291
00292 HTMLInputElement::HTMLInputElement(
const HTMLInputElement &other) :
HTMLElement(other)
00293 {
00294 }
00295
00296 HTMLInputElement::HTMLInputElement(HTMLInputElementImpl *impl) :
HTMLElement(impl)
00297 {
00298 }
00299
00300
HTMLInputElement &HTMLInputElement::operator = (
const Node &other)
00301 {
00302 assignOther( other, ID_INPUT );
00303
return *
this;
00304 }
00305
00306
HTMLInputElement &HTMLInputElement::operator = (
const HTMLInputElement &other)
00307 {
00308 HTMLElement::operator = (other);
00309
return *
this;
00310 }
00311
00312 HTMLInputElement::~HTMLInputElement()
00313 {
00314 }
00315
00316 DOMString HTMLInputElement::defaultValue()
const
00317
{
00318
if(!impl)
return DOMString();
00319
DOMString s = static_cast<ElementImpl*>(impl)->getAttribute(ATTR_VALUE);
00320
if (s.
isNull())
return DOMString(
"");
00321
return s;
00322
00323 }
00324
00325 void HTMLInputElement::setDefaultValue(
const DOMString &value )
00326 {
00327
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_VALUE, value);
00328 }
00329
00330 bool HTMLInputElement::defaultChecked()
const
00331
{
00332
if(!impl)
return 0;
00333
return !((ElementImpl *)impl)->getAttribute(ATTR_CHECKED).isNull();
00334 }
00335
00336 void HTMLInputElement::setDefaultChecked(
bool _defaultChecked )
00337 {
00338
if(impl)
00339 ((ElementImpl *)impl)->setAttribute(ATTR_CHECKED, _defaultChecked ?
"" : 0);
00340 }
00341
00342 HTMLFormElement HTMLInputElement::form()
const
00343
{
00344
return Element::form();
00345 }
00346
00347 DOMString HTMLInputElement::accept()
const
00348
{
00349
if(!impl)
return DOMString();
00350
return ((ElementImpl *)impl)->getAttribute(ATTR_ACCEPT);
00351 }
00352
00353 void HTMLInputElement::setAccept(
const DOMString &value )
00354 {
00355
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ACCEPT, value);
00356 }
00357
00358 DOMString HTMLInputElement::accessKey()
const
00359
{
00360
if(!impl)
return DOMString();
00361
return ((ElementImpl *)impl)->getAttribute(ATTR_ACCESSKEY);
00362 }
00363
00364 void HTMLInputElement::setAccessKey(
const DOMString &value )
00365 {
00366
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ACCESSKEY, value);
00367 }
00368
00369 DOMString HTMLInputElement::align()
const
00370
{
00371
if(!impl)
return DOMString();
00372
return ((ElementImpl *)impl)->getAttribute(ATTR_ALIGN);
00373 }
00374
00375 void HTMLInputElement::setAlign(
const DOMString &value )
00376 {
00377
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALIGN, value);
00378 }
00379
00380 DOMString HTMLInputElement::alt()
const
00381
{
00382
if(!impl)
return DOMString();
00383
return ((ElementImpl *)impl)->getAttribute(ATTR_ALT);
00384 }
00385
00386 void HTMLInputElement::setAlt(
const DOMString &value )
00387 {
00388
if(impl) ((ElementImpl *)impl)->setAttribute(ATTR_ALT, value);
00389 }
00390
00391 bool HTMLInputElement::checked()
const
00392
{
00393
if(!impl)
return 0;
00394
return ((HTMLInputElementImpl*)impl)->checked();
00395 }
00396
00397 void HTMLInputElement::setChecked(
bool _checked )
00398 {
00399
if(impl)
00400 ((HTMLInputElementImpl*)impl)->setChecked(_checked);
00401 }
00402
00403 bool HTMLInputElement::disabled()
const
00404
{
00405
if(!impl)
return 0;
00406
return !((ElementImpl *)impl)->getAttribute(ATTR_DISABLED).isNull();
00407 }
00408
00409 void HTMLInputElement::setDisabled(
bool _disabled )
00410 {
00411
if(impl)
00412 {
00413 ((ElementImpl *)impl)->setAttribute(ATTR_DISABLED, _disabled ?
"" : 0);
00414 }
00415 }
00416
00417 long HTMLInputElement::maxLength()
const
00418
{
00419
if(!impl)
return 0;
00420
return ((HTMLInputElementImpl *)impl)->getAttribute(ATTR_MAXLENGTH).toInt();
00421 }
00422
00423 void HTMLInputElement::setMaxLength(
long _maxLength )
00424 {
00425
if(impl) {
00426
DOMString value(QString::number(_maxLength));
00427 ((ElementImpl *)impl)->setAttribute(ATTR_MAXLENGTH,value);
00428 }
00429 }
00430
00431 DOMString HTMLInputElement::name()
const
00432
{
00433
if(!impl)
return DOMString();
00434
return static_cast<HTMLInputElementImpl* const>(impl)->name();
00435 }
00436
00437 void HTMLInputElement::setName(
const DOMString &value )
00438 {
00439
if(impl) static_cast<HTMLInputElementImpl*>(impl)->setName(value);
00440 }
00441
00442 bool HTMLInputElement::readOnly()
const
00443
{
00444
if(!impl)
return 0;
00445
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_READONLY).isNull();
00446 }
00447
00448 void HTMLInputElement::setReadOnly(
bool _readOnly )
00449 {
00450
if(impl)
00451 static_cast<ElementImpl*>(impl)->setAttribute(ATTR_READONLY, _readOnly ?
"" : 0);
00452 }
00453
00454
00455 DOMString HTMLInputElement::size()
const
00456
{
00457
if(!impl)
return DOMString();
00458
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_SIZE);
00459 }
00460
00461 void HTMLInputElement::setSize(
const DOMString &value )
00462 {
00463
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_SIZE, value);
00464 }
00465
00466 long HTMLInputElement::getSize()
const
00467
{
00468
if(!impl)
return 0;
00469
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_SIZE).toInt();
00470 }
00471
00472 void HTMLInputElement::setSize(
long value )
00473 {
00474
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_SIZE, QString::number(value));
00475 }
00476
00477 DOMString HTMLInputElement::src()
const
00478
{
00479
if(!impl)
return DOMString();
00480
DOMString s = static_cast<ElementImpl*>(impl)->getAttribute(ATTR_SRC);
00481
return !s.
isNull() ? impl->getDocument()->completeURL( s.
string() ) : s;
00482 }
00483
00484 void HTMLInputElement::setSrc(
const DOMString &value )
00485 {
00486
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_SRC, value);
00487 }
00488
00489 long HTMLInputElement::tabIndex()
const
00490
{
00491
if(!impl)
return 0;
00492
return static_cast<ElementImpl*>(impl)->tabIndex();
00493 }
00494
00495 void HTMLInputElement::setTabIndex(
long _tabIndex )
00496 {
00497
if (!impl)
return;
00498 static_cast<ElementImpl*>(impl)->setTabIndex(_tabIndex);
00499 }
00500
00501 DOMString HTMLInputElement::type()
const
00502
{
00503
if(!impl)
return DOMString();
00504
return ((HTMLInputElementImpl *)impl)->type();
00505 }
00506
00507 void HTMLInputElement::setType(
const DOMString& _type)
00508 {
00509
if (!impl)
return;
00510 static_cast<HTMLInputElementImpl*>(impl)->setType(_type);
00511 }
00512
00513 DOMString HTMLInputElement::useMap()
const
00514
{
00515
if(!impl)
return DOMString();
00516
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_USEMAP);
00517 }
00518
00519 void HTMLInputElement::setUseMap(
const DOMString &value )
00520 {
00521
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_USEMAP, value);
00522 }
00523
00524 DOMString HTMLInputElement::value()
const
00525
{
00526
if(!impl)
return DOMString();
00527
return ((HTMLInputElementImpl*)impl)->value();
00528 }
00529
00530 void HTMLInputElement::setValue(
const DOMString &value )
00531 {
00532
if (impl)
00533 ((HTMLInputElementImpl*)impl)->setValue(value);
00534
00535 }
00536
00537 void HTMLInputElement::blur( )
00538 {
00539
if(impl)
00540 ((HTMLInputElementImpl*)impl)->blur();
00541 }
00542
00543 void HTMLInputElement::focus( )
00544 {
00545
if(impl)
00546 ((HTMLInputElementImpl*)impl)->focus();
00547 }
00548
00549 void HTMLInputElement::select( )
00550 {
00551
if(impl)
00552 ((HTMLInputElementImpl *)impl)->select( );
00553 }
00554
00555 void HTMLInputElement::click( )
00556 {
00557
if(impl)
00558 ((HTMLInputElementImpl *)impl)->click( );
00559 }
00560
00561
00562
00563 HTMLLabelElement::HTMLLabelElement() :
HTMLElement()
00564 {
00565 }
00566
00567 HTMLLabelElement::HTMLLabelElement(
const HTMLLabelElement &other) :
HTMLElement(other)
00568 {
00569 }
00570
00571 HTMLLabelElement::HTMLLabelElement(HTMLLabelElementImpl *impl) :
HTMLElement(impl)
00572 {
00573 }
00574
00575
HTMLLabelElement &HTMLLabelElement::operator = (
const Node &other)
00576 {
00577 assignOther( other, ID_LABEL );
00578
return *
this;
00579 }
00580
00581
HTMLLabelElement &HTMLLabelElement::operator = (
const HTMLLabelElement &other)
00582 {
00583 HTMLElement::operator = (other);
00584
return *
this;
00585 }
00586
00587 HTMLLabelElement::~HTMLLabelElement()
00588 {
00589 }
00590
00591 DOMString HTMLLabelElement::accessKey()
const
00592
{
00593
if(!impl)
return DOMString();
00594
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ACCESSKEY);
00595 }
00596
00597 void HTMLLabelElement::setAccessKey(
const DOMString &value )
00598 {
00599
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ACCESSKEY, value);
00600 }
00601
00602 DOMString HTMLLabelElement::htmlFor()
const
00603
{
00604
if(!impl)
return DOMString();
00605
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_FOR);
00606 }
00607
00608 void HTMLLabelElement::setHtmlFor(
const DOMString &value )
00609 {
00610
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_FOR, value);
00611 }
00612
00613
00614
00615 HTMLLegendElement::HTMLLegendElement() :
HTMLElement()
00616 {
00617 }
00618
00619 HTMLLegendElement::HTMLLegendElement(
const HTMLLegendElement &other) :
HTMLElement(other)
00620 {
00621 }
00622
00623 HTMLLegendElement::HTMLLegendElement(HTMLLegendElementImpl *impl) :
HTMLElement(impl)
00624 {
00625 }
00626
00627
HTMLLegendElement &HTMLLegendElement::operator = (
const Node &other)
00628 {
00629 assignOther( other, ID_LEGEND );
00630
return *
this;
00631 }
00632
00633
HTMLLegendElement &HTMLLegendElement::operator = (
const HTMLLegendElement &other)
00634 {
00635 HTMLElement::operator = (other);
00636
return *
this;
00637 }
00638
00639 HTMLLegendElement::~HTMLLegendElement()
00640 {
00641 }
00642
00643 HTMLFormElement HTMLLegendElement::form()
const
00644
{
00645
return Element::form();
00646 }
00647
00648 DOMString HTMLLegendElement::accessKey()
const
00649
{
00650
if(!impl)
return DOMString();
00651
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ACCESSKEY);
00652 }
00653
00654 void HTMLLegendElement::setAccessKey(
const DOMString &value )
00655 {
00656
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ACCESSKEY, value);
00657 }
00658
00659 DOMString HTMLLegendElement::align()
const
00660
{
00661
if(!impl)
return DOMString();
00662
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ALIGN);
00663 }
00664
00665 void HTMLLegendElement::setAlign(
const DOMString &value )
00666 {
00667
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ALIGN, value);
00668 }
00669
00670
00671
00672 HTMLOptGroupElement::HTMLOptGroupElement() :
HTMLElement()
00673 {
00674 }
00675
00676 HTMLOptGroupElement::HTMLOptGroupElement(
const HTMLOptGroupElement &other) :
HTMLElement(other)
00677 {
00678 }
00679
00680 HTMLOptGroupElement::HTMLOptGroupElement(HTMLOptGroupElementImpl *impl) :
HTMLElement(impl)
00681 {
00682 }
00683
00684
HTMLOptGroupElement &HTMLOptGroupElement::operator = (
const Node &other)
00685 {
00686 assignOther( other, ID_OPTGROUP );
00687
return *
this;
00688 }
00689
00690
HTMLOptGroupElement &HTMLOptGroupElement::operator = (
const HTMLOptGroupElement &other)
00691 {
00692 HTMLElement::operator = (other);
00693
return *
this;
00694 }
00695
00696 HTMLOptGroupElement::~HTMLOptGroupElement()
00697 {
00698 }
00699
00700 bool HTMLOptGroupElement::disabled()
const
00701
{
00702
if(!impl)
return 0;
00703
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_DISABLED).isNull();
00704 }
00705
00706 void HTMLOptGroupElement::setDisabled(
bool _disabled )
00707 {
00708
if(impl)
00709 static_cast<ElementImpl*>(impl)->setAttribute(ATTR_DISABLED, _disabled ?
"" : 0);
00710 }
00711
00712 DOMString HTMLOptGroupElement::label()
const
00713
{
00714
if(!impl)
return DOMString();
00715
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_LABEL);
00716 }
00717
00718 void HTMLOptGroupElement::setLabel(
const DOMString &value )
00719 {
00720
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_LABEL, value);
00721 }
00722
00723
00724
00725 HTMLSelectElement::HTMLSelectElement() :
HTMLElement()
00726 {
00727 }
00728
00729 HTMLSelectElement::HTMLSelectElement(
const HTMLSelectElement &other) :
HTMLElement(other)
00730 {
00731 }
00732
00733 HTMLSelectElement::HTMLSelectElement(HTMLSelectElementImpl *impl) :
HTMLElement(impl)
00734 {
00735 }
00736
00737
HTMLSelectElement &HTMLSelectElement::operator = (
const Node &other)
00738 {
00739 assignOther( other, ID_SELECT );
00740
return *
this;
00741 }
00742
00743
HTMLSelectElement &HTMLSelectElement::operator = (
const HTMLSelectElement &other)
00744 {
00745 HTMLElement::operator = (other);
00746
return *
this;
00747 }
00748
00749 HTMLSelectElement::~HTMLSelectElement()
00750 {
00751 }
00752
00753 DOMString HTMLSelectElement::type()
const
00754
{
00755
if(!impl)
return DOMString();
00756
return ((HTMLSelectElementImpl *)impl)->type();
00757 }
00758
00759 long HTMLSelectElement::selectedIndex()
const
00760
{
00761
if(!impl)
return 0;
00762
return ((HTMLSelectElementImpl *)impl)->selectedIndex();
00763 }
00764
00765 void HTMLSelectElement::setSelectedIndex(
long _selectedIndex )
00766 {
00767
if(impl)
00768 ((HTMLSelectElementImpl *)impl)->setSelectedIndex(_selectedIndex);
00769 }
00770
00771 DOMString HTMLSelectElement::value()
const
00772
{
00773
if(!impl)
return DOMString();
00774
return static_cast<HTMLSelectElementImpl*>(impl)->value();
00775 }
00776
00777 void HTMLSelectElement::setValue(
const DOMString &value )
00778 {
00779
if(!impl || value.
isNull())
return;
00780 static_cast<HTMLSelectElementImpl*>(impl)->setValue(value.
implementation());
00781 }
00782
00783 long HTMLSelectElement::length()
const
00784
{
00785
if(!impl)
return 0;
00786
return ((HTMLSelectElementImpl *)impl)->length();
00787 }
00788
00789 HTMLFormElement HTMLSelectElement::form()
const
00790
{
00791
return Element::form();
00792 }
00793
00794 HTMLCollection HTMLSelectElement::options()
const
00795
{
00796
if(!impl)
return HTMLCollection();
00797
return HTMLCollection(impl, HTMLCollectionImpl::SELECT_OPTIONS);
00798 }
00799
00800 bool HTMLSelectElement::disabled()
const
00801
{
00802
if(!impl)
return 0;
00803
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_DISABLED).isNull();
00804 }
00805
00806 void HTMLSelectElement::setDisabled(
bool _disabled )
00807 {
00808
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_DISABLED, _disabled ?
"" : 0);
00809 }
00810
00811
00812 bool HTMLSelectElement::multiple()
const
00813
{
00814
if(!impl)
return 0;
00815
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_MULTIPLE).isNull();
00816 }
00817
00818 void HTMLSelectElement::setMultiple(
bool _multiple )
00819 {
00820
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_MULTIPLE, _multiple ?
"" : 0);
00821 }
00822
00823 DOMString HTMLSelectElement::name()
const
00824
{
00825
if(!impl)
return DOMString();
00826
return static_cast<HTMLSelectElementImpl* const>(impl)->name();
00827 }
00828
00829 void HTMLSelectElement::setName(
const DOMString &value )
00830 {
00831
if(impl) static_cast<HTMLSelectElementImpl*>(impl)->setName(value);
00832 }
00833
00834 long HTMLSelectElement::size()
const
00835
{
00836
if(!impl)
return 0;
00837
return ((HTMLSelectElementImpl *)impl)->getAttribute(ATTR_SIZE).toInt();
00838 }
00839
00840 void HTMLSelectElement::setSize(
long _size )
00841 {
00842
00843
if(impl) {
00844
DOMString value(QString::number(_size));
00845 static_cast<ElementImpl*>(impl)->setAttribute(ATTR_SIZE,value);
00846 }
00847 }
00848
00849 long HTMLSelectElement::tabIndex()
const
00850
{
00851
if(!impl)
return 0;
00852
return static_cast<ElementImpl*>(impl)->tabIndex();
00853 }
00854
00855 void HTMLSelectElement::setTabIndex(
long _tabIndex )
00856 {
00857
if (!impl)
return;
00858 static_cast<ElementImpl*>(impl)->setTabIndex(_tabIndex);
00859 }
00860
00861 void HTMLSelectElement::add(
const HTMLElement &element,
const HTMLElement &before )
00862 {
00863
if (!impl)
00864
throw DOMException(DOMException::NOT_FOUND_ERR);
00865
00866
int exceptioncode = 0;
00867 static_cast<HTMLSelectElementImpl*>(impl)->add( element, before, exceptioncode );
00868
if ( exceptioncode )
00869
throw DOMException( exceptioncode );
00870 }
00871
00872 void HTMLSelectElement::remove(
long index )
00873 {
00874
if(impl) static_cast<HTMLSelectElementImpl*>(impl)->remove( index );
00875 }
00876
00877 void HTMLSelectElement::blur( )
00878 {
00879
if(impl)
00880 ((HTMLSelectElementImpl*)impl)->blur();
00881 }
00882
00883 void HTMLSelectElement::focus( )
00884 {
00885
if(impl)
00886 ((HTMLSelectElementImpl*)impl)->focus();
00887 }
00888
00889
00890
00891 HTMLTextAreaElement::HTMLTextAreaElement() :
HTMLElement()
00892 {
00893 }
00894
00895 HTMLTextAreaElement::HTMLTextAreaElement(
const HTMLTextAreaElement &other) :
HTMLElement(other)
00896 {
00897 }
00898
00899 HTMLTextAreaElement::HTMLTextAreaElement(HTMLTextAreaElementImpl *impl) :
HTMLElement(impl)
00900 {
00901 }
00902
00903
HTMLTextAreaElement &HTMLTextAreaElement::operator = (
const Node &other)
00904 {
00905 assignOther( other, ID_TEXTAREA );
00906
return *
this;
00907 }
00908
00909
HTMLTextAreaElement &HTMLTextAreaElement::operator = (
const HTMLTextAreaElement &other)
00910 {
00911 HTMLElement::operator = (other);
00912
return *
this;
00913 }
00914
00915 HTMLTextAreaElement::~HTMLTextAreaElement()
00916 {
00917 }
00918
00919 DOMString HTMLTextAreaElement::defaultValue()
const
00920
{
00921
if(!impl)
return DOMString();
00922
return ((HTMLTextAreaElementImpl *)impl)->defaultValue();
00923 }
00924
00925 void HTMLTextAreaElement::setDefaultValue(
const DOMString &value )
00926 {
00927
if (impl) ((HTMLTextAreaElementImpl *)impl)->setDefaultValue(value);
00928 }
00929
00930 HTMLFormElement HTMLTextAreaElement::form()
const
00931
{
00932
return Element::form();
00933 }
00934
00935 DOMString HTMLTextAreaElement::accessKey()
const
00936
{
00937
if(!impl)
return DOMString();
00938
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_ACCESSKEY);
00939 }
00940
00941 void HTMLTextAreaElement::setAccessKey(
const DOMString &value )
00942 {
00943
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ACCESSKEY, value);
00944 }
00945
00946 long HTMLTextAreaElement::cols()
const
00947
{
00948
if(!impl)
return 0;
00949
return ((HTMLTextAreaElementImpl *)impl)->getAttribute(ATTR_COLS).toInt();
00950 }
00951
00952 void HTMLTextAreaElement::setCols(
long _cols )
00953 {
00954
00955
if(impl) {
00956
DOMString value(QString::number(_cols));
00957 static_cast<ElementImpl*>(impl)->setAttribute(ATTR_COLS,value);
00958 }
00959 }
00960
00961 bool HTMLTextAreaElement::disabled()
const
00962
{
00963
if(!impl)
return 0;
00964
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_DISABLED).isNull();
00965 }
00966
00967 void HTMLTextAreaElement::setDisabled(
bool _disabled )
00968 {
00969
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_DISABLED, _disabled ?
"" : 0);
00970 }
00971
00972 DOMString HTMLTextAreaElement::name()
const
00973
{
00974
if(!impl)
return DOMString();
00975
return static_cast<HTMLTextAreaElementImpl* const>(impl)->name();
00976 }
00977
00978 void HTMLTextAreaElement::setName(
const DOMString &value )
00979 {
00980
if(impl) static_cast<HTMLTextAreaElementImpl*>(impl)->setName(value);
00981 }
00982
00983 bool HTMLTextAreaElement::readOnly()
const
00984
{
00985
if(!impl)
return 0;
00986
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_READONLY).isNull();
00987 }
00988
00989 void HTMLTextAreaElement::setReadOnly(
bool _readOnly )
00990 {
00991
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_READONLY, _readOnly ?
"" : 0);
00992 }
00993
00994 long HTMLTextAreaElement::rows()
const
00995
{
00996
if(!impl)
return 0;
00997
return ((HTMLTextAreaElementImpl *)impl)->getAttribute(ATTR_ROWS).toInt();
00998 }
00999
01000 void HTMLTextAreaElement::setRows(
long _rows )
01001 {
01002
01003
if(impl) {
01004
DOMString value(QString::number(_rows));
01005 static_cast<ElementImpl*>(impl)->setAttribute(ATTR_ROWS,value);
01006 }
01007 }
01008
01009 long HTMLTextAreaElement::tabIndex()
const
01010
{
01011
if(!impl)
return 0;
01012
return static_cast<ElementImpl*>(impl)->tabIndex();
01013 }
01014
01015 void HTMLTextAreaElement::setTabIndex(
long _tabIndex )
01016 {
01017
if (!impl)
return;
01018 static_cast<ElementImpl*>(impl)->setTabIndex(_tabIndex);
01019 }
01020
01021 DOMString HTMLTextAreaElement::type()
const
01022
{
01023
if(!impl)
return DOMString();
01024
return ((HTMLTextAreaElementImpl *)impl)->type();
01025 }
01026
01027 DOMString HTMLTextAreaElement::value()
const
01028
{
01029
if(!impl)
return DOMString();
01030
return ((HTMLTextAreaElementImpl *)impl)->value();
01031 }
01032
01033 void HTMLTextAreaElement::setValue(
const DOMString &value )
01034 {
01035
if(impl) ((HTMLTextAreaElementImpl *)impl)->setValue(value);
01036 }
01037
01038 void HTMLTextAreaElement::blur( )
01039 {
01040
if(impl)
01041 ((HTMLTextAreaElementImpl*)impl)->blur();
01042 }
01043
01044 void HTMLTextAreaElement::focus( )
01045 {
01046
if(impl)
01047 ((HTMLTextAreaElementImpl*)impl)->focus();
01048 }
01049
01050 void HTMLTextAreaElement::select( )
01051 {
01052
if(impl)
01053 ((HTMLTextAreaElementImpl *)impl)->select( );
01054 }
01055
01056
01057
01058 HTMLOptionElement::HTMLOptionElement() :
HTMLElement()
01059 {
01060 }
01061
01062 HTMLOptionElement::HTMLOptionElement(
const HTMLOptionElement &other) :
HTMLElement(other)
01063 {
01064 }
01065
01066 HTMLOptionElement::HTMLOptionElement(HTMLOptionElementImpl *impl) :
HTMLElement(impl)
01067 {
01068 }
01069
01070
HTMLOptionElement &HTMLOptionElement::operator = (
const Node &other)
01071 {
01072 assignOther( other, ID_OPTION );
01073
return *
this;
01074 }
01075
01076
HTMLOptionElement &HTMLOptionElement::operator = (
const HTMLOptionElement &other)
01077 {
01078 HTMLElement::operator = (other);
01079
return *
this;
01080 }
01081
01082 HTMLOptionElement::~HTMLOptionElement()
01083 {
01084 }
01085
01086 HTMLFormElement HTMLOptionElement::form()
const
01087
{
01088
return Element::form();
01089 }
01090
01091 bool HTMLOptionElement::defaultSelected()
const
01092
{
01093
if(!impl)
return 0;
01094
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_SELECTED).isNull();
01095 }
01096
01097 void HTMLOptionElement::setDefaultSelected(
bool _defaultSelected )
01098 {
01099
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_SELECTED, _defaultSelected ?
"" : 0);
01100 }
01101
01102 DOMString HTMLOptionElement::text()
const
01103
{
01104
if(!impl)
return DOMString();
01105
return ((HTMLOptionElementImpl *)impl)->text();
01106 }
01107
01108 long HTMLOptionElement::index()
const
01109
{
01110
if(!impl)
return 0;
01111
return ((HTMLOptionElementImpl *)impl)->index();
01112 }
01113
01114 void HTMLOptionElement::setIndex(
long )
01115 {
01116
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
01117 }
01118
01119 bool HTMLOptionElement::disabled()
const
01120
{
01121
if(!impl)
return 0;
01122
return !static_cast<ElementImpl*>(impl)->getAttribute(ATTR_DISABLED).isNull();
01123 }
01124
01125 void HTMLOptionElement::setDisabled(
bool _disabled )
01126 {
01127
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_DISABLED, _disabled ?
"" : 0);
01128 }
01129
01130 DOMString HTMLOptionElement::label()
const
01131
{
01132
if(!impl)
return DOMString();
01133
return static_cast<ElementImpl*>(impl)->getAttribute(ATTR_LABEL);
01134 }
01135
01136 void HTMLOptionElement::setLabel(
const DOMString &value )
01137 {
01138
if(impl) static_cast<ElementImpl*>(impl)->setAttribute(ATTR_LABEL, value);
01139 }
01140
01141 bool HTMLOptionElement::selected()
const
01142
{
01143
if(!impl)
return 0;
01144
return ((HTMLOptionElementImpl *)impl)->selected();
01145 }
01146
01147 void HTMLOptionElement::setSelected(
bool _selected) {
01148
if(!impl)
return;
01149 ((HTMLOptionElementImpl *)impl)->setSelected(_selected);
01150 }
01151
01152 DOMString HTMLOptionElement::value()
const
01153
{
01154
if(!impl)
return DOMString();
01155
return static_cast<HTMLOptionElementImpl*>(impl)->value();
01156 }
01157
01158 void HTMLOptionElement::setValue(
const DOMString &value )
01159 {
01160
if(impl) static_cast<HTMLOptionElementImpl*>(impl)->setValue(value.
implementation());
01161 }
01162
01163
01164
01165 HTMLIsIndexElement::HTMLIsIndexElement() :
HTMLElement()
01166 {
01167 }
01168
01169 HTMLIsIndexElement::HTMLIsIndexElement(
const HTMLIsIndexElement &other) :
HTMLElement(other)
01170 {
01171 }
01172
01173 HTMLIsIndexElement::HTMLIsIndexElement(HTMLIsIndexElementImpl *impl) :
HTMLElement(impl)
01174 {
01175 }
01176
01177
HTMLIsIndexElement &HTMLIsIndexElement::operator = (
const Node &other)
01178 {
01179 assignOther( other, ID_ISINDEX );
01180
return *
this;
01181 }
01182
01183
HTMLIsIndexElement &HTMLIsIndexElement::operator = (
const HTMLIsIndexElement &other)
01184 {
01185 HTMLElement::operator = (other);
01186
return *
this;
01187 }
01188
01189 HTMLIsIndexElement::~HTMLIsIndexElement()
01190 {
01191 }
01192
01193 HTMLFormElement HTMLIsIndexElement::form()
const
01194
{
01195
return Element::form();
01196 }
01197
01198 DOMString HTMLIsIndexElement::prompt()
const
01199
{
01200
if(!impl)
return DOMString();
01201
return static_cast<HTMLIsIndexElementImpl*>(impl)->prompt();
01202 }
01203
01204 void HTMLIsIndexElement::setPrompt(
const DOMString &value )
01205 {
01206
if(impl) static_cast<HTMLIsIndexElementImpl*>(impl)->setPrompt(value);
01207 }