# khtml Library API Documentation

Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Source Files

# css_extensions.cpp

    00001
    00023 #include "dom_exception.h"
    00024 #include "dom_string.h"
    00025
    00026 #include "css_extensions.h"
    00027 #include "css_extensionsimpl.h"
    00028 using namespace DOM;
    00029
    00030
    00031 CSS2Azimuth::CSS2Azimuth() : CSSValue()
    00032 {
    00033 }
    00034
    00035 CSS2Azimuth::CSS2Azimuth(const CSS2Azimuth &other) : CSSValue(other)
    00036 {
    00037 }
    00038
    00039 CSS2Azimuth::CSS2Azimuth(CSS2AzimuthImpl *impl) : CSSValue(impl)
    00040 {
    00041 }
    00042
    00043 CSS2Azimuth &CSS2Azimuth::operator = (const CSS2Azimuth &other)
    00044 {
    00045     CSSValue::operator = (other);
    00046     return *this;
    00047 }
    00048
    00049 CSS2Azimuth::~CSS2Azimuth()
    00050 {
    00051 }
    00052
    00053 unsigned short CSS2Azimuth::azimuthType() const
    00054 {
    00055     if(!impl) return 0;
    00056     return ((CSS2AzimuthImpl *)impl)->azimuthType();
    00057 }
    00058
    00059 DOMString CSS2Azimuth::identifier() const
    00060 {
    00061     if(!impl) return 0;
    00062     return ((CSS2AzimuthImpl *)impl)->identifier();
    00063 }
    00064
    00065 bool CSS2Azimuth::behind() const
    00066 {
    00067     if(!impl) return 0;
    00068     return ((CSS2AzimuthImpl *)impl)->behind();
    00069 }
    00070
    00071 void CSS2Azimuth::setAngleValue( const unsigned short unitType, const float floatValue )
    00072 {
    00073     if(impl)
    00074         ((CSS2AzimuthImpl *)impl)->setAngleValue( unitType, floatValue );
    00075 }
    00076
    00077 float CSS2Azimuth::getAngleValue( const unsigned short unitType )
    00078 {
    00079     if(!impl) return 0;
    00080     return ((CSS2AzimuthImpl *)impl)->getAngleValue( unitType );
    00081 }
    00082
    00083 void CSS2Azimuth::setIdentifier( const DOMString &identifier, const bool behind )
    00084 {
    00085     if(impl)
    00086         ((CSS2AzimuthImpl *)impl)->setIdentifier( identifier, behind );
    00087 }
    00088
    00089
    00090
    00091 CSS2BackgroundPosition::CSS2BackgroundPosition() : CSSValue()
    00092 {
    00093 }
    00094
    00095 CSS2BackgroundPosition::CSS2BackgroundPosition(const CSS2BackgroundPosition &other) : CSSValue(other)
    00096 {
    00097 }
    00098
    00099 CSS2BackgroundPosition::CSS2BackgroundPosition(CSS2BackgroundPositionImpl *impl) : CSSValue(impl)
    00100 {
    00101 }
    00102
    00103 CSS2BackgroundPosition &CSS2BackgroundPosition::operator = (const CSS2BackgroundPosition &other)
    00104 {
    00105     CSSValue::operator = (other);
    00106     return *this;
    00107 }
    00108
    00109 CSS2BackgroundPosition::~CSS2BackgroundPosition()
    00110 {
    00111 }
    00112
    00113 unsigned short CSS2BackgroundPosition::horizontalType() const
    00114 {
    00115     if(!impl) return 0;
    00116     return ((CSS2BackgroundPositionImpl *)impl)->horizontalType();
    00117 }
    00118
    00119 unsigned short CSS2BackgroundPosition::verticalType() const
    00120 {
    00121     if(!impl) return 0;
    00122     return ((CSS2BackgroundPositionImpl *)impl)->verticalType();
    00123 }
    00124
    00125 DOMString CSS2BackgroundPosition::horizontalIdentifier() const
    00126 {
    00127     if(!impl) return 0;
    00128     return ((CSS2BackgroundPositionImpl *)impl)->horizontalIdentifier();
    00129 }
    00130
    00131 DOMString CSS2BackgroundPosition::verticalIdentifier() const
    00132 {
    00133     if(!impl) return 0;
    00134     return ((CSS2BackgroundPositionImpl *)impl)->verticalIdentifier();
    00135 }
    00136
    00137 float CSS2BackgroundPosition::getHorizontalPosition( const float horizontalType )
    00138 {
    00139     if(!impl) return 0;
    00140     return ((CSS2BackgroundPositionImpl *)impl)->getHorizontalPosition( horizontalType );
    00141 }
    00142
    00143 float CSS2BackgroundPosition::getVerticalPosition( const float verticalType )
    00144 {
    00145     if(!impl) return 0;
    00146     return ((CSS2BackgroundPositionImpl *)impl)->getVerticalPosition( verticalType );
    00147 }
    00148
    00149 void CSS2BackgroundPosition::setHorizontalPosition( const unsigned short horizontalType, const float value )
    00150 {
    00151     if(impl)
    00152         ((CSS2BackgroundPositionImpl *)impl)->setHorizontalPosition( horizontalType, value );
    00153 }
    00154
    00155 void CSS2BackgroundPosition::setVerticalPosition( const unsigned short verticalType, const float value )
    00156 {
    00157     if(impl)
    00158         ((CSS2BackgroundPositionImpl *)impl)->setVerticalPosition( verticalType, value );
    00159 }
    00160
    00161 void CSS2BackgroundPosition::setPositionIdentifier( const DOMString &horizontalIdentifier, const DOMString &verticalIdentifier )
    00162 {
    00163     if(impl)
    00164         ((CSS2BackgroundPositionImpl *)impl)->setPositionIdentifier( horizontalIdentifier, verticalIdentifier );
    00165 }
    00166
    00167
    00168
    00169 CSS2BorderSpacing::CSS2BorderSpacing() : CSSValue()
    00170 {
    00171 }
    00172
    00173 CSS2BorderSpacing::CSS2BorderSpacing(const CSS2BorderSpacing &other) : CSSValue(other)
    00174 {
    00175 }
    00176
    00177 CSS2BorderSpacing::CSS2BorderSpacing(CSS2BorderSpacingImpl *impl) : CSSValue(impl)
    00178 {
    00179 }
    00180
    00181 CSS2BorderSpacing &CSS2BorderSpacing::operator = (const CSS2BorderSpacing &other)
    00182 {
    00183     CSSValue::operator = (other);
    00184     return *this;
    00185 }
    00186
    00187 CSS2BorderSpacing::~CSS2BorderSpacing()
    00188 {
    00189 }
    00190
    00191 unsigned short CSS2BorderSpacing::horizontalType() const
    00192 {
    00193     if(!impl) return 0;
    00194     return ((CSS2BorderSpacingImpl *)impl)->horizontalType();
    00195 }
    00196
    00197 unsigned short CSS2BorderSpacing::verticalType() const
    00198 {
    00199     if(!impl) return 0;
    00200     return ((CSS2BorderSpacingImpl *)impl)->verticalType();
    00201 }
    00202
    00203 float CSS2BorderSpacing::getHorizontalSpacing( const float horizontalType )
    00204 {
    00205     if(!impl) return 0;
    00206     return ((CSS2BorderSpacingImpl *)impl)->getHorizontalSpacing( horizontalType );
    00207 }
    00208
    00209 float CSS2BorderSpacing::getVerticalSpacing( const float verticalType )
    00210 {
    00211     if(!impl) return 0;
    00212     return ((CSS2BorderSpacingImpl *)impl)->getVerticalSpacing( verticalType );
    00213 }
    00214
    00215 void CSS2BorderSpacing::setHorizontalSpacing( const unsigned short horizontalType, const float value )
    00216 {
    00217     if(impl)
    00218         ((CSS2BorderSpacingImpl *)impl)->setHorizontalSpacing( horizontalType, value );
    00219 }
    00220
    00221 void CSS2BorderSpacing::setVerticalSpacing( const unsigned short verticalType, const float value )
    00222 {
    00223     if(impl)
    00224         ((CSS2BorderSpacingImpl *)impl)->setVerticalSpacing( verticalType, value );
    00225 }
    00226
    00227 void CSS2BorderSpacing::setInherit()
    00228 {
    00229     if(impl)
    00230         ((CSS2BorderSpacingImpl *)impl)->setInherit();
    00231 }
    00232
    00233
    00234
    00235 CSS2CounterIncrement::CSS2CounterIncrement()
    00236 {
    00237 }
    00238
    00239 CSS2CounterIncrement::CSS2CounterIncrement(const CSS2CounterIncrement &other)
    00240 {
    00241 }
    00242
    00243 CSS2CounterIncrement::CSS2CounterIncrement(CSS2CounterIncrementImpl *impl)
    00244 {
    00245 }
    00246
    00247 CSS2CounterIncrement &CSS2CounterIncrement::operator = (const CSS2CounterIncrement &other)
    00248 {
    00249     ::operator = (other);
    00250     return *this;
    00251 }
    00252
    00253 CSS2CounterIncrement::~CSS2CounterIncrement()
    00254 {
    00255 }
    00256
    00257 DOMString CSS2CounterIncrement::identifier() const
    00258 {
    00259     if(!impl) return 0;
    00260     return ((ElementImpl *)impl)->getAttribute("identifier");
    00261 }
    00262
    00263 void CSS2CounterIncrement::setIdentifier( const DOMString &value )
    00264 {
    00265     if(impl) ((ElementImpl *)impl)->setAttribute("identifier", value);
    00266 }
    00267
    00268 short CSS2CounterIncrement::increment() const
    00269 {
    00270     if(!impl) return 0;
    00271     return ((CSS2CounterIncrementImpl *)impl)->increment();
    00272 }
    00273
    00274 void CSS2CounterIncrement::setIncrement( const short _increment )
    00275 {
    00276
    00277     if(impl)
    00278         ((CSS2CounterIncrementImpl *)impl)->setIncrement( _increment );
    00279 }
    00280
    00281
    00282
    00283
    00284 CSS2CounterReset::CSS2CounterReset()
    00285 {
    00286 }
    00287
    00288 CSS2CounterReset::CSS2CounterReset(const CSS2CounterReset &other)
    00289 {
    00290 }
    00291
    00292 CSS2CounterReset::CSS2CounterReset(CSS2CounterResetImpl *impl)
    00293 {
    00294 }
    00295
    00296 CSS2CounterReset &CSS2CounterReset::operator = (const CSS2CounterReset &other)
    00297 {
    00298     ::operator = (other);
    00299     return *this;
    00300 }
    00301
    00302 CSS2CounterReset::~CSS2CounterReset()
    00303 {
    00304 }
    00305
    00306 DOMString CSS2CounterReset::identifier() const
    00307 {
    00308     if(!impl) return 0;
    00309     return ((ElementImpl *)impl)->getAttribute("identifier");
    00310 }
    00311
    00312 void CSS2CounterReset::setIdentifier( const DOMString &value )
    00313 {
    00314     if(impl) ((ElementImpl *)impl)->setAttribute("identifier", value);
    00315 }
    00316
    00317 short CSS2CounterReset::reset() const
    00318 {
    00319     if(!impl) return 0;
    00320     return ((CSS2CounterResetImpl *)impl)->reset();
    00321 }
    00322
    00323 void CSS2CounterReset::setReset( const short _reset )
    00324 {
    00325
    00326     if(impl)
    00327         ((CSS2CounterResetImpl *)impl)->setReset( _reset );
    00328 }
    00329
    00330
    00331
    00332
    00333 CSS2Cursor::CSS2Cursor() : CSSValue()
    00334 {
    00335 }
    00336
    00337 CSS2Cursor::CSS2Cursor(const CSS2Cursor &other) : CSSValue(other)
    00338 {
    00339 }
    00340
    00341 CSS2Cursor::CSS2Cursor(CSS2CursorImpl *impl) : CSSValue(impl)
    00342 {
    00343 }
    00344
    00345 CSS2Cursor &CSS2Cursor::operator = (const CSS2Cursor &other)
    00346 {
    00347     CSSValue::operator = (other);
    00348     return *this;
    00349 }
    00350
    00351 CSS2Cursor::~CSS2Cursor()
    00352 {
    00353 }
    00354
    00355 unsigned short CSS2Cursor::cursorType() const
    00356 {
    00357     if(!impl) return 0;
    00358     return ((CSS2CursorImpl *)impl)->cursorType();
    00359 }
    00360
    00361 void CSS2Cursor::setCursorType( const unsigned short _cursorType )
    00362 {
    00363
    00364     if(impl)
    00365         ((CSS2CursorImpl *)impl)->setCursorType( _cursorType );
    00366 }
    00367
    00368 CSSValueList CSS2Cursor::uris() const
    00369 {
    00370     if(!impl) return 0;
    00371     return ((CSS2CursorImpl *)impl)->uris();
    00372 }
    00373
    00374 DOMString CSS2Cursor::predefinedCursor() const
    00375 {
    00376     if(!impl) return 0;
    00377     return ((ElementImpl *)impl)->getAttribute("predefinedCursor");
    00378 }
    00379
    00380 void CSS2Cursor::setPredefinedCursor( const DOMString &value )
    00381 {
    00382     if(impl) ((ElementImpl *)impl)->setAttribute("predefinedCursor", value);
    00383 }
    00384
    00385
    00386
    00387 CSS2FontFaceSrc::CSS2FontFaceSrc()
    00388 {
    00389 }
    00390
    00391 CSS2FontFaceSrc::CSS2FontFaceSrc(const CSS2FontFaceSrc &other)
    00392 {
    00393 }
    00394
    00395 CSS2FontFaceSrc::CSS2FontFaceSrc(CSS2FontFaceSrcImpl *impl)
    00396 {
    00397 }
    00398
    00399 CSS2FontFaceSrc &CSS2FontFaceSrc::operator = (const CSS2FontFaceSrc &other)
    00400 {
    00401     ::operator = (other);
    00402     return *this;
    00403 }
    00404
    00405 CSS2FontFaceSrc::~CSS2FontFaceSrc()
    00406 {
    00407 }
    00408
    00409 DOMString CSS2FontFaceSrc::uri() const
    00410 {
    00411     if(!impl) return 0;
    00412     return ((ElementImpl *)impl)->getAttribute("uri");
    00413 }
    00414
    00415 void CSS2FontFaceSrc::setUri( const DOMString &value )
    00416 {
    00417     if(impl) ((ElementImpl *)impl)->setAttribute("uri", value);
    00418 }
    00419
    00420 CSSValueList CSS2FontFaceSrc::format() const
    00421 {
    00422     if(!impl) return 0;
    00423     return ((CSS2FontFaceSrcImpl *)impl)->format();
    00424 }
    00425
    00426 DOMString CSS2FontFaceSrc::fontFaceName() const
    00427 {
    00428     if(!impl) return 0;
    00429     return ((ElementImpl *)impl)->getAttribute("fontFaceName");
    00430 }
    00431
    00432 void CSS2FontFaceSrc::setFontFaceName( const DOMString &value )
    00433 {
    00434     if(impl) ((ElementImpl *)impl)->setAttribute("fontFaceName", value);
    00435 }
    00436
    00437
    00438
    00439 CSS2FontFaceWidths::CSS2FontFaceWidths()
    00440 {
    00441 }
    00442
    00443 CSS2FontFaceWidths::CSS2FontFaceWidths(const CSS2FontFaceWidths &other)
    00444 {
    00445 }
    00446
    00447 CSS2FontFaceWidths::CSS2FontFaceWidths(CSS2FontFaceWidthsImpl *impl)
    00448 {
    00449 }
    00450
    00451 CSS2FontFaceWidths &CSS2FontFaceWidths::operator = (const CSS2FontFaceWidths &other)
    00452 {
    00453     ::operator = (other);
    00454     return *this;
    00455 }
    00456
    00457 CSS2FontFaceWidths::~CSS2FontFaceWidths()
    00458 {
    00459 }
    00460
    00461 DOMString CSS2FontFaceWidths::urange() const
    00462 {
    00463     if(!impl) return 0;
    00464     return ((ElementImpl *)impl)->getAttribute("urange");
    00465 }
    00466
    00467 void CSS2FontFaceWidths::setUrange( const DOMString &value )
    00468 {
    00469     if(impl) ((ElementImpl *)impl)->setAttribute("urange", value);
    00470 }
    00471
    00472 CSSValueList CSS2FontFaceWidths::numbers() const
    00473 {
    00474     if(!impl) return 0;
    00475     return ((CSS2FontFaceWidthsImpl *)impl)->numbers();
    00476 }
    00477
    00478
    00479
    00480
    00481 CSS2PageSize::CSS2PageSize() : CSSValue()
    00482 {
    00483 }
    00484
    00485 CSS2PageSize::CSS2PageSize(const CSS2PageSize &other) : CSSValue(other)
    00486 {
    00487 }
    00488
    00489 CSS2PageSize::CSS2PageSize(CSS2PageSizeImpl *impl) : CSSValue(impl)
    00490 {
    00491 }
    00492
    00493 CSS2PageSize &CSS2PageSize::operator = (const CSS2PageSize &other)
    00494 {
    00495     CSSValue::operator = (other);
    00496     return *this;
    00497 }
    00498
    00499 CSS2PageSize::~CSS2PageSize()
    00500 {
    00501 }
    00502
    00503 unsigned short CSS2PageSize::widthType() const
    00504 {
    00505     if(!impl) return 0;
    00506     return ((CSS2PageSizeImpl *)impl)->widthType();
    00507 }
    00508
    00509 unsigned short CSS2PageSize::heightType() const
    00510 {
    00511     if(!impl) return 0;
    00512     return ((CSS2PageSizeImpl *)impl)->heightType();
    00513 }
    00514
    00515 DOMString CSS2PageSize::identifier() const
    00516 {
    00517     if(!impl) return 0;
    00518     return ((CSS2PageSizeImpl *)impl)->identifier();
    00519 }
    00520
    00521 float CSS2PageSize::getWidth( const float widthType )
    00522 {
    00523     if(!impl) return 0;
    00524     return ((CSS2PageSizeImpl *)impl)->getWidth( widthType );
    00525 }
    00526
    00527 float CSS2PageSize::getHeightSize( const float heightType )
    00528 {
    00529     if(!impl) return 0;
    00530     return ((CSS2PageSizeImpl *)impl)->getHeightSize( heightType );
    00531 }
    00532
    00533 void CSS2PageSize::setWidthSize( const unsigned short widthType, const float value )
    00534 {
    00535     if(impl)
    00536         ((CSS2PageSizeImpl *)impl)->setWidthSize( widthType, value );
    00537 }
    00538
    00539 void CSS2PageSize::setHeightSize( const unsigned short heightType, const float value )
    00540 {
    00541     if(impl)
    00542         ((CSS2PageSizeImpl *)impl)->setHeightSize( heightType, value );
    00543 }
    00544
    00545 void CSS2PageSize::setIdentifier( const DOMString &identifier )
    00546 {
    00547     if(impl)
    00548         ((CSS2PageSizeImpl *)impl)->setIdentifier( identifier );
    00549 }
    00550
    00551
    00552
    00553 CSS2PlayDuring::CSS2PlayDuring() : CSSValue()
    00554 {
    00555 }
    00556
    00557 CSS2PlayDuring::CSS2PlayDuring(const CSS2PlayDuring &other) : CSSValue(other)
    00558 {
    00559 }
    00560
    00561 CSS2PlayDuring::CSS2PlayDuring(CSS2PlayDuringImpl *impl) : CSSValue(impl)
    00562 {
    00563 }
    00564
    00565 CSS2PlayDuring &CSS2PlayDuring::operator = (const CSS2PlayDuring &other)
    00566 {
    00567     CSSValue::operator = (other);
    00568     return *this;
    00569 }
    00570
    00571 CSS2PlayDuring::~CSS2PlayDuring()
    00572 {
    00573 }
    00574
    00575 unsigned short CSS2PlayDuring::playDuringType() const
    00576 {
    00577     if(!impl) return 0;
    00578     return ((CSS2PlayDuringImpl *)impl)->playDuringType();
    00579 }
    00580
    00581 DOMString CSS2PlayDuring::playDuringIdentifier() const
    00582 {
    00583     if(!impl) return 0;
    00584     return ((ElementImpl *)impl)->getAttribute("playDuringIdentifier");
    00585 }
    00586
    00587 void CSS2PlayDuring::setPlayDuringIdentifier( const DOMString &value )
    00588 {
    00589     if(impl) ((ElementImpl *)impl)->setAttribute("playDuringIdentifier", value);
    00590 }
    00591
    00592 DOMString CSS2PlayDuring::uri() const
    00593 {
    00594     if(!impl) return 0;
    00595     return ((ElementImpl *)impl)->getAttribute("uri");
    00596 }
    00597
    00598 void CSS2PlayDuring::setUri( const DOMString &value )
    00599 {
    00600     if(impl) ((ElementImpl *)impl)->setAttribute("uri", value);
    00601 }
    00602
    00603 bool CSS2PlayDuring::mix() const
    00604 {
    00605     if(!impl) return 0;
    00606     return ((CSS2PlayDuringImpl *)impl)->mix();
    00607 }
    00608
    00609 void CSS2PlayDuring::setMix( const bool _mix )
    00610 {
    00611
    00612     if(impl)
    00613         ((CSS2PlayDuringImpl *)impl)->setMix( _mix );
    00614 }
    00615
    00616 bool CSS2PlayDuring::repeat() const
    00617 {
    00618     if(!impl) return 0;
    00619     return ((CSS2PlayDuringImpl *)impl)->repeat();
    00620 }
    00621
    00622 void CSS2PlayDuring::setRepeat( const bool _repeat )
    00623 {
    00624
    00625     if(impl)
    00626         ((CSS2PlayDuringImpl *)impl)->setRepeat( _repeat );
    00627 }
    00628
    00629
    00630
    00631 CSS2Properties::CSS2Properties()
    00632 {
    00633 }
    00634
    00635 CSS2Properties::CSS2Properties(const CSS2Properties &other)
    00636 {
    00637 }
    00638
    00639 CSS2Properties::CSS2Properties(CSS2PropertiesImpl *impl)
    00640 {
    00641 }
    00642
    00643 CSS2Properties &CSS2Properties::operator = (const CSS2Properties &other)
    00644 {
    00645     ::operator = (other);
    00646     return *this;
    00647 }
    00648
    00649 CSS2Properties::~CSS2Properties()
    00650 {
    00651 }
    00652
    00653 DOMString CSS2Properties::azimuth() const
    00654 {
    00655     if(!impl) return 0;
    00656     return ((ElementImpl *)impl)->getAttribute("azimuth");
    00657 }
    00658
    00659 void CSS2Properties::setAzimuth( const DOMString &value )
    00660 {
    00661     if(impl) ((ElementImpl *)impl)->setAttribute("azimuth", value);
    00662 }
    00663
    00664 DOMString CSS2Properties::background() const
    00665 {
    00666     if(!impl) return 0;
    00667     return ((ElementImpl *)impl)->getAttribute("background");
    00668 }
    00669
    00670 void CSS2Properties::setBackground( const DOMString &value )
    00671 {
    00672     if(impl) ((ElementImpl *)impl)->setAttribute("background", value);
    00673 }
    00674
    00675 DOMString CSS2Properties::backgroundAttachment() const
    00676 {
    00677     if(!impl) return 0;
    00678     return ((ElementImpl *)impl)->getAttribute("backgroundAttachment");
    00679 }
    00680
    00681 void CSS2Properties::setBackgroundAttachment( const DOMString &value )
    00682 {
    00683     if(impl) ((ElementImpl *)impl)->setAttribute("backgroundAttachment", value);
    00684 }
    00685
    00686 DOMString CSS2Properties::backgroundColor() const
    00687 {
    00688     if(!impl) return 0;
    00689     return ((ElementImpl *)impl)->getAttribute("backgroundColor");
    00690 }
    00691
    00692 void CSS2Properties::setBackgroundColor( const DOMString &value )
    00693 {
    00694     if(impl) ((ElementImpl *)impl)->setAttribute("backgroundColor", value);
    00695 }
    00696
    00697 DOMString CSS2Properties::backgroundImage() const
    00698 {
    00699     if(!impl) return 0;
    00700     return ((ElementImpl *)impl)->getAttribute("backgroundImage");
    00701 }
    00702
    00703 void CSS2Properties::setBackgroundImage( const DOMString &value )
    00704 {
    00705     if(impl) ((ElementImpl *)impl)->setAttribute("backgroundImage", value);
    00706 }
    00707
    00708 DOMString CSS2Properties::backgroundPosition() const
    00709 {
    00710     if(!impl) return 0;
    00711     return ((ElementImpl *)impl)->getAttribute("backgroundPosition");
    00712 }
    00713
    00714 void CSS2Properties::setBackgroundPosition( const DOMString &value )
    00715 {
    00716     if(impl) ((ElementImpl *)impl)->setAttribute("backgroundPosition", value);
    00717 }
    00718
    00719 DOMString CSS2Properties::backgroundRepeat() const
    00720 {
    00721     if(!impl) return 0;
    00722     return ((ElementImpl *)impl)->getAttribute("backgroundRepeat");
    00723 }
    00724
    00725 void CSS2Properties::setBackgroundRepeat( const DOMString &value )
    00726 {
    00727     if(impl) ((ElementImpl *)impl)->setAttribute("backgroundRepeat", value);
    00728 }
    00729
    00730 DOMString CSS2Properties::border() const
    00731 {
    00732     if(!impl) return 0;
    00733     return ((ElementImpl *)impl)->getAttribute("border");
    00734 }
    00735
    00736 void CSS2Properties::setBorder( const DOMString &value )
    00737 {
    00738     if(impl) ((ElementImpl *)impl)->setAttribute("border", value);
    00739 }
    00740
    00741 DOMString CSS2Properties::borderCollapse() const
    00742 {
    00743     if(!impl) return 0;
    00744     return ((ElementImpl *)impl)->getAttribute("borderCollapse");
    00745 }
    00746
    00747 void CSS2Properties::setBorderCollapse( const DOMString &value )
    00748 {
    00749     if(impl) ((ElementImpl *)impl)->setAttribute("borderCollapse", value);
    00750 }
    00751
    00752 DOMString CSS2Properties::borderColor() const
    00753 {
    00754     if(!impl) return 0;
    00755     return ((ElementImpl *)impl)->getAttribute("borderColor");
    00756 }
    00757
    00758 void CSS2Properties::setBorderColor( const DOMString &value )
    00759 {
    00760     if(impl) ((ElementImpl *)impl)->setAttribute("borderColor", value);
    00761 }
    00762
    00763 DOMString CSS2Properties::borderSpacing() const
    00764 {
    00765     if(!impl) return 0;
    00766     return ((ElementImpl *)impl)->getAttribute("borderSpacing");
    00767 }
    00768
    00769 void CSS2Properties::setBorderSpacing( const DOMString &value )
    00770 {
    00771     if(impl) ((ElementImpl *)impl)->setAttribute("borderSpacing", value);
    00772 }
    00773
    00774 DOMString CSS2Properties::borderStyle() const
    00775 {
    00776     if(!impl) return 0;
    00777     return ((ElementImpl *)impl)->getAttribute("borderStyle");
    00778 }
    00779
    00780 void CSS2Properties::setBorderStyle( const DOMString &value )
    00781 {
    00782     if(impl) ((ElementImpl *)impl)->setAttribute("borderStyle", value);
    00783 }
    00784
    00785 DOMString CSS2Properties::borderTop() const
    00786 {
    00787     if(!impl) return 0;
    00788     return ((ElementImpl *)impl)->getAttribute("borderTop");
    00789 }
    00790
    00791 void CSS2Properties::setBorderTop( const DOMString &value )
    00792 {
    00793     if(impl) ((ElementImpl *)impl)->setAttribute("borderTop", value);
    00794 }
    00795
    00796 DOMString CSS2Properties::borderRight() const
    00797 {
    00798     if(!impl) return 0;
    00799     return ((ElementImpl *)impl)->getAttribute("borderRight");
    00800 }
    00801
    00802 void CSS2Properties::setBorderRight( const DOMString &value )
    00803 {
    00804     if(impl) ((ElementImpl *)impl)->setAttribute("borderRight", value);
    00805 }
    00806
    00807 DOMString CSS2Properties::borderBottom() const
    00808 {
    00809     if(!impl) return 0;
    00810     return ((ElementImpl *)impl)->getAttribute("borderBottom");
    00811 }
    00812
    00813 void CSS2Properties::setBorderBottom( const DOMString &value )
    00814 {
    00815     if(impl) ((ElementImpl *)impl)->setAttribute("borderBottom", value);
    00816 }
    00817
    00818 DOMString CSS2Properties::borderLeft() const
    00819 {
    00820     if(!impl) return 0;
    00821     return ((ElementImpl *)impl)->getAttribute("borderLeft");
    00822 }
    00823
    00824 void CSS2Properties::setBorderLeft( const DOMString &value )
    00825 {
    00826     if(impl) ((ElementImpl *)impl)->setAttribute("borderLeft", value);
    00827 }
    00828
    00829 DOMString CSS2Properties::borderTopColor() const
    00830 {
    00831     if(!impl) return 0;
    00832     return ((ElementImpl *)impl)->getAttribute("borderTopColor");
    00833 }
    00834
    00835 void CSS2Properties::setBorderTopColor( const DOMString &value )
    00836 {
    00837     if(impl) ((ElementImpl *)impl)->setAttribute("borderTopColor", value);
    00838 }
    00839
    00840 DOMString CSS2Properties::borderRightColor() const
    00841 {
    00842     if(!impl) return 0;
    00843     return ((ElementImpl *)impl)->getAttribute("borderRightColor");
    00844 }
    00845
    00846 void CSS2Properties::setBorderRightColor( const DOMString &value )
    00847 {
    00848     if(impl) ((ElementImpl *)impl)->setAttribute("borderRightColor", value);
    00849 }
    00850
    00851 DOMString CSS2Properties::borderBottomColor() const
    00852 {
    00853     if(!impl) return 0;
    00854     return ((ElementImpl *)impl)->getAttribute("borderBottomColor");
    00855 }
    00856
    00857 void CSS2Properties::setBorderBottomColor( const DOMString &value )
    00858 {
    00859     if(impl) ((ElementImpl *)impl)->setAttribute("borderBottomColor", value);
    00860 }
    00861
    00862 DOMString CSS2Properties::borderLeftColor() const
    00863 {
    00864     if(!impl) return 0;
    00865     return ((ElementImpl *)impl)->getAttribute("borderLeftColor");
    00866 }
    00867
    00868 void CSS2Properties::setBorderLeftColor( const DOMString &value )
    00869 {
    00870     if(impl) ((ElementImpl *)impl)->setAttribute("borderLeftColor", value);
    00871 }
    00872
    00873 DOMString CSS2Properties::borderTopStyle() const
    00874 {
    00875     if(!impl) return 0;
    00876     return ((ElementImpl *)impl)->getAttribute("borderTopStyle");
    00877 }
    00878
    00879 void CSS2Properties::setBorderTopStyle( const DOMString &value )
    00880 {
    00881     if(impl) ((ElementImpl *)impl)->setAttribute("borderTopStyle", value);
    00882 }
    00883
    00884 DOMString CSS2Properties::borderRightStyle() const
    00885 {
    00886     if(!impl) return 0;
    00887     return ((ElementImpl *)impl)->getAttribute("borderRightStyle");
    00888 }
    00889
    00890 void CSS2Properties::setBorderRightStyle( const DOMString &value )
    00891 {
    00892     if(impl) ((ElementImpl *)impl)->setAttribute("borderRightStyle", value);
    00893 }
    00894
    00895 DOMString CSS2Properties::borderBottomStyle() const
    00896 {
    00897     if(!impl) return 0;
    00898     return ((ElementImpl *)impl)->getAttribute("borderBottomStyle");
    00899 }
    00900
    00901 void CSS2Properties::setBorderBottomStyle( const DOMString &value )
    00902 {
    00903     if(impl) ((ElementImpl *)impl)->setAttribute("borderBottomStyle", value);
    00904 }
    00905
    00906 DOMString CSS2Properties::borderLeftStyle() const
    00907 {
    00908     if(!impl) return 0;
    00909     return ((ElementImpl *)impl)->getAttribute("borderLeftStyle");
    00910 }
    00911
    00912 void CSS2Properties::setBorderLeftStyle( const DOMString &value )
    00913 {
    00914     if(impl) ((ElementImpl *)impl)->setAttribute("borderLeftStyle", value);
    00915 }
    00916
    00917 DOMString CSS2Properties::borderTopWidth() const
    00918 {
    00919     if(!impl) return 0;
    00920     return ((ElementImpl *)impl)->getAttribute("borderTopWidth");
    00921 }
    00922
    00923 void CSS2Properties::setBorderTopWidth( const DOMString &value )
    00924 {
    00925     if(impl) ((ElementImpl *)impl)->setAttribute("borderTopWidth", value);
    00926 }
    00927
    00928 DOMString CSS2Properties::borderRightWidth() const
    00929 {
    00930     if(!impl) return 0;
    00931     return ((ElementImpl *)impl)->getAttribute("borderRightWidth");
    00932 }
    00933
    00934 void CSS2Properties::setBorderRightWidth( const DOMString &value )
    00935 {
    00936     if(impl) ((ElementImpl *)impl)->setAttribute("borderRightWidth", value);
    00937 }
    00938
    00939 DOMString CSS2Properties::borderBottomWidth() const
    00940 {
    00941     if(!impl) return 0;
    00942     return ((ElementImpl *)impl)->getAttribute("borderBottomWidth");
    00943 }
    00944
    00945 void CSS2Properties::setBorderBottomWidth( const DOMString &value )
    00946 {
    00947     if(impl) ((ElementImpl *)impl)->setAttribute("borderBottomWidth", value);
    00948 }
    00949
    00950 DOMString CSS2Properties::borderLeftWidth() const
    00951 {
    00952     if(!impl) return 0;
    00953     return ((ElementImpl *)impl)->getAttribute("borderLeftWidth");
    00954 }
    00955
    00956 void CSS2Properties::setBorderLeftWidth( const DOMString &value )
    00957 {
    00958     if(impl) ((ElementImpl *)impl)->setAttribute("borderLeftWidth", value);
    00959 }
    00960
    00961 DOMString CSS2Properties::borderWidth() const
    00962 {
    00963     if(!impl) return 0;
    00964     return ((ElementImpl *)impl)->getAttribute("borderWidth");
    00965 }
    00966
    00967 void CSS2Properties::setBorderWidth( const DOMString &value )
    00968 {
    00969     if(impl) ((ElementImpl *)impl)->setAttribute("borderWidth", value);
    00970 }
    00971
    00972 DOMString CSS2Properties::bottom() const
    00973 {
    00974     if(!impl) return 0;
    00975     return ((ElementImpl *)impl)->getAttribute("bottom");
    00976 }
    00977
    00978 void CSS2Properties::setBottom( const DOMString &value )
    00979 {
    00980     if(impl) ((ElementImpl *)impl)->setAttribute("bottom", value);
    00981 }
    00982
    00983 DOMString CSS2Properties::captionSide() const
    00984 {
    00985     if(!impl) return 0;
    00986     return ((ElementImpl *)impl)->getAttribute("captionSide");
    00987 }
    00988
    00989 void CSS2Properties::setCaptionSide( const DOMString &value )
    00990 {
    00991     if(impl) ((ElementImpl *)impl)->setAttribute("captionSide", value);
    00992 }
    00993
    00994 DOMString CSS2Properties::clear() const
    00995 {
    00996     if(!impl) return 0;
    00997     return ((ElementImpl *)impl)->getAttribute("clear");
    00998 }
    00999
    01000 void CSS2Properties::setClear( const DOMString &value )
    01001 {
    01002     if(impl) ((ElementImpl *)impl)->setAttribute("clear", value);
    01003 }
    01004
    01005 DOMString CSS2Properties::clip() const
    01006 {
    01007     if(!impl) return 0;
    01008     return ((ElementImpl *)impl)->getAttribute("clip");
    01009 }
    01010
    01011 void CSS2Properties::setClip( const DOMString &value )
    01012 {
    01013     if(impl) ((ElementImpl *)impl)->setAttribute("clip", value);
    01014 }
    01015
    01016 DOMString CSS2Properties::color() const
    01017 {
    01018     if(!impl) return 0;
    01019     return ((ElementImpl *)impl)->getAttribute("color");
    01020 }
    01021
    01022 void CSS2Properties::setColor( const DOMString &value )
    01023 {
    01024     if(impl) ((ElementImpl *)impl)->setAttribute("color", value);
    01025 }
    01026
    01027 DOMString CSS2Properties::content() const
    01028 {
    01029     if(!impl) return 0;
    01030     return ((ElementImpl *)impl)->getAttribute("content");
    01031 }
    01032
    01033 void CSS2Properties::setContent( const DOMString &value )
    01034 {
    01035     if(impl) ((ElementImpl *)impl)->setAttribute("content", value);
    01036 }
    01037
    01038 DOMString CSS2Properties::counterIncrement() const
    01039 {
    01040     if(!impl) return 0;
    01041     return ((ElementImpl *)impl)->getAttribute("counterIncrement");
    01042 }
    01043
    01044 void CSS2Properties::setCounterIncrement( const DOMString &value )
    01045 {
    01046     if(impl) ((ElementImpl *)impl)->setAttribute("counterIncrement", value);
    01047 }
    01048
    01049 DOMString CSS2Properties::counterReset() const
    01050 {
    01051     if(!impl) return 0;
    01052     return ((ElementImpl *)impl)->getAttribute("counterReset");
    01053 }
    01054
    01055 void CSS2Properties::setCounterReset( const DOMString &value )
    01056 {
    01057     if(impl) ((ElementImpl *)impl)->setAttribute("counterReset", value);
    01058 }
    01059
    01060 DOMString CSS2Properties::cue() const
    01061 {
    01062     if(!impl) return 0;
    01063     return ((ElementImpl *)impl)->getAttribute("cue");
    01064 }
    01065
    01066 void CSS2Properties::setCue( const DOMString &value )
    01067 {
    01068     if(impl) ((ElementImpl *)impl)->setAttribute("cue", value);
    01069 }
    01070
    01071 DOMString CSS2Properties::cueAfter() const
    01072 {
    01073     if(!impl) return 0;
    01074     return ((ElementImpl *)impl)->getAttribute("cueAfter");
    01075 }
    01076
    01077 void CSS2Properties::setCueAfter( const DOMString &value )
    01078 {
    01079     if(impl) ((ElementImpl *)impl)->setAttribute("cueAfter", value);
    01080 }
    01081
    01082 DOMString CSS2Properties::cueBefore() const
    01083 {
    01084     if(!impl) return 0;
    01085     return ((ElementImpl *)impl)->getAttribute("cueBefore");
    01086 }
    01087
    01088 void CSS2Properties::setCueBefore( const DOMString &value )
    01089 {
    01090     if(impl) ((ElementImpl *)impl)->setAttribute("cueBefore", value);
    01091 }
    01092
    01093 DOMString CSS2Properties::cursor() const
    01094 {
    01095     if(!impl) return 0;
    01096     return ((ElementImpl *)impl)->getAttribute("cursor");
    01097 }
    01098
    01099 void CSS2Properties::setCursor( const DOMString &value )
    01100 {
    01101     if(impl) ((ElementImpl *)impl)->setAttribute("cursor", value);
    01102 }
    01103
    01104 DOMString CSS2Properties::direction() const
    01105 {
    01106     if(!impl) return 0;
    01107     return ((ElementImpl *)impl)->getAttribute("direction");
    01108 }
    01109
    01110 void CSS2Properties::setDirection( const DOMString &value )
    01111 {
    01112     if(impl) ((ElementImpl *)impl)->setAttribute("direction", value);
    01113 }
    01114
    01115 DOMString CSS2Properties::display() const
    01116 {
    01117     if(!impl) return 0;
    01118     return ((ElementImpl *)impl)->getAttribute("display");
    01119 }
    01120
    01121 void CSS2Properties::setDisplay( const DOMString &value )
    01122 {
    01123     if(impl) ((ElementImpl *)impl)->setAttribute("display", value);
    01124 }
    01125
    01126 DOMString CSS2Properties::elevation() const
    01127 {
    01128     if(!impl) return 0;
    01129     return ((ElementImpl *)impl)->getAttribute("elevation");
    01130 }
    01131
    01132 void CSS2Properties::setElevation( const DOMString &value )
    01133 {
    01134     if(impl) ((ElementImpl *)impl)->setAttribute("elevation", value);
    01135 }
    01136
    01137 DOMString CSS2Properties::emptyCells() const
    01138 {
    01139     if(!impl) return 0;
    01140     return ((ElementImpl *)impl)->getAttribute("emptyCells");
    01141 }
    01142
    01143 void CSS2Properties::setEmptyCells( const DOMString &value )
    01144 {
    01145     if(impl) ((ElementImpl *)impl)->setAttribute("emptyCells", value);
    01146 }
    01147
    01148 DOMString CSS2Properties::cssFloat() const
    01149 {
    01150     if(!impl) return 0;
    01151     return ((ElementImpl *)impl)->getAttribute("cssFloat");
    01152 }
    01153
    01154 void CSS2Properties::setCssFloat( const DOMString &value )
    01155 {
    01156     if(impl) ((ElementImpl *)impl)->setAttribute("cssFloat", value);
    01157 }
    01158
    01159 DOMString CSS2Properties::font() const
    01160 {
    01161     if(!impl) return 0;
    01162     return ((ElementImpl *)impl)->getAttribute("font");
    01163 }
    01164
    01165 void CSS2Properties::setFont( const DOMString &value )
    01166 {
    01167     if(impl) ((ElementImpl *)impl)->setAttribute("font", value);
    01168 }
    01169
    01170 DOMString CSS2Properties::fontFamily() const
    01171 {
    01172     if(!impl) return 0;
    01173     return ((ElementImpl *)impl)->getAttribute("fontFamily");
    01174 }
    01175
    01176 void CSS2Properties::setFontFamily( const DOMString &value )
    01177 {
    01178     if(impl) ((ElementImpl *)impl)->setAttribute("fontFamily", value);
    01179 }
    01180
    01181 DOMString CSS2Properties::fontSize() const
    01182 {
    01183     if(!impl) return 0;
    01184     return ((ElementImpl *)impl)->getAttribute("fontSize");
    01185 }
    01186
    01187 void CSS2Properties::setFontSize( const DOMString &value )
    01188 {
    01189     if(impl) ((ElementImpl *)impl)->setAttribute("fontSize", value);
    01190 }
    01191
    01192 DOMString CSS2Properties::fontSizeAdjust() const
    01193 {
    01194     if(!impl) return 0;
    01195     return ((ElementImpl *)impl)->getAttribute("fontSizeAdjust");
    01196 }
    01197
    01198 void CSS2Properties::setFontSizeAdjust( const DOMString &value )
    01199 {
    01200     if(impl) ((ElementImpl *)impl)->setAttribute("fontSizeAdjust", value);
    01201 }
    01202
    01203 DOMString CSS2Properties::fontStretch() const
    01204 {
    01205     if(!impl) return 0;
    01206     return ((ElementImpl *)impl)->getAttribute("fontStretch");
    01207 }
    01208
    01209 void CSS2Properties::setFontStretch( const DOMString &value )
    01210 {
    01211     if(impl) ((ElementImpl *)impl)->setAttribute("fontStretch", value);
    01212 }
    01213
    01214 DOMString CSS2Properties::fontStyle() const
    01215 {
    01216     if(!impl) return 0;
    01217     return ((ElementImpl *)impl)->getAttribute("fontStyle");
    01218 }
    01219
    01220 void CSS2Properties::setFontStyle( const DOMString &value )
    01221 {
    01222     if(impl) ((ElementImpl *)impl)->setAttribute("fontStyle", value);
    01223 }
    01224
    01225 DOMString CSS2Properties::fontVariant() const
    01226 {
    01227     if(!impl) return 0;
    01228     return ((ElementImpl *)impl)->getAttribute("fontVariant");
    01229 }
    01230
    01231 void CSS2Properties::setFontVariant( const DOMString &value )
    01232 {
    01233     if(impl) ((ElementImpl *)impl)->setAttribute("fontVariant", value);
    01234 }
    01235
    01236 DOMString CSS2Properties::fontWeight() const
    01237 {
    01238     if(!impl) return 0;
    01239     return ((ElementImpl *)impl)->getAttribute("fontWeight");
    01240 }
    01241
    01242 void CSS2Properties::setFontWeight( const DOMString &value )
    01243 {
    01244     if(impl) ((ElementImpl *)impl)->setAttribute("fontWeight", value);
    01245 }
    01246
    01247 DOMString CSS2Properties::height() const
    01248 {
    01249     if(!impl) return 0;
    01250     return ((ElementImpl *)impl)->getAttribute("height");
    01251 }
    01252
    01253 void CSS2Properties::setHeight( const DOMString &value )
    01254 {
    01255     if(impl) ((ElementImpl *)impl)->setAttribute("height", value);
    01256 }
    01257
    01258 DOMString CSS2Properties::left() const
    01259 {
    01260     if(!impl) return 0;
    01261     return ((ElementImpl *)impl)->getAttribute("left");
    01262 }
    01263
    01264 void CSS2Properties::setLeft( const DOMString &value )
    01265 {
    01266     if(impl) ((ElementImpl *)impl)->setAttribute("left", value);
    01267 }
    01268
    01269 DOMString CSS2Properties::letterSpacing() const
    01270 {
    01271     if(!impl) return 0;
    01272     return ((ElementImpl *)impl)->getAttribute("letterSpacing");
    01273 }
    01274
    01275 void CSS2Properties::setLetterSpacing( const DOMString &value )
    01276 {
    01277     if(impl) ((ElementImpl *)impl)->setAttribute("letterSpacing", value);
    01278 }
    01279
    01280 DOMString CSS2Properties::lineHeight() const
    01281 {
    01282     if(!impl) return 0;
    01283     return ((ElementImpl *)impl)->getAttribute("lineHeight");
    01284 }
    01285
    01286 void CSS2Properties::setLineHeight( const DOMString &value )
    01287 {
    01288     if(impl) ((ElementImpl *)impl)->setAttribute("lineHeight", value);
    01289 }
    01290
    01291 DOMString CSS2Properties::listStyle() const
    01292 {
    01293     if(!impl) return 0;
    01294     return ((ElementImpl *)impl)->getAttribute("listStyle");
    01295 }
    01296
    01297 void CSS2Properties::setListStyle( const DOMString &value )
    01298 {
    01299     if(impl) ((ElementImpl *)impl)->setAttribute("listStyle", value);
    01300 }
    01301
    01302 DOMString CSS2Properties::listStyleImage() const
    01303 {
    01304     if(!impl) return 0;
    01305     return ((ElementImpl *)impl)->getAttribute("listStyleImage");
    01306 }
    01307
    01308 void CSS2Properties::setListStyleImage( const DOMString &value )
    01309 {
    01310     if(impl) ((ElementImpl *)impl)->setAttribute("listStyleImage", value);
    01311 }
    01312
    01313 DOMString CSS2Properties::listStylePosition() const
    01314 {
    01315     if(!impl) return 0;
    01316     return ((ElementImpl *)impl)->getAttribute("listStylePosition");
    01317 }
    01318
    01319 void CSS2Properties::setListStylePosition( const DOMString &value )
    01320 {
    01321     if(impl) ((ElementImpl *)impl)->setAttribute("listStylePosition", value);
    01322 }
    01323
    01324 DOMString CSS2Properties::listStyleType() const
    01325 {
    01326     if(!impl) return 0;
    01327     return ((ElementImpl *)impl)->getAttribute("listStyleType");
    01328 }
    01329
    01330 void CSS2Properties::setListStyleType( const DOMString &value )
    01331 {
    01332     if(impl) ((ElementImpl *)impl)->setAttribute("listStyleType", value);
    01333 }
    01334
    01335 DOMString CSS2Properties::margin() const
    01336 {
    01337     if(!impl) return 0;
    01338     return ((ElementImpl *)impl)->getAttribute("margin");
    01339 }
    01340
    01341 void CSS2Properties::setMargin( const DOMString &value )
    01342 {
    01343     if(impl) ((ElementImpl *)impl)->setAttribute("margin", value);
    01344 }
    01345
    01346 DOMString CSS2Properties::marginTop() const
    01347 {
    01348     if(!impl) return 0;
    01349     return ((ElementImpl *)impl)->getAttribute("marginTop");
    01350 }
    01351
    01352 void CSS2Properties::setMarginTop( const DOMString &value )
    01353 {
    01354     if(impl) ((ElementImpl *)impl)->setAttribute("marginTop", value);
    01355 }
    01356
    01357 DOMString CSS2Properties::marginRight() const
    01358 {
    01359     if(!impl) return 0;
    01360     return ((ElementImpl *)impl)->getAttribute("marginRight");
    01361 }
    01362
    01363 void CSS2Properties::setMarginRight( const DOMString &value )
    01364 {
    01365     if(impl) ((ElementImpl *)impl)->setAttribute("marginRight", value);
    01366 }
    01367
    01368 DOMString CSS2Properties::marginBottom() const
    01369 {
    01370     if(!impl) return 0;
    01371     return ((ElementImpl *)impl)->getAttribute("marginBottom");
    01372 }
    01373
    01374 void CSS2Properties::setMarginBottom( const DOMString &value )
    01375 {
    01376     if(impl) ((ElementImpl *)impl)->setAttribute("marginBottom", value);
    01377 }
    01378
    01379 DOMString CSS2Properties::marginLeft() const
    01380 {
    01381     if(!impl) return 0;
    01382     return ((ElementImpl *)impl)->getAttribute("marginLeft");
    01383 }
    01384
    01385 void CSS2Properties::setMarginLeft( const DOMString &value )
    01386 {
    01387     if(impl) ((ElementImpl *)impl)->setAttribute("marginLeft", value);
    01388 }
    01389
    01390 DOMString CSS2Properties::markerOffset() const
    01391 {
    01392     if(!impl) return 0;
    01393     return ((ElementImpl *)impl)->getAttribute("markerOffset");
    01394 }
    01395
    01396 void CSS2Properties::setMarkerOffset( const DOMString &value )
    01397 {
    01398     if(impl) ((ElementImpl *)impl)->setAttribute("markerOffset", value);
    01399 }
    01400
    01401 DOMString CSS2Properties::marks() const
    01402 {
    01403     if(!impl) return 0;
    01404     return ((ElementImpl *)impl)->getAttribute("marks");
    01405 }
    01406
    01407 void CSS2Properties::setMarks( const DOMString &value )
    01408 {
    01409     if(impl) ((ElementImpl *)impl)->setAttribute("marks", value);
    01410 }
    01411
    01412 DOMString CSS2Properties::maxHeight() const
    01413 {
    01414     if(!impl) return 0;
    01415     return ((ElementImpl *)impl)->getAttribute("maxHeight");
    01416 }
    01417
    01418 void CSS2Properties::setMaxHeight( const DOMString &value )
    01419 {
    01420     if(impl) ((ElementImpl *)impl)->setAttribute("maxHeight", value);
    01421 }
    01422
    01423 DOMString CSS2Properties::maxWidth() const
    01424 {
    01425     if(!impl) return 0;
    01426     return ((ElementImpl *)impl)->getAttribute("maxWidth");
    01427 }
    01428
    01429 void CSS2Properties::setMaxWidth( const DOMString &value )
    01430 {
    01431     if(impl) ((ElementImpl *)impl)->setAttribute("maxWidth", value);
    01432 }
    01433
    01434 DOMString CSS2Properties::minHeight() const
    01435 {
    01436     if(!impl) return 0;
    01437     return ((ElementImpl *)impl)->getAttribute("minHeight");
    01438 }
    01439
    01440 void CSS2Properties::setMinHeight( const DOMString &value )
    01441 {
    01442     if(impl) ((ElementImpl *)impl)->setAttribute("minHeight", value);
    01443 }
    01444
    01445 DOMString CSS2Properties::minWidth() const
    01446 {
    01447     if(!impl) return 0;
    01448     return ((ElementImpl *)impl)->getAttribute("minWidth");
    01449 }
    01450
    01451 void CSS2Properties::setMinWidth( const DOMString &value )
    01452 {
    01453     if(impl) ((ElementImpl *)impl)->setAttribute("minWidth", value);
    01454 }
    01455
    01456 DOMString CSS2Properties::orphans() const
    01457 {
    01458     if(!impl) return 0;
    01459     return ((ElementImpl *)impl)->getAttribute("orphans");
    01460 }
    01461
    01462 void CSS2Properties::setOrphans( const DOMString &value )
    01463 {
    01464     if(impl) ((ElementImpl *)impl)->setAttribute("orphans", value);
    01465 }
    01466
    01467 DOMString CSS2Properties::outline() const
    01468 {
    01469     if(!impl) return 0;
    01470     return ((ElementImpl *)impl)->getAttribute("outline");
    01471 }
    01472
    01473 void CSS2Properties::setOutline( const DOMString &value )
    01474 {
    01475     if(impl) ((ElementImpl *)impl)->setAttribute("outline", value);
    01476 }
    01477
    01478 DOMString CSS2Properties::outlineColor() const
    01479 {
    01480     if(!impl) return 0;
    01481     return ((ElementImpl *)impl)->getAttribute("outlineColor");
    01482 }
    01483
    01484 void CSS2Properties::setOutlineColor( const DOMString &value )
    01485 {
    01486     if(impl) ((ElementImpl *)impl)->setAttribute("outlineColor", value);
    01487 }
    01488
    01489 DOMString CSS2Properties::outlineStyle() const
    01490 {
    01491     if(!impl) return 0;
    01492     return ((ElementImpl *)impl)->getAttribute("outlineStyle");
    01493 }
    01494
    01495 void CSS2Properties::setOutlineStyle( const DOMString &value )
    01496 {
    01497     if(impl) ((ElementImpl *)impl)->setAttribute("outlineStyle", value);
    01498 }
    01499
    01500 DOMString CSS2Properties::outlineWidth() const
    01501 {
    01502     if(!impl) return 0;
    01503     return ((ElementImpl *)impl)->getAttribute("outlineWidth");
    01504 }
    01505
    01506 void CSS2Properties::setOutlineWidth( const DOMString &value )
    01507 {
    01508     if(impl) ((ElementImpl *)impl)->setAttribute("outlineWidth", value);
    01509 }
    01510
    01511 DOMString CSS2Properties::overflow() const
    01512 {
    01513     if(!impl) return 0;
    01514     return ((ElementImpl *)impl)->getAttribute("overflow");
    01515 }
    01516
    01517 void CSS2Properties::setOverflow( const DOMString &value )
    01518 {
    01519     if(impl) ((ElementImpl *)impl)->setAttribute("overflow", value);
    01520 }
    01521
    01522 DOMString CSS2Properties::padding() const
    01523 {
    01524     if(!impl) return 0;
    01525     return ((ElementImpl *)impl)->getAttribute("padding");
    01526 }
    01527
    01528 void CSS2Properties::setPadding( const DOMString &value )
    01529 {
    01530     if(impl) ((ElementImpl *)impl)->setAttribute("padding", value);
    01531 }
    01532
    01533 DOMString CSS2Properties::paddingTop() const
    01534 {
    01535     if(!impl) return 0;
    01536     return ((ElementImpl *)impl)->getAttribute("paddingTop");
    01537 }
    01538
    01539 void CSS2Properties::setPaddingTop( const DOMString &value )
    01540 {
    01541     if(impl) ((ElementImpl *)impl)->setAttribute("paddingTop", value);
    01542 }
    01543
    01544 DOMString CSS2Properties::paddingRight() const
    01545 {
    01546     if(!impl) return 0;
    01547     return ((ElementImpl *)impl)->getAttribute("paddingRight");
    01548 }
    01549
    01550 void CSS2Properties::setPaddingRight( const DOMString &value )
    01551 {
    01552     if(impl) ((ElementImpl *)impl)->setAttribute("paddingRight", value);
    01553 }
    01554
    01555 DOMString CSS2Properties::paddingBottom() const
    01556 {
    01557     if(!impl) return 0;
    01558     return ((ElementImpl *)impl)->getAttribute("paddingBottom");
    01559 }
    01560
    01561 void CSS2Properties::setPaddingBottom( const DOMString &value )
    01562 {
    01563     if(impl) ((ElementImpl *)impl)->setAttribute("paddingBottom", value);
    01564 }
    01565
    01566 DOMString CSS2Properties::paddingLeft() const
    01567 {
    01568     if(!impl) return 0;
    01569     return ((ElementImpl *)impl)->getAttribute("paddingLeft");
    01570 }
    01571
    01572 void CSS2Properties::setPaddingLeft( const DOMString &value )
    01573 {
    01574     if(impl) ((ElementImpl *)impl)->setAttribute("paddingLeft", value);
    01575 }
    01576
    01577 DOMString CSS2Properties::page() const
    01578 {
    01579     if(!impl) return 0;
    01580     return ((ElementImpl *)impl)->getAttribute("page");
    01581 }
    01582
    01583 void CSS2Properties::setPage( const DOMString &value )
    01584 {
    01585     if(impl) ((ElementImpl *)impl)->setAttribute("page", value);
    01586 }
    01587
    01588 DOMString CSS2Properties::pageBreakAfter() const
    01589 {
    01590     if(!impl) return 0;
    01591     return ((ElementImpl *)impl)->getAttribute("pageBreakAfter");
    01592 }
    01593
    01594 void CSS2Properties::setPageBreakAfter( const DOMString &value )
    01595 {
    01596     if(impl) ((ElementImpl *)impl)->setAttribute("pageBreakAfter", value);
    01597 }
    01598
    01599 DOMString CSS2Properties::pageBreakBefore() const
    01600 {
    01601     if(!impl) return 0;
    01602     return ((ElementImpl *)impl)->getAttribute("pageBreakBefore");
    01603 }
    01604
    01605 void CSS2Properties::setPageBreakBefore( const DOMString &value )
    01606 {
    01607     if(impl) ((ElementImpl *)impl)->setAttribute("pageBreakBefore", value);
    01608 }
    01609
    01610 DOMString CSS2Properties::pageBreakInside() const
    01611 {
    01612     if(!impl) return 0;
    01613     return ((ElementImpl *)impl)->getAttribute("pageBreakInside");
    01614 }
    01615
    01616 void CSS2Properties::setPageBreakInside( const DOMString &value )
    01617 {
    01618     if(impl) ((ElementImpl *)impl)->setAttribute("pageBreakInside", value);
    01619 }
    01620
    01621 DOMString CSS2Properties::pause() const
    01622 {
    01623     if(!impl) return 0;
    01624     return ((ElementImpl *)impl)->getAttribute("pause");
    01625 }
    01626
    01627 void CSS2Properties::setPause( const DOMString &value )
    01628 {
    01629     if(impl) ((ElementImpl *)impl)->setAttribute("pause", value);
    01630 }
    01631
    01632 DOMString CSS2Properties::pauseAfter() const
    01633 {
    01634     if(!impl) return 0;
    01635     return ((ElementImpl *)impl)->getAttribute("pauseAfter");
    01636 }
    01637
    01638 void CSS2Properties::setPauseAfter( const DOMString &value )
    01639 {
    01640     if(impl) ((ElementImpl *)impl)->setAttribute("pauseAfter", value);
    01641 }
    01642
    01643 DOMString CSS2Properties::pauseBefore() const
    01644 {
    01645     if(!impl) return 0;
    01646     return ((ElementImpl *)impl)->getAttribute("pauseBefore");
    01647 }
    01648
    01649 void CSS2Properties::setPauseBefore( const DOMString &value )
    01650 {
    01651     if(impl) ((ElementImpl *)impl)->setAttribute("pauseBefore", value);
    01652 }
    01653
    01654 DOMString CSS2Properties::pitch() const
    01655 {
    01656     if(!impl) return 0;
    01657     return ((ElementImpl *)impl)->getAttribute("pitch");
    01658 }
    01659
    01660 void CSS2Properties::setPitch( const DOMString &value )
    01661 {
    01662     if(impl) ((ElementImpl *)impl)->setAttribute("pitch", value);
    01663 }
    01664
    01665 DOMString CSS2Properties::pitchRange() const
    01666 {
    01667     if(!impl) return 0;
    01668     return ((ElementImpl *)impl)->getAttribute("pitchRange");
    01669 }
    01670
    01671 void CSS2Properties::setPitchRange( const DOMString &value )
    01672 {
    01673     if(impl) ((ElementImpl *)impl)->setAttribute("pitchRange", value);
    01674 }
    01675
    01676 DOMString CSS2Properties::playDuring() const
    01677 {
    01678     if(!impl) return 0;
    01679     return ((ElementImpl *)impl)->getAttribute("playDuring");
    01680 }
    01681
    01682 void CSS2Properties::setPlayDuring( const DOMString &value )
    01683 {
    01684     if(impl) ((ElementImpl *)impl)->setAttribute("playDuring", value);
    01685 }
    01686
    01687 DOMString CSS2Properties::position() const
    01688 {
    01689     if(!impl) return 0;
    01690     return ((ElementImpl *)impl)->getAttribute("position");
    01691 }
    01692
    01693 void CSS2Properties::setPosition( const DOMString &value )
    01694 {
    01695     if(impl) ((ElementImpl *)impl)->setAttribute("position", value);
    01696 }
    01697
    01698 DOMString CSS2Properties::quotes() const
    01699 {
    01700     if(!impl) return 0;
    01701     return ((ElementImpl *)impl)->getAttribute("quotes");
    01702 }
    01703
    01704 void CSS2Properties::setQuotes( const DOMString &value )
    01705 {
    01706     if(impl) ((ElementImpl *)impl)->setAttribute("quotes", value);
    01707 }
    01708
    01709 DOMString CSS2Properties::richness() const
    01710 {
    01711     if(!impl) return 0;
    01712     return ((ElementImpl *)impl)->getAttribute("richness");
    01713 }
    01714
    01715 void CSS2Properties::setRichness( const DOMString &value )
    01716 {
    01717     if(impl) ((ElementImpl *)impl)->setAttribute("richness", value);
    01718 }
    01719
    01720 DOMString CSS2Properties::right() const
    01721 {
    01722     if(!impl) return 0;
    01723     return ((ElementImpl *)impl)->getAttribute("right");
    01724 }
    01725
    01726 void CSS2Properties::setRight( const DOMString &value )
    01727 {
    01728     if(impl) ((ElementImpl *)impl)->setAttribute("right", value);
    01729 }
    01730
    01731 DOMString CSS2Properties::size() const
    01732 {
    01733     if(!impl) return 0;
    01734     return ((ElementImpl *)impl)->getAttribute("size");
    01735 }
    01736
    01737 void CSS2Properties::setSize( const DOMString &value )
    01738 {
    01739     if(impl) ((ElementImpl *)impl)->setAttribute("size", value);
    01740 }
    01741
    01742 DOMString CSS2Properties::speak() const
    01743 {
    01744     if(!impl) return 0;
    01745     return ((ElementImpl *)impl)->getAttribute("speak");
    01746 }
    01747
    01748 void CSS2Properties::setSpeak( const DOMString &value )
    01749 {
    01750     if(impl) ((ElementImpl *)impl)->setAttribute("speak", value);
    01751 }
    01752
    01753 DOMString CSS2Properties::speakHeader() const
    01754 {
    01755     if(!impl) return 0;
    01756     return ((ElementImpl *)impl)->getAttribute("speakHeader");
    01757 }
    01758
    01759 void CSS2Properties::setSpeakHeader( const DOMString &value )
    01760 {
    01761     if(impl) ((ElementImpl *)impl)->setAttribute("speakHeader", value);
    01762 }
    01763
    01764 DOMString CSS2Properties::speakNumeral() const
    01765 {
    01766     if(!impl) return 0;
    01767     return ((ElementImpl *)impl)->getAttribute("speakNumeral");
    01768 }
    01769
    01770 void CSS2Properties::setSpeakNumeral( const DOMString &value )
    01771 {
    01772     if(impl) ((ElementImpl *)impl)->setAttribute("speakNumeral", value);
    01773 }
    01774
    01775 DOMString CSS2Properties::speakPunctuation() const
    01776 {
    01777     if(!impl) return 0;
    01778     return ((ElementImpl *)impl)->getAttribute("speakPunctuation");
    01779 }
    01780
    01781 void CSS2Properties::setSpeakPunctuation( const DOMString &value )
    01782 {
    01783     if(impl) ((ElementImpl *)impl)->setAttribute("speakPunctuation", value);
    01784 }
    01785
    01786 DOMString CSS2Properties::speechRate() const
    01787 {
    01788     if(!impl) return 0;
    01789     return ((ElementImpl *)impl)->getAttribute("speechRate");
    01790 }
    01791
    01792 void CSS2Properties::setSpeechRate( const DOMString &value )
    01793 {
    01794     if(impl) ((ElementImpl *)impl)->setAttribute("speechRate", value);
    01795 }
    01796
    01797 DOMString CSS2Properties::stress() const
    01798 {
    01799     if(!impl) return 0;
    01800     return ((ElementImpl *)impl)->getAttribute("stress");
    01801 }
    01802
    01803 void CSS2Properties::setStress( const DOMString &value )
    01804 {
    01805     if(impl) ((ElementImpl *)impl)->setAttribute("stress", value);
    01806 }
    01807
    01808 DOMString CSS2Properties::tableLayout() const
    01809 {
    01810     if(!impl) return 0;
    01811     return ((ElementImpl *)impl)->getAttribute("tableLayout");
    01812 }
    01813
    01814 void CSS2Properties::setTableLayout( const DOMString &value )
    01815 {
    01816     if(impl) ((ElementImpl *)impl)->setAttribute("tableLayout", value);
    01817 }
    01818
    01819 DOMString CSS2Properties::textAlign() const
    01820 {
    01821     if(!impl) return 0;
    01822     return ((ElementImpl *)impl)->getAttribute("textAlign");
    01823 }
    01824
    01825 void CSS2Properties::setTextAlign( const DOMString &value )
    01826 {
    01827     if(impl) ((ElementImpl *)impl)->setAttribute("textAlign", value);
    01828 }
    01829
    01830 DOMString CSS2Properties::textDecoration() const
    01831 {
    01832     if(!impl) return 0;
    01833     return ((ElementImpl *)impl)->getAttribute("textDecoration");
    01834 }
    01835
    01836 void CSS2Properties::setTextDecoration( const DOMString &value )
    01837 {
    01838     if(impl) ((ElementImpl *)impl)->setAttribute("textDecoration", value);
    01839 }
    01840
    01841 DOMString CSS2Properties::textIndent() const
    01842 {
    01843     if(!impl) return 0;
    01844     return ((ElementImpl *)impl)->getAttribute("textIndent");
    01845 }
    01846
    01847 void CSS2Properties::setTextIndent( const DOMString &value )
    01848 {
    01849     if(impl) ((ElementImpl *)impl)->setAttribute("textIndent", value);
    01850 }
    01851
    01852 DOMString CSS2Properties::textShadow() const
    01853 {
    01854     if(!impl) return 0;
    01855     return ((ElementImpl *)impl)->getAttribute("textShadow");
    01856 }
    01857
    01858 void CSS2Properties::setTextShadow( const DOMString &value )
    01859 {
    01860     if(impl) ((ElementImpl *)impl)->setAttribute("textShadow", value);
    01861 }
    01862
    01863 DOMString CSS2Properties::textTransform() const
    01864 {
    01865     if(!impl) return 0;
    01866     return ((ElementImpl *)impl)->getAttribute("textTransform");
    01867 }
    01868
    01869 void CSS2Properties::setTextTransform( const DOMString &value )
    01870 {
    01871     if(impl) ((ElementImpl *)impl)->setAttribute("textTransform", value);
    01872 }
    01873
    01874 DOMString CSS2Properties::top() const
    01875 {
    01876     if(!impl) return 0;
    01877     return ((ElementImpl *)impl)->getAttribute("top");
    01878 }
    01879
    01880 void CSS2Properties::setTop( const DOMString &value )
    01881 {
    01882     if(impl) ((ElementImpl *)impl)->setAttribute("top", value);
    01883 }
    01884
    01885 DOMString CSS2Properties::unicodeBidi() const
    01886 {
    01887     if(!impl) return 0;
    01888     return ((ElementImpl *)impl)->getAttribute("unicodeBidi");
    01889 }
    01890
    01891 void CSS2Properties::setUnicodeBidi( const DOMString &value )
    01892 {
    01893     if(impl) ((ElementImpl *)impl)->setAttribute("unicodeBidi", value);
    01894 }
    01895
    01896 DOMString CSS2Properties::verticalAlign() const
    01897 {
    01898     if(!impl) return 0;
    01899     return ((ElementImpl *)impl)->getAttribute("verticalAlign");
    01900 }
    01901
    01902 void CSS2Properties::setVerticalAlign( const DOMString &value )
    01903 {
    01904     if(impl) ((ElementImpl *)impl)->setAttribute("verticalAlign", value);
    01905 }
    01906
    01907 DOMString CSS2Properties::visibility() const
    01908 {
    01909     if(!impl) return 0;
    01910     return ((ElementImpl *)impl)->getAttribute("visibility");
    01911 }
    01912
    01913 void CSS2Properties::setVisibility( const DOMString &value )
    01914 {
    01915     if(impl) ((ElementImpl *)impl)->setAttribute("visibility", value);
    01916 }
    01917
    01918 DOMString CSS2Properties::voiceFamily() const
    01919 {
    01920     if(!impl) return 0;
    01921     return ((ElementImpl *)impl)->getAttribute("voiceFamily");
    01922 }
    01923
    01924 void CSS2Properties::setVoiceFamily( const DOMString &value )
    01925 {
    01926     if(impl) ((ElementImpl *)impl)->setAttribute("voiceFamily", value);
    01927 }
    01928
    01929 DOMString CSS2Properties::volume() const
    01930 {
    01931     if(!impl) return 0;
    01932     return ((ElementImpl *)impl)->getAttribute("volume");
    01933 }
    01934
    01935 void CSS2Properties::setVolume( const DOMString &value )
    01936 {
    01937     if(impl) ((ElementImpl *)impl)->setAttribute("volume", value);
    01938 }
    01939
    01940 DOMString CSS2Properties::whiteSpace() const
    01941 {
    01942     if(!impl) return 0;
    01943     return ((ElementImpl *)impl)->getAttribute("whiteSpace");
    01944 }
    01945
    01946 void CSS2Properties::setWhiteSpace( const DOMString &value )
    01947 {
    01948     if(impl) ((ElementImpl *)impl)->setAttribute("whiteSpace", value);
    01949 }
    01950
    01951 DOMString CSS2Properties::widows() const
    01952 {
    01953     if(!impl) return 0;
    01954     return ((ElementImpl *)impl)->getAttribute("widows");
    01955 }
    01956
    01957 void CSS2Properties::setWidows( const DOMString &value )
    01958 {
    01959     if(impl) ((ElementImpl *)impl)->setAttribute("widows", value);
    01960 }
    01961
    01962 DOMString CSS2Properties::width() const
    01963 {
    01964     if(!impl) return 0;
    01965     return ((ElementImpl *)impl)->getAttribute("width");
    01966 }
    01967
    01968 void CSS2Properties::setWidth( const DOMString &value )
    01969 {
    01970     if(impl) ((ElementImpl *)impl)->setAttribute("width", value);
    01971 }
    01972
    01973 DOMString CSS2Properties::wordSpacing() const
    01974 {
    01975     if(!impl) return 0;
    01976     return ((ElementImpl *)impl)->getAttribute("wordSpacing");
    01977 }
    01978
    01979 void CSS2Properties::setWordSpacing( const DOMString &value )
    01980 {
    01981     if(impl) ((ElementImpl *)impl)->setAttribute("wordSpacing", value);
    01982 }
    01983
    01984 DOMString CSS2Properties::zIndex() const
    01985 {
    01986     if(!impl) return 0;
    01987     return ((ElementImpl *)impl)->getAttribute("zIndex");
    01988 }
    01989
    01990 void CSS2Properties::setZIndex( const DOMString &value )
    01991 {
    01992     if(impl) ((ElementImpl *)impl)->setAttribute("zIndex", value);
    01993 }
    01994
    01995
    01996
    01997 CSS2TextShadow::CSS2TextShadow()
    01998 {
    01999 }
    02000
    02001 CSS2TextShadow::CSS2TextShadow(const CSS2TextShadow &other)
    02002 {
    02003 }
    02004
    02005 CSS2TextShadow::CSS2TextShadow(CSS2TextShadowImpl *impl)
    02006 {
    02007 }
    02008
    02009 CSS2TextShadow &CSS2TextShadow::operator = (const CSS2TextShadow &other)
    02010 {
    02011     ::operator = (other);
    02012     return *this;
    02013 }
    02014
    02015 CSS2TextShadow::~CSS2TextShadow()
    02016 {
    02017 }
    02018
    02019 CSSValue CSS2TextShadow::color() const
    02020 {
    02021     if(!impl) return 0;
    02022     return ((CSS2TextShadowImpl *)impl)->color();
    02023 }
    02024
    02025 CSSValue CSS2TextShadow::horizontal() const
    02026 {
    02027     if(!impl) return 0;
    02028     return ((CSS2TextShadowImpl *)impl)->horizontal();
    02029 }
    02030
    02031 CSSValue CSS2TextShadow::vertical() const
    02032 {
    02033     if(!impl) return 0;
    02034     return ((CSS2TextShadowImpl *)impl)->vertical();
    02035 }
    02036
    02037 CSSValue CSS2TextShadow::blur() const
    02038 {
    02039     if(!impl) return 0;
    02040     return ((CSS2TextShadowImpl *)impl)->blur();
    02041 }
    02042
    02043
    02044

This file is part of the documentation for kdelibs Version 3.1.5.
Documentation copyright © 1996-2002 the KDE developers.
Generated on Wed Jan 28 13:33:29 2004 by doxygen 1.3.4 written by Dimitri van Heesch, © 1997-2001