w3c.css.properties.css3.Css3Style Maven / Gradle / Ivy
//
// $Id$
// From Sijtsche de Jong ([email protected])
//
// COPYRIGHT (c) 1995-2000 World Wide Web Consortium, (MIT, INRIA, Keio University)
// Please first read the full copyright statement at
// http://www.w3.org/Consortium/Legal/copyright-software-19980720
package org.w3c.css.properties.css3;
import org.w3c.css.parser.CssSelectors;
import org.w3c.css.properties.atsc.ATSCStyle;
import org.w3c.css.properties.css.CssAlignContent;
import org.w3c.css.properties.css.CssAlignItems;
import org.w3c.css.properties.css.CssAlignSelf;
import org.w3c.css.properties.css.CssAlignmentBaseline;
import org.w3c.css.properties.css.CssAnimation;
import org.w3c.css.properties.css.CssAnimationDelay;
import org.w3c.css.properties.css.CssAnimationDirection;
import org.w3c.css.properties.css.CssAnimationDuration;
import org.w3c.css.properties.css.CssAnimationFillMode;
import org.w3c.css.properties.css.CssAnimationIterationCount;
import org.w3c.css.properties.css.CssAnimationName;
import org.w3c.css.properties.css.CssAnimationPlayState;
import org.w3c.css.properties.css.CssAnimationTimingFunction;
import org.w3c.css.properties.css.CssAppearance;
import org.w3c.css.properties.css.CssBackfaceVisibility;
import org.w3c.css.properties.css.CssBackgroundBlendMode;
import org.w3c.css.properties.css.CssBackgroundClip;
import org.w3c.css.properties.css.CssBackgroundOrigin;
import org.w3c.css.properties.css.CssBackgroundPositionX;
import org.w3c.css.properties.css.CssBackgroundPositionY;
import org.w3c.css.properties.css.CssBackgroundSize;
import org.w3c.css.properties.css.CssBaselineShift;
import org.w3c.css.properties.css.CssBorderImageSource;
import org.w3c.css.properties.css.CssBoxDecorationBreak;
import org.w3c.css.properties.css.CssBoxShadow;
import org.w3c.css.properties.css.CssBoxSizing;
import org.w3c.css.properties.css.CssBoxSuppress;
import org.w3c.css.properties.css.CssBreakAfter;
import org.w3c.css.properties.css.CssBreakBefore;
import org.w3c.css.properties.css.CssBreakInside;
import org.w3c.css.properties.css.CssCaret;
import org.w3c.css.properties.css.CssCaretColor;
import org.w3c.css.properties.css.CssCaretShape;
import org.w3c.css.properties.css.CssColorInterpolationFilters;
import org.w3c.css.properties.css.CssColumnCount;
import org.w3c.css.properties.css.CssColumnFill;
import org.w3c.css.properties.css.CssColumnGap;
import org.w3c.css.properties.css.CssColumnRule;
import org.w3c.css.properties.css.CssColumnRuleColor;
import org.w3c.css.properties.css.CssColumnRuleStyle;
import org.w3c.css.properties.css.CssColumnRuleWidth;
import org.w3c.css.properties.css.CssColumnSpan;
import org.w3c.css.properties.css.CssColumnWidth;
import org.w3c.css.properties.css.CssColumns;
import org.w3c.css.properties.css.CssContain;
import org.w3c.css.properties.css.CssCounterSet;
import org.w3c.css.properties.css.CssDominantBaseline;
import org.w3c.css.properties.css.CssFilter;
import org.w3c.css.properties.css.CssFlex;
import org.w3c.css.properties.css.CssFlexBasis;
import org.w3c.css.properties.css.CssFlexDirection;
import org.w3c.css.properties.css.CssFlexFlow;
import org.w3c.css.properties.css.CssFlexGrow;
import org.w3c.css.properties.css.CssFlexShrink;
import org.w3c.css.properties.css.CssFlexWrap;
import org.w3c.css.properties.css.CssFloatDefer;
import org.w3c.css.properties.css.CssFloatOffset;
import org.w3c.css.properties.css.CssFloatReference;
import org.w3c.css.properties.css.CssFloodColor;
import org.w3c.css.properties.css.CssFloodOpacity;
import org.w3c.css.properties.css.CssFontFeatureSettings;
import org.w3c.css.properties.css.CssFontKerning;
import org.w3c.css.properties.css.CssFontLanguageOverride;
import org.w3c.css.properties.css.CssFontSynthesis;
import org.w3c.css.properties.css.CssFontVariantAlternates;
import org.w3c.css.properties.css.CssFontVariantCaps;
import org.w3c.css.properties.css.CssFontVariantEastAsian;
import org.w3c.css.properties.css.CssFontVariantLigatures;
import org.w3c.css.properties.css.CssFontVariantNumeric;
import org.w3c.css.properties.css.CssFontVariantPosition;
import org.w3c.css.properties.css.CssGap;
import org.w3c.css.properties.css.CssGrid;
import org.w3c.css.properties.css.CssGridArea;
import org.w3c.css.properties.css.CssGridAutoColumns;
import org.w3c.css.properties.css.CssGridAutoFlow;
import org.w3c.css.properties.css.CssGridAutoRows;
import org.w3c.css.properties.css.CssGridColumn;
import org.w3c.css.properties.css.CssGridColumnEnd;
import org.w3c.css.properties.css.CssGridColumnGap;
import org.w3c.css.properties.css.CssGridColumnStart;
import org.w3c.css.properties.css.CssGridGap;
import org.w3c.css.properties.css.CssGridRow;
import org.w3c.css.properties.css.CssGridRowEnd;
import org.w3c.css.properties.css.CssGridRowGap;
import org.w3c.css.properties.css.CssGridRowStart;
import org.w3c.css.properties.css.CssGridTemplate;
import org.w3c.css.properties.css.CssGridTemplateAreas;
import org.w3c.css.properties.css.CssGridTemplateColumns;
import org.w3c.css.properties.css.CssGridTemplateRows;
import org.w3c.css.properties.css.CssHangingPunctuation;
import org.w3c.css.properties.css.CssHyphens;
import org.w3c.css.properties.css.CssIcon;
import org.w3c.css.properties.css.CssImageOrientation;
import org.w3c.css.properties.css.CssImageResolution;
import org.w3c.css.properties.css.CssImeMode;
import org.w3c.css.properties.css.CssInitialLetter;
import org.w3c.css.properties.css.CssInitialLetterAlign;
import org.w3c.css.properties.css.CssInitialLetterWrap;
import org.w3c.css.properties.css.CssIsolation;
import org.w3c.css.properties.css.CssJustifyContent;
import org.w3c.css.properties.css.CssJustifyItems;
import org.w3c.css.properties.css.CssJustifySelf;
import org.w3c.css.properties.css.CssLightingColor;
import org.w3c.css.properties.css.CssLineBreak;
import org.w3c.css.properties.css.CssMarkerSide;
import org.w3c.css.properties.css.CssMarqueeDirection;
import org.w3c.css.properties.css.CssMarqueePlayCount;
import org.w3c.css.properties.css.CssMarqueeSpeed;
import org.w3c.css.properties.css.CssMarqueeStyle;
import org.w3c.css.properties.css.CssMixBlendMode;
import org.w3c.css.properties.css.CssNavDown;
import org.w3c.css.properties.css.CssNavLeft;
import org.w3c.css.properties.css.CssNavRight;
import org.w3c.css.properties.css.CssNavUp;
import org.w3c.css.properties.css.CssObjectFit;
import org.w3c.css.properties.css.CssObjectPosition;
import org.w3c.css.properties.css.CssOpacity;
import org.w3c.css.properties.css.CssOrder;
import org.w3c.css.properties.css.CssOutlineOffset;
import org.w3c.css.properties.css.CssOverflowStyle;
import org.w3c.css.properties.css.CssOverflowWrap;
import org.w3c.css.properties.css.CssOverflowX;
import org.w3c.css.properties.css.CssOverflowY;
import org.w3c.css.properties.css.CssPerspective;
import org.w3c.css.properties.css.CssPerspectiveOrigin;
import org.w3c.css.properties.css.CssPlaceContent;
import org.w3c.css.properties.css.CssPlaceItems;
import org.w3c.css.properties.css.CssPlaceSelf;
import org.w3c.css.properties.css.CssResize;
import org.w3c.css.properties.css.CssRest;
import org.w3c.css.properties.css.CssRestAfter;
import org.w3c.css.properties.css.CssRestBefore;
import org.w3c.css.properties.css.CssRowGap;
import org.w3c.css.properties.css.CssRubyAlign;
import org.w3c.css.properties.css.CssRubyMerge;
import org.w3c.css.properties.css.CssRubyPosition;
import org.w3c.css.properties.css.CssScrollBehavior;
import org.w3c.css.properties.css.CssScrollMargin;
import org.w3c.css.properties.css.CssScrollMarginBlock;
import org.w3c.css.properties.css.CssScrollMarginBlockEnd;
import org.w3c.css.properties.css.CssScrollMarginBlockStart;
import org.w3c.css.properties.css.CssScrollMarginBottom;
import org.w3c.css.properties.css.CssScrollMarginInline;
import org.w3c.css.properties.css.CssScrollMarginInlineEnd;
import org.w3c.css.properties.css.CssScrollMarginInlineStart;
import org.w3c.css.properties.css.CssScrollMarginLeft;
import org.w3c.css.properties.css.CssScrollMarginRight;
import org.w3c.css.properties.css.CssScrollMarginTop;
import org.w3c.css.properties.css.CssScrollPadding;
import org.w3c.css.properties.css.CssScrollPaddingBlock;
import org.w3c.css.properties.css.CssScrollPaddingBlockEnd;
import org.w3c.css.properties.css.CssScrollPaddingBlockStart;
import org.w3c.css.properties.css.CssScrollPaddingBottom;
import org.w3c.css.properties.css.CssScrollPaddingInline;
import org.w3c.css.properties.css.CssScrollPaddingInlineEnd;
import org.w3c.css.properties.css.CssScrollPaddingInlineStart;
import org.w3c.css.properties.css.CssScrollPaddingLeft;
import org.w3c.css.properties.css.CssScrollPaddingRight;
import org.w3c.css.properties.css.CssScrollPaddingTop;
import org.w3c.css.properties.css.CssScrollSnapAlign;
import org.w3c.css.properties.css.CssScrollSnapStop;
import org.w3c.css.properties.css.CssScrollSnapType;
import org.w3c.css.properties.css.CssSpeakAs;
import org.w3c.css.properties.css.CssTabSize;
import org.w3c.css.properties.css.CssTextAlignAll;
import org.w3c.css.properties.css.CssTextAlignLast;
import org.w3c.css.properties.css.CssTextCombineUpright;
import org.w3c.css.properties.css.CssTextDecorationColor;
import org.w3c.css.properties.css.CssTextDecorationLine;
import org.w3c.css.properties.css.CssTextDecorationSkip;
import org.w3c.css.properties.css.CssTextDecorationStyle;
import org.w3c.css.properties.css.CssTextEmphasis;
import org.w3c.css.properties.css.CssTextEmphasisColor;
import org.w3c.css.properties.css.CssTextEmphasisPosition;
import org.w3c.css.properties.css.CssTextEmphasisStyle;
import org.w3c.css.properties.css.CssTextJustify;
import org.w3c.css.properties.css.CssTextOrientation;
import org.w3c.css.properties.css.CssTextOverflow;
import org.w3c.css.properties.css.CssTextSizeAdjust;
import org.w3c.css.properties.css.CssTextUnderlinePosition;
import org.w3c.css.properties.css.CssTouchAction;
import org.w3c.css.properties.css.CssTransform;
import org.w3c.css.properties.css.CssTransformBox;
import org.w3c.css.properties.css.CssTransformOrigin;
import org.w3c.css.properties.css.CssTransformStyle;
import org.w3c.css.properties.css.CssTransition;
import org.w3c.css.properties.css.CssTransitionDelay;
import org.w3c.css.properties.css.CssTransitionDuration;
import org.w3c.css.properties.css.CssTransitionProperty;
import org.w3c.css.properties.css.CssTransitionTimingFunction;
import org.w3c.css.properties.css.CssUserSelect;
import org.w3c.css.properties.css.CssVoiceBalance;
import org.w3c.css.properties.css.CssVoiceDuration;
import org.w3c.css.properties.css.CssVoicePitch;
import org.w3c.css.properties.css.CssVoiceRange;
import org.w3c.css.properties.css.CssVoiceRate;
import org.w3c.css.properties.css.CssVoiceStress;
import org.w3c.css.properties.css.CssVoiceVolume;
import org.w3c.css.properties.css.CssWillChange;
import org.w3c.css.properties.css.CssWordBreak;
import org.w3c.css.properties.css.CssWritingMode;
import org.w3c.css.properties.css.counterstyle.CssAdditiveSymbols;
import org.w3c.css.properties.css.counterstyle.CssFallback;
import org.w3c.css.properties.css.counterstyle.CssNegative;
import org.w3c.css.properties.css.counterstyle.CssPad;
import org.w3c.css.properties.css.counterstyle.CssPrefix;
import org.w3c.css.properties.css.counterstyle.CssRange;
import org.w3c.css.properties.css.counterstyle.CssSuffix;
import org.w3c.css.properties.css.counterstyle.CssSymbols;
import org.w3c.css.properties.css.counterstyle.CssSystem;
import org.w3c.css.properties.css.fontface.CssFontDisplay;
import org.w3c.css.properties.css.viewport.CssMaxZoom;
import org.w3c.css.properties.css.viewport.CssMinZoom;
import org.w3c.css.properties.css.viewport.CssOrientation;
import org.w3c.css.properties.css.viewport.CssUserZoom;
import org.w3c.css.properties.css.viewport.CssZoom;
import org.w3c.css.util.ApplContext;
import org.w3c.css.util.Util;
import org.w3c.css.util.Warning;
import org.w3c.css.util.Warnings;
public class Css3Style extends ATSCStyle {
public org.w3c.css.properties.css.counterstyle.CssSpeakAs counterStyleCssSpeakAs;
public CssSystem counterStyleCssSystem;
public CssFallback counterStyleCssFallback;
public CssSymbols counterStyleCssSymbols;
public CssPrefix counterStyleCssPrefix;
public CssSuffix counterStyleCssSuffix;
public CssRange counterStyleCssRange;
public CssPad counterStyleCssPad;
public CssAdditiveSymbols counterStyleCssAdditiveSymbols;
public CssNegative counterStyleCssNegative;
public org.w3c.css.properties.css.page.CssMarks pageCssMarks;
public org.w3c.css.properties.css.viewport.CssMinWidth viewportCssMinWidth;
public org.w3c.css.properties.css.viewport.CssMaxWidth viewportCssMaxWidth;
public org.w3c.css.properties.css.viewport.CssMinHeight viewportCssMinHeight;
public org.w3c.css.properties.css.viewport.CssMaxHeight viewportCssMaxHeight;
public CssZoom viewportCssZoom;
public CssMinZoom viewportCssMinZoom;
public CssMaxZoom viewportCssMaxZoom;
public CssUserZoom viewportCssUserZoom;
public CssOrientation viewportCssOrientation;
public org.w3c.css.properties.css.viewport.CssHeight viewportCssHeight;
public org.w3c.css.properties.css.viewport.CssWidth viewportCssWidth;
public CssBackgroundPositionX cssBackgroundPositionX;
public CssBackgroundPositionY cssBackgroundPositionY;
public CssWritingMode cssWritingMode;
public CssTouchAction cssTouchAction;
public CssAppearance cssAppearance;
public CssUserSelect cssUserSelect;
public CssScrollBehavior cssScrollBehavior;
public CssScrollMarginBlockStart cssScrollMarginBlockStart;
public CssScrollMarginBlockEnd cssScrollMarginBlockEnd;
public CssScrollMarginInlineStart cssScrollMarginInlineStart;
public CssScrollMarginInlineEnd cssScrollMarginInlineEnd;
public CssScrollMarginBlock cssScrollMarginBlock;
public CssScrollMarginInline cssScrollMarginInline;
public CssScrollMarginBottom cssScrollMarginBottom;
public CssScrollMarginLeft cssScrollMarginLeft;
public CssScrollMarginRight cssScrollMarginRight;
public CssScrollMarginTop cssScrollMarginTop;
public CssScrollMargin cssScrollMargin;
public CssScrollPaddingInlineStart cssScrollPaddingInlineStart;
public CssScrollPaddingInlineEnd cssScrollPaddingInlineEnd;
public CssScrollPaddingInline cssScrollPaddingInline;
public CssScrollPaddingBlockStart cssScrollPaddingBlockStart;
public CssScrollPaddingBlockEnd cssScrollPaddingBlockEnd;
public CssScrollPaddingBlock cssScrollPaddingBlock;
public CssScrollPadding cssScrollPadding;
public CssScrollPaddingBottom cssScrollPaddingBottom;
public CssScrollPaddingLeft cssScrollPaddingLeft;
public CssScrollPaddingRight cssScrollPaddingRight;
public CssScrollPaddingTop cssScrollPaddingTop;
public CssScrollSnapStop cssScrollSnapStop;
public CssScrollSnapAlign cssScrollSnapAlign;
public CssScrollSnapType cssScrollSnapType;
public CssMarkerSide cssMarkerSide;
public CssCounterSet cssCounterSet;
public CssGridRowGap cssGridRowGap;
public CssGridColumnGap cssGridColumnGap;
public CssGridGap cssGridGap;
public CssGridRowStart cssGridRowStart;
public CssGridRowEnd cssGridRowEnd;
public CssGridColumnStart cssGridColumnStart;
public CssGridColumnEnd cssGridColumnEnd;
public CssGridColumn cssGridColumn;
public CssGridRow cssGridRow;
public CssGridArea cssGridArea;
public CssGridAutoFlow cssGridAutoFlow;
public CssGridTemplateAreas cssGridTemplateAreas;
public CssGridAutoRows cssGridAutoRows;
public CssGridAutoColumns cssGridAutoColumns;
public CssGridTemplateRows cssGridTemplateRows;
public CssGridTemplateColumns cssGridTemplateColumns;
public CssGridTemplate cssGridTemplate;
public CssGrid cssGrid;
public CssWillChange cssWillChange;
public CssContain cssContain;
public CssMixBlendMode cssMixBlendMode;
public CssIsolation cssIsolation;
public CssBackgroundBlendMode cssBackgroundBlendMode;
public CssVoiceBalance cssVoiceBalance;
public CssVoiceDuration cssVoiceDuration;
public CssVoiceRate cssVoiceRate;
public CssVoiceStress cssVoiceStress;
public CssVoiceVolume cssVoiceVolume;
public CssRestAfter cssRestAfter;
public CssRestBefore cssRestBefore;
public CssRest cssRest;
public CssSpeakAs cssSpeakAs;
public CssVoicePitch cssVoicePitch;
public CssVoiceRange cssVoiceRange;
public CssBoxSuppress cssBoxSuppress;
public CssRubyPosition cssRubyPosition;
public CssRubyAlign cssRubyAlign;
public CssRubyMerge cssRubyMerge;
@Deprecated
CssRubyOverhang cssRubyOverhang;
public CssAlignmentBaseline cssAlignmentBaseline;
public CssBaselineShift cssBaselineShift;
public CssDominantBaseline cssDominantBaseline;
public CssInitialLetter cssInitialLetter;
public CssInitialLetterAlign cssInitialLetterAlign;
public CssInitialLetterWrap cssInitialLetterWrap;
public CssOpacity cssOpacity;
public CssBackgroundClip cssBackgroundClip;
public CssBackgroundSize cssBackgroundSize;
public CssBackgroundOrigin cssBackgroundOrigin;
public CssColumns cssColumns;
public CssColumnCount cssColumnCount;
public CssColumnFill cssColumnFill;
public CssColumnGap cssColumnGap;
public CssColumnRule cssColumnRule;
public CssColumnRuleColor cssColumnRuleColor;
public CssColumnRuleStyle cssColumnRuleStyle;
public CssColumnRuleWidth cssColumnRuleWidth;
public CssColumnSpan cssColumnSpan;
public CssColumnWidth cssColumnWidth;
public CssBreakAfter cssBreakAfter;
public CssBreakBefore cssBreakBefore;
public CssBreakInside cssBreakInside;
public CssBoxShadow cssBoxShadow;
public CssBoxDecorationBreak cssBoxDecorationBreak;
public CssFontKerning cssFontKerning;
public CssFontLanguageOverride cssFontLanguageOverride;
public CssFontVariantCaps cssFontVariantCaps;
public CssFontVariantPosition cssFontVariantPosition;
public CssFontSynthesis cssFontSynthesis;
public CssFontVariantEastAsian cssFontVariantEastAsian;
public CssFontVariantLigatures cssFontVariantLigatures;
public CssFontVariantNumeric cssFontVariantNumeric;
public CssFontFeatureSettings cssFontFeatureSettings;
public CssFontVariantAlternates cssFontVariantAlternates;
public CssOverflowWrap cssOverflowWrap;
public CssWordBreak cssWordBreak;
public CssHyphens cssHyphens;
public CssLineBreak cssLineBreak;
public CssTextAlignAll cssTextAlignAll;
public CssTextAlignLast cssTextAlignLast;
public CssTextJustify cssTextJustify;
public CssTextDecorationColor cssTextDecorationColor;
public CssTextDecorationLine cssTextDecorationLine;
public CssTextDecorationSkip cssTextDecorationSkip;
public CssTextDecorationStyle cssTextDecorationStyle;
public CssTextEmphasis cssTextEmphasis;
public CssTextEmphasisColor cssTextEmphasisColor;
public CssTextEmphasisPosition cssTextEmphasisPosition;
public CssTextEmphasisStyle cssTextEmphasisStyle;
public CssTextSizeAdjust cssTextSizeAdjust;
public CssTextUnderlinePosition cssTextUnderlinePosition;
public CssHangingPunctuation cssHangingPunctuation;
public CssTabSize cssTabSize;
public CssMarqueeDirection cssMarqueeDirection;
public CssMarqueeSpeed cssMarqueeSpeed;
public CssMarqueeStyle cssMarqueeStyle;
public CssMarqueePlayCount cssMarqueePlayCount;
public CssOverflowStyle cssOverflowStyle;
public CssTransition cssTransition;
public CssTransitionDelay cssTransitionDelay;
public CssTransitionDuration cssTransitionDuration;
public CssTransitionProperty cssTransitionProperty;
public CssTransitionTimingFunction cssTransitionTimingFunction;
public CssAnimation cssAnimation;
public CssAnimationDelay cssAnimationDelay;
public CssAnimationDirection cssAnimationDirection;
public CssAnimationDuration cssAnimationDuration;
public CssAnimationFillMode cssAnimationFillMode;
public CssAnimationIterationCount cssAnimationIterationCount;
public CssAnimationName cssAnimationName;
public CssAnimationPlayState cssAnimationPlayState;
public CssAnimationTimingFunction cssAnimationTimingFunction;
public CssAlignContent cssAlignContent;
public CssAlignItems cssAlignItems;
public CssAlignSelf cssAlignSelf;
public CssFlex cssFlex;
public CssFlexBasis cssFlexBasis;
public CssFlexDirection cssFlexDirection;
public CssFlexWrap cssFlexWrap;
public CssFlexFlow cssFlexFlow;
public CssFlexGrow cssFlexGrow;
public CssFlexShrink cssFlexShrink;
public CssJustifyContent cssJustifyContent;
public CssOrder cssOrder;
public CssTransformStyle cssTransformStyle;
public CssBackfaceVisibility cssBackfaceVisibility;
public CssPerspective cssPerspective;
public CssPerspectiveOrigin cssPerspectiveOrigin;
public CssTransformOrigin cssTransformOrigin;
public CssTransform cssTransform;
public CssTransformBox cssTransformBox;
public CssBoxSizing cssBoxSizing;
public CssResize cssResize;
public CssOutlineOffset cssOutlineOffset;
public CssImeMode cssImeMode;
public CssNavUp cssNavUp;
public CssNavRight cssNavRight;
public CssNavDown cssNavDown;
public CssNavLeft cssNavLeft;
public CssTextOverflow cssTextOverflow;
public CssIcon cssIcon;
public CssCaretColor cssCaretColor;
public CssCaretShape cssCaretShape;
public CssCaret cssCaret;
public CssOverflowX cssOverflowX;
public CssOverflowY cssOverflowY;
public CssObjectFit cssObjectFit;
public CssObjectPosition cssObjectPosition;
public CssImageOrientation cssImageOrientation;
public CssImageResolution cssImageResolution;
CssRubySpan cssRubySpan;
public CssFilter cssFilter;
public CssColorInterpolationFilters cssColorInterpolationFilters;
public CssFloodColor cssFloodColor;
public CssFloodOpacity cssFloodOpacity;
public CssLightingColor cssLightingColor;
public CssFloatReference cssFloatReference;
public CssFloatOffset cssFloatOffset;
public CssFloatDefer cssFloatDefer;
public CssTextCombineUpright cssTextCombineUpright;
public CssTextOrientation cssTextOrientation;
public CssRowGap cssRowGap;
public CssGap cssGap;
public CssJustifySelf cssJustifySelf;
public CssPlaceSelf cssPlaceSelf;
public CssPlaceContent cssPlaceContent;
public CssJustifyItems cssJustifyItems;
public CssPlaceItems cssPlaceItems;
public CssFontDisplay fontFaceCssFontDisplay;
public org.w3c.css.properties.css.page.CssMarks getPageCssMarks() {
if (pageCssMarks == null) {
pageCssMarks =
(org.w3c.css.properties.css.page.CssMarks) style.CascadingOrder(new org.w3c.css.properties.css.page.CssMarks(),
style, selector);
}
return pageCssMarks;
}
public CssFontDisplay getFontFaceCssFontDisplay() {
if (fontFaceCssFontDisplay == null) {
fontFaceCssFontDisplay =
(CssFontDisplay) style.CascadingOrder(new CssFontDisplay(),
style, selector);
}
return fontFaceCssFontDisplay;
}
public CssPlaceItems getPlaceItems() {
if (cssPlaceItems == null) {
cssPlaceItems =
(CssPlaceItems) style.CascadingOrder(new CssPlaceItems(),
style, selector);
}
return cssPlaceItems;
}
public CssJustifyItems getJustifyItems() {
if (cssJustifyItems == null) {
cssJustifyItems =
(CssJustifyItems) style.CascadingOrder(new CssJustifyItems(),
style, selector);
}
return cssJustifyItems;
}
public CssPlaceContent getPlaceContent() {
if (cssPlaceContent == null) {
cssPlaceContent =
(CssPlaceContent) style.CascadingOrder(new CssPlaceContent(),
style, selector);
}
return cssPlaceContent;
}
public CssPlaceSelf getPlaceSelf() {
if (cssPlaceSelf == null) {
cssPlaceSelf =
(CssPlaceSelf) style.CascadingOrder(new CssPlaceSelf(),
style, selector);
}
return cssPlaceSelf;
}
public CssJustifySelf getJustifySelf() {
if (cssJustifySelf == null) {
cssJustifySelf =
(CssJustifySelf) style.CascadingOrder(new CssJustifySelf(),
style, selector);
}
return cssJustifySelf;
}
public CssGap getGap() {
if (cssGap == null) {
cssGap =
(CssGap) style.CascadingOrder(new CssGap(),
style, selector);
}
return cssGap;
}
public CssRowGap getRowGap() {
if (cssRowGap == null) {
cssRowGap =
(CssRowGap) style.CascadingOrder(new CssRowGap(),
style, selector);
}
return cssRowGap;
}
public CssTextCombineUpright getTextCombineUpright() {
if (cssTextCombineUpright == null) {
cssTextCombineUpright =
(CssTextCombineUpright) style.CascadingOrder(new CssTextCombineUpright(),
style, selector);
}
return cssTextCombineUpright;
}
public CssTextOrientation getTextOrientation() {
if (cssTextOrientation == null) {
cssTextOrientation =
(CssTextOrientation) style.CascadingOrder(new CssTextOrientation(),
style, selector);
}
return cssTextOrientation;
}
public org.w3c.css.properties.css.viewport.CssWidth getViewportWidth() {
if (viewportCssWidth == null) {
viewportCssWidth =
(org.w3c.css.properties.css.viewport.CssWidth) style.CascadingOrder(new org.w3c.css.properties.css.viewport.CssWidth(),
style, selector);
}
return viewportCssWidth;
}
public org.w3c.css.properties.css.viewport.CssHeight getViewportHeight() {
if (viewportCssHeight == null) {
viewportCssHeight =
(org.w3c.css.properties.css.viewport.CssHeight) style.CascadingOrder(new org.w3c.css.properties.css.viewport.CssHeight(),
style, selector);
}
return viewportCssHeight;
}
public CssOrientation getViewportOrientation() {
if (viewportCssOrientation == null) {
viewportCssOrientation =
(org.w3c.css.properties.css.viewport.CssOrientation) style.CascadingOrder(new CssOrientation(),
style, selector);
}
return viewportCssOrientation;
}
public CssUserZoom getViewportUserZoom() {
if (viewportCssUserZoom == null) {
viewportCssUserZoom =
(org.w3c.css.properties.css.viewport.CssUserZoom) style.CascadingOrder(new CssUserZoom(),
style, selector);
}
return viewportCssUserZoom;
}
public CssMaxZoom getViewportMaxZoom() {
if (viewportCssMaxZoom == null) {
viewportCssMaxZoom =
(org.w3c.css.properties.css.viewport.CssMaxZoom) style.CascadingOrder(new CssMaxZoom(),
style, selector);
}
return viewportCssMaxZoom;
}
public CssMinZoom getViewportMinZoom() {
if (viewportCssMinZoom == null) {
viewportCssMinZoom =
(org.w3c.css.properties.css.viewport.CssMinZoom) style.CascadingOrder(new CssMinZoom(),
style, selector);
}
return viewportCssMinZoom;
}
public CssZoom getViewportZoom() {
if (viewportCssZoom == null) {
viewportCssZoom =
(org.w3c.css.properties.css.viewport.CssZoom) style.CascadingOrder(new CssZoom(),
style, selector);
}
return viewportCssZoom;
}
public org.w3c.css.properties.css.viewport.CssMaxHeight getViewportMaxHeight() {
if (viewportCssMaxHeight == null) {
viewportCssMaxHeight =
(org.w3c.css.properties.css.viewport.CssMaxHeight) style.CascadingOrder(new CssMaxHeight(),
style, selector);
}
return viewportCssMaxHeight;
}
public org.w3c.css.properties.css.viewport.CssMinHeight getViewportMinHeight() {
if (viewportCssMinHeight == null) {
viewportCssMinHeight =
(org.w3c.css.properties.css.viewport.CssMinHeight) style.CascadingOrder(new CssMinHeight(),
style, selector);
}
return viewportCssMinHeight;
}
public org.w3c.css.properties.css.viewport.CssMaxWidth getViewportMaxWidth() {
if (viewportCssMaxWidth == null) {
viewportCssMaxWidth =
(org.w3c.css.properties.css.viewport.CssMaxWidth) style.CascadingOrder(new CssMaxWidth(),
style, selector);
}
return viewportCssMaxWidth;
}
public org.w3c.css.properties.css.viewport.CssMinWidth getViewportMinWidth() {
if (viewportCssMinWidth == null) {
viewportCssMinWidth =
(org.w3c.css.properties.css.viewport.CssMinWidth) style.CascadingOrder(new CssMinWidth(),
style, selector);
}
return viewportCssMinWidth;
}
public CssBackgroundPositionY getBackgroundPositionY() {
if (cssBackgroundPositionY == null) {
cssBackgroundPositionY =
(CssBackgroundPositionY) style.CascadingOrder(new CssBackgroundPositionY(),
style, selector);
}
return cssBackgroundPositionY;
}
public CssBackgroundPositionX getBackgroundPositionX() {
if (cssBackgroundPositionX == null) {
cssBackgroundPositionX =
(CssBackgroundPositionX) style.CascadingOrder(new CssBackgroundPositionX(),
style, selector);
}
return cssBackgroundPositionX;
}
public CssWritingMode getWritingMode() {
if (cssWritingMode == null) {
cssWritingMode =
(CssWritingMode) style.CascadingOrder(new CssWritingMode(),
style, selector);
}
return cssWritingMode;
}
public CssTouchAction getTouchAction() {
if (cssTouchAction == null) {
cssTouchAction =
(CssTouchAction) style.CascadingOrder(new CssTouchAction(),
style, selector);
}
return cssTouchAction;
}
public CssAppearance getAppearance() {
if (cssAppearance == null) {
cssAppearance =
(CssAppearance) style.CascadingOrder(new CssAppearance(),
style, selector);
}
return cssAppearance;
}
public CssUserSelect getUserSelect() {
if (cssUserSelect == null) {
cssUserSelect =
(CssUserSelect) style.CascadingOrder(new CssUserSelect(),
style, selector);
}
return cssUserSelect;
}
public CssScrollBehavior getScrollBehavior() {
if (cssScrollBehavior == null) {
cssScrollBehavior =
(CssScrollBehavior) style.CascadingOrder(new CssScrollBehavior(),
style, selector);
}
return cssScrollBehavior;
}
public org.w3c.css.properties.css.counterstyle.CssSpeakAs getCounterStyleCssSpeakAs() {
if (counterStyleCssSpeakAs == null) {
counterStyleCssSpeakAs = (org.w3c.css.properties.css.counterstyle.CssSpeakAs) style.CascadingOrder(new org.w3c.css.properties.css.counterstyle.CssSpeakAs(), style, selector);
}
return counterStyleCssSpeakAs;
}
public org.w3c.css.properties.css.counterstyle.CssSystem getCounterStyleCssSystem() {
if (counterStyleCssSystem == null) {
counterStyleCssSystem = (org.w3c.css.properties.css.counterstyle.CssSystem) style.CascadingOrder(new org.w3c.css.properties.css.counterstyle.CssSystem(), style, selector);
}
return counterStyleCssSystem;
}
public org.w3c.css.properties.css.counterstyle.CssFallback getCounterStyleCssFallback() {
if (counterStyleCssFallback == null) {
counterStyleCssFallback = (org.w3c.css.properties.css.counterstyle.CssFallback) style.CascadingOrder(new org.w3c.css.properties.css.counterstyle.CssFallback(), style, selector);
}
return counterStyleCssFallback;
}
public org.w3c.css.properties.css.counterstyle.CssSymbols getCounterStyleCssSymbols() {
if (counterStyleCssSymbols == null) {
counterStyleCssSymbols = (org.w3c.css.properties.css.counterstyle.CssSymbols) style.CascadingOrder(new org.w3c.css.properties.css.counterstyle.CssSymbols(), style, selector);
}
return counterStyleCssSymbols;
}
public org.w3c.css.properties.css.counterstyle.CssPrefix getCounterStyleCssPrefix() {
if (counterStyleCssPrefix == null) {
counterStyleCssPrefix = (org.w3c.css.properties.css.counterstyle.CssPrefix) style.CascadingOrder(new org.w3c.css.properties.css.counterstyle.CssPrefix(), style, selector);
}
return counterStyleCssPrefix;
}
public org.w3c.css.properties.css.counterstyle.CssSuffix getCounterStyleCssSuffix() {
if (counterStyleCssSuffix == null) {
counterStyleCssSuffix = (org.w3c.css.properties.css.counterstyle.CssSuffix) style.CascadingOrder(new org.w3c.css.properties.css.counterstyle.CssSuffix(), style, selector);
}
return counterStyleCssSuffix;
}
public org.w3c.css.properties.css.counterstyle.CssRange getCounterStyleCssRange() {
if (counterStyleCssRange == null) {
counterStyleCssRange = (org.w3c.css.properties.css.counterstyle.CssRange) style.CascadingOrder(new org.w3c.css.properties.css.counterstyle.CssRange(), style, selector);
}
return counterStyleCssRange;
}
public org.w3c.css.properties.css.counterstyle.CssPad getCounterStyleCssPad() {
if (counterStyleCssPad == null) {
counterStyleCssPad = (org.w3c.css.properties.css.counterstyle.CssPad) style.CascadingOrder(new org.w3c.css.properties.css.counterstyle.CssPad(), style, selector);
}
return counterStyleCssPad;
}
public org.w3c.css.properties.css.counterstyle.CssAdditiveSymbols getCounterStyleCssAdditiveSymbols() {
if (counterStyleCssAdditiveSymbols == null) {
counterStyleCssAdditiveSymbols = (org.w3c.css.properties.css.counterstyle.CssAdditiveSymbols) style.CascadingOrder(new org.w3c.css.properties.css.counterstyle.CssAdditiveSymbols(), style, selector);
}
return counterStyleCssAdditiveSymbols;
}
public org.w3c.css.properties.css.counterstyle.CssNegative getCounterStyleCssNegative() {
if (counterStyleCssNegative == null) {
counterStyleCssNegative = (org.w3c.css.properties.css.counterstyle.CssNegative) style.CascadingOrder(new org.w3c.css.properties.css.counterstyle.CssNegative(), style, selector);
}
return counterStyleCssNegative;
}
public CssBorderImageSource getBorderImageSource() {
if (cssBorder.borderImage.source == null) {
cssBorder.borderImage.source = (CssBorderImageSource) style.CascadingOrder(new CssBorderImageSource(), style, selector);
}
return cssBorder.borderImage.source;
}
public CssMarkerSide getMarkerSide() {
if (cssMarkerSide == null) {
cssMarkerSide =
(CssMarkerSide) style.CascadingOrder(new CssMarkerSide(),
style, selector);
}
return cssMarkerSide;
}
public CssCounterSet getCounterSet() {
if (cssCounterSet == null) {
cssCounterSet =
(CssCounterSet) style.CascadingOrder(new CssCounterSet(),
style, selector);
}
return cssCounterSet;
}
public CssGridColumnGap getGridColumnGap() {
if (cssGridColumnGap == null) {
cssGridColumnGap =
(CssGridColumnGap) style.CascadingOrder(new CssGridColumnGap(),
style, selector);
}
return cssGridColumnGap;
}
public CssGridGap getGridGap() {
if (cssGridGap == null) {
cssGridGap =
(CssGridGap) style.CascadingOrder(new CssGridGap(),
style, selector);
}
return cssGridGap;
}
public CssGridRowGap getGridRowGap() {
if (cssGridRowGap == null) {
cssGridRowGap =
(CssGridRowGap) style.CascadingOrder(new CssGridRowGap(),
style, selector);
}
return cssGridRowGap;
}
public CssGridRowStart getGridRowStart() {
if (cssGridRowStart == null) {
cssGridRowStart =
(CssGridRowStart) style.CascadingOrder(new CssGridRowStart(),
style, selector);
}
return cssGridRowStart;
}
public CssGridRowEnd getGridRowEnd() {
if (cssGridRowEnd == null) {
cssGridRowEnd =
(CssGridRowEnd) style.CascadingOrder(new CssGridRowEnd(),
style, selector);
}
return cssGridRowEnd;
}
public CssGridColumnStart getGridColumnStart() {
if (cssGridColumnStart == null) {
cssGridColumnStart =
(CssGridColumnStart) style.CascadingOrder(new CssGridColumnStart(),
style, selector);
}
return cssGridColumnStart;
}
public CssGridColumnEnd getGridColumnEnd() {
if (cssGridColumnEnd == null) {
cssGridColumnEnd =
(CssGridColumnEnd) style.CascadingOrder(new CssGridColumnEnd(),
style, selector);
}
return cssGridColumnEnd;
}
public CssGridColumn getGridColumn() {
if (cssGridColumn == null) {
cssGridColumn =
(CssGridColumn) style.CascadingOrder(new CssGridColumn(),
style, selector);
}
return cssGridColumn;
}
public CssGridRow getGridRow() {
if (cssGridRow == null) {
cssGridRow =
(CssGridRow) style.CascadingOrder(new CssGridRow(),
style, selector);
}
return cssGridRow;
}
public CssGridArea getGridArea() {
if (cssGridArea == null) {
cssGridArea =
(CssGridArea) style.CascadingOrder(new CssGridArea(),
style, selector);
}
return cssGridArea;
}
public CssGridTemplateAreas getGridTemplateAreas() {
if (cssGridTemplateAreas == null) {
cssGridTemplateAreas =
(CssGridTemplateAreas) style.CascadingOrder(new CssGridTemplateAreas(),
style, selector);
}
return cssGridTemplateAreas;
}
public CssGridAutoFlow getGridAutoFlow() {
if (cssGridAutoFlow == null) {
cssGridAutoFlow =
(CssGridAutoFlow) style.CascadingOrder(new CssGridAutoFlow(),
style, selector);
}
return cssGridAutoFlow;
}
public CssGridAutoRows getGridAutoRows() {
if (cssGridAutoRows == null) {
cssGridAutoRows =
(CssGridAutoRows) style.CascadingOrder(new CssGridAutoRows(),
style, selector);
}
return cssGridAutoRows;
}
public CssGridAutoColumns getGridAutoColumns() {
if (cssGridAutoColumns == null) {
cssGridAutoColumns =
(CssGridAutoColumns) style.CascadingOrder(new CssGridAutoColumns(),
style, selector);
}
return cssGridAutoColumns;
}
public CssGridTemplateRows getGridTemplateRows() {
if (cssGridTemplateRows == null) {
cssGridTemplateRows =
(CssGridTemplateRows) style.CascadingOrder(new CssGridTemplateRows(),
style, selector);
}
return cssGridTemplateRows;
}
public CssGridTemplateColumns getGridTemplateColumns() {
if (cssGridTemplateColumns == null) {
cssGridTemplateColumns =
(CssGridTemplateColumns) style.CascadingOrder(new CssGridTemplateColumns(),
style, selector);
}
return cssGridTemplateColumns;
}
public CssGridTemplate getGridTemplate() {
if (cssGridTemplate == null) {
cssGridTemplate =
(CssGridTemplate) style.CascadingOrder(new CssGridTemplate(),
style, selector);
}
return cssGridTemplate;
}
public CssGrid getGrid() {
if (cssGrid == null) {
cssGrid =
(CssGrid) style.CascadingOrder(new CssGrid(),
style, selector);
}
return cssGrid;
}
public CssScrollMarginBlockStart getScrollMarginBlockStart() {
if (cssScrollMarginBlockStart == null) {
cssScrollMarginBlockStart =
(CssScrollMarginBlockStart) style.CascadingOrder(new CssScrollMarginBlockStart(),
style, selector);
}
return cssScrollMarginBlockStart;
}
public CssScrollMarginBlockEnd getScrollMarginBlockEnd() {
if (cssScrollMarginBlockEnd == null) {
cssScrollMarginBlockEnd =
(CssScrollMarginBlockEnd) style.CascadingOrder(new CssScrollMarginBlockEnd(),
style, selector);
}
return cssScrollMarginBlockEnd;
}
public CssScrollMarginInlineStart getScrollMarginInlineStart() {
if (cssScrollMarginInlineStart == null) {
cssScrollMarginInlineStart =
(CssScrollMarginInlineStart) style.CascadingOrder(new CssScrollMarginInlineStart(),
style, selector);
}
return cssScrollMarginInlineStart;
}
public CssScrollMarginInlineEnd getScrollMarginInlineEnd() {
if (cssScrollMarginInlineEnd == null) {
cssScrollMarginInlineEnd =
(CssScrollMarginInlineEnd) style.CascadingOrder(new CssScrollMarginInlineEnd(),
style, selector);
}
return cssScrollMarginInlineEnd;
}
public CssScrollMarginBlock getScrollMarginBlock() {
if (cssScrollMarginBlock == null) {
cssScrollMarginBlock =
(CssScrollMarginBlock) style.CascadingOrder(new org.w3c.css.properties.css.CssScrollMarginBlock(),
style, selector);
}
return cssScrollMarginBlock;
}
public CssScrollMarginInline getScrollMarginInline() {
if (cssScrollMarginInline == null) {
cssScrollMarginInline =
(CssScrollMarginInline) style.CascadingOrder(new CssScrollMarginInline(),
style, selector);
}
return cssScrollMarginInline;
}
public CssScrollMarginBottom getScrollMarginBottom() {
if (cssScrollMarginBottom == null) {
cssScrollMarginBottom =
(CssScrollMarginBottom) style.CascadingOrder(new CssScrollMarginBottom(),
style, selector);
}
return cssScrollMarginBottom;
}
public CssScrollMarginLeft getScrollMarginLeft() {
if (cssScrollMarginLeft == null) {
cssScrollMarginLeft =
(CssScrollMarginLeft) style.CascadingOrder(new CssScrollMarginLeft(),
style, selector);
}
return cssScrollMarginLeft;
}
public CssScrollMarginRight getScrollMarginRight() {
if (cssScrollMarginRight == null) {
cssScrollMarginRight =
(CssScrollMarginRight) style.CascadingOrder(new CssScrollMarginRight(),
style, selector);
}
return cssScrollMarginRight;
}
public CssScrollMarginTop getScrollMarginTop() {
if (cssScrollMarginTop == null) {
cssScrollMarginTop =
(CssScrollMarginTop) style.CascadingOrder(new CssScrollMarginTop(),
style, selector);
}
return cssScrollMarginTop;
}
public CssScrollMargin getScrollMargin() {
if (cssScrollMargin == null) {
cssScrollMargin =
(CssScrollMargin) style.CascadingOrder(new CssScrollMargin(),
style, selector);
}
return cssScrollMargin;
}
public CssScrollPaddingInlineStart getScrollPaddingInlineStart() {
if (cssScrollPaddingInlineStart == null) {
cssScrollPaddingInlineStart =
(CssScrollPaddingInlineStart) style.CascadingOrder(new CssScrollPaddingInlineStart(),
style, selector);
}
return cssScrollPaddingInlineStart;
}
public CssScrollPaddingInlineEnd getScrollPaddingInlineEnd() {
if (cssScrollPaddingInlineEnd == null) {
cssScrollPaddingInlineEnd =
(CssScrollPaddingInlineEnd) style.CascadingOrder(new CssScrollPaddingInlineEnd(),
style, selector);
}
return cssScrollPaddingInlineEnd;
}
public CssScrollPaddingInline getScrollPaddingInline() {
if (cssScrollPaddingInline == null) {
cssScrollPaddingInline =
(CssScrollPaddingInline) style.CascadingOrder(new CssScrollPaddingInline(),
style, selector);
}
return cssScrollPaddingInline;
}
public CssScrollPaddingBlockStart getScrollPaddingBlockStart() {
if (cssScrollPaddingBlockStart == null) {
cssScrollPaddingBlockStart =
(CssScrollPaddingBlockStart) style.CascadingOrder(new CssScrollPaddingBlockStart(),
style, selector);
}
return cssScrollPaddingBlockStart;
}
public CssScrollPaddingBlockEnd getScrollPaddingBlockEnd() {
if (cssScrollPaddingBlockEnd == null) {
cssScrollPaddingBlockEnd =
(CssScrollPaddingBlockEnd) style.CascadingOrder(new CssScrollPaddingBlockEnd(),
style, selector);
}
return cssScrollPaddingBlockEnd;
}
public CssScrollPaddingBlock getScrollPaddingBlock() {
if (cssScrollPaddingBlock == null) {
cssScrollPaddingBlock =
(CssScrollPaddingBlock) style.CascadingOrder(new CssScrollPaddingBlock(),
style, selector);
}
return cssScrollPaddingBlock;
}
public CssScrollPadding getScrollPadding() {
if (cssScrollPadding == null) {
cssScrollPadding =
(CssScrollPadding) style.CascadingOrder(new CssScrollPadding(),
style, selector);
}
return cssScrollPadding;
}
public CssScrollPaddingBottom getScrollPaddingBottom() {
if (cssScrollPaddingBottom == null) {
cssScrollPaddingBottom =
(CssScrollPaddingBottom) style.CascadingOrder(new CssScrollPaddingBottom(),
style, selector);
}
return cssScrollPaddingBottom;
}
public CssScrollPaddingLeft getScrollPaddingLeft() {
if (cssScrollPaddingLeft == null) {
cssScrollPaddingLeft =
(CssScrollPaddingLeft) style.CascadingOrder(new CssScrollPaddingLeft(),
style, selector);
}
return cssScrollPaddingLeft;
}
public CssScrollPaddingRight getScrollPaddingRight() {
if (cssScrollPaddingRight == null) {
cssScrollPaddingRight =
(CssScrollPaddingRight) style.CascadingOrder(new CssScrollPaddingRight(),
style, selector);
}
return cssScrollPaddingRight;
}
public CssScrollPaddingTop getScrollPaddingTop() {
if (cssScrollPaddingTop == null) {
cssScrollPaddingTop =
(CssScrollPaddingTop) style.CascadingOrder(new CssScrollPaddingTop(),
style, selector);
}
return cssScrollPaddingTop;
}
public CssScrollSnapStop getScrollSnapStop() {
if (cssScrollSnapStop == null) {
cssScrollSnapStop =
(CssScrollSnapStop) style.CascadingOrder(new CssScrollSnapStop(),
style, selector);
}
return cssScrollSnapStop;
}
public CssScrollSnapAlign getScrollSnapAlign() {
if (cssScrollSnapAlign == null) {
cssScrollSnapAlign =
(CssScrollSnapAlign) style.CascadingOrder(new CssScrollSnapAlign(),
style, selector);
}
return cssScrollSnapAlign;
}
public CssScrollSnapType getScrollSnapType() {
if (cssScrollSnapType == null) {
cssScrollSnapType =
(CssScrollSnapType) style.CascadingOrder(new CssScrollSnapType(),
style, selector);
}
return cssScrollSnapType;
}
public CssWillChange getWillChange() {
if (cssWillChange == null) {
cssWillChange =
(CssWillChange) style.CascadingOrder(new CssWillChange(),
style, selector);
}
return cssWillChange;
}
public CssContain getContain() {
if (cssContain == null) {
cssContain =
(CssContain) style.CascadingOrder(new CssContain(),
style, selector);
}
return cssContain;
}
public CssMixBlendMode getMixBlendMode() {
if (cssMixBlendMode == null) {
cssMixBlendMode =
(CssMixBlendMode) style.CascadingOrder(new CssMixBlendMode(),
style, selector);
}
return cssMixBlendMode;
}
public CssIsolation getIsolation() {
if (cssIsolation == null) {
cssIsolation =
(CssIsolation) style.CascadingOrder(new CssIsolation(),
style, selector);
}
return cssIsolation;
}
public CssBackgroundBlendMode getBackgroundBlendMode() {
if (cssBackgroundBlendMode == null) {
cssBackgroundBlendMode =
(CssBackgroundBlendMode) style.CascadingOrder(new CssBackgroundBlendMode(),
style, selector);
}
return cssBackgroundBlendMode;
}
public CssOpacity getOpacity() {
if (cssOpacity == null) {
cssOpacity =
(CssOpacity) style.CascadingOrder(new CssOpacity(),
style, selector);
}
return cssOpacity;
}
public CssRubyPosition getRubyPosition() {
if (cssRubyPosition == null) {
cssRubyPosition =
(CssRubyPosition) style.CascadingOrder(
new CssRubyPosition(), style, selector);
}
return cssRubyPosition;
}
public CssRubyAlign getRubyAlign() {
if (cssRubyAlign == null) {
cssRubyAlign =
(CssRubyAlign) style.CascadingOrder(
new CssRubyAlign(), style, selector);
}
return cssRubyAlign;
}
public CssRubyMerge getRubyMerge() {
if (cssRubyMerge == null) {
cssRubyMerge =
(CssRubyMerge) style.CascadingOrder(
new CssRubyMerge(), style, selector);
}
return cssRubyMerge;
}
@Deprecated
public CssRubyOverhang getRubyOverhang() {
if (cssRubyOverhang == null) {
cssRubyOverhang =
(CssRubyOverhang) style.CascadingOrder(
new CssRubyOverhang(), style, selector);
}
return cssRubyOverhang;
}
public CssBoxSuppress getBoxSuppress() {
if (cssBoxSuppress == null) {
cssBoxSuppress =
(CssBoxSuppress) style.CascadingOrder(
new CssBoxSuppress(), style, selector);
}
return cssBoxSuppress;
}
public CssBoxSizing getBoxSizing() {
if (cssBoxSizing == null) {
cssBoxSizing =
(CssBoxSizing) style.CascadingOrder(
new CssBoxSizing(), style, selector);
}
return cssBoxSizing;
}
public CssResize getResize() {
if (cssResize == null) {
cssResize =
(CssResize) style.CascadingOrder(
new CssResize(), style, selector);
}
return cssResize;
}
public CssTextJustify getTextJustify() {
if (cssTextJustify == null) {
cssTextJustify =
(CssTextJustify) style.CascadingOrder(
new CssTextJustify(), style, selector);
}
return cssTextJustify;
}
public CssTextAlignAll getTextAlignAll() {
if (cssTextAlignAll == null) {
cssTextAlignAll =
(CssTextAlignAll) style.CascadingOrder(
new CssTextAlignAll(), style, selector);
}
return cssTextAlignAll;
}
public CssTextAlignLast getTextAlignLast() {
if (cssTextAlignLast == null) {
cssTextAlignLast =
(CssTextAlignLast) style.CascadingOrder(
new CssTextAlignLast(), style, selector);
}
return cssTextAlignLast;
}
public CssDominantBaseline getDominantBaseline() {
if (cssDominantBaseline == null) {
cssDominantBaseline =
(CssDominantBaseline) style.CascadingOrder(
new CssDominantBaseline(), style, selector);
}
return cssDominantBaseline;
}
public CssAlignmentBaseline getAlignmentBaseline() {
if (cssAlignmentBaseline == null) {
cssAlignmentBaseline =
(CssAlignmentBaseline) style.CascadingOrder(
new CssAlignmentBaseline(), style, selector);
}
return cssAlignmentBaseline;
}
public CssBaselineShift getBaselineShift() {
if (cssBaselineShift == null) {
cssBaselineShift =
(CssBaselineShift) style.CascadingOrder(
new CssBaselineShift(), style, selector);
}
return cssBaselineShift;
}
public CssInitialLetter getInitialLetter() {
if (cssInitialLetter == null) {
cssInitialLetter =
(CssInitialLetter) style.CascadingOrder(
new CssInitialLetter(), style, selector);
}
return cssInitialLetter;
}
public CssInitialLetterAlign getInitialLetterAlign() {
if (cssInitialLetterAlign == null) {
cssInitialLetterAlign =
(CssInitialLetterAlign) style.CascadingOrder(
new CssInitialLetterAlign(), style, selector);
}
return cssInitialLetterAlign;
}
public CssInitialLetterWrap getInitialLetterWrap() {
if (cssInitialLetterWrap == null) {
cssInitialLetterWrap =
(CssInitialLetterWrap) style.CascadingOrder(
new CssInitialLetterWrap(), style, selector);
}
return cssInitialLetterWrap;
}
public CssLineBreak getLineBreak() {
if (cssLineBreak == null) {
cssLineBreak =
(CssLineBreak) style.CascadingOrder(
new CssLineBreak(), style, selector);
}
return cssLineBreak;
}
public CssWordBreak getWordBreak() {
if (cssWordBreak == null) {
cssWordBreak =
(CssWordBreak) style.CascadingOrder(
new CssWordBreak(), style, selector);
}
return cssWordBreak;
}
public CssColumns getColumns() {
if (cssColumns == null) {
cssColumns =
(CssColumns) style.CascadingOrder(
new CssColumns(), style, selector);
}
return cssColumns;
}
public CssColumnCount getColumnCount() {
if (cssColumnCount == null) {
cssColumnCount =
(CssColumnCount) style.CascadingOrder(
new CssColumnCount(), style, selector);
}
return cssColumnCount;
}
public CssColumnSpan getColumnSpan() {
if (cssColumnSpan == null) {
cssColumnSpan =
(CssColumnSpan) style.CascadingOrder(
new CssColumnSpan(), style, selector);
}
return cssColumnSpan;
}
public CssColumnWidth getColumnWidth() {
if (cssColumnWidth == null) {
cssColumnWidth =
(CssColumnWidth) style.CascadingOrder(
new CssColumnWidth(), style, selector);
}
return cssColumnWidth;
}
public CssBackgroundClip getCssBackgroundClip() {
if (cssBackgroundClip == null) {
cssBackgroundClip =
(CssBackgroundClip) style.CascadingOrder(
new CssBackgroundClip(), style, selector);
}
return cssBackgroundClip;
}
public CssBackgroundSize getCssBackgroundSize() {
if (cssBackgroundSize == null) {
cssBackgroundSize =
(CssBackgroundSize) style.CascadingOrder(
new CssBackgroundSize(), style, selector);
}
return cssBackgroundSize;
}
public CssBackgroundOrigin getCssBackgroundOrigin() {
if (cssBackgroundOrigin == null) {
cssBackgroundOrigin =
(CssBackgroundOrigin) style.CascadingOrder(
new CssBackgroundOrigin(), style, selector);
}
return cssBackgroundOrigin;
}
public CssHangingPunctuation getHangingPunctuation() {
if (cssHangingPunctuation == null) {
cssHangingPunctuation =
(CssHangingPunctuation) style.CascadingOrder(
new CssHangingPunctuation(), style, selector);
}
return cssHangingPunctuation;
}
public CssColumnGap getColumnGap() {
if (cssColumnGap == null) {
cssColumnGap =
(CssColumnGap) style.CascadingOrder(
new CssColumnGap(), style, selector);
}
return cssColumnGap;
}
public CssBreakBefore getBreakBefore() {
if (cssBreakBefore == null) {
cssBreakBefore =
(CssBreakBefore) style.CascadingOrder(
new CssBreakBefore(), style, selector);
}
return cssBreakBefore;
}
public CssBreakAfter getBreakAfter() {
if (cssBreakAfter == null) {
cssBreakAfter =
(CssBreakAfter) style.CascadingOrder(
new CssBreakAfter(), style, selector);
}
return cssBreakAfter;
}
public CssBreakInside getBreakInside() {
if (cssBreakInside == null) {
cssBreakInside =
(CssBreakInside) style.CascadingOrder(
new CssBreakInside(), style, selector);
}
return cssBreakInside;
}
public CssColumnFill getColumnFill() {
if (cssColumnFill == null) {
cssColumnFill =
(CssColumnFill) style.CascadingOrder(
new CssColumnFill(), style, selector);
}
return cssColumnFill;
}
public CssColumnRuleColor getColumnRuleColor() {
if (cssColumnRuleColor == null) {
cssColumnRuleColor =
(CssColumnRuleColor) style.CascadingOrder(
new CssColumnRuleColor(), style, selector);
}
return cssColumnRuleColor;
}
public CssColumnRuleStyle getColumnRuleStyle() {
if (cssColumnRuleStyle == null) {
cssColumnRuleStyle =
(CssColumnRuleStyle) style.CascadingOrder(
new CssColumnRuleStyle(), style, selector);
}
return cssColumnRuleStyle;
}
public CssColumnRuleWidth getColumnRuleWidth() {
if (cssColumnRuleWidth == null) {
cssColumnRuleWidth =
(CssColumnRuleWidth) style.CascadingOrder(
new CssColumnRuleWidth(), style, selector);
}
return cssColumnRuleWidth;
}
public CssColumnRule getColumnRule() {
if (cssColumnRule == null) {
cssColumnRule =
(CssColumnRule) style.CascadingOrder(
new CssColumnRule(), style, selector);
}
return cssColumnRule;
}
public CssIcon getIcon() {
if (cssIcon == null) {
cssIcon =
(CssIcon) style.CascadingOrder(
new CssIcon(), style, selector);
}
return cssIcon;
}
// TODO FIXME should be getNavUp... fix ATSC for that.
public CssNavUp getNavUpCSS3() {
if (cssNavUp == null) {
cssNavUp =
(CssNavUp) style.CascadingOrder(
new CssNavUp(), style, selector);
}
return cssNavUp;
}
public CssNavRight getNavRightCSS3() {
if (cssNavRight == null) {
cssNavRight =
(CssNavRight) style.CascadingOrder(
new CssNavRight(), style, selector);
}
return cssNavRight;
}
public CssNavDown getNavDownCSS3() {
if (cssNavDown == null) {
cssNavDown =
(CssNavDown) style.CascadingOrder(
new CssNavDown(), style, selector);
}
return cssNavDown;
}
public CssNavLeft getNavLeftCSS3() {
if (cssNavLeft == null) {
cssNavLeft =
(CssNavLeft) style.CascadingOrder(
new CssNavLeft(), style, selector);
}
return cssNavLeft;
}
public CssCaretColor getCaretColor() {
if (cssCaretColor == null) {
cssCaretColor =
(CssCaretColor) style.CascadingOrder(
new CssCaretColor(), style, selector);
}
return cssCaretColor;
}
public CssCaretShape getCaretShape() {
if (cssCaretShape == null) {
cssCaretShape =
(CssCaretShape) style.CascadingOrder(
new CssCaretShape(), style, selector);
}
return cssCaretShape;
}
public CssCaret getCaret() {
if (cssCaret == null) {
cssCaret =
(CssCaret) style.CascadingOrder(
new CssCaret(), style, selector);
}
return cssCaret;
}
public CssOutlineOffset getOutlineOffset() {
if (cssOutlineOffset == null) {
cssOutlineOffset =
(CssOutlineOffset) style.CascadingOrder(
new CssOutlineOffset(), style, selector);
}
return cssOutlineOffset;
}
public CssOverflowX getOverflowX() {
if (cssOverflowX == null) {
cssOverflowX =
(CssOverflowX) style.CascadingOrder(
new CssOverflowX(), style, selector);
}
return cssOverflowX;
}
public CssOverflowY getOverflowY() {
if (cssOverflowY == null) {
cssOverflowY =
(CssOverflowY) style.CascadingOrder(
new CssOverflowY(), style, selector);
}
return cssOverflowY;
}
public CssRubySpan getRubySpan() {
if (cssRubySpan == null) {
cssRubySpan =
(CssRubySpan) style.CascadingOrder(
new CssRubySpan(), style, selector);
}
return cssRubySpan;
}
public CssMarqueeDirection getMarqueeDirection() {
if (cssMarqueeDirection == null) {
cssMarqueeDirection =
(CssMarqueeDirection) style.CascadingOrder(
new CssMarqueeDirection(), style, selector);
}
return cssMarqueeDirection;
}
public CssMarqueePlayCount getMarqueePlayCount() {
if (cssMarqueePlayCount == null) {
cssMarqueePlayCount =
(CssMarqueePlayCount) style.CascadingOrder(
new CssMarqueePlayCount(), style, selector);
}
return cssMarqueePlayCount;
}
public CssMarqueeSpeed getMarqueeSpeed() {
if (cssMarqueeSpeed == null) {
cssMarqueeSpeed =
(CssMarqueeSpeed) style.CascadingOrder(
new CssMarqueeSpeed(), style, selector);
}
return cssMarqueeSpeed;
}
public CssMarqueeStyle getMarqueeStyle() {
if (cssMarqueeStyle == null) {
cssMarqueeStyle =
(CssMarqueeStyle) style.CascadingOrder(
new CssMarqueeStyle(), style, selector);
}
return cssMarqueeStyle;
}
public CssOverflowStyle getOverflowStyle() {
if (cssOverflowStyle == null) {
cssOverflowStyle =
(CssOverflowStyle) style.CascadingOrder(
new CssOverflowStyle(), style, selector);
}
return cssOverflowStyle;
}
public org.w3c.css.properties.css.CssBorderTopRightRadius getBorderTopRightRadius() {
if (cssBorder.borderRadius.topRight == null) {
cssBorder.borderRadius.topRight =
(org.w3c.css.properties.css.CssBorderTopRightRadius) style.CascadingOrder(
new CssBorderTopRightRadius(), style, selector);
}
return cssBorder.borderRadius.topRight;
}
public org.w3c.css.properties.css.CssBorderBottomRightRadius getBorderBottomRightRadius() {
if (cssBorder.borderRadius.bottomRight == null) {
cssBorder.borderRadius.bottomRight =
(org.w3c.css.properties.css.CssBorderBottomRightRadius) style.CascadingOrder(
new CssBorderBottomRightRadius(), style, selector);
}
return cssBorder.borderRadius.bottomRight;
}
public org.w3c.css.properties.css.CssBorderBottomLeftRadius getBorderBottomLeftRadius() {
if (cssBorder.borderRadius.bottomLeft == null) {
cssBorder.borderRadius.bottomLeft =
(org.w3c.css.properties.css.CssBorderBottomLeftRadius) style.CascadingOrder(
new org.w3c.css.properties.css.CssBorderBottomLeftRadius(), style, selector);
}
return cssBorder.borderRadius.bottomLeft;
}
public org.w3c.css.properties.css.CssBorderTopLeftRadius getBorderTopLeftRadius() {
if (cssBorder.borderRadius.topLeft == null) {
cssBorder.borderRadius.topLeft =
(org.w3c.css.properties.css.CssBorderTopLeftRadius) style.CascadingOrder(
new org.w3c.css.properties.css.CssBorderTopLeftRadius(), style, selector);
}
return cssBorder.borderRadius.topLeft;
}
public org.w3c.css.properties.css.CssBorderRadius getBorderRadius() {
if (cssBorder.borderRadius == null) {
cssBorder.borderRadius =
(org.w3c.css.properties.css.CssBorderRadius) style.CascadingOrder(
new org.w3c.css.properties.css.CssBorderRadius(), style, selector);
}
return cssBorder.borderRadius;
}
public CssBoxShadow getBoxShadow() {
if (cssBoxShadow == null) {
cssBoxShadow =
(CssBoxShadow) style.CascadingOrder(
new CssBoxShadow(), style, selector);
}
return cssBoxShadow;
}
public CssBoxDecorationBreak getBoxDecorationBreak() {
if (cssBoxDecorationBreak == null) {
cssBoxDecorationBreak =
(CssBoxDecorationBreak) style.CascadingOrder(
new CssBoxDecorationBreak(), style, selector);
}
return cssBoxDecorationBreak;
}
public CssFontKerning getFontKerning() {
if (cssFontKerning == null) {
cssFontKerning =
(CssFontKerning) style.CascadingOrder(
new CssFontKerning(), style, selector);
}
return cssFontKerning;
}
public CssFontLanguageOverride getFontLanguageOverride() {
if (cssFontLanguageOverride == null) {
cssFontLanguageOverride =
(CssFontLanguageOverride) style.CascadingOrder(
new CssFontLanguageOverride(), style, selector);
}
return cssFontLanguageOverride;
}
public CssFontVariantCaps getFontVariantCaps() {
if (cssFontVariantCaps == null) {
cssFontVariantCaps =
(CssFontVariantCaps) style.CascadingOrder(
new CssFontVariantCaps(), style, selector);
}
return cssFontVariantCaps;
}
public CssFontVariantPosition getFontVariantPosition() {
if (cssFontVariantCaps == null) {
cssFontVariantCaps =
(CssFontVariantCaps) style.CascadingOrder(
new CssFontVariantCaps(), style, selector);
}
return cssFontVariantPosition;
}
public CssFontSynthesis getFontSynthesis() {
if (cssFontSynthesis == null) {
cssFontSynthesis =
(CssFontSynthesis) style.CascadingOrder(
new CssFontSynthesis(), style, selector);
}
return cssFontSynthesis;
}
public CssFontVariantEastAsian getFontVariantEastAsian() {
if (cssFontVariantEastAsian == null) {
cssFontVariantEastAsian =
(CssFontVariantEastAsian) style.CascadingOrder(
new CssFontVariantEastAsian(), style, selector);
}
return cssFontVariantEastAsian;
}
public CssFontVariantLigatures getFontVariantLigatures() {
if (cssFontVariantLigatures == null) {
cssFontVariantLigatures =
(CssFontVariantLigatures) style.CascadingOrder(
new CssFontVariantLigatures(), style, selector);
}
return cssFontVariantLigatures;
}
public CssFontVariantNumeric getFontVariantNumeric() {
if (cssFontVariantNumeric == null) {
cssFontVariantNumeric =
(CssFontVariantNumeric) style.CascadingOrder(
new CssFontVariantNumeric(), style, selector);
}
return cssFontVariantNumeric;
}
public CssFontFeatureSettings getFontFeatureSettings() {
if (cssFontFeatureSettings == null) {
cssFontFeatureSettings =
(CssFontFeatureSettings) style.CascadingOrder(
new CssFontFeatureSettings(), style, selector);
}
return cssFontFeatureSettings;
}
public CssFontVariantAlternates getFontVariantAlternates() {
if (cssFontVariantAlternates == null) {
cssFontVariantAlternates =
(CssFontVariantAlternates) style.CascadingOrder(
new CssFontVariantAlternates(), style, selector);
}
return cssFontVariantAlternates;
}
public CssOverflowWrap getOverflowWrap() {
if (cssOverflowWrap == null) {
cssOverflowWrap =
(CssOverflowWrap) style.CascadingOrder(
new CssOverflowWrap(), style, selector);
}
return cssOverflowWrap;
}
public CssHyphens getHyphens() {
if (cssHyphens == null) {
cssHyphens =
(CssHyphens) style.CascadingOrder(
new CssHyphens(), style, selector);
}
return cssHyphens;
}
public CssTextDecorationStyle getTextDecorationStyle() {
if (cssTextDecorationStyle == null) {
cssTextDecorationStyle =
(CssTextDecorationStyle) style.CascadingOrder(
new CssTextDecorationStyle(), style, selector);
}
return cssTextDecorationStyle;
}
public CssTextDecorationColor getTextDecorationColor() {
if (cssTextDecorationColor == null) {
cssTextDecorationColor =
(CssTextDecorationColor) style.CascadingOrder(
new CssTextDecorationColor(), style, selector);
}
return cssTextDecorationColor;
}
public CssTextDecorationLine getTextDecorationLine() {
if (cssTextDecorationLine == null) {
cssTextDecorationLine =
(CssTextDecorationLine) style.CascadingOrder(
new CssTextDecorationLine(), style, selector);
}
return cssTextDecorationLine;
}
public CssTextDecorationSkip getTextDecorationSkip() {
if (cssTextDecorationSkip == null) {
cssTextDecorationSkip =
(CssTextDecorationSkip) style.CascadingOrder(
new CssTextDecorationSkip(), style, selector);
}
return cssTextDecorationSkip;
}
public CssTextEmphasis getTextEmphasis() {
if (cssTextEmphasis == null) {
cssTextEmphasis =
(CssTextEmphasis) style.CascadingOrder(
new CssTextEmphasis(), style, selector);
}
return cssTextEmphasis;
}
public CssTextEmphasisColor getTextEmphasisColor() {
if (cssTextEmphasisColor == null) {
cssTextEmphasisColor =
(CssTextEmphasisColor) style.CascadingOrder(
new CssTextEmphasisColor(), style, selector);
}
return cssTextEmphasisColor;
}
public CssTextEmphasisPosition getTextEmphasisPosition() {
if (cssTextEmphasisPosition == null) {
cssTextEmphasisPosition =
(CssTextEmphasisPosition) style.CascadingOrder(
new CssTextEmphasisPosition(), style, selector);
}
return cssTextEmphasisPosition;
}
public CssTextEmphasisStyle getTextEmphasisStyle() {
if (cssTextEmphasisStyle == null) {
cssTextEmphasisStyle =
(CssTextEmphasisStyle) style.CascadingOrder(
new CssTextEmphasisStyle(), style, selector);
}
return cssTextEmphasisStyle;
}
public CssTextSizeAdjust getTextSizeAdjust() {
if (cssTextSizeAdjust == null) {
cssTextSizeAdjust =
(CssTextSizeAdjust) style.CascadingOrder(
new CssTextSizeAdjust(), style, selector);
}
return cssTextSizeAdjust;
}
public CssTextUnderlinePosition getTextUnderlinePosition() {
if (cssTextUnderlinePosition == null) {
cssTextUnderlinePosition =
(CssTextUnderlinePosition) style.CascadingOrder(
new CssTextUnderlinePosition(), style, selector);
}
return cssTextUnderlinePosition;
}
public CssTabSize getTabSize() {
if (cssTabSize == null) {
cssTabSize =
(CssTabSize) style.CascadingOrder(
new CssTabSize(), style, selector);
}
return cssTabSize;
}
public CssAnimation getAnimation() {
if (cssAnimation == null) {
cssAnimation =
(CssAnimation) style.CascadingOrder(
new CssAnimation(), style, selector);
}
return cssAnimation;
}
public CssAnimationDelay getAnimationDelay() {
if (cssAnimationDelay == null) {
cssAnimationDelay =
(CssAnimationDelay) style.CascadingOrder(
new CssAnimationDelay(), style, selector);
}
return cssAnimationDelay;
}
public CssAnimationDirection getAnimationDirection() {
if (cssAnimationDirection == null) {
cssAnimationDirection =
(CssAnimationDirection) style.CascadingOrder(
new CssAnimationDirection(), style, selector);
}
return cssAnimationDirection;
}
public CssAnimationDuration getAnimationDuration() {
if (cssAnimationDuration == null) {
cssAnimationDuration =
(CssAnimationDuration) style.CascadingOrder(
new CssAnimationDuration(), style, selector);
}
return cssAnimationDuration;
}
public CssAnimationIterationCount getAnimationIterationCount() {
if (cssAnimationIterationCount == null) {
cssAnimationIterationCount =
(CssAnimationIterationCount) style.CascadingOrder(
new CssAnimationIterationCount(), style, selector);
}
return cssAnimationIterationCount;
}
public CssAnimationName getAnimationName() {
if (cssAnimationName == null) {
cssAnimationName =
(CssAnimationName) style.CascadingOrder(
new CssAnimationName(), style, selector);
}
return cssAnimationName;
}
public CssAnimationPlayState getAnimationPlayState() {
if (cssAnimationPlayState == null) {
cssAnimationPlayState =
(CssAnimationPlayState) style.CascadingOrder(
new CssAnimationPlayState(), style, selector);
}
return cssAnimationPlayState;
}
public CssAnimationFillMode getAnimationFillMode() {
if (cssAnimationFillMode == null) {
cssAnimationFillMode =
(CssAnimationFillMode) style.CascadingOrder(
new CssAnimationFillMode(), style, selector);
}
return cssAnimationFillMode;
}
public CssAnimationTimingFunction getAnimationTimingFunction() {
if (cssAnimationTimingFunction == null) {
cssAnimationTimingFunction =
(CssAnimationTimingFunction) style.CascadingOrder(
new CssAnimationTimingFunction(), style, selector);
}
return cssAnimationTimingFunction;
}
public CssTransitionDelay getTransitionDelay() {
if (cssTransitionDelay == null) {
cssTransitionDelay =
(CssTransitionDelay) style.CascadingOrder(
new CssTransitionDelay(), style, selector);
}
return cssTransitionDelay;
}
public CssTransitionDuration getTransitionDuration() {
if (cssTransitionDuration == null) {
cssTransitionDuration =
(CssTransitionDuration) style.CascadingOrder(
new CssTransitionDuration(), style, selector);
}
return cssTransitionDuration;
}
public CssTransitionProperty getTransitionProperty() {
if (cssTransitionProperty == null) {
cssTransitionProperty =
(CssTransitionProperty) style.CascadingOrder(
new CssTransitionProperty(), style, selector);
}
return cssTransitionProperty;
}
public CssTransitionTimingFunction getTransitionTimingFunction() {
if (cssTransitionTimingFunction == null) {
cssTransitionTimingFunction =
(CssTransitionTimingFunction) style.CascadingOrder(
new CssTransitionTimingFunction(), style, selector);
}
return cssTransitionTimingFunction;
}
public CssTransition getTransition() {
if (cssTransition == null) {
cssTransition =
(CssTransition) style.CascadingOrder(
new CssTransition(), style, selector);
}
return cssTransition;
}
public CssAlignContent getAlignContent() {
if (cssAlignContent == null) {
cssAlignContent =
(CssAlignContent) style.CascadingOrder(
new CssAlignContent(), style, selector);
}
return cssAlignContent;
}
public CssAlignItems getAlignItems() {
if (cssAlignItems == null) {
cssAlignItems =
(CssAlignItems) style.CascadingOrder(
new CssAlignItems(), style, selector);
}
return cssAlignItems;
}
public CssAlignSelf getAlignSelf() {
if (cssAlignSelf == null) {
cssAlignSelf =
(CssAlignSelf) style.CascadingOrder(
new CssAlignSelf(), style, selector);
}
return cssAlignSelf;
}
public CssFlex getFlex() {
if (cssFlex == null) {
cssFlex =
(CssFlex) style.CascadingOrder(
new CssFlex(), style, selector);
}
return cssFlex;
}
public CssFlexBasis getFlexBasis() {
if (cssFlexBasis == null) {
cssFlexBasis =
(CssFlexBasis) style.CascadingOrder(
new CssFlexBasis(), style, selector);
}
return cssFlexBasis;
}
public CssFlexDirection getFlexDirection() {
if (cssFlexDirection == null) {
cssFlexDirection =
(CssFlexDirection) style.CascadingOrder(
new CssFlexDirection(), style, selector);
}
return cssFlexDirection;
}
public CssFlexWrap getFlexWrap() {
if (cssFlexWrap == null) {
cssFlexWrap =
(CssFlexWrap) style.CascadingOrder(
new CssFlexWrap(), style, selector);
}
return cssFlexWrap;
}
public CssFlexFlow getFlexFlow() {
if (cssFlexFlow == null) {
cssFlexFlow =
(CssFlexFlow) style.CascadingOrder(
new CssFlexFlow(), style, selector);
}
return cssFlexFlow;
}
public CssFlexGrow getFlexGrow() {
if (cssFlexGrow == null) {
cssFlexGrow =
(CssFlexGrow) style.CascadingOrder(
new CssFlexGrow(), style, selector);
}
return cssFlexGrow;
}
public CssFlexShrink getFlexShrink() {
if (cssFlexShrink == null) {
cssFlexShrink =
(CssFlexShrink) style.CascadingOrder(
new CssFlexShrink(), style, selector);
}
return cssFlexShrink;
}
public CssJustifyContent getJustifyContent() {
if (cssJustifyContent == null) {
cssJustifyContent =
(CssJustifyContent) style.CascadingOrder(
new CssJustifyContent(), style, selector);
}
return cssJustifyContent;
}
public CssOrder getOrder() {
if (cssOrder == null) {
cssOrder =
(CssOrder) style.CascadingOrder(
new CssOrder(), style, selector);
}
return cssOrder;
}
public CssTransformStyle getTransformStyle() {
if (cssTransformStyle == null) {
cssTransformStyle =
(CssTransformStyle) style.CascadingOrder(
new CssTransformStyle(), style, selector);
}
return cssTransformStyle;
}
public CssBackfaceVisibility getBackfaceVisibility() {
if (cssBackfaceVisibility == null) {
cssBackfaceVisibility =
(CssBackfaceVisibility) style.CascadingOrder(
new CssBackfaceVisibility(), style, selector);
}
return cssBackfaceVisibility;
}
public CssPerspective getPerspective() {
if (cssPerspective == null) {
cssPerspective =
(CssPerspective) style.CascadingOrder(
new CssPerspective(), style, selector);
}
return cssPerspective;
}
public CssPerspectiveOrigin getPerspectiveOrigin() {
if (cssPerspectiveOrigin == null) {
cssPerspectiveOrigin =
(CssPerspectiveOrigin) style.CascadingOrder(
new CssPerspectiveOrigin(), style, selector);
}
return cssPerspectiveOrigin;
}
public CssTransformOrigin getTransformOrigin() {
if (cssTransformOrigin == null) {
cssTransformOrigin =
(CssTransformOrigin) style.CascadingOrder(
new CssTransformOrigin(), style, selector);
}
return cssTransformOrigin;
}
public CssTransform getTransform() {
if (cssTransform == null) {
cssTransform =
(CssTransform) style.CascadingOrder(
new CssTransform(), style, selector);
}
return cssTransform;
}
public CssTransformBox getTransformBox() {
if (cssTransformBox == null) {
cssTransformBox =
(CssTransformBox) style.CascadingOrder(
new CssTransformBox(), style, selector);
}
return cssTransformBox;
}
public CssImeMode getImeMode() {
if (cssImeMode == null) {
cssImeMode =
(CssImeMode) style.CascadingOrder(
new CssImeMode(), style, selector);
}
return cssImeMode;
}
public CssTextOverflow getTextOverflow() {
if (cssTextOverflow == null) {
cssTextOverflow =
(CssTextOverflow) style.CascadingOrder(
new CssTextOverflow(), style, selector);
}
return cssTextOverflow;
}
public CssObjectFit getObjectFit() {
if (cssObjectFit == null) {
cssObjectFit =
(CssObjectFit) style.CascadingOrder(
new CssObjectFit(), style, selector);
}
return cssObjectFit;
}
public CssObjectPosition getObjectPosition() {
if (cssObjectPosition == null) {
cssObjectPosition =
(CssObjectPosition) style.CascadingOrder(
new CssObjectPosition(), style, selector);
}
return cssObjectPosition;
}
public CssImageOrientation getImageOrientation() {
if (cssImageOrientation == null) {
cssImageOrientation =
(CssImageOrientation) style.CascadingOrder(
new CssImageOrientation(), style, selector);
}
return cssImageOrientation;
}
public CssImageResolution getImageResolution() {
if (cssImageResolution == null) {
cssImageResolution =
(CssImageResolution) style.CascadingOrder(
new CssImageResolution(), style, selector);
}
return cssImageResolution;
}
public final CssVoiceBalance getVoiceBalance() {
if (cssVoiceBalance == null) {
cssVoiceBalance =
(CssVoiceBalance) style.CascadingOrder(new CssVoiceBalance(),
style, selector);
}
return cssVoiceBalance;
}
public final CssVoiceStress getVoiceStress() {
if (cssVoiceStress == null) {
cssVoiceStress =
(CssVoiceStress) style.CascadingOrder(new CssVoiceStress(),
style, selector);
}
return cssVoiceStress;
}
public final CssVoiceDuration getVoiceDuration() {
if (cssVoiceDuration == null) {
cssVoiceDuration =
(CssVoiceDuration) style.CascadingOrder(new CssVoiceDuration(),
style, selector);
}
return cssVoiceDuration;
}
public final CssVoiceRate getVoiceRate() {
if (cssVoiceRate == null) {
cssVoiceRate =
(CssVoiceRate) style.CascadingOrder(new CssVoiceRate(),
style, selector);
}
return cssVoiceRate;
}
public final CssVoiceVolume getVoiceVolume() {
if (cssVoiceVolume == null) {
cssVoiceVolume =
(CssVoiceVolume) style.CascadingOrder(new CssVoiceVolume(),
style, selector);
}
return cssVoiceVolume;
}
public final CssRestAfter getRestAfter() {
if (cssRestAfter == null) {
cssRestAfter =
(CssRestAfter) style.CascadingOrder(new CssRestAfter(),
style, selector);
}
return cssRestAfter;
}
public final CssRestBefore getRestBefore() {
if (cssRestBefore == null) {
cssRestBefore =
(CssRestBefore) style.CascadingOrder(new CssRestBefore(),
style, selector);
}
return cssRestBefore;
}
public final CssRest getRest() {
if (cssRest == null) {
cssRest =
(CssRest) style.CascadingOrder(new CssRest(),
style, selector);
}
return cssRest;
}
public final CssSpeakAs getSpeakAs() {
if (cssSpeakAs == null) {
cssSpeakAs = (CssSpeakAs) style.CascadingOrder(new CssSpeakAs(), style, selector);
}
return cssSpeakAs;
}
public final CssVoicePitch getVoicePitch() {
if (cssVoicePitch == null) {
cssVoicePitch = (CssVoicePitch) style.CascadingOrder(new CssVoicePitch(), style, selector);
}
return cssVoicePitch;
}
public final CssVoiceRange getVoiceRange() {
if (cssVoiceRange == null) {
cssVoiceRange = (CssVoiceRange) style.CascadingOrder(new CssVoiceRange(), style, selector);
}
return cssVoiceRange;
}
public final CssFilter getFilter() {
if (cssFilter == null) {
cssFilter = (CssFilter) style.CascadingOrder(new CssFilter(), style, selector);
}
return cssFilter;
}
public final CssColorInterpolationFilters getColorInterpolationFilters() {
if (cssColorInterpolationFilters == null) {
cssColorInterpolationFilters = (CssColorInterpolationFilters) style.CascadingOrder(
new CssColorInterpolationFilters(), style, selector);
}
return cssColorInterpolationFilters;
}
public final CssFloodColor getFloodColor() {
if (cssFloodColor == null) {
cssFloodColor = (CssFloodColor) style.CascadingOrder(new CssFloodColor(), style, selector);
}
return cssFloodColor;
}
public final CssFloodOpacity getFloodOpacity() {
if (cssFloodOpacity == null) {
cssFloodOpacity = (CssFloodOpacity) style.CascadingOrder(new CssFloodOpacity(), style, selector);
}
return cssFloodOpacity;
}
public final CssLightingColor getLightingColor() {
if (cssLightingColor == null) {
cssLightingColor = (CssLightingColor) style.CascadingOrder(new CssLightingColor(), style, selector);
}
return cssLightingColor;
}
public final CssFloatReference getFloatReference() {
if (cssFloatReference == null) {
cssFloatReference = (CssFloatReference) style.CascadingOrder(new CssFloatReference(), style, selector);
}
return cssFloatReference;
}
public final CssFloatDefer getFloatDefer() {
if (cssFloatDefer == null) {
cssFloatDefer = (CssFloatDefer) style.CascadingOrder(new CssFloatDefer(), style, selector);
}
return cssFloatDefer;
}
public final CssFloatOffset getFloatOffset() {
if (cssFloatOffset == null) {
cssFloatOffset = (CssFloatOffset) style.CascadingOrder(new CssFloatOffset(), style, selector);
}
return cssFloatOffset;
}
///
/**
* Returns the name of the actual selector
*/
public String getSelector() {
return (selector.getElement().toLowerCase());
}
/* public boolean isRubyText() {
return(((selector.getElement()).toLowerCase() == "ruby") ||
((selector.getElement()).toLowerCase() == "rb") ||
((selector.getElement()).toLowerCase() == "rt") ||
((selector.getElement()).toLowerCase() == "rbc") ||
((selector.getElement()).toLowerCase() == "rtc"));
}
public void findConflicts(ApplContext ac) {
if ((cssRubyPosition != null)
&& (selector != null)
&& (!isRubyText())) {
warnings.addWarning(new Warning(cssRubyPosition,
"ruby-text", 1, ac));
}
if ((cssRubyOverhang != null)
&& (selector != null)
&& (!isRubyText())) {
warnings.addWarning(new Warning(cssRubyOverhang,
"ruby-text", 1, ac));
}
}
*/
/**
* Find conflicts in this Style
* For the float elements
*
* @param warnings For warnings reports.
* @param allSelectors All contexts is the entire style sheet.
*/
private void findConflictsBlockElements(ApplContext ac, Warnings warnings,
CssSelectors selector,
CssSelectors[] allSelectors) {
if (Util.fromHTMLFile) {
if ((selector != null) &&
(!selector.isBlockLevelElement())) {
if (cssColumnCount != null) {
warnings.addWarning(new Warning(cssColumnCount,
"block-level", 1, ac));
}
if (cssColumnGap != null) {
warnings.addWarning(new Warning(cssColumnGap,
"block-level", 1, ac));
}
if (cssColumnSpan != null) {
warnings.addWarning(new Warning(cssColumnSpan,
"block-level", 1, ac));
}
if (cssColumnWidth != null) {
warnings.addWarning(new Warning(cssColumnWidth,
"block-level", 1, ac));
}
}
}
}
/**
* Find conflicts in this Style
*
* @param warnings For warnings reports.
* @param allSelectors All contexts is the entire style sheet.
*/
public void findConflicts(ApplContext ac, Warnings warnings,
CssSelectors selector, CssSelectors[] allSelectors) {
findConflictsBlockElements(ac, warnings, selector, allSelectors);
super.findConflicts(ac, warnings, selector, allSelectors);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy