use super::*;
pub(in crate::css) fn logical_mapping_context(
base_style: &ComputedStyle,
declarations: &[CascadedDeclaration<'_>],
inheritance_source: &ComputedStyle,
) -> (Direction, WritingMode) {
let mut direction = base_style.direction;
let mut writing_mode = base_style.writing_mode;
for declaration in declarations {
let Some(property) = declaration.property.modeled() else {
continue;
};
let value = trim_css_value(&declaration.value);
if contains_css_variable_reference(value)
|| declaration_is_revert(value)
|| declaration_is_revert_layer(value)
{
continue;
}
if matches!(property, ModeledProperty::All) {
if let Some(keyword) = CssWideDefaultKeyword::parse(value) {
writing_mode = defaulted_writing_mode(keyword, inheritance_source);
}
continue;
}
if let Some(keyword) = CssWideDefaultKeyword::parse(value) {
match property {
ModeledProperty::Longhand(ModeledLonghand::Direction) => {
direction = defaulted_direction(keyword, inheritance_source)
}
ModeledProperty::Longhand(ModeledLonghand::WritingMode) => {
writing_mode = defaulted_writing_mode(keyword, inheritance_source);
}
_ => {}
}
continue;
}
match property {
ModeledProperty::Longhand(ModeledLonghand::Direction) => {
if let Some(parsed) = parse_direction(value) {
direction = parsed;
}
}
ModeledProperty::Longhand(ModeledLonghand::WritingMode) => {
if let Some(parsed) = parse_writing_mode(value) {
writing_mode = parsed;
}
}
_ => {}
}
}
(direction, writing_mode)
}
pub(in crate::css) fn defaulted_direction(
keyword: CssWideDefaultKeyword,
inheritance_source: &ComputedStyle,
) -> Direction {
match keyword {
CssWideDefaultKeyword::Initial => ComputedStyle::initial().direction,
CssWideDefaultKeyword::Inherit | CssWideDefaultKeyword::Unset => {
inheritance_source.direction
}
}
}
pub(in crate::css) fn defaulted_writing_mode(
keyword: CssWideDefaultKeyword,
inheritance_source: &ComputedStyle,
) -> WritingMode {
match keyword {
CssWideDefaultKeyword::Initial => ComputedStyle::initial().writing_mode,
CssWideDefaultKeyword::Inherit | CssWideDefaultKeyword::Unset => {
inheritance_source.writing_mode
}
}
}
pub(in crate::css) fn parse_direction(value: &str) -> Option<Direction> {
match trim_css_value(value).to_ascii_lowercase().as_str() {
"ltr" => Some(Direction::Ltr),
"rtl" => Some(Direction::Rtl),
_ => None,
}
}
pub(in crate::css) fn parse_writing_mode(value: &str) -> Option<WritingMode> {
match trim_css_value(value).to_ascii_lowercase().as_str() {
"horizontal-tb" => Some(WritingMode::HorizontalTb),
"vertical-rl" => Some(WritingMode::VerticalRl),
"vertical-lr" => Some(WritingMode::VerticalLr),
"sideways-rl" => Some(WritingMode::SidewaysRl),
"sideways-lr" => Some(WritingMode::SidewaysLr),
_ => None,
}
}
pub(in crate::css) fn parse_text_orientation(value: &str) -> Option<TextOrientation> {
match trim_css_value(value).to_ascii_lowercase().as_str() {
"mixed" => Some(TextOrientation::Mixed),
"upright" => Some(TextOrientation::Upright),
"sideways" => Some(TextOrientation::Sideways),
_ => None,
}
}
pub(in crate::css) fn parse_text_combine_upright(value: &str) -> Option<TextCombineUpright> {
let tokens = split_css_component_values(trim_css_value(value));
match tokens.as_slice() {
[keyword] if keyword.eq_ignore_ascii_case("none") => Some(TextCombineUpright::None),
[keyword] if keyword.eq_ignore_ascii_case("all") => Some(TextCombineUpright::All),
[keyword, digits] if keyword.eq_ignore_ascii_case("digits") => digits
.parse::<u8>()
.ok()
.filter(|digits| (2..=4).contains(digits))
.map(TextCombineUpright::Digits),
_ => None,
}
}