KHtml

css_extensions.cpp
1 
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 CSS2Azimuth::CSS2Azimuth() : CSSValue()
30 {
31 }
32 
33 CSS2Azimuth::CSS2Azimuth(const CSS2Azimuth &other) : CSSValue(other)
34 {
35 }
36 
37 CSS2Azimuth::CSS2Azimuth(CSS2AzimuthImpl *impl) : CSSValue(impl)
38 {
39 }
40 
41 CSS2Azimuth &CSS2Azimuth::operator = (const CSS2Azimuth &other)
42 {
43  CSSValue::operator = (other);
44  return *this;
45 }
46 
47 CSS2Azimuth::~CSS2Azimuth()
48 {
49 }
50 
51 unsigned short CSS2Azimuth::azimuthType() const
52 {
53  if (!impl) {
54  return 0;
55  }
56  return ((CSS2AzimuthImpl *)impl)->azimuthType();
57 }
58 
59 DOMString CSS2Azimuth::identifier() const
60 {
61  if (!impl) {
62  return 0;
63  }
64  return ((CSS2AzimuthImpl *)impl)->identifier();
65 }
66 
67 bool CSS2Azimuth::behind() const
68 {
69  if (!impl) {
70  return 0;
71  }
72  return ((CSS2AzimuthImpl *)impl)->behind();
73 }
74 
75 void CSS2Azimuth::setAngleValue(const unsigned short unitType, const float floatValue)
76 {
77  if (impl) {
78  ((CSS2AzimuthImpl *)impl)->setAngleValue(unitType, floatValue);
79  }
80 }
81 
82 float CSS2Azimuth::getAngleValue(const unsigned short unitType)
83 {
84  if (!impl) {
85  return 0;
86  }
87  return ((CSS2AzimuthImpl *)impl)->getAngleValue(unitType);
88 }
89 
90 void CSS2Azimuth::setIdentifier(const DOMString &identifier, const bool behind)
91 {
92  if (impl) {
93  ((CSS2AzimuthImpl *)impl)->setIdentifier(identifier, behind);
94  }
95 }
96 
97 CSS2BackgroundPosition::CSS2BackgroundPosition() : CSSValue()
98 {
99 }
100 
101 CSS2BackgroundPosition::CSS2BackgroundPosition(const CSS2BackgroundPosition &other) : CSSValue(other)
102 {
103 }
104 
105 CSS2BackgroundPosition::CSS2BackgroundPosition(CSS2BackgroundPositionImpl *impl) : CSSValue(impl)
106 {
107 }
108 
109 CSS2BackgroundPosition &CSS2BackgroundPosition::operator = (const CSS2BackgroundPosition &other)
110 {
111  CSSValue::operator = (other);
112  return *this;
113 }
114 
115 CSS2BackgroundPosition::~CSS2BackgroundPosition()
116 {
117 }
118 
119 unsigned short CSS2BackgroundPosition::horizontalType() const
120 {
121  if (!impl) {
122  return 0;
123  }
124  return ((CSS2BackgroundPositionImpl *)impl)->horizontalType();
125 }
126 
127 unsigned short CSS2BackgroundPosition::verticalType() const
128 {
129  if (!impl) {
130  return 0;
131  }
132  return ((CSS2BackgroundPositionImpl *)impl)->verticalType();
133 }
134 
135 DOMString CSS2BackgroundPosition::horizontalIdentifier() const
136 {
137  if (!impl) {
138  return 0;
139  }
140  return ((CSS2BackgroundPositionImpl *)impl)->horizontalIdentifier();
141 }
142 
143 DOMString CSS2BackgroundPosition::verticalIdentifier() const
144 {
145  if (!impl) {
146  return 0;
147  }
148  return ((CSS2BackgroundPositionImpl *)impl)->verticalIdentifier();
149 }
150 
151 float CSS2BackgroundPosition::getHorizontalPosition(const float horizontalType)
152 {
153  if (!impl) {
154  return 0;
155  }
156  return ((CSS2BackgroundPositionImpl *)impl)->getHorizontalPosition(horizontalType);
157 }
158 
159 float CSS2BackgroundPosition::getVerticalPosition(const float verticalType)
160 {
161  if (!impl) {
162  return 0;
163  }
164  return ((CSS2BackgroundPositionImpl *)impl)->getVerticalPosition(verticalType);
165 }
166 
167 void CSS2BackgroundPosition::setHorizontalPosition(const unsigned short horizontalType, const float value)
168 {
169  if (impl) {
170  ((CSS2BackgroundPositionImpl *)impl)->setHorizontalPosition(horizontalType, value);
171  }
172 }
173 
174 void CSS2BackgroundPosition::setVerticalPosition(const unsigned short verticalType, const float value)
175 {
176  if (impl) {
177  ((CSS2BackgroundPositionImpl *)impl)->setVerticalPosition(verticalType, value);
178  }
179 }
180 
181 void CSS2BackgroundPosition::setPositionIdentifier(const DOMString &horizontalIdentifier, const DOMString &verticalIdentifier)
182 {
183  if (impl) {
184  ((CSS2BackgroundPositionImpl *)impl)->setPositionIdentifier(horizontalIdentifier, verticalIdentifier);
185  }
186 }
187 
188 CSS2BorderSpacing::CSS2BorderSpacing() : CSSValue()
189 {
190 }
191 
192 CSS2BorderSpacing::CSS2BorderSpacing(const CSS2BorderSpacing &other) : CSSValue(other)
193 {
194 }
195 
196 CSS2BorderSpacing::CSS2BorderSpacing(CSS2BorderSpacingImpl *impl) : CSSValue(impl)
197 {
198 }
199 
200 CSS2BorderSpacing &CSS2BorderSpacing::operator = (const CSS2BorderSpacing &other)
201 {
202  CSSValue::operator = (other);
203  return *this;
204 }
205 
206 CSS2BorderSpacing::~CSS2BorderSpacing()
207 {
208 }
209 
210 unsigned short CSS2BorderSpacing::horizontalType() const
211 {
212  if (!impl) {
213  return 0;
214  }
215  return ((CSS2BorderSpacingImpl *)impl)->horizontalType();
216 }
217 
218 unsigned short CSS2BorderSpacing::verticalType() const
219 {
220  if (!impl) {
221  return 0;
222  }
223  return ((CSS2BorderSpacingImpl *)impl)->verticalType();
224 }
225 
226 float CSS2BorderSpacing::getHorizontalSpacing(const float horizontalType)
227 {
228  if (!impl) {
229  return 0;
230  }
231  return ((CSS2BorderSpacingImpl *)impl)->getHorizontalSpacing(horizontalType);
232 }
233 
234 float CSS2BorderSpacing::getVerticalSpacing(const float verticalType)
235 {
236  if (!impl) {
237  return 0;
238  }
239  return ((CSS2BorderSpacingImpl *)impl)->getVerticalSpacing(verticalType);
240 }
241 
242 void CSS2BorderSpacing::setHorizontalSpacing(const unsigned short horizontalType, const float value)
243 {
244  if (impl) {
245  ((CSS2BorderSpacingImpl *)impl)->setHorizontalSpacing(horizontalType, value);
246  }
247 }
248 
249 void CSS2BorderSpacing::setVerticalSpacing(const unsigned short verticalType, const float value)
250 {
251  if (impl) {
252  ((CSS2BorderSpacingImpl *)impl)->setVerticalSpacing(verticalType, value);
253  }
254 }
255 
256 void CSS2BorderSpacing::setInherit()
257 {
258  if (impl) {
259  ((CSS2BorderSpacingImpl *)impl)->setInherit();
260  }
261 }
262 
263 CSS2CounterIncrement::CSS2CounterIncrement()
264 {
265 }
266 
267 CSS2CounterIncrement::CSS2CounterIncrement(const CSS2CounterIncrement &other)
268 {
269 }
270 
271 CSS2CounterIncrement::CSS2CounterIncrement(CSS2CounterIncrementImpl *impl)
272 {
273 }
274 
275 CSS2CounterIncrement &CSS2CounterIncrement::operator = (const CSS2CounterIncrement &other)
276 {
277  ::operator = (other);
278  return *this;
279 }
280 
281 CSS2CounterIncrement::~CSS2CounterIncrement()
282 {
283 }
284 
285 DOMString CSS2CounterIncrement::identifier() const
286 {
287  if (!impl) {
288  return 0;
289  }
290  return ((ElementImpl *)impl)->getAttribute("identifier");
291 }
292 
293 void CSS2CounterIncrement::setIdentifier(const DOMString &value)
294 {
295  if (impl) {
296  ((ElementImpl *)impl)->setAttribute("identifier", value);
297  }
298 }
299 
300 short CSS2CounterIncrement::increment() const
301 {
302  if (!impl) {
303  return 0;
304  }
305  return ((CSS2CounterIncrementImpl *)impl)->increment();
306 }
307 
308 void CSS2CounterIncrement::setIncrement(const short _increment)
309 {
310 
311  if (impl) {
312  ((CSS2CounterIncrementImpl *)impl)->setIncrement(_increment);
313  }
314 }
315 
316 CSS2CounterReset::CSS2CounterReset()
317 {
318 }
319 
320 CSS2CounterReset::CSS2CounterReset(const CSS2CounterReset &other)
321 {
322 }
323 
324 CSS2CounterReset::CSS2CounterReset(CSS2CounterResetImpl *impl)
325 {
326 }
327 
328 CSS2CounterReset &CSS2CounterReset::operator = (const CSS2CounterReset &other)
329 {
330  ::operator = (other);
331  return *this;
332 }
333 
334 CSS2CounterReset::~CSS2CounterReset()
335 {
336 }
337 
338 DOMString CSS2CounterReset::identifier() const
339 {
340  if (!impl) {
341  return 0;
342  }
343  return ((ElementImpl *)impl)->getAttribute("identifier");
344 }
345 
346 void CSS2CounterReset::setIdentifier(const DOMString &value)
347 {
348  if (impl) {
349  ((ElementImpl *)impl)->setAttribute("identifier", value);
350  }
351 }
352 
353 short CSS2CounterReset::reset() const
354 {
355  if (!impl) {
356  return 0;
357  }
358  return ((CSS2CounterResetImpl *)impl)->reset();
359 }
360 
361 void CSS2CounterReset::setReset(const short _reset)
362 {
363 
364  if (impl) {
365  ((CSS2CounterResetImpl *)impl)->setReset(_reset);
366  }
367 }
368 
369 CSS2Cursor::CSS2Cursor() : CSSValue()
370 {
371 }
372 
373 CSS2Cursor::CSS2Cursor(const CSS2Cursor &other) : CSSValue(other)
374 {
375 }
376 
377 CSS2Cursor::CSS2Cursor(CSS2CursorImpl *impl) : CSSValue(impl)
378 {
379 }
380 
381 CSS2Cursor &CSS2Cursor::operator = (const CSS2Cursor &other)
382 {
383  CSSValue::operator = (other);
384  return *this;
385 }
386 
387 CSS2Cursor::~CSS2Cursor()
388 {
389 }
390 
391 unsigned short CSS2Cursor::cursorType() const
392 {
393  if (!impl) {
394  return 0;
395  }
396  return ((CSS2CursorImpl *)impl)->cursorType();
397 }
398 
399 void CSS2Cursor::setCursorType(const unsigned short _cursorType)
400 {
401 
402  if (impl) {
403  ((CSS2CursorImpl *)impl)->setCursorType(_cursorType);
404  }
405 }
406 
407 CSSValueList CSS2Cursor::uris() const
408 {
409  if (!impl) {
410  return 0;
411  }
412  return ((CSS2CursorImpl *)impl)->uris();
413 }
414 
415 DOMString CSS2Cursor::predefinedCursor() const
416 {
417  if (!impl) {
418  return 0;
419  }
420  return ((ElementImpl *)impl)->getAttribute("predefinedCursor");
421 }
422 
423 void CSS2Cursor::setPredefinedCursor(const DOMString &value)
424 {
425  if (impl) {
426  ((ElementImpl *)impl)->setAttribute("predefinedCursor", value);
427  }
428 }
429 
430 CSS2FontFaceSrc::CSS2FontFaceSrc()
431 {
432 }
433 
434 CSS2FontFaceSrc::CSS2FontFaceSrc(const CSS2FontFaceSrc &other)
435 {
436 }
437 
438 CSS2FontFaceSrc::CSS2FontFaceSrc(CSS2FontFaceSrcImpl *impl)
439 {
440 }
441 
442 CSS2FontFaceSrc &CSS2FontFaceSrc::operator = (const CSS2FontFaceSrc &other)
443 {
444  ::operator = (other);
445  return *this;
446 }
447 
448 CSS2FontFaceSrc::~CSS2FontFaceSrc()
449 {
450 }
451 
452 DOMString CSS2FontFaceSrc::uri() const
453 {
454  if (!impl) {
455  return 0;
456  }
457  return ((ElementImpl *)impl)->getAttribute("uri");
458 }
459 
460 void CSS2FontFaceSrc::setUri(const DOMString &value)
461 {
462  if (impl) {
463  ((ElementImpl *)impl)->setAttribute("uri", value);
464  }
465 }
466 
467 CSSValueList CSS2FontFaceSrc::format() const
468 {
469  if (!impl) {
470  return 0;
471  }
472  return ((CSS2FontFaceSrcImpl *)impl)->format();
473 }
474 
475 DOMString CSS2FontFaceSrc::fontFaceName() const
476 {
477  if (!impl) {
478  return 0;
479  }
480  return ((ElementImpl *)impl)->getAttribute("fontFaceName");
481 }
482 
483 void CSS2FontFaceSrc::setFontFaceName(const DOMString &value)
484 {
485  if (impl) {
486  ((ElementImpl *)impl)->setAttribute("fontFaceName", value);
487  }
488 }
489 
490 CSS2FontFaceWidths::CSS2FontFaceWidths()
491 {
492 }
493 
494 CSS2FontFaceWidths::CSS2FontFaceWidths(const CSS2FontFaceWidths &other)
495 {
496 }
497 
498 CSS2FontFaceWidths::CSS2FontFaceWidths(CSS2FontFaceWidthsImpl *impl)
499 {
500 }
501 
502 CSS2FontFaceWidths &CSS2FontFaceWidths::operator = (const CSS2FontFaceWidths &other)
503 {
504  ::operator = (other);
505  return *this;
506 }
507 
508 CSS2FontFaceWidths::~CSS2FontFaceWidths()
509 {
510 }
511 
512 DOMString CSS2FontFaceWidths::urange() const
513 {
514  if (!impl) {
515  return 0;
516  }
517  return ((ElementImpl *)impl)->getAttribute("urange");
518 }
519 
520 void CSS2FontFaceWidths::setUrange(const DOMString &value)
521 {
522  if (impl) {
523  ((ElementImpl *)impl)->setAttribute("urange", value);
524  }
525 }
526 
527 CSSValueList CSS2FontFaceWidths::numbers() const
528 {
529  if (!impl) {
530  return 0;
531  }
532  return ((CSS2FontFaceWidthsImpl *)impl)->numbers();
533 }
534 
535 CSS2PageSize::CSS2PageSize() : CSSValue()
536 {
537 }
538 
539 CSS2PageSize::CSS2PageSize(const CSS2PageSize &other) : CSSValue(other)
540 {
541 }
542 
543 CSS2PageSize::CSS2PageSize(CSS2PageSizeImpl *impl) : CSSValue(impl)
544 {
545 }
546 
547 CSS2PageSize &CSS2PageSize::operator = (const CSS2PageSize &other)
548 {
549  CSSValue::operator = (other);
550  return *this;
551 }
552 
553 CSS2PageSize::~CSS2PageSize()
554 {
555 }
556 
557 unsigned short CSS2PageSize::widthType() const
558 {
559  if (!impl) {
560  return 0;
561  }
562  return ((CSS2PageSizeImpl *)impl)->widthType();
563 }
564 
565 unsigned short CSS2PageSize::heightType() const
566 {
567  if (!impl) {
568  return 0;
569  }
570  return ((CSS2PageSizeImpl *)impl)->heightType();
571 }
572 
573 DOMString CSS2PageSize::identifier() const
574 {
575  if (!impl) {
576  return 0;
577  }
578  return ((CSS2PageSizeImpl *)impl)->identifier();
579 }
580 
581 float CSS2PageSize::getWidth(const float widthType)
582 {
583  if (!impl) {
584  return 0;
585  }
586  return ((CSS2PageSizeImpl *)impl)->getWidth(widthType);
587 }
588 
589 float CSS2PageSize::getHeightSize(const float heightType)
590 {
591  if (!impl) {
592  return 0;
593  }
594  return ((CSS2PageSizeImpl *)impl)->getHeightSize(heightType);
595 }
596 
597 void CSS2PageSize::setWidthSize(const unsigned short widthType, const float value)
598 {
599  if (impl) {
600  ((CSS2PageSizeImpl *)impl)->setWidthSize(widthType, value);
601  }
602 }
603 
604 void CSS2PageSize::setHeightSize(const unsigned short heightType, const float value)
605 {
606  if (impl) {
607  ((CSS2PageSizeImpl *)impl)->setHeightSize(heightType, value);
608  }
609 }
610 
611 void CSS2PageSize::setIdentifier(const DOMString &identifier)
612 {
613  if (impl) {
614  ((CSS2PageSizeImpl *)impl)->setIdentifier(identifier);
615  }
616 }
617 
618 CSS2PlayDuring::CSS2PlayDuring() : CSSValue()
619 {
620 }
621 
622 CSS2PlayDuring::CSS2PlayDuring(const CSS2PlayDuring &other) : CSSValue(other)
623 {
624 }
625 
626 CSS2PlayDuring::CSS2PlayDuring(CSS2PlayDuringImpl *impl) : CSSValue(impl)
627 {
628 }
629 
630 CSS2PlayDuring &CSS2PlayDuring::operator = (const CSS2PlayDuring &other)
631 {
632  CSSValue::operator = (other);
633  return *this;
634 }
635 
636 CSS2PlayDuring::~CSS2PlayDuring()
637 {
638 }
639 
640 unsigned short CSS2PlayDuring::playDuringType() const
641 {
642  if (!impl) {
643  return 0;
644  }
645  return ((CSS2PlayDuringImpl *)impl)->playDuringType();
646 }
647 
648 DOMString CSS2PlayDuring::playDuringIdentifier() const
649 {
650  if (!impl) {
651  return 0;
652  }
653  return ((ElementImpl *)impl)->getAttribute("playDuringIdentifier");
654 }
655 
656 void CSS2PlayDuring::setPlayDuringIdentifier(const DOMString &value)
657 {
658  if (impl) {
659  ((ElementImpl *)impl)->setAttribute("playDuringIdentifier", value);
660  }
661 }
662 
663 DOMString CSS2PlayDuring::uri() const
664 {
665  if (!impl) {
666  return 0;
667  }
668  return ((ElementImpl *)impl)->getAttribute("uri");
669 }
670 
671 void CSS2PlayDuring::setUri(const DOMString &value)
672 {
673  if (impl) {
674  ((ElementImpl *)impl)->setAttribute("uri", value);
675  }
676 }
677 
678 bool CSS2PlayDuring::mix() const
679 {
680  if (!impl) {
681  return 0;
682  }
683  return ((CSS2PlayDuringImpl *)impl)->mix();
684 }
685 
686 void CSS2PlayDuring::setMix(const bool _mix)
687 {
688 
689  if (impl) {
690  ((CSS2PlayDuringImpl *)impl)->setMix(_mix);
691  }
692 }
693 
694 bool CSS2PlayDuring::repeat() const
695 {
696  if (!impl) {
697  return 0;
698  }
699  return ((CSS2PlayDuringImpl *)impl)->repeat();
700 }
701 
702 void CSS2PlayDuring::setRepeat(const bool _repeat)
703 {
704 
705  if (impl) {
706  ((CSS2PlayDuringImpl *)impl)->setRepeat(_repeat);
707  }
708 }
709 
710 CSS2Properties::CSS2Properties()
711 {
712 }
713 
714 CSS2Properties::CSS2Properties(const CSS2Properties &other)
715 {
716 }
717 
718 CSS2Properties::CSS2Properties(CSS2PropertiesImpl *impl)
719 {
720 }
721 
722 CSS2Properties &CSS2Properties::operator = (const CSS2Properties &other)
723 {
724  ::operator = (other);
725  return *this;
726 }
727 
728 CSS2Properties::~CSS2Properties()
729 {
730 }
731 
732 DOMString CSS2Properties::azimuth() const
733 {
734  if (!impl) {
735  return 0;
736  }
737  return ((ElementImpl *)impl)->getAttribute("azimuth");
738 }
739 
740 void CSS2Properties::setAzimuth(const DOMString &value)
741 {
742  if (impl) {
743  ((ElementImpl *)impl)->setAttribute("azimuth", value);
744  }
745 }
746 
747 DOMString CSS2Properties::background() const
748 {
749  if (!impl) {
750  return 0;
751  }
752  return ((ElementImpl *)impl)->getAttribute("background");
753 }
754 
755 void CSS2Properties::setBackground(const DOMString &value)
756 {
757  if (impl) {
758  ((ElementImpl *)impl)->setAttribute("background", value);
759  }
760 }
761 
762 DOMString CSS2Properties::backgroundAttachment() const
763 {
764  if (!impl) {
765  return 0;
766  }
767  return ((ElementImpl *)impl)->getAttribute("backgroundAttachment");
768 }
769 
770 void CSS2Properties::setBackgroundAttachment(const DOMString &value)
771 {
772  if (impl) {
773  ((ElementImpl *)impl)->setAttribute("backgroundAttachment", value);
774  }
775 }
776 
777 DOMString CSS2Properties::backgroundColor() const
778 {
779  if (!impl) {
780  return 0;
781  }
782  return ((ElementImpl *)impl)->getAttribute("backgroundColor");
783 }
784 
785 void CSS2Properties::setBackgroundColor(const DOMString &value)
786 {
787  if (impl) {
788  ((ElementImpl *)impl)->setAttribute("backgroundColor", value);
789  }
790 }
791 
792 DOMString CSS2Properties::backgroundImage() const
793 {
794  if (!impl) {
795  return 0;
796  }
797  return ((ElementImpl *)impl)->getAttribute("backgroundImage");
798 }
799 
800 void CSS2Properties::setBackgroundImage(const DOMString &value)
801 {
802  if (impl) {
803  ((ElementImpl *)impl)->setAttribute("backgroundImage", value);
804  }
805 }
806 
807 DOMString CSS2Properties::backgroundPosition() const
808 {
809  if (!impl) {
810  return 0;
811  }
812  return ((ElementImpl *)impl)->getAttribute("backgroundPosition");
813 }
814 
815 void CSS2Properties::setBackgroundPosition(const DOMString &value)
816 {
817  if (impl) {
818  ((ElementImpl *)impl)->setAttribute("backgroundPosition", value);
819  }
820 }
821 
822 DOMString CSS2Properties::backgroundRepeat() const
823 {
824  if (!impl) {
825  return 0;
826  }
827  return ((ElementImpl *)impl)->getAttribute("backgroundRepeat");
828 }
829 
830 void CSS2Properties::setBackgroundRepeat(const DOMString &value)
831 {
832  if (impl) {
833  ((ElementImpl *)impl)->setAttribute("backgroundRepeat", value);
834  }
835 }
836 
837 DOMString CSS2Properties::border() const
838 {
839  if (!impl) {
840  return 0;
841  }
842  return ((ElementImpl *)impl)->getAttribute("border");
843 }
844 
845 void CSS2Properties::setBorder(const DOMString &value)
846 {
847  if (impl) {
848  ((ElementImpl *)impl)->setAttribute("border", value);
849  }
850 }
851 
852 DOMString CSS2Properties::borderCollapse() const
853 {
854  if (!impl) {
855  return 0;
856  }
857  return ((ElementImpl *)impl)->getAttribute("borderCollapse");
858 }
859 
860 void CSS2Properties::setBorderCollapse(const DOMString &value)
861 {
862  if (impl) {
863  ((ElementImpl *)impl)->setAttribute("borderCollapse", value);
864  }
865 }
866 
867 DOMString CSS2Properties::borderColor() const
868 {
869  if (!impl) {
870  return 0;
871  }
872  return ((ElementImpl *)impl)->getAttribute("borderColor");
873 }
874 
875 void CSS2Properties::setBorderColor(const DOMString &value)
876 {
877  if (impl) {
878  ((ElementImpl *)impl)->setAttribute("borderColor", value);
879  }
880 }
881 
882 DOMString CSS2Properties::borderSpacing() const
883 {
884  if (!impl) {
885  return 0;
886  }
887  return ((ElementImpl *)impl)->getAttribute("borderSpacing");
888 }
889 
890 void CSS2Properties::setBorderSpacing(const DOMString &value)
891 {
892  if (impl) {
893  ((ElementImpl *)impl)->setAttribute("borderSpacing", value);
894  }
895 }
896 
897 DOMString CSS2Properties::borderStyle() const
898 {
899  if (!impl) {
900  return 0;
901  }
902  return ((ElementImpl *)impl)->getAttribute("borderStyle");
903 }
904 
905 void CSS2Properties::setBorderStyle(const DOMString &value)
906 {
907  if (impl) {
908  ((ElementImpl *)impl)->setAttribute("borderStyle", value);
909  }
910 }
911 
912 DOMString CSS2Properties::borderTop() const
913 {
914  if (!impl) {
915  return 0;
916  }
917  return ((ElementImpl *)impl)->getAttribute("borderTop");
918 }
919 
920 void CSS2Properties::setBorderTop(const DOMString &value)
921 {
922  if (impl) {
923  ((ElementImpl *)impl)->setAttribute("borderTop", value);
924  }
925 }
926 
927 DOMString CSS2Properties::borderRight() const
928 {
929  if (!impl) {
930  return 0;
931  }
932  return ((ElementImpl *)impl)->getAttribute("borderRight");
933 }
934 
935 void CSS2Properties::setBorderRight(const DOMString &value)
936 {
937  if (impl) {
938  ((ElementImpl *)impl)->setAttribute("borderRight", value);
939  }
940 }
941 
942 DOMString CSS2Properties::borderBottom() const
943 {
944  if (!impl) {
945  return 0;
946  }
947  return ((ElementImpl *)impl)->getAttribute("borderBottom");
948 }
949 
950 void CSS2Properties::setBorderBottom(const DOMString &value)
951 {
952  if (impl) {
953  ((ElementImpl *)impl)->setAttribute("borderBottom", value);
954  }
955 }
956 
957 DOMString CSS2Properties::borderLeft() const
958 {
959  if (!impl) {
960  return 0;
961  }
962  return ((ElementImpl *)impl)->getAttribute("borderLeft");
963 }
964 
965 void CSS2Properties::setBorderLeft(const DOMString &value)
966 {
967  if (impl) {
968  ((ElementImpl *)impl)->setAttribute("borderLeft", value);
969  }
970 }
971 
972 DOMString CSS2Properties::borderTopColor() const
973 {
974  if (!impl) {
975  return 0;
976  }
977  return ((ElementImpl *)impl)->getAttribute("borderTopColor");
978 }
979 
980 void CSS2Properties::setBorderTopColor(const DOMString &value)
981 {
982  if (impl) {
983  ((ElementImpl *)impl)->setAttribute("borderTopColor", value);
984  }
985 }
986 
987 DOMString CSS2Properties::borderRightColor() const
988 {
989  if (!impl) {
990  return 0;
991  }
992  return ((ElementImpl *)impl)->getAttribute("borderRightColor");
993 }
994 
995 void CSS2Properties::setBorderRightColor(const DOMString &value)
996 {
997  if (impl) {
998  ((ElementImpl *)impl)->setAttribute("borderRightColor", value);
999  }
1000 }
1001 
1002 DOMString CSS2Properties::borderBottomColor() const
1003 {
1004  if (!impl) {
1005  return 0;
1006  }
1007  return ((ElementImpl *)impl)->getAttribute("borderBottomColor");
1008 }
1009 
1010 void CSS2Properties::setBorderBottomColor(const DOMString &value)
1011 {
1012  if (impl) {
1013  ((ElementImpl *)impl)->setAttribute("borderBottomColor", value);
1014  }
1015 }
1016 
1017 DOMString CSS2Properties::borderLeftColor() const
1018 {
1019  if (!impl) {
1020  return 0;
1021  }
1022  return ((ElementImpl *)impl)->getAttribute("borderLeftColor");
1023 }
1024 
1025 void CSS2Properties::setBorderLeftColor(const DOMString &value)
1026 {
1027  if (impl) {
1028  ((ElementImpl *)impl)->setAttribute("borderLeftColor", value);
1029  }
1030 }
1031 
1032 DOMString CSS2Properties::borderTopStyle() const
1033 {
1034  if (!impl) {
1035  return 0;
1036  }
1037  return ((ElementImpl *)impl)->getAttribute("borderTopStyle");
1038 }
1039 
1040 void CSS2Properties::setBorderTopStyle(const DOMString &value)
1041 {
1042  if (impl) {
1043  ((ElementImpl *)impl)->setAttribute("borderTopStyle", value);
1044  }
1045 }
1046 
1047 DOMString CSS2Properties::borderRightStyle() const
1048 {
1049  if (!impl) {
1050  return 0;
1051  }
1052  return ((ElementImpl *)impl)->getAttribute("borderRightStyle");
1053 }
1054 
1055 void CSS2Properties::setBorderRightStyle(const DOMString &value)
1056 {
1057  if (impl) {
1058  ((ElementImpl *)impl)->setAttribute("borderRightStyle", value);
1059  }
1060 }
1061 
1062 DOMString CSS2Properties::borderBottomStyle() const
1063 {
1064  if (!impl) {
1065  return 0;
1066  }
1067  return ((ElementImpl *)impl)->getAttribute("borderBottomStyle");
1068 }
1069 
1070 void CSS2Properties::setBorderBottomStyle(const DOMString &value)
1071 {
1072  if (impl) {
1073  ((ElementImpl *)impl)->setAttribute("borderBottomStyle", value);
1074  }
1075 }
1076 
1077 DOMString CSS2Properties::borderLeftStyle() const
1078 {
1079  if (!impl) {
1080  return 0;
1081  }
1082  return ((ElementImpl *)impl)->getAttribute("borderLeftStyle");
1083 }
1084 
1085 void CSS2Properties::setBorderLeftStyle(const DOMString &value)
1086 {
1087  if (impl) {
1088  ((ElementImpl *)impl)->setAttribute("borderLeftStyle", value);
1089  }
1090 }
1091 
1092 DOMString CSS2Properties::borderTopWidth() const
1093 {
1094  if (!impl) {
1095  return 0;
1096  }
1097  return ((ElementImpl *)impl)->getAttribute("borderTopWidth");
1098 }
1099 
1100 void CSS2Properties::setBorderTopWidth(const DOMString &value)
1101 {
1102  if (impl) {
1103  ((ElementImpl *)impl)->setAttribute("borderTopWidth", value);
1104  }
1105 }
1106 
1107 DOMString CSS2Properties::borderRightWidth() const
1108 {
1109  if (!impl) {
1110  return 0;
1111  }
1112  return ((ElementImpl *)impl)->getAttribute("borderRightWidth");
1113 }
1114 
1115 void CSS2Properties::setBorderRightWidth(const DOMString &value)
1116 {
1117  if (impl) {
1118  ((ElementImpl *)impl)->setAttribute("borderRightWidth", value);
1119  }
1120 }
1121 
1122 DOMString CSS2Properties::borderBottomWidth() const
1123 {
1124  if (!impl) {
1125  return 0;
1126  }
1127  return ((ElementImpl *)impl)->getAttribute("borderBottomWidth");
1128 }
1129 
1130 void CSS2Properties::setBorderBottomWidth(const DOMString &value)
1131 {
1132  if (impl) {
1133  ((ElementImpl *)impl)->setAttribute("borderBottomWidth", value);
1134  }
1135 }
1136 
1137 DOMString CSS2Properties::borderLeftWidth() const
1138 {
1139  if (!impl) {
1140  return 0;
1141  }
1142  return ((ElementImpl *)impl)->getAttribute("borderLeftWidth");
1143 }
1144 
1145 void CSS2Properties::setBorderLeftWidth(const DOMString &value)
1146 {
1147  if (impl) {
1148  ((ElementImpl *)impl)->setAttribute("borderLeftWidth", value);
1149  }
1150 }
1151 
1152 DOMString CSS2Properties::borderWidth() const
1153 {
1154  if (!impl) {
1155  return 0;
1156  }
1157  return ((ElementImpl *)impl)->getAttribute("borderWidth");
1158 }
1159 
1160 void CSS2Properties::setBorderWidth(const DOMString &value)
1161 {
1162  if (impl) {
1163  ((ElementImpl *)impl)->setAttribute("borderWidth", value);
1164  }
1165 }
1166 
1167 DOMString CSS2Properties::bottom() const
1168 {
1169  if (!impl) {
1170  return 0;
1171  }
1172  return ((ElementImpl *)impl)->getAttribute("bottom");
1173 }
1174 
1175 void CSS2Properties::setBottom(const DOMString &value)
1176 {
1177  if (impl) {
1178  ((ElementImpl *)impl)->setAttribute("bottom", value);
1179  }
1180 }
1181 
1182 DOMString CSS2Properties::captionSide() const
1183 {
1184  if (!impl) {
1185  return 0;
1186  }
1187  return ((ElementImpl *)impl)->getAttribute("captionSide");
1188 }
1189 
1190 void CSS2Properties::setCaptionSide(const DOMString &value)
1191 {
1192  if (impl) {
1193  ((ElementImpl *)impl)->setAttribute("captionSide", value);
1194  }
1195 }
1196 
1197 DOMString CSS2Properties::clear() const
1198 {
1199  if (!impl) {
1200  return 0;
1201  }
1202  return ((ElementImpl *)impl)->getAttribute("clear");
1203 }
1204 
1205 void CSS2Properties::setClear(const DOMString &value)
1206 {
1207  if (impl) {
1208  ((ElementImpl *)impl)->setAttribute("clear", value);
1209  }
1210 }
1211 
1212 DOMString CSS2Properties::clip() const
1213 {
1214  if (!impl) {
1215  return 0;
1216  }
1217  return ((ElementImpl *)impl)->getAttribute("clip");
1218 }
1219 
1220 void CSS2Properties::setClip(const DOMString &value)
1221 {
1222  if (impl) {
1223  ((ElementImpl *)impl)->setAttribute("clip", value);
1224  }
1225 }
1226 
1227 DOMString CSS2Properties::color() const
1228 {
1229  if (!impl) {
1230  return 0;
1231  }
1232  return ((ElementImpl *)impl)->getAttribute("color");
1233 }
1234 
1235 void CSS2Properties::setColor(const DOMString &value)
1236 {
1237  if (impl) {
1238  ((ElementImpl *)impl)->setAttribute("color", value);
1239  }
1240 }
1241 
1242 DOMString CSS2Properties::content() const
1243 {
1244  if (!impl) {
1245  return 0;
1246  }
1247  return ((ElementImpl *)impl)->getAttribute("content");
1248 }
1249 
1250 void CSS2Properties::setContent(const DOMString &value)
1251 {
1252  if (impl) {
1253  ((ElementImpl *)impl)->setAttribute("content", value);
1254  }
1255 }
1256 
1257 DOMString CSS2Properties::counterIncrement() const
1258 {
1259  if (!impl) {
1260  return 0;
1261  }
1262  return ((ElementImpl *)impl)->getAttribute("counterIncrement");
1263 }
1264 
1265 void CSS2Properties::setCounterIncrement(const DOMString &value)
1266 {
1267  if (impl) {
1268  ((ElementImpl *)impl)->setAttribute("counterIncrement", value);
1269  }
1270 }
1271 
1272 DOMString CSS2Properties::counterReset() const
1273 {
1274  if (!impl) {
1275  return 0;
1276  }
1277  return ((ElementImpl *)impl)->getAttribute("counterReset");
1278 }
1279 
1280 void CSS2Properties::setCounterReset(const DOMString &value)
1281 {
1282  if (impl) {
1283  ((ElementImpl *)impl)->setAttribute("counterReset", value);
1284  }
1285 }
1286 
1287 DOMString CSS2Properties::cue() const
1288 {
1289  if (!impl) {
1290  return 0;
1291  }
1292  return ((ElementImpl *)impl)->getAttribute("cue");
1293 }
1294 
1295 void CSS2Properties::setCue(const DOMString &value)
1296 {
1297  if (impl) {
1298  ((ElementImpl *)impl)->setAttribute("cue", value);
1299  }
1300 }
1301 
1302 DOMString CSS2Properties::cueAfter() const
1303 {
1304  if (!impl) {
1305  return 0;
1306  }
1307  return ((ElementImpl *)impl)->getAttribute("cueAfter");
1308 }
1309 
1310 void CSS2Properties::setCueAfter(const DOMString &value)
1311 {
1312  if (impl) {
1313  ((ElementImpl *)impl)->setAttribute("cueAfter", value);
1314  }
1315 }
1316 
1317 DOMString CSS2Properties::cueBefore() const
1318 {
1319  if (!impl) {
1320  return 0;
1321  }
1322  return ((ElementImpl *)impl)->getAttribute("cueBefore");
1323 }
1324 
1325 void CSS2Properties::setCueBefore(const DOMString &value)
1326 {
1327  if (impl) {
1328  ((ElementImpl *)impl)->setAttribute("cueBefore", value);
1329  }
1330 }
1331 
1332 DOMString CSS2Properties::cursor() const
1333 {
1334  if (!impl) {
1335  return 0;
1336  }
1337  return ((ElementImpl *)impl)->getAttribute("cursor");
1338 }
1339 
1340 void CSS2Properties::setCursor(const DOMString &value)
1341 {
1342  if (impl) {
1343  ((ElementImpl *)impl)->setAttribute("cursor", value);
1344  }
1345 }
1346 
1347 DOMString CSS2Properties::direction() const
1348 {
1349  if (!impl) {
1350  return 0;
1351  }
1352  return ((ElementImpl *)impl)->getAttribute("direction");
1353 }
1354 
1355 void CSS2Properties::setDirection(const DOMString &value)
1356 {
1357  if (impl) {
1358  ((ElementImpl *)impl)->setAttribute("direction", value);
1359  }
1360 }
1361 
1362 DOMString CSS2Properties::display() const
1363 {
1364  if (!impl) {
1365  return 0;
1366  }
1367  return ((ElementImpl *)impl)->getAttribute("display");
1368 }
1369 
1370 void CSS2Properties::setDisplay(const DOMString &value)
1371 {
1372  if (impl) {
1373  ((ElementImpl *)impl)->setAttribute("display", value);
1374  }
1375 }
1376 
1377 DOMString CSS2Properties::elevation() const
1378 {
1379  if (!impl) {
1380  return 0;
1381  }
1382  return ((ElementImpl *)impl)->getAttribute("elevation");
1383 }
1384 
1385 void CSS2Properties::setElevation(const DOMString &value)
1386 {
1387  if (impl) {
1388  ((ElementImpl *)impl)->setAttribute("elevation", value);
1389  }
1390 }
1391 
1392 DOMString CSS2Properties::emptyCells() const
1393 {
1394  if (!impl) {
1395  return 0;
1396  }
1397  return ((ElementImpl *)impl)->getAttribute("emptyCells");
1398 }
1399 
1400 void CSS2Properties::setEmptyCells(const DOMString &value)
1401 {
1402  if (impl) {
1403  ((ElementImpl *)impl)->setAttribute("emptyCells", value);
1404  }
1405 }
1406 
1407 DOMString CSS2Properties::cssFloat() const
1408 {
1409  if (!impl) {
1410  return 0;
1411  }
1412  return ((ElementImpl *)impl)->getAttribute("cssFloat");
1413 }
1414 
1415 void CSS2Properties::setCssFloat(const DOMString &value)
1416 {
1417  if (impl) {
1418  ((ElementImpl *)impl)->setAttribute("cssFloat", value);
1419  }
1420 }
1421 
1422 DOMString CSS2Properties::font() const
1423 {
1424  if (!impl) {
1425  return 0;
1426  }
1427  return ((ElementImpl *)impl)->getAttribute("font");
1428 }
1429 
1430 void CSS2Properties::setFont(const DOMString &value)
1431 {
1432  if (impl) {
1433  ((ElementImpl *)impl)->setAttribute("font", value);
1434  }
1435 }
1436 
1437 DOMString CSS2Properties::fontFamily() const
1438 {
1439  if (!impl) {
1440  return 0;
1441  }
1442  return ((ElementImpl *)impl)->getAttribute("fontFamily");
1443 }
1444 
1445 void CSS2Properties::setFontFamily(const DOMString &value)
1446 {
1447  if (impl) {
1448  ((ElementImpl *)impl)->setAttribute("fontFamily", value);
1449  }
1450 }
1451 
1452 DOMString CSS2Properties::fontSize() const
1453 {
1454  if (!impl) {
1455  return 0;
1456  }
1457  return ((ElementImpl *)impl)->getAttribute("fontSize");
1458 }
1459 
1460 void CSS2Properties::setFontSize(const DOMString &value)
1461 {
1462  if (impl) {
1463  ((ElementImpl *)impl)->setAttribute("fontSize", value);
1464  }
1465 }
1466 
1467 DOMString CSS2Properties::fontSizeAdjust() const
1468 {
1469  if (!impl) {
1470  return 0;
1471  }
1472  return ((ElementImpl *)impl)->getAttribute("fontSizeAdjust");
1473 }
1474 
1475 void CSS2Properties::setFontSizeAdjust(const DOMString &value)
1476 {
1477  if (impl) {
1478  ((ElementImpl *)impl)->setAttribute("fontSizeAdjust", value);
1479  }
1480 }
1481 
1482 DOMString CSS2Properties::fontStretch() const
1483 {
1484  if (!impl) {
1485  return 0;
1486  }
1487  return ((ElementImpl *)impl)->getAttribute("fontStretch");
1488 }
1489 
1490 void CSS2Properties::setFontStretch(const DOMString &value)
1491 {
1492  if (impl) {
1493  ((ElementImpl *)impl)->setAttribute("fontStretch", value);
1494  }
1495 }
1496 
1497 DOMString CSS2Properties::fontStyle() const
1498 {
1499  if (!impl) {
1500  return 0;
1501  }
1502  return ((ElementImpl *)impl)->getAttribute("fontStyle");
1503 }
1504 
1505 void CSS2Properties::setFontStyle(const DOMString &value)
1506 {
1507  if (impl) {
1508  ((ElementImpl *)impl)->setAttribute("fontStyle", value);
1509  }
1510 }
1511 
1512 DOMString CSS2Properties::fontVariant() const
1513 {
1514  if (!impl) {
1515  return 0;
1516  }
1517  return ((ElementImpl *)impl)->getAttribute("fontVariant");
1518 }
1519 
1520 void CSS2Properties::setFontVariant(const DOMString &value)
1521 {
1522  if (impl) {
1523  ((ElementImpl *)impl)->setAttribute("fontVariant", value);
1524  }
1525 }
1526 
1527 DOMString CSS2Properties::fontWeight() const
1528 {
1529  if (!impl) {
1530  return 0;
1531  }
1532  return ((ElementImpl *)impl)->getAttribute("fontWeight");
1533 }
1534 
1535 void CSS2Properties::setFontWeight(const DOMString &value)
1536 {
1537  if (impl) {
1538  ((ElementImpl *)impl)->setAttribute("fontWeight", value);
1539  }
1540 }
1541 
1542 DOMString CSS2Properties::height() const
1543 {
1544  if (!impl) {
1545  return 0;
1546  }
1547  return ((ElementImpl *)impl)->getAttribute("height");
1548 }
1549 
1550 void CSS2Properties::setHeight(const DOMString &value)
1551 {
1552  if (impl) {
1553  ((ElementImpl *)impl)->setAttribute("height", value);
1554  }
1555 }
1556 
1557 DOMString CSS2Properties::left() const
1558 {
1559  if (!impl) {
1560  return 0;
1561  }
1562  return ((ElementImpl *)impl)->getAttribute("left");
1563 }
1564 
1565 void CSS2Properties::setLeft(const DOMString &value)
1566 {
1567  if (impl) {
1568  ((ElementImpl *)impl)->setAttribute("left", value);
1569  }
1570 }
1571 
1572 DOMString CSS2Properties::letterSpacing() const
1573 {
1574  if (!impl) {
1575  return 0;
1576  }
1577  return ((ElementImpl *)impl)->getAttribute("letterSpacing");
1578 }
1579 
1580 void CSS2Properties::setLetterSpacing(const DOMString &value)
1581 {
1582  if (impl) {
1583  ((ElementImpl *)impl)->setAttribute("letterSpacing", value);
1584  }
1585 }
1586 
1587 DOMString CSS2Properties::lineHeight() const
1588 {
1589  if (!impl) {
1590  return 0;
1591  }
1592  return ((ElementImpl *)impl)->getAttribute("lineHeight");
1593 }
1594 
1595 void CSS2Properties::setLineHeight(const DOMString &value)
1596 {
1597  if (impl) {
1598  ((ElementImpl *)impl)->setAttribute("lineHeight", value);
1599  }
1600 }
1601 
1602 DOMString CSS2Properties::listStyle() const
1603 {
1604  if (!impl) {
1605  return 0;
1606  }
1607  return ((ElementImpl *)impl)->getAttribute("listStyle");
1608 }
1609 
1610 void CSS2Properties::setListStyle(const DOMString &value)
1611 {
1612  if (impl) {
1613  ((ElementImpl *)impl)->setAttribute("listStyle", value);
1614  }
1615 }
1616 
1617 DOMString CSS2Properties::listStyleImage() const
1618 {
1619  if (!impl) {
1620  return 0;
1621  }
1622  return ((ElementImpl *)impl)->getAttribute("listStyleImage");
1623 }
1624 
1625 void CSS2Properties::setListStyleImage(const DOMString &value)
1626 {
1627  if (impl) {
1628  ((ElementImpl *)impl)->setAttribute("listStyleImage", value);
1629  }
1630 }
1631 
1632 DOMString CSS2Properties::listStylePosition() const
1633 {
1634  if (!impl) {
1635  return 0;
1636  }
1637  return ((ElementImpl *)impl)->getAttribute("listStylePosition");
1638 }
1639 
1640 void CSS2Properties::setListStylePosition(const DOMString &value)
1641 {
1642  if (impl) {
1643  ((ElementImpl *)impl)->setAttribute("listStylePosition", value);
1644  }
1645 }
1646 
1647 DOMString CSS2Properties::listStyleType() const
1648 {
1649  if (!impl) {
1650  return 0;
1651  }
1652  return ((ElementImpl *)impl)->getAttribute("listStyleType");
1653 }
1654 
1655 void CSS2Properties::setListStyleType(const DOMString &value)
1656 {
1657  if (impl) {
1658  ((ElementImpl *)impl)->setAttribute("listStyleType", value);
1659  }
1660 }
1661 
1662 DOMString CSS2Properties::margin() const
1663 {
1664  if (!impl) {
1665  return 0;
1666  }
1667  return ((ElementImpl *)impl)->getAttribute("margin");
1668 }
1669 
1670 void CSS2Properties::setMargin(const DOMString &value)
1671 {
1672  if (impl) {
1673  ((ElementImpl *)impl)->setAttribute("margin", value);
1674  }
1675 }
1676 
1677 DOMString CSS2Properties::marginTop() const
1678 {
1679  if (!impl) {
1680  return 0;
1681  }
1682  return ((ElementImpl *)impl)->getAttribute("marginTop");
1683 }
1684 
1685 void CSS2Properties::setMarginTop(const DOMString &value)
1686 {
1687  if (impl) {
1688  ((ElementImpl *)impl)->setAttribute("marginTop", value);
1689  }
1690 }
1691 
1692 DOMString CSS2Properties::marginRight() const
1693 {
1694  if (!impl) {
1695  return 0;
1696  }
1697  return ((ElementImpl *)impl)->getAttribute("marginRight");
1698 }
1699 
1700 void CSS2Properties::setMarginRight(const DOMString &value)
1701 {
1702  if (impl) {
1703  ((ElementImpl *)impl)->setAttribute("marginRight", value);
1704  }
1705 }
1706 
1707 DOMString CSS2Properties::marginBottom() const
1708 {
1709  if (!impl) {
1710  return 0;
1711  }
1712  return ((ElementImpl *)impl)->getAttribute("marginBottom");
1713 }
1714 
1715 void CSS2Properties::setMarginBottom(const DOMString &value)
1716 {
1717  if (impl) {
1718  ((ElementImpl *)impl)->setAttribute("marginBottom", value);
1719  }
1720 }
1721 
1722 DOMString CSS2Properties::marginLeft() const
1723 {
1724  if (!impl) {
1725  return 0;
1726  }
1727  return ((ElementImpl *)impl)->getAttribute("marginLeft");
1728 }
1729 
1730 void CSS2Properties::setMarginLeft(const DOMString &value)
1731 {
1732  if (impl) {
1733  ((ElementImpl *)impl)->setAttribute("marginLeft", value);
1734  }
1735 }
1736 
1737 DOMString CSS2Properties::markerOffset() const
1738 {
1739  if (!impl) {
1740  return 0;
1741  }
1742  return ((ElementImpl *)impl)->getAttribute("markerOffset");
1743 }
1744 
1745 void CSS2Properties::setMarkerOffset(const DOMString &value)
1746 {
1747  if (impl) {
1748  ((ElementImpl *)impl)->setAttribute("markerOffset", value);
1749  }
1750 }
1751 
1752 DOMString CSS2Properties::marks() const
1753 {
1754  if (!impl) {
1755  return 0;
1756  }
1757  return ((ElementImpl *)impl)->getAttribute("marks");
1758 }
1759 
1760 void CSS2Properties::setMarks(const DOMString &value)
1761 {
1762  if (impl) {
1763  ((ElementImpl *)impl)->setAttribute("marks", value);
1764  }
1765 }
1766 
1767 DOMString CSS2Properties::maxHeight() const
1768 {
1769  if (!impl) {
1770  return 0;
1771  }
1772  return ((ElementImpl *)impl)->getAttribute("maxHeight");
1773 }
1774 
1775 void CSS2Properties::setMaxHeight(const DOMString &value)
1776 {
1777  if (impl) {
1778  ((ElementImpl *)impl)->setAttribute("maxHeight", value);
1779  }
1780 }
1781 
1782 DOMString CSS2Properties::maxWidth() const
1783 {
1784  if (!impl) {
1785  return 0;
1786  }
1787  return ((ElementImpl *)impl)->getAttribute("maxWidth");
1788 }
1789 
1790 void CSS2Properties::setMaxWidth(const DOMString &value)
1791 {
1792  if (impl) {
1793  ((ElementImpl *)impl)->setAttribute("maxWidth", value);
1794  }
1795 }
1796 
1797 DOMString CSS2Properties::minHeight() const
1798 {
1799  if (!impl) {
1800  return 0;
1801  }
1802  return ((ElementImpl *)impl)->getAttribute("minHeight");
1803 }
1804 
1805 void CSS2Properties::setMinHeight(const DOMString &value)
1806 {
1807  if (impl) {
1808  ((ElementImpl *)impl)->setAttribute("minHeight", value);
1809  }
1810 }
1811 
1812 DOMString CSS2Properties::minWidth() const
1813 {
1814  if (!impl) {
1815  return 0;
1816  }
1817  return ((ElementImpl *)impl)->getAttribute("minWidth");
1818 }
1819 
1820 void CSS2Properties::setMinWidth(const DOMString &value)
1821 {
1822  if (impl) {
1823  ((ElementImpl *)impl)->setAttribute("minWidth", value);
1824  }
1825 }
1826 
1827 DOMString CSS2Properties::orphans() const
1828 {
1829  if (!impl) {
1830  return 0;
1831  }
1832  return ((ElementImpl *)impl)->getAttribute("orphans");
1833 }
1834 
1835 void CSS2Properties::setOrphans(const DOMString &value)
1836 {
1837  if (impl) {
1838  ((ElementImpl *)impl)->setAttribute("orphans", value);
1839  }
1840 }
1841 
1842 DOMString CSS2Properties::outline() const
1843 {
1844  if (!impl) {
1845  return 0;
1846  }
1847  return ((ElementImpl *)impl)->getAttribute("outline");
1848 }
1849 
1850 void CSS2Properties::setOutline(const DOMString &value)
1851 {
1852  if (impl) {
1853  ((ElementImpl *)impl)->setAttribute("outline", value);
1854  }
1855 }
1856 
1857 DOMString CSS2Properties::outlineColor() const
1858 {
1859  if (!impl) {
1860  return 0;
1861  }
1862  return ((ElementImpl *)impl)->getAttribute("outlineColor");
1863 }
1864 
1865 void CSS2Properties::setOutlineColor(const DOMString &value)
1866 {
1867  if (impl) {
1868  ((ElementImpl *)impl)->setAttribute("outlineColor", value);
1869  }
1870 }
1871 
1872 DOMString CSS2Properties::outlineStyle() const
1873 {
1874  if (!impl) {
1875  return 0;
1876  }
1877  return ((ElementImpl *)impl)->getAttribute("outlineStyle");
1878 }
1879 
1880 void CSS2Properties::setOutlineStyle(const DOMString &value)
1881 {
1882  if (impl) {
1883  ((ElementImpl *)impl)->setAttribute("outlineStyle", value);
1884  }
1885 }
1886 
1887 DOMString CSS2Properties::outlineWidth() const
1888 {
1889  if (!impl) {
1890  return 0;
1891  }
1892  return ((ElementImpl *)impl)->getAttribute("outlineWidth");
1893 }
1894 
1895 void CSS2Properties::setOutlineWidth(const DOMString &value)
1896 {
1897  if (impl) {
1898  ((ElementImpl *)impl)->setAttribute("outlineWidth", value);
1899  }
1900 }
1901 
1902 DOMString CSS2Properties::overflow() const
1903 {
1904  if (!impl) {
1905  return 0;
1906  }
1907  return ((ElementImpl *)impl)->getAttribute("overflow");
1908 }
1909 
1910 void CSS2Properties::setOverflow(const DOMString &value)
1911 {
1912  if (impl) {
1913  ((ElementImpl *)impl)->setAttribute("overflow", value);
1914  }
1915 }
1916 
1917 DOMString CSS2Properties::padding() const
1918 {
1919  if (!impl) {
1920  return 0;
1921  }
1922  return ((ElementImpl *)impl)->getAttribute("padding");
1923 }
1924 
1925 void CSS2Properties::setPadding(const DOMString &value)
1926 {
1927  if (impl) {
1928  ((ElementImpl *)impl)->setAttribute("padding", value);
1929  }
1930 }
1931 
1932 DOMString CSS2Properties::paddingTop() const
1933 {
1934  if (!impl) {
1935  return 0;
1936  }
1937  return ((ElementImpl *)impl)->getAttribute("paddingTop");
1938 }
1939 
1940 void CSS2Properties::setPaddingTop(const DOMString &value)
1941 {
1942  if (impl) {
1943  ((ElementImpl *)impl)->setAttribute("paddingTop", value);
1944  }
1945 }
1946 
1947 DOMString CSS2Properties::paddingRight() const
1948 {
1949  if (!impl) {
1950  return 0;
1951  }
1952  return ((ElementImpl *)impl)->getAttribute("paddingRight");
1953 }
1954 
1955 void CSS2Properties::setPaddingRight(const DOMString &value)
1956 {
1957  if (impl) {
1958  ((ElementImpl *)impl)->setAttribute("paddingRight", value);
1959  }
1960 }
1961 
1962 DOMString CSS2Properties::paddingBottom() const
1963 {
1964  if (!impl) {
1965  return 0;
1966  }
1967  return ((ElementImpl *)impl)->getAttribute("paddingBottom");
1968 }
1969 
1970 void CSS2Properties::setPaddingBottom(const DOMString &value)
1971 {
1972  if (impl) {
1973  ((ElementImpl *)impl)->setAttribute("paddingBottom", value);
1974  }
1975 }
1976 
1977 DOMString CSS2Properties::paddingLeft() const
1978 {
1979  if (!impl) {
1980  return 0;
1981  }
1982  return ((ElementImpl *)impl)->getAttribute("paddingLeft");
1983 }
1984 
1985 void CSS2Properties::setPaddingLeft(const DOMString &value)
1986 {
1987  if (impl) {
1988  ((ElementImpl *)impl)->setAttribute("paddingLeft", value);
1989  }
1990 }
1991 
1992 DOMString CSS2Properties::page() const
1993 {
1994  if (!impl) {
1995  return 0;
1996  }
1997  return ((ElementImpl *)impl)->getAttribute("page");
1998 }
1999 
2000 void CSS2Properties::setPage(const DOMString &value)
2001 {
2002  if (impl) {
2003  ((ElementImpl *)impl)->setAttribute("page", value);
2004  }
2005 }
2006 
2007 DOMString CSS2Properties::pageBreakAfter() const
2008 {
2009  if (!impl) {
2010  return 0;
2011  }
2012  return ((ElementImpl *)impl)->getAttribute("pageBreakAfter");
2013 }
2014 
2015 void CSS2Properties::setPageBreakAfter(const DOMString &value)
2016 {
2017  if (impl) {
2018  ((ElementImpl *)impl)->setAttribute("pageBreakAfter", value);
2019  }
2020 }
2021 
2022 DOMString CSS2Properties::pageBreakBefore() const
2023 {
2024  if (!impl) {
2025  return 0;
2026  }
2027  return ((ElementImpl *)impl)->getAttribute("pageBreakBefore");
2028 }
2029 
2030 void CSS2Properties::setPageBreakBefore(const DOMString &value)
2031 {
2032  if (impl) {
2033  ((ElementImpl *)impl)->setAttribute("pageBreakBefore", value);
2034  }
2035 }
2036 
2037 DOMString CSS2Properties::pageBreakInside() const
2038 {
2039  if (!impl) {
2040  return 0;
2041  }
2042  return ((ElementImpl *)impl)->getAttribute("pageBreakInside");
2043 }
2044 
2045 void CSS2Properties::setPageBreakInside(const DOMString &value)
2046 {
2047  if (impl) {
2048  ((ElementImpl *)impl)->setAttribute("pageBreakInside", value);
2049  }
2050 }
2051 
2052 DOMString CSS2Properties::pause() const
2053 {
2054  if (!impl) {
2055  return 0;
2056  }
2057  return ((ElementImpl *)impl)->getAttribute("pause");
2058 }
2059 
2060 void CSS2Properties::setPause(const DOMString &value)
2061 {
2062  if (impl) {
2063  ((ElementImpl *)impl)->setAttribute("pause", value);
2064  }
2065 }
2066 
2067 DOMString CSS2Properties::pauseAfter() const
2068 {
2069  if (!impl) {
2070  return 0;
2071  }
2072  return ((ElementImpl *)impl)->getAttribute("pauseAfter");
2073 }
2074 
2075 void CSS2Properties::setPauseAfter(const DOMString &value)
2076 {
2077  if (impl) {
2078  ((ElementImpl *)impl)->setAttribute("pauseAfter", value);
2079  }
2080 }
2081 
2082 DOMString CSS2Properties::pauseBefore() const
2083 {
2084  if (!impl) {
2085  return 0;
2086  }
2087  return ((ElementImpl *)impl)->getAttribute("pauseBefore");
2088 }
2089 
2090 void CSS2Properties::setPauseBefore(const DOMString &value)
2091 {
2092  if (impl) {
2093  ((ElementImpl *)impl)->setAttribute("pauseBefore", value);
2094  }
2095 }
2096 
2097 DOMString CSS2Properties::pitch() const
2098 {
2099  if (!impl) {
2100  return 0;
2101  }
2102  return ((ElementImpl *)impl)->getAttribute("pitch");
2103 }
2104 
2105 void CSS2Properties::setPitch(const DOMString &value)
2106 {
2107  if (impl) {
2108  ((ElementImpl *)impl)->setAttribute("pitch", value);
2109  }
2110 }
2111 
2112 DOMString CSS2Properties::pitchRange() const
2113 {
2114  if (!impl) {
2115  return 0;
2116  }
2117  return ((ElementImpl *)impl)->getAttribute("pitchRange");
2118 }
2119 
2120 void CSS2Properties::setPitchRange(const DOMString &value)
2121 {
2122  if (impl) {
2123  ((ElementImpl *)impl)->setAttribute("pitchRange", value);
2124  }
2125 }
2126 
2127 DOMString CSS2Properties::playDuring() const
2128 {
2129  if (!impl) {
2130  return 0;
2131  }
2132  return ((ElementImpl *)impl)->getAttribute("playDuring");
2133 }
2134 
2135 void CSS2Properties::setPlayDuring(const DOMString &value)
2136 {
2137  if (impl) {
2138  ((ElementImpl *)impl)->setAttribute("playDuring", value);
2139  }
2140 }
2141 
2142 DOMString CSS2Properties::position() const
2143 {
2144  if (!impl) {
2145  return 0;
2146  }
2147  return ((ElementImpl *)impl)->getAttribute("position");
2148 }
2149 
2150 void CSS2Properties::setPosition(const DOMString &value)
2151 {
2152  if (impl) {
2153  ((ElementImpl *)impl)->setAttribute("position", value);
2154  }
2155 }
2156 
2157 DOMString CSS2Properties::quotes() const
2158 {
2159  if (!impl) {
2160  return 0;
2161  }
2162  return ((ElementImpl *)impl)->getAttribute("quotes");
2163 }
2164 
2165 void CSS2Properties::setQuotes(const DOMString &value)
2166 {
2167  if (impl) {
2168  ((ElementImpl *)impl)->setAttribute("quotes", value);
2169  }
2170 }
2171 
2172 DOMString CSS2Properties::richness() const
2173 {
2174  if (!impl) {
2175  return 0;
2176  }
2177  return ((ElementImpl *)impl)->getAttribute("richness");
2178 }
2179 
2180 void CSS2Properties::setRichness(const DOMString &value)
2181 {
2182  if (impl) {
2183  ((ElementImpl *)impl)->setAttribute("richness", value);
2184  }
2185 }
2186 
2187 DOMString CSS2Properties::right() const
2188 {
2189  if (!impl) {
2190  return 0;
2191  }
2192  return ((ElementImpl *)impl)->getAttribute("right");
2193 }
2194 
2195 void CSS2Properties::setRight(const DOMString &value)
2196 {
2197  if (impl) {
2198  ((ElementImpl *)impl)->setAttribute("right", value);
2199  }
2200 }
2201 
2202 DOMString CSS2Properties::size() const
2203 {
2204  if (!impl) {
2205  return 0;
2206  }
2207  return ((ElementImpl *)impl)->getAttribute("size");
2208 }
2209 
2210 void CSS2Properties::setSize(const DOMString &value)
2211 {
2212  if (impl) {
2213  ((ElementImpl *)impl)->setAttribute("size", value);
2214  }
2215 }
2216 
2217 DOMString CSS2Properties::speak() const
2218 {
2219  if (!impl) {
2220  return 0;
2221  }
2222  return ((ElementImpl *)impl)->getAttribute("speak");
2223 }
2224 
2225 void CSS2Properties::setSpeak(const DOMString &value)
2226 {
2227  if (impl) {
2228  ((ElementImpl *)impl)->setAttribute("speak", value);
2229  }
2230 }
2231 
2232 DOMString CSS2Properties::speakHeader() const
2233 {
2234  if (!impl) {
2235  return 0;
2236  }
2237  return ((ElementImpl *)impl)->getAttribute("speakHeader");
2238 }
2239 
2240 void CSS2Properties::setSpeakHeader(const DOMString &value)
2241 {
2242  if (impl) {
2243  ((ElementImpl *)impl)->setAttribute("speakHeader", value);
2244  }
2245 }
2246 
2247 DOMString CSS2Properties::speakNumeral() const
2248 {
2249  if (!impl) {
2250  return 0;
2251  }
2252  return ((ElementImpl *)impl)->getAttribute("speakNumeral");
2253 }
2254 
2255 void CSS2Properties::setSpeakNumeral(const DOMString &value)
2256 {
2257  if (impl) {
2258  ((ElementImpl *)impl)->setAttribute("speakNumeral", value);
2259  }
2260 }
2261 
2262 DOMString CSS2Properties::speakPunctuation() const
2263 {
2264  if (!impl) {
2265  return 0;
2266  }
2267  return ((ElementImpl *)impl)->getAttribute("speakPunctuation");
2268 }
2269 
2270 void CSS2Properties::setSpeakPunctuation(const DOMString &value)
2271 {
2272  if (impl) {
2273  ((ElementImpl *)impl)->setAttribute("speakPunctuation", value);
2274  }
2275 }
2276 
2277 DOMString CSS2Properties::speechRate() const
2278 {
2279  if (!impl) {
2280  return 0;
2281  }
2282  return ((ElementImpl *)impl)->getAttribute("speechRate");
2283 }
2284 
2285 void CSS2Properties::setSpeechRate(const DOMString &value)
2286 {
2287  if (impl) {
2288  ((ElementImpl *)impl)->setAttribute("speechRate", value);
2289  }
2290 }
2291 
2292 DOMString CSS2Properties::stress() const
2293 {
2294  if (!impl) {
2295  return 0;
2296  }
2297  return ((ElementImpl *)impl)->getAttribute("stress");
2298 }
2299 
2300 void CSS2Properties::setStress(const DOMString &value)
2301 {
2302  if (impl) {
2303  ((ElementImpl *)impl)->setAttribute("stress", value);
2304  }
2305 }
2306 
2307 DOMString CSS2Properties::tableLayout() const
2308 {
2309  if (!impl) {
2310  return 0;
2311  }
2312  return ((ElementImpl *)impl)->getAttribute("tableLayout");
2313 }
2314 
2315 void CSS2Properties::setTableLayout(const DOMString &value)
2316 {
2317  if (impl) {
2318  ((ElementImpl *)impl)->setAttribute("tableLayout", value);
2319  }
2320 }
2321 
2322 DOMString CSS2Properties::textAlign() const
2323 {
2324  if (!impl) {
2325  return 0;
2326  }
2327  return ((ElementImpl *)impl)->getAttribute("textAlign");
2328 }
2329 
2330 void CSS2Properties::setTextAlign(const DOMString &value)
2331 {
2332  if (impl) {
2333  ((ElementImpl *)impl)->setAttribute("textAlign", value);
2334  }
2335 }
2336 
2337 DOMString CSS2Properties::textDecoration() const
2338 {
2339  if (!impl) {
2340  return 0;
2341  }
2342  return ((ElementImpl *)impl)->getAttribute("textDecoration");
2343 }
2344 
2345 void CSS2Properties::setTextDecoration(const DOMString &value)
2346 {
2347  if (impl) {
2348  ((ElementImpl *)impl)->setAttribute("textDecoration", value);
2349  }
2350 }
2351 
2352 DOMString CSS2Properties::textIndent() const
2353 {
2354  if (!impl) {
2355  return 0;
2356  }
2357  return ((ElementImpl *)impl)->getAttribute("textIndent");
2358 }
2359 
2360 void CSS2Properties::setTextIndent(const DOMString &value)
2361 {
2362  if (impl) {
2363  ((ElementImpl *)impl)->setAttribute("textIndent", value);
2364  }
2365 }
2366 
2367 DOMString CSS2Properties::textShadow() const
2368 {
2369  if (!impl) {
2370  return 0;
2371  }
2372  return ((ElementImpl *)impl)->getAttribute("textShadow");
2373 }
2374 
2375 void CSS2Properties::setTextShadow(const DOMString &value)
2376 {
2377  if (impl) {
2378  ((ElementImpl *)impl)->setAttribute("textShadow", value);
2379  }
2380 }
2381 
2382 DOMString CSS2Properties::textTransform() const
2383 {
2384  if (!impl) {
2385  return 0;
2386  }
2387  return ((ElementImpl *)impl)->getAttribute("textTransform");
2388 }
2389 
2390 void CSS2Properties::setTextTransform(const DOMString &value)
2391 {
2392  if (impl) {
2393  ((ElementImpl *)impl)->setAttribute("textTransform", value);
2394  }
2395 }
2396 
2397 DOMString CSS2Properties::top() const
2398 {
2399  if (!impl) {
2400  return 0;
2401  }
2402  return ((ElementImpl *)impl)->getAttribute("top");
2403 }
2404 
2405 void CSS2Properties::setTop(const DOMString &value)
2406 {
2407  if (impl) {
2408  ((ElementImpl *)impl)->setAttribute("top", value);
2409  }
2410 }
2411 
2412 DOMString CSS2Properties::unicodeBidi() const
2413 {
2414  if (!impl) {
2415  return 0;
2416  }
2417  return ((ElementImpl *)impl)->getAttribute("unicodeBidi");
2418 }
2419 
2420 void CSS2Properties::setUnicodeBidi(const DOMString &value)
2421 {
2422  if (impl) {
2423  ((ElementImpl *)impl)->setAttribute("unicodeBidi", value);
2424  }
2425 }
2426 
2427 DOMString CSS2Properties::verticalAlign() const
2428 {
2429  if (!impl) {
2430  return 0;
2431  }
2432  return ((ElementImpl *)impl)->getAttribute("verticalAlign");
2433 }
2434 
2435 void CSS2Properties::setVerticalAlign(const DOMString &value)
2436 {
2437  if (impl) {
2438  ((ElementImpl *)impl)->setAttribute("verticalAlign", value);
2439  }
2440 }
2441 
2442 DOMString CSS2Properties::visibility() const
2443 {
2444  if (!impl) {
2445  return 0;
2446  }
2447  return ((ElementImpl *)impl)->getAttribute("visibility");
2448 }
2449 
2450 void CSS2Properties::setVisibility(const DOMString &value)
2451 {
2452  if (impl) {
2453  ((ElementImpl *)impl)->setAttribute("visibility", value);
2454  }
2455 }
2456 
2457 DOMString CSS2Properties::voiceFamily() const
2458 {
2459  if (!impl) {
2460  return 0;
2461  }
2462  return ((ElementImpl *)impl)->getAttribute("voiceFamily");
2463 }
2464 
2465 void CSS2Properties::setVoiceFamily(const DOMString &value)
2466 {
2467  if (impl) {
2468  ((ElementImpl *)impl)->setAttribute("voiceFamily", value);
2469  }
2470 }
2471 
2472 DOMString CSS2Properties::volume() const
2473 {
2474  if (!impl) {
2475  return 0;
2476  }
2477  return ((ElementImpl *)impl)->getAttribute("volume");
2478 }
2479 
2480 void CSS2Properties::setVolume(const DOMString &value)
2481 {
2482  if (impl) {
2483  ((ElementImpl *)impl)->setAttribute("volume", value);
2484  }
2485 }
2486 
2487 DOMString CSS2Properties::whiteSpace() const
2488 {
2489  if (!impl) {
2490  return 0;
2491  }
2492  return ((ElementImpl *)impl)->getAttribute("whiteSpace");
2493 }
2494 
2495 void CSS2Properties::setWhiteSpace(const DOMString &value)
2496 {
2497  if (impl) {
2498  ((ElementImpl *)impl)->setAttribute("whiteSpace", value);
2499  }
2500 }
2501 
2502 DOMString CSS2Properties::widows() const
2503 {
2504  if (!impl) {
2505  return 0;
2506  }
2507  return ((ElementImpl *)impl)->getAttribute("widows");
2508 }
2509 
2510 void CSS2Properties::setWidows(const DOMString &value)
2511 {
2512  if (impl) {
2513  ((ElementImpl *)impl)->setAttribute("widows", value);
2514  }
2515 }
2516 
2517 DOMString CSS2Properties::width() const
2518 {
2519  if (!impl) {
2520  return 0;
2521  }
2522  return ((ElementImpl *)impl)->getAttribute("width");
2523 }
2524 
2525 void CSS2Properties::setWidth(const DOMString &value)
2526 {
2527  if (impl) {
2528  ((ElementImpl *)impl)->setAttribute("width", value);
2529  }
2530 }
2531 
2532 DOMString CSS2Properties::wordSpacing() const
2533 {
2534  if (!impl) {
2535  return 0;
2536  }
2537  return ((ElementImpl *)impl)->getAttribute("wordSpacing");
2538 }
2539 
2540 void CSS2Properties::setWordSpacing(const DOMString &value)
2541 {
2542  if (impl) {
2543  ((ElementImpl *)impl)->setAttribute("wordSpacing", value);
2544  }
2545 }
2546 
2547 DOMString CSS2Properties::zIndex() const
2548 {
2549  if (!impl) {
2550  return 0;
2551  }
2552  return ((ElementImpl *)impl)->getAttribute("zIndex");
2553 }
2554 
2555 void CSS2Properties::setZIndex(const DOMString &value)
2556 {
2557  if (impl) {
2558  ((ElementImpl *)impl)->setAttribute("zIndex", value);
2559  }
2560 }
2561 
2562 CSS2TextShadow::CSS2TextShadow()
2563 {
2564 }
2565 
2566 CSS2TextShadow::CSS2TextShadow(const CSS2TextShadow &other)
2567 {
2568 }
2569 
2570 CSS2TextShadow::CSS2TextShadow(CSS2TextShadowImpl *impl)
2571 {
2572 }
2573 
2574 CSS2TextShadow &CSS2TextShadow::operator = (const CSS2TextShadow &other)
2575 {
2576  ::operator = (other);
2577  return *this;
2578 }
2579 
2580 CSS2TextShadow::~CSS2TextShadow()
2581 {
2582 }
2583 
2584 CSSValue CSS2TextShadow::color() const
2585 {
2586  if (!impl) {
2587  return 0;
2588  }
2589  return ((CSS2TextShadowImpl *)impl)->color();
2590 }
2591 
2592 CSSValue CSS2TextShadow::horizontal() const
2593 {
2594  if (!impl) {
2595  return 0;
2596  }
2597  return ((CSS2TextShadowImpl *)impl)->horizontal();
2598 }
2599 
2600 CSSValue CSS2TextShadow::vertical() const
2601 {
2602  if (!impl) {
2603  return 0;
2604  }
2605  return ((CSS2TextShadowImpl *)impl)->vertical();
2606 }
2607 
2608 CSSValue CSS2TextShadow::blur() const
2609 {
2610  if (!impl) {
2611  return 0;
2612  }
2613  return ((CSS2TextShadowImpl *)impl)->blur();
2614 }
2615 
The CSS2Cursor interface represents a simple value for the widths CSS Level 2 descriptor.
The CSS2Cursor interface represents the src CSS Level 2 descriptor.
The CSS2CounterReset interface represents a simple value for the counter-reset CSS Level 2 property...
The CSSValueList interface provides the absraction of an ordered collection of CSS values...
Definition: css_value.h:311
The CSS2Properties interface represents a convenience mechanism for retrieving and setting properties...
This class implements the basic string we use in the DOM.
Definition: dom_string.h:44
The CSS2Azimuth interface represents the azimuth CSS Level 2 property.
The CSS2CounterIncrement interface represents a imple value for the counter-increment CSS Level 2 pr...
The CSS2BorderSpacing interface represents the border-spacing CSS Level 2 property.
The CSS2Cursor interface represents the size CSS Level 2 descriptor.
This library provides a full-featured HTML parser and widget.
The CSS2PlayDuring interface represents the play-during CSS Level 2 property.
The CSS2TextShadow interface represents a simple value for the text-shadow CSS Level 2 property...
The CSS2Cursor interface represents the cursor CSS Level 2 property.
The CSSValue interface represents a simple or a complexe value.
Definition: css_value.h:237
The CSS2BackgroundPosition interface represents the background-position CSS Level 2 property...
This file is part of the KDE documentation.
Documentation copyright © 1996-2020 The KDE developers.
Generated on Sat Jul 4 2020 22:46:16 by doxygen 1.8.11 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.