# khtml Library API Documentation

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

# css_extensions.cpp

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

This file is part of the documentation for khtml Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:33:07 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003