Untitled diff

Created Diff never expires
// Copyright (c) 2014 The Chromium Authors. All rights reserved.
// Copyright (c) 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// found in the LICENSE file.


#ifndef ComputedStyleBase_h
#ifndef ComputedStyleBase_h
#define ComputedStyleBase_h
#define ComputedStyleBase_h


#include "core/ComputedStyleBaseConstants.h"
#include "core/ComputedStyleBaseConstants.h"
#include "core/CoreExport.h"
#include "core/CoreExport.h"
#include "platform/text/TextDirection.h"
#include "platform/text/TextDirection.h"
#include "platform/text/UnicodeBidi.h"
#include "platform/text/UnicodeBidi.h"
#include "platform/text/WritingMode.h"
#include "platform/text/WritingMode.h"




namespace blink {
namespace blink {


// The generated portion of ComputedStyle. For more info, see the header comment
// The generated portion of ComputedStyle. For more info, see the header comment
// in ComputedStyle.h.
// in ComputedStyle.h.
class CORE_EXPORT ComputedStyleBase {
class CORE_EXPORT ComputedStyleBase {
public:
public:
ALWAYS_INLINE ComputedStyleBase() :
ALWAYS_INLINE ComputedStyleBase() :
m_listStyleType(static_cast<unsigned>(EListStyleType::kDisc)),
m_listStyleType(static_cast<unsigned>(EListStyleType::kDisc)),
m_breakBefore(static_cast<unsigned>(EBreakBetween::kAuto)),
m_breakBefore(static_cast<unsigned>(EBreakBetween::kAuto)),
m_breakAfter(static_cast<unsigned>(EBreakBetween::kAuto)),
m_breakAfter(static_cast<unsigned>(EBreakBetween::kAuto)),
m_pointerEvents(static_cast<unsigned>(EPointerEvents::kAuto)),
m_pointerEvents(static_cast<unsigned>(EPointerEvents::kAuto)),
m_textAlign(static_cast<unsigned>(ETextAlign::kStart)),
m_textAlign(static_cast<unsigned>(ETextAlign::kStart)),
m_unicodeBidi(static_cast<unsigned>(UnicodeBidi::kNormal)),
m_unicodeBidi(static_cast<unsigned>(UnicodeBidi::kNormal)),
m_overflowX(static_cast<unsigned>(EOverflow::kVisible)),
m_overflowX(static_cast<unsigned>(EOverflow::kVisible)),
m_overflowY(static_cast<unsigned>(EOverflow::kVisible)),
m_overflowY(static_cast<unsigned>(EOverflow::kVisible)),
m_boxDirectionIsInherited(static_cast<unsigned>(true)),
m_boxDirectionIsInherited(static_cast<unsigned>(true)),
m_position(static_cast<unsigned>(EPosition::kStatic)),
m_position(static_cast<unsigned>(EPosition::kStatic)),
m_whiteSpace(static_cast<unsigned>(EWhiteSpace::kNormal)),
m_whiteSpace(static_cast<unsigned>(EWhiteSpace::kNormal)),
m_clear(static_cast<unsigned>(EClear::kNone)),
m_clear(static_cast<unsigned>(EClear::kNone)),
m_captionSide(static_cast<unsigned>(ECaptionSide::kTop)),
m_captionSide(static_cast<unsigned>(ECaptionSide::kTop)),
m_writingMode(static_cast<unsigned>(WritingMode::kHorizontalTb)),
m_writingMode(static_cast<unsigned>(WritingMode::kHorizontalTb)),
m_floating(static_cast<unsigned>(EFloat::kNone)),
m_floating(static_cast<unsigned>(EFloat::kNone)),
m_breakInside(static_cast<unsigned>(EBreakInside::kAuto)),
m_breakInside(static_cast<unsigned>(EBreakInside::kAuto)),
m_overflowAnchor(static_cast<unsigned>(EOverflowAnchor::kAuto)),
m_overflowAnchor(static_cast<unsigned>(EOverflowAnchor::kAuto)),
m_textTransform(static_cast<unsigned>(ETextTransform::kNone)),
m_textTransform(static_cast<unsigned>(ETextTransform::kNone)),
m_visibility(static_cast<unsigned>(EVisibility::kVisible)),
m_visibility(static_cast<unsigned>(EVisibility::kVisible)),
m_boxDirection(static_cast<unsigned>(EBoxDirection::kNormal)),
m_boxDirection(static_cast<unsigned>(EBoxDirection::kNormal)),
m_captionSideIsInherited(static_cast<unsigned>(true)),
m_captionSideIsInherited(static_cast<unsigned>(true)),
m_printColorAdjustIsInherited(static_cast<unsigned>(true)),
m_printColorAdjustIsInherited(static_cast<unsigned>(true)),
m_printColorAdjust(static_cast<unsigned>(EPrintColorAdjust::kEconomy)),
m_printColorAdjust(static_cast<unsigned>(EPrintColorAdjust::kEconomy)),
m_borderCollapseIsInherited(static_cast<unsigned>(true)),
m_borderCollapseIsInherited(static_cast<unsigned>(true)),
m_borderCollapse(static_cast<unsigned>(EBorderCollapse::kSeparate)),
m_borderCollapse(static_cast<unsigned>(EBorderCollapse::kSeparate)),
m_rtlOrderingIsInherited(static_cast<unsigned>(true)),
m_rtlOrderingIsInherited(static_cast<unsigned>(true)),
m_rtlOrdering(static_cast<unsigned>(EOrder::kLogical)),
m_rtlOrdering(static_cast<unsigned>(EOrder::kLogical)),
m_whiteSpaceIsInherited(static_cast<unsigned>(true)),
m_whiteSpaceIsInherited(static_cast<unsigned>(true)),
m_tableLayout(static_cast<unsigned>(ETableLayout::kAuto)),
m_tableLayout(static_cast<unsigned>(ETableLayout::kAuto)),
m_listStylePositionIsInherited(static_cast<unsigned>(true)),
m_listStylePositionIsInherited(static_cast<unsigned>(true)),
m_listStylePosition(static_cast<unsigned>(EListStylePosition::kOutside)),
m_listStylePosition(static_cast<unsigned>(EListStylePosition::kOutside)),
m_pointerEventsIsInherited(static_cast<unsigned>(true)),
m_pointerEventsIsInherited(static_cast<unsigned>(true)),
m_textTransformIsInherited(static_cast<unsigned>(true)),
m_textTransformIsInherited(static_cast<unsigned>(true)),
m_direction(static_cast<unsigned>(TextDirection::kLtr)),
m_direction(static_cast<unsigned>(TextDirection::kLtr)),
m_emptyCellsIsInherited(static_cast<unsigned>(true)),
m_emptyCellsIsInherited(static_cast<unsigned>(true)),
m_emptyCells(static_cast<unsigned>(EEmptyCells::kShow)),
m_emptyCells(static_cast<unsigned>(EEmptyCells::kShow)),
m_visibilityIsInherited(static_cast<unsigned>(true)),
m_visibilityIsInherited(static_cast<unsigned>(true)),
m_unique(static_cast<unsigned>(false))
m_unique(static_cast<unsigned>(false))
{}
{}
~ComputedStyleBase() {}
~ComputedStyleBase() {}


ALWAYS_INLINE ComputedStyleBase(const ComputedStyleBase& o) :
ALWAYS_INLINE ComputedStyleBase(const ComputedStyleBase& o) :
m_listStyleType(o.m_listStyleType),
m_listStyleType(o.m_listStyleType),
m_breakBefore(o.m_breakBefore),
m_breakBefore(o.m_breakBefore),
m_breakAfter(o.m_breakAfter),
m_breakAfter(o.m_breakAfter),
m_pointerEvents(o.m_pointerEvents),
m_pointerEvents(o.m_pointerEvents),
m_textAlign(o.m_textAlign),
m_textAlign(o.m_textAlign),
m_unicodeBidi(o.m_unicodeBidi),
m_unicodeBidi(o.m_unicodeBidi),
m_overflowX(o.m_overflowX),
m_overflowX(o.m_overflowX),
m_overflowY(o.m_overflowY),
m_overflowY(o.m_overflowY),
m_boxDirectionIsInherited(o.m_boxDirectionIsInherited),
m_boxDirectionIsInherited(o.m_boxDirectionIsInherited),
m_position(o.m_position),
m_position(o.m_position),
m_whiteSpace(o.m_whiteSpace),
m_whiteSpace(o.m_whiteSpace),
m_clear(o.m_clear),
m_clear(o.m_clear),
m_captionSide(o.m_captionSide),
m_captionSide(o.m_captionSide),
m_writingMode(o.m_writingMode),
m_writingMode(o.m_writingMode),
m_floating(o.m_floating),
m_floating(o.m_floating),
m_breakInside(o.m_breakInside),
m_breakInside(o.m_breakInside),
m_overflowAnchor(o.m_overflowAnchor),
m_overflowAnchor(o.m_overflowAnchor),
m_textTransform(o.m_textTransform),
m_textTransform(o.m_textTransform),
m_visibility(o.m_visibility),
m_visibility(o.m_visibility),
m_boxDirection(o.m_boxDirection),
m_boxDirection(o.m_boxDirection),
m_captionSideIsInherited(o.m_captionSideIsInherited),
m_captionSideIsInherited(o.m_captionSideIsInherited),
m_printColorAdjustIsInherited(o.m_printColorAdjustIsInherited),
m_printColorAdjustIsInherited(o.m_printColorAdjustIsInherited),
m_printColorAdjust(o.m_printColorAdjust),
m_printColorAdjust(o.m_printColorAdjust),
m_borderCollapseIsInherited(o.m_borderCollapseIsInherited),
m_borderCollapseIsInherited(o.m_borderCollapseIsInherited),
m_borderCollapse(o.m_borderCollapse),
m_borderCollapse(o.m_borderCollapse),
m_rtlOrderingIsInherited(o.m_rtlOrderingIsInherited),
m_rtlOrderingIsInherited(o.m_rtlOrderingIsInherited),
m_rtlOrdering(o.m_rtlOrdering),
m_rtlOrdering(o.m_rtlOrdering),
m_whiteSpaceIsInherited(o.m_whiteSpaceIsInherited),
m_whiteSpaceIsInherited(o.m_whiteSpaceIsInherited),
m_tableLayout(o.m_tableLayout),
m_tableLayout(o.m_tableLayout),
m_listStylePositionIsInherited(o.m_listStylePositionIsInherited),
m_listStylePositionIsInherited(o.m_listStylePositionIsInherited),
m_listStylePosition(o.m_listStylePosition),
m_listStylePosition(o.m_listStylePosition),
m_pointerEventsIsInherited(o.m_pointerEventsIsInherited),
m_pointerEventsIsInherited(o.m_pointerEventsIsInherited),
m_textTransformIsInherited(o.m_textTransformIsInherited),
m_textTransformIsInherited(o.m_textTransformIsInherited),
m_direction(o.m_direction),
m_direction(o.m_direction),
m_emptyCellsIsInherited(o.m_emptyCellsIsInherited),
m_emptyCellsIsInherited(o.m_emptyCellsIsInherited),
m_emptyCells(o.m_emptyCells),
m_emptyCells(o.m_emptyCells),
m_visibilityIsInherited(o.m_visibilityIsInherited),
m_visibilityIsInherited(o.m_visibilityIsInherited),
m_unique(o.m_unique)
m_unique(o.m_unique)
{}
{}


bool operator==(const ComputedStyleBase& o) const {
bool operator==(const ComputedStyleBase& o) const {
return true &&
return true &&
m_listStyleType == o.m_listStyleType &&
m_listStyleType == o.m_listStyleType &&
m_breakBefore == o.m_breakBefore &&
m_breakBefore == o.m_breakBefore &&
m_breakAfter == o.m_breakAfter &&
m_breakAfter == o.m_breakAfter &&
m_pointerEvents == o.m_pointerEvents &&
m_pointerEvents == o.m_pointerEvents &&
m_textAlign == o.m_textAlign &&
m_textAlign == o.m_textAlign &&
m_unicodeBidi == o.m_unicodeBidi &&
m_unicodeBidi == o.m_unicodeBidi &&
m_overflowX == o.m_overflowX &&
m_overflowX == o.m_overflowX &&
m_overflowY == o.m_overflowY &&
m_overflowY == o.m_overflowY &&
m_boxDirectionIsInherited == o.m_boxDirectionIsInherited &&
m_boxDirectionIsInherited == o.m_boxDirectionIsInherited &&
m_position == o.m_position &&
m_position == o.m_position &&
m_whiteSpace == o.m_whiteSpace &&
m_whiteSpace == o.m_whiteSpace &&
m_clear == o.m_clear &&
m_clear == o.m_clear &&
m_captionSide == o.m_captionSide &&
m_captionSide == o.m_captionSide &&
m_writingMode == o.m_writingMode &&
m_writingMode == o.m_writingMode &&
m_floating == o.m_floating &&
m_floating == o.m_floating &&
m_breakInside == o.m_breakInside &&
m_breakInside == o.m_breakInside &&
m_overflowAnchor == o.m_overflowAnchor &&
m_overflowAnchor == o.m_overflowAnchor &&
m_textTransform == o.m_textTransform &&
m_textTransform == o.m_textTransform &&
m_visibility == o.m_visibility &&
m_visibility == o.m_visibility &&
m_boxDirection == o.m_boxDirection &&
m_boxDirection == o.m_boxDirection &&
m_captionSideIsInherited == o.m_captionSideIsInherited &&
m_captionSideIsInherited == o.m_captionSideIsInherited &&
m_printColorAdjustIsInherited == o.m_printColorAdjustIsInherited &&
m_printColorAdjustIsInherited == o.m_printColorAdjustIsInherited &&
m_printColorAdjust == o.m_printColorAdjust &&
m_printColorAdjust == o.m_printColorAdjust &&
m_borderCollapseIsInherited == o.m_borderCollapseIsInherited &&
m_borderCollapseIsInherited == o.m_borderCollapseIsInherited &&
m_borderCollapse == o.m_borderCollapse &&
m_borderCollapse == o.m_borderCollapse &&
m_rtlOrderingIsInherited == o.m_rtlOrderingIsInherited &&
m_rtlOrderingIsInherited == o.m_rtlOrderingIsInherited &&
m_rtlOrdering == o.m_rtlOrdering &&
m_rtlOrdering == o.m_rtlOrdering &&
m_whiteSpaceIsInherited == o.m_whiteSpaceIsInherited &&
m_whiteSpaceIsInherited == o.m_whiteSpaceIsInherited &&
m_tableLayout == o.m_tableLayout &&
m_tableLayout == o.m_tableLayout &&
m_listStylePositionIsInherited == o.m_listStylePositionIsInherited &&
m_listStylePositionIsInherited == o.m_listStylePositionIsInherited &&
m_listStylePosition == o.m_listStylePosition &&
m_listStylePosition == o.m_listStylePosition &&
m_pointerEventsIsInherited == o.m_pointerEventsIsInherited &&
m_pointerEventsIsInherited == o.m_pointerEventsIsInherited &&
m_textTransformIsInherited == o.m_textTransformIsInherited &&
m_textTransformIsInherited == o.m_textTransformIsInherited &&
m_direction == o.m_direction &&
m_direction == o.m_direction &&
m_emptyCellsIsInherited == o.m_emptyCellsIsInherited &&
m_emptyCellsIsInherited == o.m_emptyCellsIsInherited &&
m_emptyCells == o.m_emptyCells &&
m_emptyCells == o.m_emptyCells &&
m_visibilityIsInherited == o.m_visibilityIsInherited &&
m_visibilityIsInherited == o.m_visibilityIsInherited &&
m_unique == o.m_unique
m_unique == o.m_unique
;
;
}
}


bool operator!=(const ComputedStyleBase& o) const { return !(*this == o); }
bool operator!=(const ComputedStyleBase& o) const { return !(*this == o); }


inline bool inheritedEqual(const ComputedStyleBase& o) const {
inline bool inheritedEqual(const ComputedStyleBase& o) const {
return true &&
return true &&
m_listStyleType == o.m_listStyleType &&
m_listStyleType == o.m_listStyleType &&
m_pointerEvents == o.m_pointerEvents &&
m_pointerEvents == o.m_pointerEvents &&
m_textAlign == o.m_textAlign &&
m_textAlign == o.m_textAlign &&
m_whiteSpace == o.m_whiteSpace &&
m_whiteSpace == o.m_whiteSpace &&
m_captionSide == o.m_captionSide &&
m_captionSide == o.m_captionSide &&
m_writingMode == o.m_writingMode &&
m_writingMode == o.m_writingMode &&
m_textTransform == o.m_textTransform &&
m_textTransform == o.m_textTransform &&
m_visibility == o.m_visibility &&
m_visibility == o.m_visibility &&
m_boxDirection == o.m_boxDirection &&
m_boxDirection == o.m_boxDirection &&
m_printColorAdjust == o.m_printColorAdjust &&
m_printColorAdjust == o.m_printColorAdjust &&
m_borderCollapse == o.m_borderCollapse &&
m_borderCollapse == o.m_borderCollapse &&
m_rtlOrdering == o.m_rtlOrdering &&
m_rtlOrdering == o.m_rtlOrdering &&
m_listStylePosition == o.m_listStylePosition &&
m_listStylePosition == o.m_listStylePosition &&
m_direction == o.m_direction &&
m_direction == o.m_direction &&
m_emptyCells == o.m_emptyCells
m_emptyCells == o.m_emptyCells
;
;
}
}


inline bool independentInheritedEqual(const ComputedStyleBase& o) const {
inline bool independentInheritedEqual(const ComputedStyleBase& o) const {
return true &&
return true &&
m_pointerEvents == o.m_pointerEvents &&
m_pointerEvents == o.m_pointerEvents &&
m_whiteSpace == o.m_whiteSpace &&
m_whiteSpace == o.m_whiteSpace &&
m_captionSide == o.m_captionSide &&
m_captionSide == o.m_captionSide &&
m_textTransform == o.m_textTransform &&
m_textTransform == o.m_textTransform &&
m_visibility == o.m_visibility &&
m_visibility == o.m_visibility &&
m_boxDirection == o.m_boxDirection &&
m_boxDirection == o.m_boxDirection &&
m_printColorAdjust == o.m_printColorAdjust &&
m_printColorAdjust == o.m_printColorAdjust &&
m_borderCollapse == o.m_borderCollapse &&
m_borderCollapse == o.m_borderCollapse &&
m_rtlOrdering == o.m_rtlOrdering &&
m_rtlOrdering == o.m_rtlOrdering &&
m_listStylePosition == o.m_listStylePosition &&
m_listStylePosition == o.m_listStylePosition &&
m_emptyCells == o.m_emptyCells
m_emptyCells == o.m_emptyCells
;
;
}
}


inline bool nonIndependentInheritedEqual(const ComputedStyleBase& o) const {
inline bool nonIndependentInheritedEqual(const ComputedStyleBase& o) const {
return true &&
return true &&
m_listStyleType == o.m_listStyleType &&
m_listStyleType == o.m_listStyleType &&
m_textAlign == o.m_textAlign &&
m_textAlign == o.m_textAlign &&
m_writingMode == o.m_writingMode &&
m_writingMode == o.m_writingMode &&
m_direction == o.m_direction
m_direction == o.m_direction
;
;
}
}


inline bool nonInheritedEqual(const ComputedStyleBase& o) const {
inline bool nonInheritedEqual(const ComputedStyleBase& o) const {
return true &&
return true &&
m_breakBefore == o.m_breakBefore &&
m_breakBefore == o.m_breakBefore &&
m_breakAfter == o.m_breakAfter &&
m_breakAfter == o.m_breakAfter &&
m_unicodeBidi == o.m_unicodeBidi &&
m_unicodeBidi == o.m_unicodeBidi &&
m_overflowX == o.m_overflowX &&
m_overflowX == o.m_overflowX &&
m_overflowY == o.m_overflowY &&
m_overflowY == o.m_overflowY &&
m_position == o.m_position &&
m_position == o.m_position &&
m_clear == o.m_clear &&
m_clear == o.m_clear &&
m_floating == o.m_floating &&
m_floating == o.m_floating &&
m_breakInside == o.m_breakInside &&
m_breakInside == o.m_breakInside &&
m_overflowAnchor == o.m_overflowAnchor &&
m_overflowAnchor == o.m_overflowAnchor &&
m_tableLayout == o.m_tableLayout
m_tableLayout == o.m_tableLayout
;
;
}
}


enum IsAtShadowBoundary {
enum IsAtShadowBoundary {
AtShadowBoundary,
AtShadowBoundary,
NotAtShadowBoundary,
NotAtShadowBoundary,
};
};
void inheritFrom(const ComputedStyleBase& inheritParent,
void inheritFrom(const ComputedStyleBase& inheritParent,
IsAtShadowBoundary isAtShadowBoundary = NotAtShadowBoundary);
IsAtShadowBoundary isAtShadowBoundary = NotAtShadowBoundary);


void copyNonInheritedFromCached(const ComputedStyleBase& other);
void copyNonInheritedFromCached(const ComputedStyleBase& other);


// Copies the values of any independent inherited properties from the parent
// Copies the values of any independent inherited properties from the parent
// style that are marked as inherited by this style.
// style that are marked as inherited by this style.
void propagateIndependentInheritedProperties(
void propagateIndependentInheritedProperties(
const ComputedStyleBase& parentStyle);
const ComputedStyleBase& parentStyle);


// Fields.
// Fields.
// TODO(sashab): Remove initialFoo() static methods and update callers to
// TODO(sashab): Remove initialFoo() static methods and update callers to
// use resetFoo(), which can be more efficient.
// use resetFoo(), which can be more efficient.


// list-style-type
// list-style-type
inline static EListStyleType initialListStyleType() {
inline static EListStyleType initialListStyleType() {
return EListStyleType::kDisc;
return EListStyleType::kDisc;
}
}
EListStyleType listStyleType() const {
EListStyleType listStyleType() const {
return static_cast<EListStyleType>(m_listStyleType);
return static_cast<EListStyleType>(m_listStyleType);
}
}
void setListStyleType(EListStyleType v) {
void setListStyleType(EListStyleType v) {
m_listStyleType = static_cast<unsigned>(v);
m_listStyleType = static_cast<unsigned>(v);
}
}
inline void resetListStyleType() {
inline void resetListStyleType() {
m_listStyleType = static_cast<unsigned>(EListStyleType::kDisc);
m_listStyleType = static_cast<unsigned>(EListStyleType::kDisc);
}
}


// break-before
// break-before
inline static EBreakBetween initialBreakBefore() {
inline static EBreakBetween initialBreakBefore() {
return EBreakBetween::kAuto;
return EBreakBetween::kAuto;
}
}
EBreakBetween breakBefore() const {
EBreakBetween breakBefore() const {
return static_cast<EBreakBetween>(m_breakBefore);
return static_cast<EBreakBetween>(m_breakBefore);
}
}
void setBreakBefore(EBreakBetween v) {
void setBreakBefore(EBreakBetween v) {
m_breakBefore = static_cast<unsigned>(v);
m_breakBefore = static_cast<unsigned>(v);
}
}
inline void resetBreakBefore() {
inline void resetBreakBefore() {
m_breakBefore = static_cast<unsigned>(EBreakBetween::kAuto);
m_breakBefore = static_cast<unsigned>(EBreakBetween::kAuto);
}
}


// break-after
// break-after
inline static EBreakBetween initialBreakAfter() {
inline static EBreakBetween initialBreakAfter() {
return EBreakBetween::kAuto;
return EBreakBetween::kAuto;
}
}
EBreakBetween breakAfter() const {
EBreakBetween breakAfter() const {
return static_cast<EBreakBetween>(m_breakAfter);
return static_cast<EBreakBetween>(m_breakAfter);
}
}
void setBreakAfter(EBreakBetween v) {
void setBreakAfter(EBreakBetween v) {
m_breakAfter = static_cast<unsigned>(v);
m_breakAfter = static_cast<unsigned>(v);
}
}
inline void resetBreakAfter() {
inline void resetBreakAfter() {
m_breakAfter = static_cast<unsigned>(EBreakBetween::kAuto);
m_breakAfter = static_cast<unsigned>(EBreakBetween::kAuto);
}
}


// pointer-events
// pointer-events
inline static EPointerEvents initialPointerEvents() {
inline static EPointerEvents initialPointerEvents() {
return EPointerEvents::kAuto;
return EPointerEvents::kAuto;
}
}
EPointerEvents pointerEvents() const {
EPointerEvents pointerEvents() const {
return static_cast<EPointerEvents>(m_pointerEvents);
return static_cast<EPointerEvents>(m_pointerEvents);
}
}
void setPointerEvents(EPointerEvents v) {
void setPointerEvents(EPointerEvents v) {
m_pointerEvents = static_cast<unsigned>(v);
m_pointerEvents = static_cast<unsigned>(v);
}
}
inline void resetPointerEvents() {
inline void resetPointerEvents() {
m_pointerEvents = static_cast<unsigned>(EPointerEvents::kAuto);
m_pointerEvents = static_cast<unsigned>(EPointerEvents::kAuto);
}
}


// text-align
// text-align
inline static ETextAlign initialTextAlign() {
inline static ETextAlign initialTextAlign() {
return ETextAlign::kStart;
return ETextAlign::kStart;
}
}
ETextAlign textAlign() const {
ETextAlign textAlign() const {
return static_cast<ETextAlign>(m_textAlign);
return static_cast<ETextAlign>(m_textAlign);
}
}
void setTextAlign(ETextAlign v) {
void setTextAlign(ETextAlign v) {
m_textAlign = static_cast<unsigned>(v);
m_textAlign = static_cast<unsigned>(v);
}
}
inline void resetTextAlign() {
inline void resetTextAlign() {
m_textAlign = static_cast<unsigned>(ETextAlign::kStart);
m_textAlign = static_cast<unsigned>(ETextAlign::kStart);
}
}


// unicode-bidi
// unicode-bidi
inline static UnicodeBidi initialUnicodeBidi() {
inline static UnicodeBidi initialUnicodeBidi() {
return UnicodeBidi::kNormal;
return UnicodeBidi::kNormal;
}
}
UnicodeBidi getUnicodeBidi() const {
UnicodeBidi getUnicodeBidi() const {
return static_cast<UnicodeBidi>(m_unicodeBidi);
return static_cast<UnicodeBidi>(m_unicodeBidi);
}
}
void setUnicodeBidi(UnicodeBidi v) {
void setUnicodeBidi(UnicodeBidi v) {
m_unicodeBidi = static_cast<unsigned>(v);
m_unicodeBidi = static_cast<unsigned>(v);
}
}
inline void resetUnicodeBidi() {
inline void resetUnicodeBidi() {
m_unicodeBidi = static_cast<unsigned>(UnicodeBidi::kNormal);
m_unicodeBidi = static_cast<unsigned>(UnicodeBidi::kNormal);
}
}


// overflow-x
// overflow-x
inline static EOverflow initialOverflowX() {
inline static EOverflow initialOverflowX() {
return EOverflow::kVisible;
return EOverflow::kVisible;
}
}
EOverflow overflowX() const {
EOverflow overflowX() const {
return static_cast<EOverflow>(m_overflowX);
return static_cast<EOverflow>(m_overflowX);
}
}
void setOverflowX(EOverflow v) {
void setOverflowX(EOverflow v) {
m_overflowX = static_cast<unsigned>(v);
m_overflowX = static_cast<unsigned>(v);
}
}
inline void resetOverflowX() {
inline void resetOverflowX() {
m_overflowX = static_cast<unsigned>(EOverflow::kVisible);
m_overflowX = static_cast<unsigned>(EOverflow::kVisible);
}
}


// overflow-y
// overflow-y
inline static EOverflow initialOverflowY() {
inline static EOverflow initialOverflowY() {
return EOverflow::kVisible;
return EOverflow::kVisible;
}
}
EOverflow overflowY() const {
EOverflow overflowY() const {
return static_cast<EOverflow>(m_overflowY);
return static_cast<EOverflow>(m_overflowY);
}
}
void setOverflowY(EOverflow v) {
void setOverflowY(EOverflow v) {
m_overflowY = static_cast<unsigned>(v);
m_overflowY = static_cast<unsigned>(v);
}
}
inline void resetOverflowY() {
inline void resetOverflowY() {
m_overflowY = static_cast<unsigned>(EOverflow::kVisible);
m_overflowY = static_cast<unsigned>(EOverflow::kVisible);
}
}


// -webkit-box-direction
// -webkit-box-direction
inline static bool initialBoxDirectionIsInherited() {
inline static bool initialBoxDirectionIsInherited() {
return true;
return true;
}
}
bool boxDirectionIsInherited() const {
bool boxDirectionIsInherited() const {
return static_cast<bool>(m_boxDirectionIsInherited);
return static_cast<bool>(m_boxDirectionIsInherited);
}
}
void setBoxDirectionIsInherited(bool v) {
void setBoxDirectionIsInherited(bool v) {
m_boxDirectionIsInherited = static_cast<unsigned>(v);
m_boxDirectionIsInherited = static_cast<unsigned>(v);
}
}
inline void resetBoxDirectionIsInherited() {
inline void resetBoxDirectionIsInherited() {
m_boxDirectionIsInherited = static_cast<unsigned>(true);
m_boxDirectionIsInherited = static_cast<unsigned>(true);
}
}


// position
// position
inline static EPosition initialPosition() {
inline static EPosition initialPosition() {
return EPosition::kStatic;
return EPosition::kStatic;
}
}
EPosition position() const {
EPosition position() const {
return static_cast<EPosition>(m_position);
return static_cast<EPosition>(m_position);
}
}
void setPosition(EPosition v) {
void setPosition(EPosition v) {
m_position = static_cast<unsigned>(v);
m_position = static_cast<unsigned>(v);
}
}
inline void resetPosition() {
inline void resetPosition() {
m_position = static_cast<unsigned>(EPosition::kStatic);
m_position = static_cast<unsigned>(EPosition::kStatic);
}
}


// white-space
// white-space
inline static EWhiteSpace initialWhiteSpace() {
inline static EWhiteSpace initialWhiteSpace() {
return EWhiteSpace::kNormal;
return EWhiteSpace::kNormal;
}
}
EWhiteSpace whiteSpace() const {
EWhiteSpace whiteSpace() const {
return static_cast<EWhiteSpace>(m_whiteSpace);
return static_cast<EWhiteSpace>(m_whiteSpace);
}
}
void setWhiteSpace(EWhiteSpace v) {
void setWhiteSpace(EWhiteSpace v) {
m_whiteSpace = static_cast<unsigned>(v);
m_whiteSpace = static_cast<unsigned>(v);
}
}
inline void resetWhiteSpace() {
inline void resetWhiteSpace() {
m_whiteSpace = static_cast<unsigned>(EWhiteSpace::kNormal);
m_whiteSpace = static_cast<unsigned>(EWhiteSpace::kNormal);
}
}


// clear
// clear
inline static EClear initialClear() {
inline static EClear initialClear() {
return EClear::kNone;
return EClear::kNone;
}
}
EClear clear() const {
EClear clear() const {
return static_cast<EClear>(m_clear);
return static_cast<EClear>(m_clear);
}
}
void setClear(EClear v) {
void setClear(EClear v) {
m_clear = static_cast<unsigned>(v);
m_clear = static_cast<unsigned>(v);
}
}
inline void resetClear() {
inline void resetClear() {
m_clear = static_cast<unsigned>(EClear::kNone);
m_clear = static_cast<unsigned>(EClear::kNone);
}
}


// caption-side
// caption-side
inline static ECaptionSide initialCaptionSide() {
inline static ECaptionSide initialCaptionSide() {
return ECaptionSide::kTop;
return ECaptionSide::kTop;
}
}
ECaptionSide captionSide() const {
ECaptionSide captionSide() const {
return static_cast<ECaptionSide>(m_captionSide);
return static_cast<ECaptionSide>(m_captionSide);
}
}
void setCaptionSide(ECaptionSide v) {
void setCaptionSide(ECaptionSide v) {
m_captionSide = static_cast<unsigned>(v);
m_captionSide = static_cast<unsigned>(v);
}
}
inline void resetCaptionSide() {
inline void resetCaptionSide() {
m_captionSide = static_cast<unsigned>(ECaptionSide::kTop);
m_captionSide = static_cast<unsigned>(ECaptionSide::kTop);
}
}


// writing-mode
// writing-mode
inline static WritingMode initialWritingMode() {
inline static WritingMode initialWritingMode() {
return WritingMode::kHorizontalTb;
return WritingMode::kHorizontalTb;
}
}
WritingMode getWritingMode() const {
WritingMode getWritingMode() const {
return static_cast<WritingMode>(m_writingMode);
return static_cast<WritingMode>(m_writingMode);
}
}
void setWritingMode(WritingMode v) {
void setWritingMode(WritingMode v) {
m_writingMode = static_cast<unsigned>(v);
m_writingMode = static_cast<unsigned>(v);
}
}
inline void resetWritingMode() {
inline void resetWritingMode() {
m_writingMode = static_cast<unsigned>(WritingMode::kHorizontalTb);
m_writingMode = static_cast<unsigned>(WritingMode::kHorizontalTb);
}
}


// float
// float
inline static EFloat initialFloating() {
inline static EFloat initialFloating() {
return EFloat::kNone;
return EFloat::kNone;
}
}
EFloat floating() const {
EFloat floating() const {
return static_cast<EFloat>(m_floating);
return static_cast<EFloat>(m_floating);
}
}
void setFloating(EFloat v) {
void setFloating(EFloat v) {
m_floating = static_cast<unsigned>(v);
m_floating = static_cast<unsigned>(v);
}
}
inline void resetFloating() {
inline void resetFloating() {
m_floating = static_cast<unsigned>(EFloat::kNone);
m_floating = static_cast<unsigned>(EFloat::kNone);
}
}


// break-inside
// break-inside
inline static EBreakInside initialBreakInside() {
inline static EBreakInside initialBreakInside() {
return EBreakInside::kAuto;
return EBreakInside::kAuto;
}
}
EBreakInside breakInside() const {
EBreakInside breakInside() const {
return static_cast<EBreakInside>(m_breakInside);
return static_cast<EBreakInside>(m_breakInside);
}
}
void setBreakInside(EBreakInside v) {
void setBreakInside(EBreakInside v) {
m_breakInside = static_cast<unsigned>(v);
m_breakInside = static_cast<unsigned>(v);
}
}
inline void resetBreakInside() {
inline void resetBreakInside() {
m_breakInside = static_cast<unsigned>(EBreakInside::kAuto);
m_breakInside = static_cast<unsigned>(EBreakInside::kAuto);
}
}


// overflow-anchor
// overflow-anchor
inline static EOverflowAnchor initialOverflowAnchor() {
inline static EOverflowAnchor initialOverflowAnchor() {
return EOverflowAnchor::kAuto;
return EOverflowAnchor::kAuto;
}
}
EOverflowAnchor overflowAnchor() const {
EOverflowAnchor overflowAnchor() const {
return static_cast<EOverflowAnchor>(m_overflowAnchor);
return static_cast<EOverflowAnchor>(m_overflowAnchor);
}
}
void setOverflowAnchor(EOverflowAnchor v) {
void setOverflowAnchor(EOverflowAnchor v) {
m_overflowAnchor = static_cast<unsigned>(v);
m_overflowAnchor = static_cast<unsigned>(v);
}
}
inline void resetOverflowAnchor() {
inline void resetOverflowAnchor() {
m_overflowAnchor = static_cast<unsigned>(EOverflowAnchor::kAuto);
m_overflowAnchor = static_cast<unsigned>(EOverflowAnchor::kAuto);
}
}


// text-transform
// text-transform
inline static ETextTransform initialTextTransform() {
inline static ETextTransform initialTextTransform() {
return ETextTransform::kNone;
return ETextTransform::kNone;
}
}
ETextTransform textTransform() const {
ETextTransform textTransform() const {
return static_cast<ETextTransform>(m_textTransform);
return static_cast<ETextTransform>(m_textTransform);
}
}
void setTextTransform(ETextTransform v) {
void setTextTransform(ETextTransform v) {
m_textTransform = static_cast<unsigned>(v);
m_textTransform = static_cast<unsigned>(v);
}
}
inline void resetTextTransform() {
inline void resetTextTransform() {
m_textTransform = static_cast<unsigned>(ETextTransform::kNone);
m_textTransform = static_cast<unsigned>(ETextTransform::kNone);
}
}


// visibility
// visibility
inline static EVisibility initialVisibility() {
inline static EVisibility initialVisibility() {
return EVisibility::kVisible;
return EVisibility::kVisible;
}
}
EVisibility visibility() const {
EVisibility visibility() const {
return static_cast<EVisibility>(m_visibility);
return static_cast<EVisibility>(m_visibility);
}
}
void setVisibility(EVisibility v) {
void setVisibility(EVisibility v) {
m_visibility = static_cast<unsigned>(v);
m_visibility = static_cast<unsigned>(v);
}
}
inline void resetVisibility() {
inline void resetVisibility() {
m_visibility = static_cast<unsigned>(EVisibility::kVisible);
m_visibility = static_cast<unsigned>(EVisibility::kVisible);
}
}


// -webkit-box-direction
// -webkit-box-direction
inline static EBoxDirection initialBoxDirection() {
inline static EBoxDirection initialBoxDirection() {
return EBoxDirection::kNormal;
return EBoxDirection::kNormal;
}
}
EBoxDirection boxDirection() const {
EBoxDirection boxDirection() const {
return static_cast<EBoxDirection>(m_boxDirection);
return static_cast<EBoxDirection>(m_boxDirection);
}
}
void setBoxDirection(EBoxDirection v) {
void setBoxDirection(EBoxDirection v) {
m_boxDirection = static_cast<unsigned>(v);
m_boxDirection = static_cast<unsigned>(v);
}
}
inline void resetBoxDirection() {
inline void resetBoxDirection() {
m_boxDirection = static_cast<unsigned>(EBoxDirection::kNormal);
m_boxDirection = static_cast<unsigned>(EBoxDirection::kNormal);
}
}


// caption-side
// caption-side
inline static bool initialCaptionSideIsInherited() {
inline static bool initialCaptionSideIsInherited() {
return true;
return true;
}
}
bool captionSideIsInherited() const {
bool captionSideIsInherited() const {
return static_cast<bool>(m_captionSideIsInherited);
return static_cast<bool>(m_captionSideIsInherited);
}
}
void setCaptionSideIsInherited(bool v) {
void setCaptionSideIsInherited(bool v) {
m_captionSideIsInherited = static_cast<unsigned>(v);
m_captionSideIsInherited = static_cast<unsigned>(v);
}
}
inline void resetCaptionSideIsInherited() {
inline void resetCaptionSideIsInherited() {
m_captionSideIsInherited = static_cast<unsigned>(true);
m_captionSideIsInherited = static_cast<unsigned>(true);
}
}


// -webkit-print-color-adjust
// -webkit-print-color-adjust
inline static bool initialPrintColorAdjustIsInherited() {
inline static bool initialPrintColorAdjustIsInherited() {
return true;
return true;
}
}
bool printColorAdjustIsInherited() const {
bool printColorAdjustIsInherited() const {
return static_cast<bool>(m_printColorAdjustIsInherited);
return static_cast<bool>(m_printColorAdjustIsInherited);
}
}
void setPrintColorAdjustIsInherited(bool v) {
void setPrintColorAdjustIsInherited(bool v) {
m_printColorAdjustIsInherited = static_cast<unsigned>(v);
m_printColorAdjustIsInherited = static_cast<unsigned>(v);
}
}
inline void resetPrintColorAdjustIsInherited() {
inline void resetPrintColorAdjustIsInherited() {
m_printColorAdjustIsInherited = static_cast<unsigned>(true);
m_printColorAdjustIsInherited = static_cast<unsigned>(true);
}
}


// -webkit-print-color-adjust
// -webkit-print-color-adjust
inline static EPrintColorAdjust initialPrintColorAdjust() {
inline static EPrintColorAdjust initialPrintColorAdjust() {
return EPrintColorAdjust::kEconomy;
return EPrintColorAdjust::kEconomy;
}
}
EPrintColorAdjust printColorAdjust() const {
EPrintColorAdjust printColorAdjust() const {
return static_cast<EPrintColorAdjust>(m_printColorAdjust);
return static_cast<EPrintColorAdjust>(m_printColorAdjust);
}
}
void setPrintColorAdjust(EPrintColorAdjust v) {
void setPrintColorAdjust(EPrintColorAdjust v) {
m_printColorAdjust = static_cast<unsigned>(v);
m_printColorAdjust = static_cast<unsigned>(v);
}
}
inline void resetPrintColorAdjust() {
inline void resetPrintColorAdjust() {
m_printColorAdjust = static_cast<unsigned>(EPrintColorAdjust::kEconomy);
m_printColorAdjust = static_cast<unsigned>(EPrintColorAdjust::kEconomy);
}
}


// border-collapse
// border-collapse
inline static bool initialBorderCollapseIsInherited() {
inline static bool initialBorderCollapseIsInherited() {
return true;
return true;
}
}
bool borderCollapseIsInherited() const {
bool borderCollapseIsInherited() const {
return static_cast<bool>(m_borderCollapseIsInherited);
return static_cast<bool>(m_borderCollapseIsInherited);
}
}
void setBorderCollapseIsInherited(bool v) {
void setBorderCollapseIsInherited(bool v) {
m_borderCollapseIsInherited = static_cast<unsigned>(v);
m_borderCollapseIsInherited = static_cast<unsigned>(v);
}
}
inline void resetBorderCollapseIsInherited() {
inline void resetBorderCollapseIsInherited() {
m_borderCollapseIsInherited = static_cast<unsigned>(true);
m_borderCollapseIsInherited = static_cast<unsigned>(true);
}
}


// border-collapse
// border-collapse
inline static EBorderCollapse initialBorderCollapse() {
inline static EBorderCollapse initialBorderCollapse() {
return EBorderCollapse::kSeparate;
return EBorderCollapse::kSeparate;
}
}
EBorderCollapse borderCollapse() const {
EBorderCollapse borderCollapse() const {
return static_cast<EBorderCollapse>(m_borderCollapse);
return static_cast<EBorderCollapse>(m_borderCollapse);
}
}
void setBorderCollapse(EBorderCollapse v) {
void setBorderCollapse(EBorderCollapse v) {
m_borderCollapse = static_cast<unsigned>(v);
m_borderCollapse = static_cast<unsigned>(v);
}
}
inline void resetBorderCollapse() {
inline void resetBorderCollapse() {
m_borderCollapse = static_cast<unsigned>(EBorderCollapse::kSeparate);
m_borderCollapse = static_cast<unsigned>(EBorderCollapse::kSeparate);
}
}


// -webkit-rtl-ordering
// -webkit-rtl-ordering
inline static bool initialRtlOrderingIsInherited() {
inline static bool initialRtlOrderingIsInherited() {
return true;
return true;
}
}
bool rtlOrderingIsInherited() const {
bool rtlOrderingIsInherited() const {
return static_cast<bool>(m_rtlOrderingIsInherited);
return static_cast<bool>(m_rtlOrderingIsInherited);
}
}
void setRtlOrderingIsInherited(bool v) {
void setRtlOrderingIsInherited(bool v) {
m_rtlOrderingIsInherited = static_cast<unsigned>(v);
m_rtlOrderingIsInherited = static_cast<unsigned>(v);
}
}
inline void resetRtlOrderingIsInherited() {
inline void resetRtlOrderingIsInherited() {
m_rtlOrderingIsInherited = static_cast<unsigned>(true);
m_rtlOrderingIsInherited = static_cast<unsigned>(true);
}
}


// -webkit-rtl-ordering
// -webkit-rtl-ordering
inline static EOrder initialRtlOrdering() {
inline static EOrder initialRtlOrdering() {
return EOrder::kLogical;
return EOrder::kLogical;
}
}
EOrder rtlOrdering() const {
EOrder rtlOrdering() const {
return static_cast<EOrder>(m_rtlOrdering);
return static_cast<EOrder>(m_rtlOrdering);
}
}
void setRtlOrdering(EOrder v) {
void setRtlOrdering(EOrder v) {
m_rtlOrdering = static_cast<unsigned>(v);
m_rtlOrdering = static_cast<unsigned>(v);
}
}
inline void resetRtlOrdering() {
inline void resetRtlOrdering() {
m_rtlOrdering = static_cast<unsigned>(EOrder::kLogical);
m_rtlOrdering = static_cast<unsigned>(EOrder::kLogical);
}
}


// white-space
// white-space
inline static bool initialWhiteSpaceIsInherited() {
inline static bool initialWhiteSpaceIsInherited() {
return true;
return true;
}
}
bool whiteSpaceIsInherited() const {
bool whiteSpaceIsInherited() const {
return static_cast<bool>(m_whiteSpaceIsInherited);
return static_cast<bool>(m_whiteSpaceIsInherited);
}
}
void setWhiteSpaceIsInherited(bool v) {
void setWhiteSpaceIsInherited(bool v) {
m_whiteSpaceIsInherited = static_cast<unsigned>(v);
m_whiteSpaceIsInherited = static_cast<unsigned>(v);
}
}
inline void resetWhiteSpaceIsInherited() {
inline void resetWhiteSpaceIsInherited() {
m_whiteSpaceIsInherited = static_cast<unsigned>(true);
m_whiteSpaceIsInherited = static_cast<unsigned>(true);
}
}


// table-layout
// table-layout
inline static ETableLayout initialTableLayout() {
inline static ETableLayout initialTableLayout() {
return ETableLayout::kAuto;
return ETableLayout::kAuto;
}
}
ETableLayout tableLayout() const {
ETableLayout tableLayout() const {
return static_cast<ETableLayout>(m_tableLayout);
return static_cast<ETableLayout>(m_tableLayout);
}
}
void setTableLayout(ETableLayout v) {
void setTableLayout(ETableLayout v) {
m_tableLayout = static_cast<unsigned>(v);
m_tableLayout = static_cast<unsigned>(v);
}
}
inline void resetTableLayout() {
inline void resetTableLayout() {
m_tableLayout = static_cast<unsigned>(ETableLayout::kAuto);
m_tableLayout = static_cast<unsigned>(ETableLayout::kAuto);
}
}


// list-style-position
// list-style-position
inline static bool initialListStylePositionIsInherited() {
inline static bool initialListStylePositionIsInherited() {
return true;
return true;
}
}
bool listStylePositionIsInherited() const {
bool listStylePositionIsInherited() const {
return static_cast<bool>(m_listStylePositionIsInherited);
return static_cast<bool>(m_listStylePositionIsInherited);
}
}
void setListStylePositionIsInherited(bool v) {
void setListStylePositionIsInherited(bool v) {
m_listStylePositionIsInherited = static_cast<unsigned>(v);
m_listStylePositionIsInherited = static_cast<unsigned>(v);
}
}
inline void resetListStylePositionIsInherited() {
inline void resetListStylePositionIsInherited() {
m_listStylePositionIsInherited = static_cast<unsigned>(true);
m_listStylePositionIsInherited = static_cast<unsigned>(true);
}
}


// list-style-position
// list-style-position
inline static EListStylePosition initialListStylePosition() {
inline static EListStylePosition initialListStylePosition() {
return EListStylePosition::kOutside;
return EListStylePosition::kOutside;
}
}
EListStylePosition listStylePosition() const {
EListStylePosition listStylePosition() const {
return static_cast<EListStylePosition>(m_listStylePosition);
return static_cast<EListStylePosition>(m_listStylePosition);
}
}
void setListStylePosition(EListStylePosition v) {
void setListStylePosition(EListStylePosition v) {
m_listStylePosition = static_cast<unsigned>(v);
m_listStylePosition = static_cast<unsigned>(v);
}
}
inline void resetListStylePosition() {
inline void resetListStylePosition() {
m_listStylePosition = static_cast<unsigned>(EListStylePosition::kOutside);
m_listStylePosition = static_cast<unsigned>(EListStylePosition::kOutside);
}
}


// pointer-events
// pointer-events
inline static bool initialPointerEventsIsInherited() {
inline static bool initialPointerEventsIsInherited() {
return true;
return true;
}
}
bool pointerEventsIsInherited() const {
bool pointerEventsIsInherited() const {
return static_cast<bool>(m_pointerEventsIsInherited);
return static_cast<bool>(m_pointerEventsIsInherited);
}
}
void setPointerEventsIsInherited(bool v) {
void setPointerEventsIsInherited(bool v) {
m_pointerEventsIsInherited = static_cast<unsigned>(v);
m_pointerEventsIsInherited = static_cast<unsigned>(v);
}
}
inline void resetPointerEventsIsInherited() {
inline void resetPointerEventsIsInherited() {
m_pointerEventsIsInherited = static_cast<unsigned>(true);
m_pointerEventsIsInherited = static_cast<unsigned>(true);
}
}


// text-transform
// text-transform
inline static bool initialTextTransformIsInherited() {
inline static bool initialTextTransformIsInherited() {
return true;
return true;
}
}
bool textTransformIsInherited() const {
bool textTransformIsInherited() const {
return static_cast<bool>(m_textTransformIsInherited);
return static_cast<bool>(m_textTransformIsInherited);
}
}
void setTextTransformIsInherited(bool v) {
void setTextTransformIsInherited(bool v) {
m_textTransformIsInherited = static_cast<unsigned>(v);
m_textTransformIsInherited = static_cast<unsigned>(v);
}
}
inline void resetTextTransformIsInherited() {
inline void resetTextTransformIsInherited() {
m_textTransformIsInherited = static_cast<unsigned>(true);
m_textTransformIsInherited = static_cast<unsigned>(true);
}
}


// direction
// direction
inline static TextDirection initialDirection() {
inline static TextDirection initialDirection() {
return TextDirection::kLtr;
return TextDirection::kLtr;
}
}
TextDirection direction() const {
TextDirection direction() const {
return static_cast<TextDirection>(m_direction);
return static_cast<TextDirection>(m_direction);
}
}
void setDirection(TextDirection v) {
void setDirection(TextDirection v) {
m_direction = static_cast<unsigned>(v);
m_direction = static_cast<unsigned>(v);
}
}
inline void resetDirection() {
inline void resetDirection() {
m_direction = static_cast<unsigned>(TextDirection::kLtr);
m_direction = static_cast<unsigned>(TextDirection::kLtr);
}
}


// empty-cells
// empty-cells
inline static bool initialEmptyCellsIsInherited() {
inline static bool initialEmptyCellsIsInherited() {
return true;
return true;
}
}
bool emptyCellsIsInherited() const {
bool emptyCellsIsInherited() const {
return static_cast<bool>(m_emptyCellsIsInherited);
return static_cast<bool>(m_emptyCellsIsInherited);
}
}
void setEmptyCellsIsInherited(bool v) {
void setEmptyCellsIsInherited(bool v) {
m_emptyCellsIsInherited = static_cast<unsigned>(v);
m_emptyCellsIsInherited = static_cast<unsigned>(v);
}
}
inline void resetEmptyCellsIsInherited() {
inline void resetEmptyCellsIsInherited() {
m_emptyCellsIsInherited = static_cast<unsigned>(true);
m_emptyCellsIsInherited = static_cast<unsigned>(true);
}
}


// empty-cells
// empty-cells
inline static EEmptyCells initialEmptyCells() {
inline static EEmptyCells initialEmptyCells() {
return EEmptyCells::kShow;
return EEmptyCells::kShow;
}
}
EEmptyCells emptyCells() const {
EEmptyCells emptyCells() const {
return static_cast<EEmptyCells>(m_emptyCells);
return static_cast<EEmptyCells>(m_emptyCells);
}
}
void setEmptyCells(EEmptyCells v) {
void setEmptyCells(EEmptyCells v) {
m_emptyCells = static_cast<unsigned>(v);
m_emptyCells = static_cast<unsigned>(v);
}
}
inline void resetEmptyCells() {
inline void resetEmptyCells() {
m_emptyCells = static_cast<unsigned>(EEmptyCells::kShow);
m_emptyCells = static_cast<unsigned>(EEmptyCells::kShow);
}
}


// visibility
// visibility
inline static bool initialVisibilityIsInherited() {
inline static bool initialVisibilityIsInherited() {
return true;
return true;
}
}
bool visibilityIsInherited() const {
bool visibilityIsInherited() const {
return static_cast<bool>(m_visibilityIsInherited);
return static_cast<bool>(m_visibilityIsInherited);
}
}
void setVisibilityIsInherited(bool v) {
void setVisibilityIsInherited(bool v) {
m_visibilityIsInherited = static_cast<unsigned>(v);
m_visibilityIsInherited = static_cast<unsigned>(v);
}
}
inline void resetVisibilityIsInherited() {
inline void resetVisibilityIsInherited() {
m_visibilityIsInherited = static_cast<unsigned>(true);
m_visibilityIsInherited = static_cast<unsigned>(true);
}
}


// unique
// unique
inline static bool initialUnique() {
return false;
}
bool unique() const {
bool unique() const {
return static_cast<bool>(m_unique);
return m_unique;
}
}
void setUniq
void setUnique() {
m_unique = static_cast<unsigned>(true);
}

protected:
// Storage