khtml/dom/css_extensions.cpp

   1 /**
   2  * This file is part of the DOM implementation for KDE.
   3  *
   4  * Copyright 1999 Lars Knoll (knoll@kde.org)
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public License
  17  * along with this library; see the file COPYING.LIB.  If not, write to
  18  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  *
  21  */
  22 #include "css_extensions.h"
  23 #include "css_extensionsimpl.h"
  24
  25 #include "dom_exception.h"
  26 #include "dom_string.h"
  27 using namespace DOM;
  28
  29
  30 CSS2Azimuth::CSS2Azimuth() : CSSValue()
  31 {
  32 }
  33
  34 CSS2Azimuth::CSS2Azimuth(const CSS2Azimuth &other) : CSSValue(other)
  35 {
  36 }
  37
  38 CSS2Azimuth::CSS2Azimuth(CSS2AzimuthImpl *impl) : CSSValue(impl)
  39 {
  40 }
  41
  42 CSS2Azimuth &CSS2Azimuth::operator = (const CSS2Azimuth &other)
  43 {
  44     CSSValue::operator = (other);
  45     return *this;
  46 }
  47
  48 CSS2Azimuth::~CSS2Azimuth()
  49 {
  50 }
  51
  52 unsigned short CSS2Azimuth::azimuthType() const
  53 {
  54     if(!impl) return 0;
  55     return ((CSS2AzimuthImpl *)impl)->azimuthType();
  56 }
  57
  58 DOMString CSS2Azimuth::identifier() const
  59 {
  60     if(!impl) return 0;
  61     return ((CSS2AzimuthImpl *)impl)->identifier();
  62 }
  63
  64 bool CSS2Azimuth::behind() const
  65 {
  66     if(!impl) return 0;
  67     return ((CSS2AzimuthImpl *)impl)->behind();
  68 }
  69
  70 void CSS2Azimuth::setAngleValue( const unsigned short unitType, const float floatValue )
  71 {
  72     if(impl)
  73         ((CSS2AzimuthImpl *)impl)->setAngleValue( unitType, floatValue );
  74 }
  75
  76 float CSS2Azimuth::getAngleValue( const unsigned short unitType )
  77 {
  78     if(!impl) return 0;
  79     return ((CSS2AzimuthImpl *)impl)->getAngleValue( unitType );
  80 }
  81
  82 void CSS2Azimuth::setIdentifier( const DOMString &identifier, const bool behind )
  83 {
  84     if(impl)
  85         ((CSS2AzimuthImpl *)impl)->setIdentifier( identifier, behind );
  86 }
  87
  88
  89
  90 CSS2BackgroundPosition::CSS2BackgroundPosition() : CSSValue()
  91 {
  92 }
  93
  94 CSS2BackgroundPosition::CSS2BackgroundPosition(const CSS2BackgroundPosition &other) : CSSValue(other)
  95 {
  96 }
  97
  98 CSS2BackgroundPosition::CSS2BackgroundPosition(CSS2BackgroundPositionImpl *impl) : CSSValue(impl)
  99 {
 100 }
 101
 102 CSS2BackgroundPosition &CSS2BackgroundPosition::operator = (const CSS2BackgroundPosition &other)
 103 {
 104     CSSValue::operator = (other);
 105     return *this;
 106 }
 107
 108 CSS2BackgroundPosition::~CSS2BackgroundPosition()
 109 {
 110 }
 111
 112 unsigned short CSS2BackgroundPosition::horizontalType() const
 113 {
 114     if(!impl) return 0;
 115     return ((CSS2BackgroundPositionImpl *)impl)->horizontalType();
 116 }
 117
 118 unsigned short CSS2BackgroundPosition::verticalType() const
 119 {
 120     if(!impl) return 0;
 121     return ((CSS2BackgroundPositionImpl *)impl)->verticalType();
 122 }
 123
 124 DOMString CSS2BackgroundPosition::horizontalIdentifier() const
 125 {
 126     if(!impl) return 0;
 127     return ((CSS2BackgroundPositionImpl *)impl)->horizontalIdentifier();
 128 }
 129
 130 DOMString CSS2BackgroundPosition::verticalIdentifier() const
 131 {
 132     if(!impl) return 0;
 133     return ((CSS2BackgroundPositionImpl *)impl)->verticalIdentifier();
 134 }
 135
 136 float CSS2BackgroundPosition::getHorizontalPosition( const float horizontalType )
 137 {
 138     if(!impl) return 0;
 139     return ((CSS2BackgroundPositionImpl *)impl)->getHorizontalPosition( horizontalType );
 140 }
 141
 142 float CSS2BackgroundPosition::getVerticalPosition( const float verticalType )
 143 {
 144     if(!impl) return 0;
 145     return ((CSS2BackgroundPositionImpl *)impl)->getVerticalPosition( verticalType );
 146 }
 147
 148 void CSS2BackgroundPosition::setHorizontalPosition( const unsigned short horizontalType, const float value )
 149 {
 150     if(impl)
 151         ((CSS2BackgroundPositionImpl *)impl)->setHorizontalPosition( horizontalType, value );
 152 }
 153
 154 void CSS2BackgroundPosition::setVerticalPosition( const unsigned short verticalType, const float value )
 155 {
 156     if(impl)
 157         ((CSS2BackgroundPositionImpl *)impl)->setVerticalPosition( verticalType, value );
 158 }
 159
 160 void CSS2BackgroundPosition::setPositionIdentifier( const DOMString &horizontalIdentifier, const DOMString &verticalIdentifier )
 161 {
 162     if(impl)
 163         ((CSS2BackgroundPositionImpl *)impl)->setPositionIdentifier( horizontalIdentifier, verticalIdentifier );
 164 }
 165
 166
 167
 168 CSS2BorderSpacing::CSS2BorderSpacing() : CSSValue()
 169 {
 170 }
 171
 172 CSS2BorderSpacing::CSS2BorderSpacing(const CSS2BorderSpacing &other) : CSSValue(other)
 173 {
 174 }
 175
 176 CSS2BorderSpacing::CSS2BorderSpacing(CSS2BorderSpacingImpl *impl) : CSSValue(impl)
 177 {
 178 }
 179
 180 CSS2BorderSpacing &CSS2BorderSpacing::operator = (const CSS2BorderSpacing &other)
 181 {
 182     CSSValue::operator = (other);
 183     return *this;
 184 }
 185
 186 CSS2BorderSpacing::~CSS2BorderSpacing()
 187 {
 188 }
 189
 190 unsigned short CSS2BorderSpacing::horizontalType() const
 191 {
 192     if(!impl) return 0;
 193     return ((CSS2BorderSpacingImpl *)impl)->horizontalType();
 194 }
 195
 196 unsigned short CSS2BorderSpacing::verticalType() const
 197 {
 198     if(!impl) return 0;
 199     return ((CSS2BorderSpacingImpl *)impl)->verticalType();
 200 }
 201
 202 float CSS2BorderSpacing::getHorizontalSpacing( const float horizontalType )
 203 {
 204     if(!impl) return 0;
 205     return ((CSS2BorderSpacingImpl *)impl)->getHorizontalSpacing( horizontalType );
 206 }
 207
 208 float CSS2BorderSpacing::getVerticalSpacing( const float verticalType )
 209 {
 210     if(!impl) return 0;
 211     return ((CSS2BorderSpacingImpl *)impl)->getVerticalSpacing( verticalType );
 212 }
 213
 214 void CSS2BorderSpacing::setHorizontalSpacing( const unsigned short horizontalType, const float value )
 215 {
 216     if(impl)
 217         ((CSS2BorderSpacingImpl *)impl)->setHorizontalSpacing( horizontalType, value );
 218 }
 219
 220 void CSS2BorderSpacing::setVerticalSpacing( const unsigned short verticalType, const float value )
 221 {
 222     if(impl)
 223         ((CSS2BorderSpacingImpl *)impl)->setVerticalSpacing( verticalType, value );
 224 }
 225
 226 void CSS2BorderSpacing::setInherit()
 227 {
 228     if(impl)
 229         ((CSS2BorderSpacingImpl *)impl)->setInherit();
 230 }
 231
 232
 233
 234 CSS2CounterIncrement::CSS2CounterIncrement()
 235 {
 236 }
 237
 238 CSS2CounterIncrement::CSS2CounterIncrement(const CSS2CounterIncrement &other)
 239 {
 240 }
 241
 242 CSS2CounterIncrement::CSS2CounterIncrement(CSS2CounterIncrementImpl *impl)
 243 {
 244 }
 245
 246 CSS2CounterIncrement &CSS2CounterIncrement::operator = (const CSS2CounterIncrement &other)
 247 {
 248     ::operator = (other);
 249     return *this;
 250 }
 251
 252 CSS2CounterIncrement::~CSS2CounterIncrement()
 253 {
 254 }
 255
 256 DOMString CSS2CounterIncrement::identifier() const
 257 {
 258     if(!impl) return 0;
 259     return ((ElementImpl *)impl)->getAttribute("identifier");
 260 }
 261
 262 void CSS2CounterIncrement::setIdentifier( const DOMString &value )
 263 {
 264     if(impl) ((ElementImpl *)impl)->setAttribute("identifier", value);
 265 }
 266
 267 short CSS2CounterIncrement::increment() const
 268 {
 269     if(!impl) return 0;
 270     return ((CSS2CounterIncrementImpl *)impl)->increment();
 271 }
 272
 273 void CSS2CounterIncrement::setIncrement( const short _increment )
 274 {
 275
 276     if(impl)
 277         ((CSS2CounterIncrementImpl *)impl)->setIncrement( _increment );
 278 }
 279
 280
 281
 282
 283 CSS2CounterReset::CSS2CounterReset()
 284 {
 285 }
 286
 287 CSS2CounterReset::CSS2CounterReset(const CSS2CounterReset &other)
 288 {
 289 }
 290
 291 CSS2CounterReset::CSS2CounterReset(CSS2CounterResetImpl *impl)
 292 {
 293 }
 294
 295 CSS2CounterReset &CSS2CounterReset::operator = (const CSS2CounterReset &other)
 296 {
 297     ::operator = (other);
 298     return *this;
 299 }
 300
 301 CSS2CounterReset::~CSS2CounterReset()
 302 {
 303 }
 304
 305 DOMString CSS2CounterReset::identifier() const
 306 {
 307     if(!impl) return 0;
 308     return ((ElementImpl *)impl)->getAttribute("identifier");
 309 }
 310
 311 void CSS2CounterReset::setIdentifier( const DOMString &value )
 312 {
 313     if(impl) ((ElementImpl *)impl)->setAttribute("identifier", value);
 314 }
 315
 316 short CSS2CounterReset::reset() const
 317 {
 318     if(!impl) return 0;
 319     return ((CSS2CounterResetImpl *)impl)->reset();
 320 }
 321
 322 void CSS2CounterReset::setReset( const short _reset )
 323 {
 324
 325     if(impl)
 326         ((CSS2CounterResetImpl *)impl)->setReset( _reset );
 327 }
 328
 329
 330
 331
 332 CSS2Cursor::CSS2Cursor() : CSSValue()
 333 {
 334 }
 335
 336 CSS2Cursor::CSS2Cursor(const CSS2Cursor &other) : CSSValue(other)
 337 {
 338 }
 339
 340 CSS2Cursor::CSS2Cursor(CSS2CursorImpl *impl) : CSSValue(impl)
 341 {
 342 }
 343
 344 CSS2Cursor &CSS2Cursor::operator = (const CSS2Cursor &other)
 345 {
 346     CSSValue::operator = (other);
 347     return *this;
 348 }
 349
 350 CSS2Cursor::~CSS2Cursor()
 351 {
 352 }
 353
 354 unsigned short CSS2Cursor::cursorType() const
 355 {
 356     if(!impl) return 0;
 357     return ((CSS2CursorImpl *)impl)->cursorType();
 358 }
 359
 360 void CSS2Cursor::setCursorType( const unsigned short _cursorType )
 361 {
 362
 363     if(impl)
 364         ((CSS2CursorImpl *)impl)->setCursorType( _cursorType );
 365 }
 366
 367 CSSValueList CSS2Cursor::uris() const
 368 {
 369     if(!impl) return 0;
 370     return ((CSS2CursorImpl *)impl)->uris();
 371 }
 372
 373 DOMString CSS2Cursor::predefinedCursor() const
 374 {
 375     if(!impl) return 0;
 376     return ((ElementImpl *)impl)->getAttribute("predefinedCursor");
 377 }
 378
 379 void CSS2Cursor::setPredefinedCursor( const DOMString &value )
 380 {
 381     if(impl) ((ElementImpl *)impl)->setAttribute("predefinedCursor", value);
 382 }
 383
 384
 385
 386 CSS2FontFaceSrc::CSS2FontFaceSrc()
 387 {
 388 }
 389
 390 CSS2FontFaceSrc::CSS2FontFaceSrc(const CSS2FontFaceSrc &other)
 391 {
 392 }
 393
 394 CSS2FontFaceSrc::CSS2FontFaceSrc(CSS2FontFaceSrcImpl *impl)
 395 {
 396 }
 397
 398 CSS2FontFaceSrc &CSS2FontFaceSrc::operator = (const CSS2FontFaceSrc &other)
 399 {
 400     ::operator = (other);
 401     return *this;
 402 }
 403
 404 CSS2FontFaceSrc::~CSS2FontFaceSrc()
 405 {
 406 }
 407
 408 DOMString CSS2FontFaceSrc::uri() const
 409 {
 410     if(!impl) return 0;
 411     return ((ElementImpl *)impl)->getAttribute("uri");
 412 }
 413
 414 void CSS2FontFaceSrc::setUri( const DOMString &value )
 415 {
 416     if(impl) ((ElementImpl *)impl)->setAttribute("uri", value);
 417 }
 418
 419 CSSValueList CSS2FontFaceSrc::format() const
 420 {
 421     if(!impl) return 0;
 422     return ((CSS2FontFaceSrcImpl *)impl)->format();
 423 }
 424
 425 DOMString CSS2FontFaceSrc::fontFaceName() const
 426 {
 427     if(!impl) return 0;
 428     return ((ElementImpl *)impl)->getAttribute("fontFaceName");
 429 }
 430
 431 void CSS2FontFaceSrc::setFontFaceName( const DOMString &value )
 432 {
 433     if(impl) ((ElementImpl *)impl)->setAttribute("fontFaceName", value);
 434 }
 435
 436
 437
 438 CSS2FontFaceWidths::CSS2FontFaceWidths()
 439 {
 440 }
 441
 442 CSS2FontFaceWidths::CSS2FontFaceWidths(const CSS2FontFaceWidths &other)
 443 {
 444 }
 445
 446 CSS2FontFaceWidths::CSS2FontFaceWidths(CSS2FontFaceWidthsImpl *impl)
 447 {
 448 }
 449
 450 CSS2FontFaceWidths &CSS2FontFaceWidths::operator = (const CSS2FontFaceWidths &other)
 451 {
 452     ::operator = (other);
 453     return *this;
 454 }
 455
 456 CSS2FontFaceWidths::~CSS2FontFaceWidths()
 457 {
 458 }
 459
 460 DOMString CSS2FontFaceWidths::urange() const
 461 {
 462     if(!impl) return 0;
 463     return ((ElementImpl *)impl)->getAttribute("urange");
 464 }
 465
 466 void CSS2FontFaceWidths::setUrange( const DOMString &value )
 467 {
 468     if(impl) ((ElementImpl *)impl)->setAttribute("urange", value);
 469 }
 470
 471 CSSValueList CSS2FontFaceWidths::numbers() const
 472 {
 473     if(!impl) return 0;
 474     return ((CSS2FontFaceWidthsImpl *)impl)->numbers();
 475 }
 476
 477
 478
 479
 480 CSS2PageSize::CSS2PageSize() : CSSValue()
 481 {
 482 }
 483
 484 CSS2PageSize::CSS2PageSize(const CSS2PageSize &other) : CSSValue(other)
 485 {
 486 }
 487
 488 CSS2PageSize::CSS2PageSize(CSS2PageSizeImpl *impl) : CSSValue(impl)
 489 {
 490 }
 491
 492 CSS2PageSize &CSS2PageSize::operator = (const CSS2PageSize &other)
 493 {
 494     CSSValue::operator = (other);
 495     return *this;
 496 }
 497
 498 CSS2PageSize::~CSS2PageSize()
 499 {
 500 }
 501
 502 unsigned short CSS2PageSize::widthType() const
 503 {
 504     if(!impl) return 0;
 505     return ((CSS2PageSizeImpl *)impl)->widthType();
 506 }
 507
 508 unsigned short CSS2PageSize::heightType() const
 509 {
 510     if(!impl) return 0;
 511     return ((CSS2PageSizeImpl *)impl)->heightType();
 512 }
 513
 514 DOMString CSS2PageSize::identifier() const
 515 {
 516     if(!impl) return 0;
 517     return ((CSS2PageSizeImpl *)impl)->identifier();
 518 }
 519
 520 float CSS2PageSize::getWidth( const float widthType )
 521 {
 522     if(!impl) return 0;
 523     return ((CSS2PageSizeImpl *)impl)->getWidth( widthType );
 524 }
 525
 526 float CSS2PageSize::getHeightSize( const float heightType )
 527 {
 528     if(!impl) return 0;
 529     return ((CSS2PageSizeImpl *)impl)->getHeightSize( heightType );
 530 }
 531
 532 void CSS2PageSize::setWidthSize( const unsigned short widthType, const float value )
 533 {
 534     if(impl)
 535         ((CSS2PageSizeImpl *)impl)->setWidthSize( widthType, value );
 536 }
 537
 538 void CSS2PageSize::setHeightSize( const unsigned short heightType, const float value )
 539 {
 540     if(impl)
 541         ((CSS2PageSizeImpl *)impl)->setHeightSize( heightType, value );
 542 }
 543
 544 void CSS2PageSize::setIdentifier( const DOMString &identifier )
 545 {
 546     if(impl)
 547         ((CSS2PageSizeImpl *)impl)->setIdentifier( identifier );
 548 }
 549
 550
 551
 552 CSS2PlayDuring::CSS2PlayDuring() : CSSValue()
 553 {
 554 }
 555
 556 CSS2PlayDuring::CSS2PlayDuring(const CSS2PlayDuring &other) : CSSValue(other)
 557 {
 558 }
 559
 560 CSS2PlayDuring::CSS2PlayDuring(CSS2PlayDuringImpl *impl) : CSSValue(impl)
 561 {
 562 }
 563
 564 CSS2PlayDuring &CSS2PlayDuring::operator = (const CSS2PlayDuring &other)
 565 {
 566     CSSValue::operator = (other);
 567     return *this;
 568 }
 569
 570 CSS2PlayDuring::~CSS2PlayDuring()
 571 {
 572 }
 573
 574 unsigned short CSS2PlayDuring::playDuringType() const
 575 {
 576     if(!impl) return 0;
 577     return ((CSS2PlayDuringImpl *)impl)->playDuringType();
 578 }
 579
 580 DOMString CSS2PlayDuring::playDuringIdentifier() const
 581 {
 582     if(!impl) return 0;
 583     return ((ElementImpl *)impl)->getAttribute("playDuringIdentifier");
 584 }
 585
 586 void CSS2PlayDuring::setPlayDuringIdentifier( const DOMString &value )
 587 {
 588     if(impl) ((ElementImpl *)impl)->setAttribute("playDuringIdentifier", value);
 589 }
 590
 591 DOMString CSS2PlayDuring::uri() const
 592 {
 593     if(!impl) return 0;
 594     return ((ElementImpl *)impl)->getAttribute("uri");
 595 }
 596
 597 void CSS2PlayDuring::setUri( const DOMString &value )
 598 {
 599     if(impl) ((ElementImpl *)impl)->setAttribute("uri", value);
 600 }
 601
 602 bool CSS2PlayDuring::mix() const
 603 {
 604     if(!impl) return 0;
 605     return ((CSS2PlayDuringImpl *)impl)->mix();
 606 }
 607
 608 void CSS2PlayDuring::setMix( const bool _mix )
 609 {
 610
 611     if(impl)
 612         ((CSS2PlayDuringImpl *)impl)->setMix( _mix );
 613 }
 614
 615 bool CSS2PlayDuring::repeat() const
 616 {
 617     if(!impl) return 0;
 618     return ((CSS2PlayDuringImpl *)impl)->repeat();
 619 }
 620
 621 void CSS2PlayDuring::setRepeat( const bool _repeat )
 622 {
 623
 624     if(impl)
 625         ((CSS2PlayDuringImpl *)impl)->setRepeat( _repeat );
 626 }
 627
 628
 629
 630 CSS2Properties::CSS2Properties()
 631 {
 632 }
 633
 634 CSS2Properties::CSS2Properties(const CSS2Properties &other)
 635 {
 636 }
 637
 638 CSS2Properties::CSS2Properties(CSS2PropertiesImpl *impl)
 639 {
 640 }
 641
 642 CSS2Properties &CSS2Properties::operator = (const CSS2Properties &other)
 643 {
 644     ::operator = (other);
 645     return *this;
 646 }
 647
 648 CSS2Properties::~CSS2Properties()
 649 {
 650 }
 651
 652 DOMString CSS2Properties::azimuth() const
 653 {
 654     if(!impl) return 0;
 655     return ((ElementImpl *)impl)->getAttribute("azimuth");
 656 }
 657
 658 void CSS2Properties::setAzimuth( const DOMString &value )
 659 {
 660     if(impl) ((ElementImpl *)impl)->setAttribute("azimuth", value);
 661 }
 662
 663 DOMString CSS2Properties::background() const
 664 {
 665     if(!impl) return 0;
 666     return ((ElementImpl *)impl)->getAttribute("background");
 667 }
 668
 669 void CSS2Properties::setBackground( const DOMString &value )
 670 {
 671     if(impl) ((ElementImpl *)impl)->setAttribute("background", value);
 672 }
 673
 674 DOMString CSS2Properties::backgroundAttachment() const
 675 {
 676     if(!impl) return 0;
 677     return ((ElementImpl *)impl)->getAttribute("backgroundAttachment");
 678 }
 679
 680 void CSS2Properties::setBackgroundAttachment( const DOMString &value )
 681 {
 682     if(impl) ((ElementImpl *)impl)->setAttribute("backgroundAttachment", value);
 683 }
 684
 685 DOMString CSS2Properties::backgroundColor() const
 686 {
 687     if(!impl) return 0;
 688     return ((ElementImpl *)impl)->getAttribute("backgroundColor");
 689 }
 690
 691 void CSS2Properties::setBackgroundColor( const DOMString &value )
 692 {
 693     if(impl) ((ElementImpl *)impl)->setAttribute("backgroundColor", value);
 694 }
 695
 696 DOMString CSS2Properties::backgroundImage() const
 697 {
 698     if(!impl) return 0;
 699     return ((ElementImpl *)impl)->getAttribute("backgroundImage");
 700 }
 701
 702 void CSS2Properties::setBackgroundImage( const DOMString &value )
 703 {
 704     if(impl) ((ElementImpl *)impl)->setAttribute("backgroundImage", value);
 705 }
 706
 707 DOMString CSS2Properties::backgroundPosition() const
 708 {
 709     if(!impl) return 0;
 710     return ((ElementImpl *)impl)->getAttribute("backgroundPosition");
 711 }
 712
 713 void CSS2Properties::setBackgroundPosition( const DOMString &value )
 714 {
 715     if(impl) ((ElementImpl *)impl)->setAttribute("backgroundPosition", value);
 716 }
 717
 718 DOMString CSS2Properties::backgroundRepeat() const
 719 {
 720     if(!impl) return 0;
 721     return ((ElementImpl *)impl)->getAttribute("backgroundRepeat");
 722 }
 723
 724 void CSS2Properties::setBackgroundRepeat( const DOMString &value )
 725 {
 726     if(impl) ((ElementImpl *)impl)->setAttribute("backgroundRepeat", value);
 727 }
 728
 729 DOMString CSS2Properties::border() const
 730 {
 731     if(!impl) return 0;
 732     return ((ElementImpl *)impl)->getAttribute("border");
 733 }
 734
 735 void CSS2Properties::setBorder( const DOMString &value )
 736 {
 737     if(impl) ((ElementImpl *)impl)->setAttribute("border", value);
 738 }
 739
 740 DOMString CSS2Properties::borderCollapse() const
 741 {
 742     if(!impl) return 0;
 743     return ((ElementImpl *)impl)->getAttribute("borderCollapse");
 744 }
 745
 746 void CSS2Properties::setBorderCollapse( const DOMString &value )
 747 {
 748     if(impl) ((ElementImpl *)impl)->setAttribute("borderCollapse", value);
 749 }
 750
 751 DOMString CSS2Properties::borderColor() const
 752 {
 753     if(!impl) return 0;
 754     return ((ElementImpl *)impl)->getAttribute("borderColor");
 755 }
 756
 757 void CSS2Properties::setBorderColor( const DOMString &value )
 758 {
 759     if(impl) ((ElementImpl *)impl)->setAttribute("borderColor", value);
 760 }
 761
 762 DOMString CSS2Properties::borderSpacing() const
 763 {
 764     if(!impl) return 0;
 765     return ((ElementImpl *)impl)->getAttribute("borderSpacing");
 766 }
 767
 768 void CSS2Properties::setBorderSpacing( const DOMString &value )
 769 {
 770     if(impl) ((ElementImpl *)impl)->setAttribute("borderSpacing", value);
 771 }
 772
 773 DOMString CSS2Properties::borderStyle() const
 774 {
 775     if(!impl) return 0;
 776     return ((ElementImpl *)impl)->getAttribute("borderStyle");
 777 }
 778
 779 void CSS2Properties::setBorderStyle( const DOMString &value )
 780 {
 781     if(impl) ((ElementImpl *)impl)->setAttribute("borderStyle", value);
 782 }
 783
 784 DOMString CSS2Properties::borderTop() const
 785 {
 786     if(!impl) return 0;
 787     return ((ElementImpl *)impl)->getAttribute("borderTop");
 788 }
 789
 790 void CSS2Properties::setBorderTop( const DOMString &value )
 791 {
 792     if(impl) ((ElementImpl *)impl)->setAttribute("borderTop", value);
 793 }
 794
 795 DOMString CSS2Properties::borderRight() const
 796 {
 797     if(!impl) return 0;
 798     return ((ElementImpl *)impl)->getAttribute("borderRight");
 799 }
 800
 801 void CSS2Properties::setBorderRight( const DOMString &value )
 802 {
 803     if(impl) ((ElementImpl *)impl)->setAttribute("borderRight", value);
 804 }
 805
 806 DOMString CSS2Properties::borderBottom() const
 807 {
 808     if(!impl) return 0;
 809     return ((ElementImpl *)impl)->getAttribute("borderBottom");
 810 }
 811
 812 void CSS2Properties::setBorderBottom( const DOMString &value )
 813 {
 814     if(impl) ((ElementImpl *)impl)->setAttribute("borderBottom", value);
 815 }
 816
 817 DOMString CSS2Properties::borderLeft() const
 818 {
 819     if(!impl) return 0;
 820     return ((ElementImpl *)impl)->getAttribute("borderLeft");
 821 }
 822
 823 void CSS2Properties::setBorderLeft( const DOMString &value )
 824 {
 825     if(impl) ((ElementImpl *)impl)->setAttribute("borderLeft", value);
 826 }
 827
 828 DOMString CSS2Properties::borderTopColor() const
 829 {
 830     if(!impl) return 0;
 831     return ((ElementImpl *)impl)->getAttribute("borderTopColor");
 832 }
 833
 834 void CSS2Properties::setBorderTopColor( const DOMString &value )
 835 {
 836     if(impl) ((ElementImpl *)impl)->setAttribute("borderTopColor", value);
 837 }
 838
 839 DOMString CSS2Properties::borderRightColor() const
 840 {
 841     if(!impl) return 0;
 842     return ((ElementImpl *)impl)->getAttribute("borderRightColor");
 843 }
 844
 845 void CSS2Properties::setBorderRightColor( const DOMString &value )
 846 {
 847     if(impl) ((ElementImpl *)impl)->setAttribute("borderRightColor", value);
 848 }
 849
 850 DOMString CSS2Properties::borderBottomColor() const
 851 {
 852     if(!impl) return 0;
 853     return ((ElementImpl *)impl)->getAttribute("borderBottomColor");
 854 }
 855
 856 void CSS2Properties::setBorderBottomColor( const DOMString &value )
 857 {
 858     if(impl) ((ElementImpl *)impl)->setAttribute("borderBottomColor", value);
 859 }
 860
 861 DOMString CSS2Properties::borderLeftColor() const
 862 {
 863     if(!impl) return 0;
 864     return ((ElementImpl *)impl)->getAttribute("borderLeftColor");
 865 }
 866
 867 void CSS2Properties::setBorderLeftColor( const DOMString &value )
 868 {
 869     if(impl) ((ElementImpl *)impl)->setAttribute("borderLeftColor", value);
 870 }
 871
 872 DOMString CSS2Properties::borderTopStyle() const
 873 {
 874     if(!impl) return 0;
 875     return ((ElementImpl *)impl)->getAttribute("borderTopStyle");
 876 }
 877
 878 void CSS2Properties::setBorderTopStyle( const DOMString &value )
 879 {
 880     if(impl) ((ElementImpl *)impl)->setAttribute("borderTopStyle", value);
 881 }
 882
 883 DOMString CSS2Properties::borderRightStyle() const
 884 {
 885     if(!impl) return 0;
 886     return ((ElementImpl *)impl)->getAttribute("borderRightStyle");
 887 }
 888
 889 void CSS2Properties::setBorderRightStyle( const DOMString &value )
 890 {
 891     if(impl) ((ElementImpl *)impl)->setAttribute("borderRightStyle", value);
 892 }
 893
 894 DOMString CSS2Properties::borderBottomStyle() const
 895 {
 896     if(!impl) return 0;
 897     return ((ElementImpl *)impl)->getAttribute("borderBottomStyle");
 898 }
 899
 900 void CSS2Properties::setBorderBottomStyle( const DOMString &value )
 901 {
 902     if(impl) ((ElementImpl *)impl)->setAttribute("borderBottomStyle", value);
 903 }
 904
 905 DOMString CSS2Properties::borderLeftStyle() const
 906 {
 907     if(!impl) return 0;
 908     return ((ElementImpl *)impl)->getAttribute("borderLeftStyle");
 909 }
 910
 911 void CSS2Properties::setBorderLeftStyle( const DOMString &value )
 912 {
 913     if(impl) ((ElementImpl *)impl)->setAttribute("borderLeftStyle", value);
 914 }
 915
 916 DOMString CSS2Properties::borderTopWidth() const
 917 {
 918     if(!impl) return 0;
 919     return ((ElementImpl *)impl)->getAttribute("borderTopWidth");
 920 }
 921
 922 void CSS2Properties::setBorderTopWidth( const DOMString &value )
 923 {
 924     if(impl) ((ElementImpl *)impl)->setAttribute("borderTopWidth", value);
 925 }
 926
 927 DOMString CSS2Properties::borderRightWidth() const
 928 {
 929     if(!impl) return 0;
 930     return ((ElementImpl *)impl)->getAttribute("borderRightWidth");
 931 }
 932
 933 void CSS2Properties::setBorderRightWidth( const DOMString &value )
 934 {
 935     if(impl) ((ElementImpl *)impl)->setAttribute("borderRightWidth", value);
 936 }
 937
 938 DOMString CSS2Properties::borderBottomWidth() const
 939 {
 940     if(!impl) return 0;
 941     return ((ElementImpl *)impl)->getAttribute("borderBottomWidth");
 942 }
 943
 944 void CSS2Properties::setBorderBottomWidth( const DOMString &value )
 945 {
 946     if(impl) ((ElementImpl *)impl)->setAttribute("borderBottomWidth", value);
 947 }
 948
 949 DOMString CSS2Properties::borderLeftWidth() const
 950 {
 951     if(!impl) return 0;
 952     return ((ElementImpl *)impl)->getAttribute("borderLeftWidth");
 953 }
 954
 955 void CSS2Properties::setBorderLeftWidth( const DOMString &value )
 956 {
 957     if(impl) ((ElementImpl *)impl)->setAttribute("borderLeftWidth", value);
 958 }
 959
 960 DOMString CSS2Properties::borderWidth() const
 961 {
 962     if(!impl) return 0;
 963     return ((ElementImpl *)impl)->getAttribute("borderWidth");
 964 }
 965
 966 void CSS2Properties::setBorderWidth( const DOMString &value )
 967 {
 968     if(impl) ((ElementImpl *)impl)->setAttribute("borderWidth", value);
 969 }
 970
 971 DOMString CSS2Properties::bottom() const
 972 {
 973     if(!impl) return 0;
 974     return ((ElementImpl *)impl)->getAttribute("bottom");
 975 }
 976
 977 void CSS2Properties::setBottom( const DOMString &value )
 978 {
 979     if(impl) ((ElementImpl *)impl)->setAttribute("bottom", value);
 980 }
 981
 982 DOMString CSS2Properties::captionSide() const
 983 {
 984     if(!impl) return 0;
 985     return ((ElementImpl *)impl)->getAttribute("captionSide");
 986 }
 987
 988 void CSS2Properties::setCaptionSide( const DOMString &value )
 989 {
 990     if(impl) ((ElementImpl *)impl)->setAttribute("captionSide", value);
 991 }
 992
 993 DOMString CSS2Properties::clear() const
 994 {
 995     if(!impl) return 0;
 996     return ((ElementImpl *)impl)->getAttribute("clear");
 997 }
 998
 999 void CSS2Properties::setClear( const DOMString &value )
1000 {
1001     if(impl) ((ElementImpl *)impl)->setAttribute("clear", value);
1002 }
1003
1004 DOMString CSS2Properties::clip() const
1005 {
1006     if(!impl) return 0;
1007     return ((ElementImpl *)impl)->getAttribute("clip");
1008 }
1009
1010 void CSS2Properties::setClip( const DOMString &value )
1011 {
1012     if(impl) ((ElementImpl *)impl)->setAttribute("clip", value);
1013 }
1014
1015 DOMString CSS2Properties::color() const
1016 {
1017     if(!impl) return 0;
1018     return ((ElementImpl *)impl)->getAttribute("color");
1019 }
1020
1021 void CSS2Properties::setColor( const DOMString &value )
1022 {
1023     if(impl) ((ElementImpl *)impl)->setAttribute("color", value);
1024 }
1025
1026 DOMString CSS2Properties::content() const
1027 {
1028     if(!impl) return 0;
1029     return ((ElementImpl *)impl)->getAttribute("content");
1030 }
1031
1032 void CSS2Properties::setContent( const DOMString &value )
1033 {
1034     if(impl) ((ElementImpl *)impl)->setAttribute("content", value);
1035 }
1036
1037 DOMString CSS2Properties::counterIncrement() const
1038 {
1039     if(!impl) return 0;
1040     return ((ElementImpl *)impl)->getAttribute("counterIncrement");
1041 }
1042
1043 void CSS2Properties::setCounterIncrement( const DOMString &value )
1044 {
1045     if(impl) ((ElementImpl *)impl)->setAttribute("counterIncrement", value);
1046 }
1047
1048 DOMString CSS2Properties::counterReset() const
1049 {
1050     if(!impl) return 0;
1051     return ((ElementImpl *)impl)->getAttribute("counterReset");
1052 }
1053
1054 void CSS2Properties::setCounterReset( const DOMString &value )
1055 {
1056     if(impl) ((ElementImpl *)impl)->setAttribute("counterReset", value);
1057 }
1058
1059 DOMString CSS2Properties::cue() const
1060 {
1061     if(!impl) return 0;
1062     return ((ElementImpl *)impl)->getAttribute("cue");
1063 }
1064
1065 void CSS2Properties::setCue( const DOMString &value )
1066 {
1067     if(impl) ((ElementImpl *)impl)->setAttribute("cue", value);
1068 }
1069
1070 DOMString CSS2Properties::cueAfter() const
1071 {
1072     if(!impl) return 0;
1073     return ((ElementImpl *)impl)->getAttribute("cueAfter");
1074 }
1075
1076 void CSS2Properties::setCueAfter( const DOMString &value )
1077 {
1078     if(impl) ((ElementImpl *)impl)->setAttribute("cueAfter", value);
1079 }
1080
1081 DOMString CSS2Properties::cueBefore() const
1082 {
1083     if(!impl) return 0;
1084     return ((ElementImpl *)impl)->getAttribute("cueBefore");
1085 }
1086
1087 void CSS2Properties::setCueBefore( const DOMString &value )
1088 {
1089     if(impl) ((ElementImpl *)impl)->setAttribute("cueBefore", value);
1090 }
1091
1092 DOMString CSS2Properties::cursor() const
1093 {
1094     if(!impl) return 0;
1095     return ((ElementImpl *)impl)->getAttribute("cursor");
1096 }
1097
1098 void CSS2Properties::setCursor( const DOMString &value )
1099 {
1100     if(impl) ((ElementImpl *)impl)->setAttribute("cursor", value);
1101 }
1102
1103 DOMString CSS2Properties::direction() const
1104 {
1105     if(!impl) return 0;
1106     return ((ElementImpl *)impl)->getAttribute("direction");
1107 }
1108
1109 void CSS2Properties::setDirection( const DOMString &value )
1110 {
1111     if(impl) ((ElementImpl *)impl)->setAttribute("direction", value);
1112 }
1113
1114 DOMString CSS2Properties::display() const
1115 {
1116     if(!impl) return 0;
1117     return ((ElementImpl *)impl)->getAttribute("display");
1118 }
1119
1120 void CSS2Properties::setDisplay( const DOMString &value )
1121 {
1122     if(impl) ((ElementImpl *)impl)->setAttribute("display", value);
1123 }
1124
1125 DOMString CSS2Properties::elevation() const
1126 {
1127     if(!impl) return 0;
1128     return ((ElementImpl *)impl)->getAttribute("elevation");
1129 }
1130
1131 void CSS2Properties::setElevation( const DOMString &value )
1132 {
1133     if(impl) ((ElementImpl *)impl)->setAttribute("elevation", value);
1134 }
1135
1136 DOMString CSS2Properties::emptyCells() const
1137 {
1138     if(!impl) return 0;
1139     return ((ElementImpl *)impl)->getAttribute("emptyCells");
1140 }
1141
1142 void CSS2Properties::setEmptyCells( const DOMString &value )
1143 {
1144     if(impl) ((ElementImpl *)impl)->setAttribute("emptyCells", value);
1145 }
1146
1147 DOMString CSS2Properties::cssFloat() const
1148 {
1149     if(!impl) return 0;
1150     return ((ElementImpl *)impl)->getAttribute("cssFloat");
1151 }
1152
1153 void CSS2Properties::setCssFloat( const DOMString &value )
1154 {
1155     if(impl) ((ElementImpl *)impl)->setAttribute("cssFloat", value);
1156 }
1157
1158 DOMString CSS2Properties::font() const
1159 {
1160     if(!impl) return 0;
1161     return ((ElementImpl *)impl)->getAttribute("font");
1162 }
1163
1164 void CSS2Properties::setFont( const DOMString &value )
1165 {
1166     if(impl) ((ElementImpl *)impl)->setAttribute("font", value);
1167 }
1168
1169 DOMString CSS2Properties::fontFamily() const
1170 {
1171     if(!impl) return 0;
1172     return ((ElementImpl *)impl)->getAttribute("fontFamily");
1173 }
1174
1175 void CSS2Properties::setFontFamily( const DOMString &value )
1176 {
1177     if(impl) ((ElementImpl *)impl)->setAttribute("fontFamily", value);
1178 }
1179
1180 DOMString CSS2Properties::fontSize() const
1181 {
1182     if(!impl) return 0;
1183     return ((ElementImpl *)impl)->getAttribute("fontSize");
1184 }
1185
1186 void CSS2Properties::setFontSize( const DOMString &value )
1187 {
1188     if(impl) ((ElementImpl *)impl)->setAttribute("fontSize", value);
1189 }
1190
1191 DOMString CSS2Properties::fontSizeAdjust() const
1192 {
1193     if(!impl) return 0;
1194     return ((ElementImpl *)impl)->getAttribute("fontSizeAdjust");
1195 }
1196
1197 void CSS2Properties::setFontSizeAdjust( const DOMString &value )
1198 {
1199     if(impl) ((ElementImpl *)impl)->setAttribute("fontSizeAdjust", value);
1200 }
1201
1202 DOMString CSS2Properties::fontStretch() const
1203 {
1204     if(!impl) return 0;
1205     return ((ElementImpl *)impl)->getAttribute("fontStretch");
1206 }
1207
1208 void CSS2Properties::setFontStretch( const DOMString &value )
1209 {
1210     if(impl) ((ElementImpl *)impl)->setAttribute("fontStretch", value);
1211 }
1212
1213 DOMString CSS2Properties::fontStyle() const
1214 {
1215     if(!impl) return 0;
1216     return ((ElementImpl *)impl)->getAttribute("fontStyle");
1217 }
1218
1219 void CSS2Properties::setFontStyle( const DOMString &value )
1220 {
1221     if(impl) ((ElementImpl *)impl)->setAttribute("fontStyle", value);
1222 }
1223
1224 DOMString CSS2Properties::fontVariant() const
1225 {
1226     if(!impl) return 0;
1227     return ((ElementImpl *)impl)->getAttribute("fontVariant");
1228 }
1229
1230 void CSS2Properties::setFontVariant( const DOMString &value )
1231 {
1232     if(impl) ((ElementImpl *)impl)->setAttribute("fontVariant", value);
1233 }
1234
1235 DOMString CSS2Properties::fontWeight() const
1236 {
1237     if(!impl) return 0;
1238     return ((ElementImpl *)impl)->getAttribute("fontWeight");
1239 }
1240
1241 void CSS2Properties::setFontWeight( const DOMString &value )
1242 {
1243     if(impl) ((ElementImpl *)impl)->setAttribute("fontWeight", value);
1244 }
1245
1246 DOMString CSS2Properties::height() const
1247 {
1248     if(!impl) return 0;
1249     return ((ElementImpl *)impl)->getAttribute("height");
1250 }
1251
1252 void CSS2Properties::setHeight( const DOMString &value )
1253 {
1254     if(impl) ((ElementImpl *)impl)->setAttribute("height", value);
1255 }
1256
1257 DOMString CSS2Properties::left() const
1258 {
1259     if(!impl) return 0;
1260     return ((ElementImpl *)impl)->getAttribute("left");
1261 }
1262
1263 void CSS2Properties::setLeft( const DOMString &value )
1264 {
1265     if(impl) ((ElementImpl *)impl)->setAttribute("left", value);
1266 }
1267
1268 DOMString CSS2Properties::letterSpacing() const
1269 {
1270     if(!impl) return 0;
1271     return ((ElementImpl *)impl)->getAttribute("letterSpacing");
1272 }
1273
1274 void CSS2Properties::setLetterSpacing( const DOMString &value )
1275 {
1276     if(impl) ((ElementImpl *)impl)->setAttribute("letterSpacing", value);
1277 }
1278
1279 DOMString CSS2Properties::lineHeight() const
1280 {
1281     if(!impl) return 0;
1282     return ((ElementImpl *)impl)->getAttribute("lineHeight");
1283 }
1284
1285 void CSS2Properties::setLineHeight( const DOMString &value )
1286 {
1287     if(impl) ((ElementImpl *)impl)->setAttribute("lineHeight", value);
1288 }
1289
1290 DOMString CSS2Properties::listStyle() const
1291 {
1292     if(!impl) return 0;
1293     return ((ElementImpl *)impl)->getAttribute("listStyle");
1294 }
1295
1296 void CSS2Properties::setListStyle( const DOMString &value )
1297 {
1298     if(impl) ((ElementImpl *)impl)->setAttribute("listStyle", value);
1299 }
1300
1301 DOMString CSS2Properties::listStyleImage() const
1302 {
1303     if(!impl) return 0;
1304     return ((ElementImpl *)impl)->getAttribute("listStyleImage");
1305 }
1306
1307 void CSS2Properties::setListStyleImage( const DOMString &value )
1308 {
1309     if(impl) ((ElementImpl *)impl)->setAttribute("listStyleImage", value);
1310 }
1311
1312 DOMString CSS2Properties::listStylePosition() const
1313 {
1314     if(!impl) return 0;
1315     return ((ElementImpl *)impl)->getAttribute("listStylePosition");
1316 }
1317
1318 void CSS2Properties::setListStylePosition( const DOMString &value )
1319 {
1320     if(impl) ((ElementImpl *)impl)->setAttribute("listStylePosition", value);
1321 }
1322
1323 DOMString CSS2Properties::listStyleType() const
1324 {
1325     if(!impl) return 0;
1326     return ((ElementImpl *)impl)->getAttribute("listStyleType");
1327 }
1328
1329 void CSS2Properties::setListStyleType( const DOMString &value )
1330 {
1331     if(impl) ((ElementImpl *)impl)->setAttribute("listStyleType", value);
1332 }
1333
1334 DOMString CSS2Properties::margin() const
1335 {
1336     if(!impl) return 0;
1337     return ((ElementImpl *)impl)->getAttribute("margin");
1338 }
1339
1340 void CSS2Properties::setMargin( const DOMString &value )
1341 {
1342     if(impl) ((ElementImpl *)impl)->setAttribute("margin", value);
1343 }
1344
1345 DOMString CSS2Properties::marginTop() const
1346 {
1347     if(!impl) return 0;
1348     return ((ElementImpl *)impl)->getAttribute("marginTop");
1349 }
1350
1351 void CSS2Properties::setMarginTop( const DOMString &value )
1352 {
1353     if(impl) ((ElementImpl *)impl)->setAttribute("marginTop", value);
1354 }
1355
1356 DOMString CSS2Properties::marginRight() const
1357 {
1358     if(!impl) return 0;
1359     return ((ElementImpl *)impl)->getAttribute("marginRight");
1360 }
1361
1362 void CSS2Properties::setMarginRight( const DOMString &value )
1363 {
1364     if(impl) ((ElementImpl *)impl)->setAttribute("marginRight", value);
1365 }
1366
1367 DOMString CSS2Properties::marginBottom() const
1368 {
1369     if(!impl) return 0;
1370     return ((ElementImpl *)impl)->getAttribute("marginBottom");
1371 }
1372
1373 void CSS2Properties::setMarginBottom( const DOMString &value )
1374 {
1375     if(impl) ((ElementImpl *)impl)->setAttribute("marginBottom", value);
1376 }
1377
1378 DOMString CSS2Properties::marginLeft() const
1379 {
1380     if(!impl) return 0;
1381     return ((ElementImpl *)impl)->getAttribute("marginLeft");
1382 }
1383
1384 void CSS2Properties::setMarginLeft( const DOMString &value )
1385 {
1386     if(impl) ((ElementImpl *)impl)->setAttribute("marginLeft", value);
1387 }
1388
1389 DOMString CSS2Properties::markerOffset() const
1390 {
1391     if(!impl) return 0;
1392     return ((ElementImpl *)impl)->getAttribute("markerOffset");
1393 }
1394
1395 void CSS2Properties::setMarkerOffset( const DOMString &value )
1396 {
1397     if(impl) ((ElementImpl *)impl)->setAttribute("markerOffset", value);
1398 }
1399
1400 DOMString CSS2Properties::marks() const
1401 {
1402     if(!impl) return 0;
1403     return ((ElementImpl *)impl)->getAttribute("marks");
1404 }
1405
1406 void CSS2Properties::setMarks( const DOMString &value )
1407 {
1408     if(impl) ((ElementImpl *)impl)->setAttribute("marks", value);
1409 }
1410
1411 DOMString CSS2Properties::maxHeight() const
1412 {
1413     if(!impl) return 0;
1414     return ((ElementImpl *)impl)->getAttribute("maxHeight");
1415 }
1416
1417 void CSS2Properties::setMaxHeight( const DOMString &value )
1418 {
1419     if(impl) ((ElementImpl *)impl)->setAttribute("maxHeight", value);
1420 }
1421
1422 DOMString CSS2Properties::maxWidth() const
1423 {
1424     if(!impl) return 0;
1425     return ((ElementImpl *)impl)->getAttribute("maxWidth");
1426 }
1427
1428 void CSS2Properties::setMaxWidth( const DOMString &value )
1429 {
1430     if(impl) ((ElementImpl *)impl)->setAttribute("maxWidth", value);
1431 }
1432
1433 DOMString CSS2Properties::minHeight() const
1434 {
1435     if(!impl) return 0;
1436     return ((ElementImpl *)impl)->getAttribute("minHeight");
1437 }
1438
1439 void CSS2Properties::setMinHeight( const DOMString &value )
1440 {
1441     if(impl) ((ElementImpl *)impl)->setAttribute("minHeight", value);
1442 }
1443
1444 DOMString CSS2Properties::minWidth() const
1445 {
1446     if(!impl) return 0;
1447     return ((ElementImpl *)impl)->getAttribute("minWidth");
1448 }
1449
1450 void CSS2Properties::setMinWidth( const DOMString &value )
1451 {
1452     if(impl) ((ElementImpl *)impl)->setAttribute("minWidth", value);
1453 }
1454
1455 DOMString CSS2Properties::orphans() const
1456 {
1457     if(!impl) return 0;
1458     return ((ElementImpl *)impl)->getAttribute("orphans");
1459 }
1460
1461 void CSS2Properties::setOrphans( const DOMString &value )
1462 {
1463     if(impl) ((ElementImpl *)impl)->setAttribute("orphans", value);
1464 }
1465
1466 DOMString CSS2Properties::outline() const
1467 {
1468     if(!impl) return 0;
1469     return ((ElementImpl *)impl)->getAttribute("outline");
1470 }
1471
1472 void CSS2Properties::setOutline( const DOMString &value )
1473 {
1474     if(impl) ((ElementImpl *)impl)->setAttribute("outline", value);
1475 }
1476
1477 DOMString CSS2Properties::outlineColor() const
1478 {
1479     if(!impl) return 0;
1480     return ((ElementImpl *)impl)->getAttribute("outlineColor");
1481 }
1482
1483 void CSS2Properties::setOutlineColor( const DOMString &value )
1484 {
1485     if(impl) ((ElementImpl *)impl)->setAttribute("outlineColor", value);
1486 }
1487
1488 DOMString CSS2Properties::outlineStyle() const
1489 {
1490     if(!impl) return 0;
1491     return ((ElementImpl *)impl)->getAttribute("outlineStyle");
1492 }
1493
1494 void CSS2Properties::setOutlineStyle( const DOMString &value )
1495 {
1496     if(impl) ((ElementImpl *)impl)->setAttribute("outlineStyle", value);
1497 }
1498
1499 DOMString CSS2Properties::outlineWidth() const
1500 {
1501     if(!impl) return 0;
1502     return ((ElementImpl *)impl)->getAttribute("outlineWidth");
1503 }
1504
1505 void CSS2Properties::setOutlineWidth( const DOMString &value )
1506 {
1507     if(impl) ((ElementImpl *)impl)->setAttribute("outlineWidth", value);
1508 }
1509
1510 DOMString CSS2Properties::overflow() const
1511 {
1512     if(!impl) return 0;
1513     return ((ElementImpl *)impl)->getAttribute("overflow");
1514 }
1515
1516 void CSS2Properties::setOverflow( const DOMString &value )
1517 {
1518     if(impl) ((ElementImpl *)impl)->setAttribute("overflow", value);
1519 }
1520
1521 DOMString CSS2Properties::padding() const
1522 {
1523     if(!impl) return 0;
1524     return ((ElementImpl *)impl)->getAttribute("padding");
1525 }
1526
1527 void CSS2Properties::setPadding( const DOMString &value )
1528 {
1529     if(impl) ((ElementImpl *)impl)->setAttribute("padding", value);
1530 }
1531
1532 DOMString CSS2Properties::paddingTop() const
1533 {
1534     if(!impl) return 0;
1535     return ((ElementImpl *)impl)->getAttribute("paddingTop");
1536 }
1537
1538 void CSS2Properties::setPaddingTop( const DOMString &value )
1539 {
1540     if(impl) ((ElementImpl *)impl)->setAttribute("paddingTop", value);
1541 }
1542
1543 DOMString CSS2Properties::paddingRight() const
1544 {
1545     if(!impl) return 0;
1546     return ((ElementImpl *)impl)->getAttribute("paddingRight");
1547 }
1548
1549 void CSS2Properties::setPaddingRight( const DOMString &value )
1550 {
1551     if(impl) ((ElementImpl *)impl)->setAttribute("paddingRight", value);
1552 }
1553
1554 DOMString CSS2Properties::paddingBottom() const
1555 {
1556     if(!impl) return 0;
1557     return ((ElementImpl *)impl)->getAttribute("paddingBottom");
1558 }
1559
1560 void CSS2Properties::setPaddingBottom( const DOMString &value )
1561 {
1562     if(impl) ((ElementImpl *)impl)->setAttribute("paddingBottom", value);
1563 }
1564
1565 DOMString CSS2Properties::paddingLeft() const
1566 {
1567     if(!impl) return 0;
1568     return ((ElementImpl *)impl)->getAttribute("paddingLeft");
1569 }
1570
1571 void CSS2Properties::setPaddingLeft( const DOMString &value )
1572 {
1573     if(impl) ((ElementImpl *)impl)->setAttribute("paddingLeft", value);
1574 }
1575
1576 DOMString CSS2Properties::page() const
1577 {
1578     if(!impl) return 0;
1579     return ((ElementImpl *)impl)->getAttribute("page");
1580 }
1581
1582 void CSS2Properties::setPage( const DOMString &value )
1583 {
1584     if(impl) ((ElementImpl *)impl)->setAttribute("page", value);
1585 }
1586
1587 DOMString CSS2Properties::pageBreakAfter() const
1588 {
1589     if(!impl) return 0;
1590     return ((ElementImpl *)impl)->getAttribute("pageBreakAfter");
1591 }
1592
1593 void CSS2Properties::setPageBreakAfter( const DOMString &value )
1594 {
1595     if(impl) ((ElementImpl *)impl)->setAttribute("pageBreakAfter", value);
1596 }
1597
1598 DOMString CSS2Properties::pageBreakBefore() const
1599 {
1600     if(!impl) return 0;
1601     return ((ElementImpl *)impl)->getAttribute("pageBreakBefore");
1602 }
1603
1604 void CSS2Properties::setPageBreakBefore( const DOMString &value )
1605 {
1606     if(impl) ((ElementImpl *)impl)->setAttribute("pageBreakBefore", value);
1607 }
1608
1609 DOMString CSS2Properties::pageBreakInside() const
1610 {
1611     if(!impl) return 0;
1612     return ((ElementImpl *)impl)->getAttribute("pageBreakInside");
1613 }
1614
1615 void CSS2Properties::setPageBreakInside( const DOMString &value )
1616 {
1617     if(impl) ((ElementImpl *)impl)->setAttribute("pageBreakInside", value);
1618 }
1619
1620 DOMString CSS2Properties::pause() const
1621 {
1622     if(!impl) return 0;
1623     return ((ElementImpl *)impl)->getAttribute("pause");
1624 }
1625
1626 void CSS2Properties::setPause( const DOMString &value )
1627 {
1628     if(impl) ((ElementImpl *)impl)->setAttribute("pause", value);
1629 }
1630
1631 DOMString CSS2Properties::pauseAfter() const
1632 {
1633     if(!impl) return 0;
1634     return ((ElementImpl *)impl)->getAttribute("pauseAfter");
1635 }
1636
1637 void CSS2Properties::setPauseAfter( const DOMString &value )
1638 {
1639     if(impl) ((ElementImpl *)impl)->setAttribute("pauseAfter", value);
1640 }
1641
1642 DOMString CSS2Properties::pauseBefore() const
1643 {
1644     if(!impl) return 0;
1645     return ((ElementImpl *)impl)->getAttribute("pauseBefore");
1646 }
1647
1648 void CSS2Properties::setPauseBefore( const DOMString &value )
1649 {
1650     if(impl) ((ElementImpl *)impl)->setAttribute("pauseBefore", value);
1651 }
1652
1653 DOMString CSS2Properties::pitch() const
1654 {
1655     if(!impl) return 0;
1656     return ((ElementImpl *)impl)->getAttribute("pitch");
1657 }
1658
1659 void CSS2Properties::setPitch( const DOMString &value )
1660 {
1661     if(impl) ((ElementImpl *)impl)->setAttribute("pitch", value);
1662 }
1663
1664 DOMString CSS2Properties::pitchRange() const
1665 {
1666     if(!impl) return 0;
1667     return ((ElementImpl *)impl)->getAttribute("pitchRange");
1668 }
1669
1670 void CSS2Properties::setPitchRange( const DOMString &value )
1671 {
1672     if(impl) ((ElementImpl *)impl)->setAttribute("pitchRange", value);
1673 }
1674
1675 DOMString CSS2Properties::playDuring() const
1676 {
1677     if(!impl) return 0;
1678     return ((ElementImpl *)impl)->getAttribute("playDuring");
1679 }
1680
1681 void CSS2Properties::setPlayDuring( const DOMString &value )
1682 {
1683     if(impl) ((ElementImpl *)impl)->setAttribute("playDuring", value);
1684 }
1685
1686 DOMString CSS2Properties::position() const
1687 {
1688     if(!impl) return 0;
1689     return ((ElementImpl *)impl)->getAttribute("position");
1690 }
1691
1692 void CSS2Properties::setPosition( const DOMString &value )
1693 {
1694     if(impl) ((ElementImpl *)impl)->setAttribute("position", value);
1695 }
1696
1697 DOMString CSS2Properties::quotes() const
1698 {
1699     if(!impl) return 0;
1700     return ((ElementImpl *)impl)->getAttribute("quotes");
1701 }
1702
1703 void CSS2Properties::setQuotes( const DOMString &value )
1704 {
1705     if(impl) ((ElementImpl *)impl)->setAttribute("quotes", value);
1706 }
1707
1708 DOMString CSS2Properties::richness() const
1709 {
1710     if(!impl) return 0;
1711     return ((ElementImpl *)impl)->getAttribute("richness");
1712 }
1713
1714 void CSS2Properties::setRichness( const DOMString &value )
1715 {
1716     if(impl) ((ElementImpl *)impl)->setAttribute("richness", value);
1717 }
1718
1719 DOMString CSS2Properties::right() const
1720 {
1721     if(!impl) return 0;
1722     return ((ElementImpl *)impl)->getAttribute("right");
1723 }
1724
1725 void CSS2Properties::setRight( const DOMString &value )
1726 {
1727     if(impl) ((ElementImpl *)impl)->setAttribute("right", value);
1728 }
1729
1730 DOMString CSS2Properties::size() const
1731 {
1732     if(!impl) return 0;
1733     return ((ElementImpl *)impl)->getAttribute("size");
1734 }
1735
1736 void CSS2Properties::setSize( const DOMString &value )
1737 {
1738     if(impl) ((ElementImpl *)impl)->setAttribute("size", value);
1739 }
1740
1741 DOMString CSS2Properties::speak() const
1742 {
1743     if(!impl) return 0;
1744     return ((ElementImpl *)impl)->getAttribute("speak");
1745 }
1746
1747 void CSS2Properties::setSpeak( const DOMString &value )
1748 {
1749     if(impl) ((ElementImpl *)impl)->setAttribute("speak", value);
1750 }
1751
1752 DOMString CSS2Properties::speakHeader() const
1753 {
1754     if(!impl) return 0;
1755     return ((ElementImpl *)impl)->getAttribute("speakHeader");
1756 }
1757
1758 void CSS2Properties::setSpeakHeader( const DOMString &value )
1759 {
1760     if(impl) ((ElementImpl *)impl)->setAttribute("speakHeader", value);
1761 }
1762
1763 DOMString CSS2Properties::speakNumeral() const
1764 {
1765     if(!impl) return 0;
1766     return ((ElementImpl *)impl)->getAttribute("speakNumeral");
1767 }
1768
1769 void CSS2Properties::setSpeakNumeral( const DOMString &value )
1770 {
1771     if(impl) ((ElementImpl *)impl)->setAttribute("speakNumeral", value);
1772 }
1773
1774 DOMString CSS2Properties::speakPunctuation() const
1775 {
1776     if(!impl) return 0;
1777     return ((ElementImpl *)impl)->getAttribute("speakPunctuation");
1778 }
1779
1780 void CSS2Properties::setSpeakPunctuation( const DOMString &value )
1781 {
1782     if(impl) ((ElementImpl *)impl)->setAttribute("speakPunctuation", value);
1783 }
1784
1785 DOMString CSS2Properties::speechRate() const
1786 {
1787     if(!impl) return 0;
1788     return ((ElementImpl *)impl)->getAttribute("speechRate");
1789 }
1790
1791 void CSS2Properties::setSpeechRate( const DOMString &value )
1792 {
1793     if(impl) ((ElementImpl *)impl)->setAttribute("speechRate", value);
1794 }
1795
1796 DOMString CSS2Properties::stress() const
1797 {
1798     if(!impl) return 0;
1799     return ((ElementImpl *)impl)->getAttribute("stress");
1800 }
1801
1802 void CSS2Properties::setStress( const DOMString &value )
1803 {
1804     if(impl) ((ElementImpl *)impl)->setAttribute("stress", value);
1805 }
1806
1807 DOMString CSS2Properties::tableLayout() const
1808 {
1809     if(!impl) return 0;
1810     return ((ElementImpl *)impl)->getAttribute("tableLayout");
1811 }
1812
1813 void CSS2Properties::setTableLayout( const DOMString &value )
1814 {
1815     if(impl) ((ElementImpl *)impl)->setAttribute("tableLayout", value);
1816 }
1817
1818 DOMString CSS2Properties::textAlign() const
1819 {
1820     if(!impl) return 0;
1821     return ((ElementImpl *)impl)->getAttribute("textAlign");
1822 }
1823
1824 void CSS2Properties::setTextAlign( const DOMString &value )
1825 {
1826     if(impl) ((ElementImpl *)impl)->setAttribute("textAlign", value);
1827 }
1828
1829 DOMString CSS2Properties::textDecoration() const
1830 {
1831     if(!impl) return 0;
1832     return ((ElementImpl *)impl)->getAttribute("textDecoration");
1833 }
1834
1835 void CSS2Properties::setTextDecoration( const DOMString &value )
1836 {
1837     if(impl) ((ElementImpl *)impl)->setAttribute("textDecoration", value);
1838 }
1839
1840 DOMString CSS2Properties::textIndent() const
1841 {
1842     if(!impl) return 0;
1843     return ((ElementImpl *)impl)->getAttribute("textIndent");
1844 }
1845
1846 void CSS2Properties::setTextIndent( const DOMString &value )
1847 {
1848     if(impl) ((ElementImpl *)impl)->setAttribute("textIndent", value);
1849 }
1850
1851 DOMString CSS2Properties::textShadow() const
1852 {
1853     if(!impl) return 0;
1854     return ((ElementImpl *)impl)->getAttribute("textShadow");
1855 }
1856
1857 void CSS2Properties::setTextShadow( const DOMString &value )
1858 {
1859     if(impl) ((ElementImpl *)impl)->setAttribute("textShadow", value);
1860 }
1861
1862 DOMString CSS2Properties::textTransform() const
1863 {
1864     if(!impl) return 0;
1865     return ((ElementImpl *)impl)->getAttribute("textTransform");
1866 }
1867
1868 void CSS2Properties::setTextTransform( const DOMString &value )
1869 {
1870     if(impl) ((ElementImpl *)impl)->setAttribute("textTransform", value);
1871 }
1872
1873 DOMString CSS2Properties::top() const
1874 {
1875     if(!impl) return 0;
1876     return ((ElementImpl *)impl)->getAttribute("top");
1877 }
1878
1879 void CSS2Properties::setTop( const DOMString &value )
1880 {
1881     if(impl) ((ElementImpl *)impl)->setAttribute("top", value);
1882 }
1883
1884 DOMString CSS2Properties::unicodeBidi() const
1885 {
1886     if(!impl) return 0;
1887     return ((ElementImpl *)impl)->getAttribute("unicodeBidi");
1888 }
1889
1890 void CSS2Properties::setUnicodeBidi( const DOMString &value )
1891 {
1892     if(impl) ((ElementImpl *)impl)->setAttribute("unicodeBidi", value);
1893 }
1894
1895 DOMString CSS2Properties::verticalAlign() const
1896 {
1897     if(!impl) return 0;
1898     return ((ElementImpl *)impl)->getAttribute("verticalAlign");
1899 }
1900
1901 void CSS2Properties::setVerticalAlign( const DOMString &value )
1902 {
1903     if(impl) ((ElementImpl *)impl)->setAttribute("verticalAlign", value);
1904 }
1905
1906 DOMString CSS2Properties::visibility() const
1907 {
1908     if(!impl) return 0;
1909     return ((ElementImpl *)impl)->getAttribute("visibility");
1910 }
1911
1912 void CSS2Properties::setVisibility( const DOMString &value )
1913 {
1914     if(impl) ((ElementImpl *)impl)->setAttribute("visibility", value);
1915 }
1916
1917 DOMString CSS2Properties::voiceFamily() const
1918 {
1919     if(!impl) return 0;
1920     return ((ElementImpl *)impl)->getAttribute("voiceFamily");
1921 }
1922
1923 void CSS2Properties::setVoiceFamily( const DOMString &value )
1924 {
1925     if(impl) ((ElementImpl *)impl)->setAttribute("voiceFamily", value);
1926 }
1927
1928 DOMString CSS2Properties::volume() const
1929 {
1930     if(!impl) return 0;
1931     return ((ElementImpl *)impl)->getAttribute("volume");
1932 }
1933
1934 void CSS2Properties::setVolume( const DOMString &value )
1935 {
1936     if(impl) ((ElementImpl *)impl)->setAttribute("volume", value);
1937 }
1938
1939 DOMString CSS2Properties::whiteSpace() const
1940 {
1941     if(!impl) return 0;
1942     return ((ElementImpl *)impl)->getAttribute("whiteSpace");
1943 }
1944
1945 void CSS2Properties::setWhiteSpace( const DOMString &value )
1946 {
1947     if(impl) ((ElementImpl *)impl)->setAttribute("whiteSpace", value);
1948 }
1949
1950 DOMString CSS2Properties::widows() const
1951 {
1952     if(!impl) return 0;
1953     return ((ElementImpl *)impl)->getAttribute("widows");
1954 }
1955
1956 void CSS2Properties::setWidows( const DOMString &value )
1957 {
1958     if(impl) ((ElementImpl *)impl)->setAttribute("widows", value);
1959 }
1960
1961 DOMString CSS2Properties::width() const
1962 {
1963     if(!impl) return 0;
1964     return ((ElementImpl *)impl)->getAttribute("width");
1965 }
1966
1967 void CSS2Properties::setWidth( const DOMString &value )
1968 {
1969     if(impl) ((ElementImpl *)impl)->setAttribute("width", value);
1970 }
1971
1972 DOMString CSS2Properties::wordSpacing() const
1973 {
1974     if(!impl) return 0;
1975     return ((ElementImpl *)impl)->getAttribute("wordSpacing");
1976 }
1977
1978 void CSS2Properties::setWordSpacing( const DOMString &value )
1979 {
1980     if(impl) ((ElementImpl *)impl)->setAttribute("wordSpacing", value);
1981 }
1982
1983 DOMString CSS2Properties::zIndex() const
1984 {
1985     if(!impl) return 0;
1986     return ((ElementImpl *)impl)->getAttribute("zIndex");
1987 }
1988
1989 void CSS2Properties::setZIndex( const DOMString &value )
1990 {
1991     if(impl) ((ElementImpl *)impl)->setAttribute("zIndex", value);
1992 }
1993
1994
1995
1996 CSS2TextShadow::CSS2TextShadow()
1997 {
1998 }
1999
2000 CSS2TextShadow::CSS2TextShadow(const CSS2TextShadow &other)
2001 {
2002 }
2003
2004 CSS2TextShadow::CSS2TextShadow(CSS2TextShadowImpl *impl)
2005 {
2006 }
2007
2008 CSS2TextShadow &CSS2TextShadow::operator = (const CSS2TextShadow &other)
2009 {
2010     ::operator = (other);
2011     return *this;
2012 }
2013
2014 CSS2TextShadow::~CSS2TextShadow()
2015 {
2016 }
2017
2018 CSSValue CSS2TextShadow::color() const
2019 {
2020     if(!impl) return 0;
2021     return ((CSS2TextShadowImpl *)impl)->color();
2022 }
2023
2024 CSSValue CSS2TextShadow::horizontal() const
2025 {
2026     if(!impl) return 0;
2027     return ((CSS2TextShadowImpl *)impl)->horizontal();
2028 }
2029
2030 CSSValue CSS2TextShadow::vertical() const
2031 {
2032     if(!impl) return 0;
2033     return ((CSS2TextShadowImpl *)impl)->vertical();
2034 }
2035
2036 CSSValue CSS2TextShadow::blur() const
2037 {
2038     if(!impl) return 0;
2039     return ((CSS2TextShadowImpl *)impl)->blur();
2040 }
2041
2042
2043