azul_css/codegen/

format.rs

//! Generates const-compatible Rust source code from parsed CSS values.
//!
//! This module provides the [`FormatAsRustCode`] trait for converting CSS types
//! into Rust source strings, [`GetHash`] for content-based deduplication, and
//! [`VecContents`] for collecting heap-allocated CSS values that must be
//! declared as `const` slices before use in generated code.
//!
//! Primary consumer: `core::xml` uses this for CSS-to-Rust code generation.

use alloc::{collections::btree_map::BTreeMap, format, string::String, string::ToString, vec::Vec};
use core::fmt::Write;
use core::hash::Hash;

// wildcard imports: the code generator references the full set of property types
// across every css sub-module; listing them all explicitly is unmaintainable.
#[allow(clippy::wildcard_imports)]
use crate::{
    corety::*,
    css::*,
    props::{basic::*, layout::*, property::*, style::*},
};

/// Formats a value as const-compatible Rust source code.
pub trait FormatAsRustCode {
    fn format_as_rust_code(&self, tabs: usize) -> String;
}

/// Returns a deterministic 64-bit hash for content-based deduplication.
pub trait GetHash {
    fn get_hash(&self) -> u64;
}

impl<T: Hash> GetHash for T {
    fn get_hash(&self) -> u64 {
        use core::hash::Hasher;
        let mut hasher = std::hash::DefaultHasher::new();
        self.hash(&mut hasher);
        hasher.finish()
    }
}

// In order to generate the Rust code, all items that implement Drop
// have to be declared before being used.

impl<T: FormatAsRustCode + 'static> FormatAsRustCode for BoxOrStatic<T> {
    fn format_as_rust_code(&self, tabs: usize) -> String {
        self.as_ref().format_as_rust_code(tabs)
    }
}

/// Collects heap-allocated CSS values (strings, vecs) that must be emitted as
/// `const` slice declarations before the generated Rust code can reference them.
#[derive(Debug, Default)]
pub struct VecContents {
    // the u64 is the hash of the type (generated by string.get_hash())
    pub strings: BTreeMap<u64, AzString>,
    pub style_filters: BTreeMap<u64, StyleFilterVec>,
    pub style_background_sizes: BTreeMap<u64, StyleBackgroundSizeVec>,
    pub style_background_repeats: BTreeMap<u64, StyleBackgroundRepeatVec>,
    pub style_background_contents: BTreeMap<u64, StyleBackgroundContentVec>,
    pub style_background_positions: BTreeMap<u64, StyleBackgroundPositionVec>,
    pub style_transforms: BTreeMap<u64, StyleTransformVec>,
    pub font_families: BTreeMap<u64, StyleFontFamilyVec>,
    pub linear_color_stops: BTreeMap<u64, NormalizedLinearColorStopVec>,
    pub radial_color_stops: BTreeMap<u64, NormalizedRadialColorStopVec>,
}

impl VecContents {
    pub fn format(&self, tabs: usize) -> String {
        let mut result = String::new();
        let t = "    ".repeat(tabs);
        let t2 = "    ".repeat(tabs + 1);

        for (key, item) in &self.strings {
            let _ = write!(
                result,
                "\r\n    const STRING_{}: AzString = AzString::from_const_str(\"{}\");",
                key,
                item.as_str()
            );
        }

        for (key, item) in &self.style_filters {
            let val = item
                .iter()
                .map(|filter| format_style_filter(filter, tabs + 1))
                .collect::<Vec<_>>()
                .join(&format!(",\r\n{t}"));

            let _ =
                write!(result,
                "\r\n    const STYLE_FILTER_{key}_ITEMS: &[StyleFilter] = &[\r\n{t2}{val}\r\n{t}];"
            );
        }

        for (key, item) in &self.style_background_sizes {
            let val = item
                .iter()
                .map(format_style_background_size)
                .collect::<Vec<_>>()
                .join(&format!(",\r\n{t}"));

            let _ = write!(
                result,
                "\r\n    const STYLE_BACKGROUND_SIZE_{key}_ITEMS: &[StyleBackgroundSize] = \
                 &[\r\n{t2}{val}\r\n{t}];"
            );
        }

        for (key, item) in &self.style_background_repeats {
            let val = item
                .iter()
                .map(|bgr| bgr.format_as_rust_code(tabs + 1))
                .collect::<Vec<_>>()
                .join(&format!(",\r\n{t}"));

            let _ =
                write!(result,
                "\r\n    const STYLE_BACKGROUND_REPEAT_{key}_ITEMS: &[StyleBackgroundRepeat] = \
                 &[\r\n{t2}{val}\r\n{t}];"
            );
        }

        for (key, item) in &self.style_background_contents {
            let val = item
                .iter()
                .map(|bgc| format_style_background_content(bgc, tabs + 1))
                .collect::<Vec<_>>()
                .join(&format!(",\r\n{t}"));

            let _ =
                write!(result,
                "\r\n    const STYLE_BACKGROUND_CONTENT_{key}_ITEMS: &[StyleBackgroundContent] = \
                 &[\r\n{t2}{val}\r\n{t}];"
            );
        }

        for (key, item) in &self.style_background_positions {
            let val = item
                .iter()
                .map(|bgp| format_style_background_position(bgp, tabs))
                .collect::<Vec<_>>()
                .join(&format!(",\r\n{t}"));

            let _ = write!(result,
                "\r\n    const STYLE_BACKGROUND_POSITION_{key}_ITEMS: &[StyleBackgroundPosition] = \
                 &[\r\n{t2}{val}\r\n{t}];"
            );
        }

        for (key, item) in &self.style_transforms {
            let val = format_style_transforms(item.as_ref(), tabs + 1);

            let _ = write!(result,
                "\r\n    const STYLE_TRANSFORM_{key}_ITEMS: &[StyleTransform] = &[\r\n{t2}{val}\r\n{t}];"
            );
        }

        for (key, item) in &self.font_families {
            let val = format_font_ids(item.as_ref(), tabs + 1);

            let _ = write!(result,
                "\r\n    const STYLE_FONT_FAMILY_{key}_ITEMS: &[StyleFontFamily] = &[\r\n{t2}{val}\r\n{t}];"
            );
        }

        for (key, item) in &self.linear_color_stops {
            let val = format_linear_color_stops(item.as_ref(), 1);

            let _ = write!(
                result,
                "\r\n    const LINEAR_COLOR_STOP_{key}_ITEMS: &[NormalizedLinearColorStop] = \
                 &[\r\n{t2}{val}\r\n{t}];"
            );
        }

        for (key, item) in &self.radial_color_stops {
            let val = format_radial_color_stops(item.as_ref(), tabs);

            let _ = write!(
                result,
                "\r\n    const RADIAL_COLOR_STOP_{key}_ITEMS: &[NormalizedRadialColorStop] = \
                 &[\r\n{t2}{val}\r\n{t}];"
            );
        }

        result
    }

    // given a CSS property, clones all the necessary strings (see class documentation)
    // Cross-type dispatch over CssProperty variants; identical-looking arm bodies
    // bind different value types and can't merge (clippy::match_same_arms FP).
    #[allow(clippy::match_same_arms)]
    pub fn insert_from_css_property(&mut self, prop: &CssProperty) {
        match prop {
            CssProperty::FontFamily(CssPropertyValue::Exact(v)) => {
                for family in v {
                    match family {
                        StyleFontFamily::System(s) => {
                            // if the font-family is surrounded by quotes, strip them ("Arial" ->
                            // Arial)
                            let s = s.as_str();
                            let s = s.trim();
                            let s = s.trim_start_matches('\"');
                            let s = s.trim_end_matches('\"');
                            let s = s.trim_start_matches('\'');
                            let s = s.trim_end_matches('\'');

                            self.strings.insert(s.get_hash(), s.to_string().into());
                        }
                        StyleFontFamily::File(s) => {
                            let s = s.as_str();
                            let s = s.trim();
                            let s = s.trim_start_matches('\"');
                            let s = s.trim_end_matches('\"');
                            let s = s.trim_start_matches('\'');
                            let s = s.trim_end_matches('\'');

                            self.strings.insert(s.get_hash(), s.to_string().into());
                        }
                        _ => {}
                    }
                }
                self.font_families.insert(v.get_hash(), v.clone());
            }
            CssProperty::Transform(CssPropertyValue::Exact(v)) => {
                self.style_transforms.insert(v.get_hash(), v.clone());
            }
            CssProperty::BackgroundRepeat(CssPropertyValue::Exact(v)) => {
                self.style_background_repeats
                    .insert(v.get_hash(), v.clone());
            }
            CssProperty::BackgroundSize(CssPropertyValue::Exact(v)) => {
                self.style_background_sizes.insert(v.get_hash(), v.clone());
            }
            CssProperty::BackgroundPosition(CssPropertyValue::Exact(v)) => {
                self.style_background_positions
                    .insert(v.get_hash(), v.clone());
            }
            CssProperty::BackgroundContent(CssPropertyValue::Exact(ref v)) => {
                for background in v {
                    match background {
                        StyleBackgroundContent::Image(id) => {
                            self.strings.insert(id.get_hash(), id.clone());
                        }
                        StyleBackgroundContent::LinearGradient(lg) => {
                            self.linear_color_stops
                                .insert(lg.stops.get_hash(), lg.stops.clone());
                        }
                        StyleBackgroundContent::RadialGradient(rg) => {
                            self.linear_color_stops
                                .insert(rg.stops.get_hash(), rg.stops.clone());
                        }
                        StyleBackgroundContent::ConicGradient(lg) => {
                            self.radial_color_stops
                                .insert(lg.stops.get_hash(), lg.stops.clone());
                        }
                        _ => {}
                    }
                }
                self.style_background_contents
                    .insert(v.get_hash(), v.clone());
            }
            CssProperty::Filter(CssPropertyValue::Exact(v)) => {
                self.style_filters.insert(v.get_hash(), v.clone());
            }
            CssProperty::BackdropFilter(CssPropertyValue::Exact(v)) => {
                self.style_filters.insert(v.get_hash(), v.clone());
            }
            _ => {}
        }
    }
}

// Helper functions for formatting values

/// Formats a `PixelValue` as a const-compatible Rust constructor call.
#[must_use]
pub fn format_pixel_value(p: &PixelValue) -> String {
    let value = p.number.get();

    // Decompose into integer + fractional parts using the absolute value so
    // that negative numbers are handled correctly.  Previously, floorf on a
    // negative value (e.g. -1.5 → -2) caused the wrong reconstruction.
    let abs_val = libm::fabsf(value);
    let sign: isize = if value < 0.0 { -1 } else { 1 };
    let pre_comma = f32_to_isize(libm::floorf(abs_val)) * sign;
    let post_comma = f32_to_isize(libm::roundf((abs_val - libm::floorf(abs_val)) * 100.0));

    match p.metric {
        SizeMetric::Pt => format!(
            "PixelValue::const_pt_fractional({pre_comma}, {post_comma})"
        ),
        SizeMetric::Em => format!(
            "PixelValue::const_em_fractional({pre_comma}, {post_comma})"
        ),
        other => format!(
            "PixelValue::const_from_metric_fractional(SizeMetric::{other:?}, {pre_comma}, {post_comma})"
        ),
    }
}

/// Truncating `f32` → `isize` for the integer / fractional parts of const CSS
/// dimension values (always small and non-negative after `fabsf`). Rust's
/// `as isize` saturates out-of-range floats; this isolates the one unavoidable
/// float→int cast behind a documented attribute. Behaviour-preserving.
#[inline]
#[allow(clippy::cast_possible_truncation)]
const fn f32_to_isize(v: f32) -> isize {
    v as isize
}

/// Formats a `PixelValueNoPercent` as a const-compatible Rust constructor call.
#[must_use]
pub fn format_pixel_value_no_percent(p: &PixelValueNoPercent) -> String {
    format!(
        "PixelValueNoPercent {{ inner: {} }}",
        format_pixel_value(&p.inner)
    )
}

/// Formats a `FloatValue` as a const-compatible Rust constructor call.
#[must_use]
pub fn format_float_value(f: &FloatValue) -> String {
    let value = f.get();
    let abs_val = libm::fabsf(value);
    let sign: isize = if value < 0.0 { -1 } else { 1 };
    let pre_comma = f32_to_isize(libm::floorf(abs_val)) * sign;
    let post_comma = f32_to_isize(libm::roundf((abs_val - libm::floorf(abs_val)) * 100.0));
    format!("FloatValue::const_new_fractional({pre_comma}, {post_comma})")
}

/// Formats a `PercentageValue` as a const-compatible Rust constructor call.
#[must_use]
pub fn format_percentage_value(f: &PercentageValue) -> String {
    let value = f.normalized() * 100.0;
    let abs_val = libm::fabsf(value);
    let sign: isize = if value < 0.0 { -1 } else { 1 };
    let pre_comma = f32_to_isize(libm::floorf(abs_val)) * sign;
    let post_comma = f32_to_isize(libm::roundf((abs_val - libm::floorf(abs_val)) * 100.0));
    format!("PercentageValue::const_new_fractional({pre_comma}, {post_comma})")
}

/// Formats an `AngleValue` as a const-compatible Rust constructor call.
#[must_use]
pub fn format_angle_value(f: &AngleValue) -> String {
    let value = f.number.get();
    let abs_val = libm::fabsf(value);
    let sign: isize = if value < 0.0 { -1 } else { 1 };
    let pre_comma = f32_to_isize(libm::floorf(abs_val)) * sign;
    let post_comma = f32_to_isize(libm::roundf((abs_val - libm::floorf(abs_val)) * 100.0));
    format!(
        "AngleValue::const_from_metric_fractional(AngleMetric::{:?}, {}, {})",
        f.metric, pre_comma, post_comma
    )
}

/// Formats a `ColorU` as a const-compatible Rust struct literal.
#[must_use]
pub fn format_color_value(c: &ColorU) -> String {
    format!(
        "ColorU {{ r: {}, g: {}, b: {}, a: {} }}",
        c.r, c.g, c.b, c.a
    )
}

fn format_grid_line(line: &GridLine, _tabs: usize) -> String {
    match line {
        GridLine::Auto => "GridLine::Auto".to_string(),
        GridLine::Line(n) => format!("GridLine::Line({n})"),
        GridLine::Named(named) => format!(
            "GridLine::Named(NamedGridLine {{ grid_line_name: AzString::from_const_str({:?}), span_count: {} }})",
            named.grid_line_name.as_ref(),
            named.span_count,
        ),
        GridLine::Span(n) => format!("GridLine::Span({n})"),
    }
}

fn format_color_or_system(c: ColorOrSystem) -> String {
    use crate::props::basic::color::{ColorOrSystem, SystemColorRef};
    match c {
        ColorOrSystem::Color(color) => {
            format!("ColorOrSystem::Color({})", format_color_value(&color))
        }
        ColorOrSystem::System(system_ref) => {
            let variant = match system_ref {
                SystemColorRef::Text => "Text",
                SystemColorRef::Background => "Background",
                SystemColorRef::Accent => "Accent",
                SystemColorRef::AccentText => "AccentText",
                SystemColorRef::ButtonFace => "ButtonFace",
                SystemColorRef::ButtonText => "ButtonText",
                SystemColorRef::WindowBackground => "WindowBackground",
                SystemColorRef::SelectionBackground => "SelectionBackground",
                SystemColorRef::SelectionText => "SelectionText",
            };
            format!("ColorOrSystem::System(SystemColorRef::{variant})")
        }
    }
}

// Macro implementations for common patterns

macro_rules! impl_float_value_fmt {
    ($struct_name:ident) => {
        impl FormatAsRustCode for $struct_name {
            fn format_as_rust_code(&self, _tabs: usize) -> String {
                format!(
                    "{} {{ inner: {} }}",
                    stringify!($struct_name),
                    format_float_value(&self.inner)
                )
            }
        }
    };
}

impl_float_value_fmt!(LayoutFlexGrow);
impl_float_value_fmt!(LayoutFlexShrink);

macro_rules! impl_percentage_value_fmt {
    ($struct_name:ident) => {
        impl FormatAsRustCode for $struct_name {
            fn format_as_rust_code(&self, _tabs: usize) -> String {
                format!(
                    "{} {{ inner: {} }}",
                    stringify!($struct_name),
                    format_percentage_value(&self.inner)
                )
            }
        }
    };
}

impl_percentage_value_fmt!(StyleLineHeight);
impl_percentage_value_fmt!(StyleOpacity);

macro_rules! impl_pixel_value_fmt {
    ($struct_name:ident) => {
        impl FormatAsRustCode for $struct_name {
            fn format_as_rust_code(&self, _tabs: usize) -> String {
                format!(
                    "{} {{ inner: {} }}",
                    stringify!($struct_name),
                    format_pixel_value(&self.inner)
                )
            }
        }
    };
}

impl_pixel_value_fmt!(StyleTabSize);
impl_pixel_value_fmt!(StyleBorderTopLeftRadius);
impl_pixel_value_fmt!(StyleBorderBottomLeftRadius);
impl_pixel_value_fmt!(StyleBorderTopRightRadius);
impl_pixel_value_fmt!(StyleBorderBottomRightRadius);

impl_pixel_value_fmt!(LayoutBorderTopWidth);
impl_pixel_value_fmt!(LayoutBorderLeftWidth);
impl_pixel_value_fmt!(LayoutBorderRightWidth);
impl_pixel_value_fmt!(LayoutBorderBottomWidth);
impl_pixel_value_fmt!(StyleLetterSpacing);
impl_pixel_value_fmt!(StyleWordSpacing);
impl_pixel_value_fmt!(StyleFontSize);

impl_pixel_value_fmt!(LayoutMarginTop);
impl_pixel_value_fmt!(LayoutMarginBottom);
impl_pixel_value_fmt!(LayoutMarginRight);
impl_pixel_value_fmt!(LayoutMarginLeft);

impl_pixel_value_fmt!(LayoutPaddingTop);
impl_pixel_value_fmt!(LayoutPaddingBottom);
impl_pixel_value_fmt!(LayoutPaddingRight);
impl_pixel_value_fmt!(LayoutPaddingLeft);
impl_pixel_value_fmt!(LayoutPaddingInlineStart);
impl_pixel_value_fmt!(LayoutPaddingInlineEnd);

impl FormatAsRustCode for LayoutWidth {
    fn format_as_rust_code(&self, _tabs: usize) -> String {
        match self {
            Self::Auto => "LayoutWidth::Auto".to_string(),
            Self::Px(px) => format!("LayoutWidth::Px({})", format_pixel_value(px)),
            Self::MinContent => "LayoutWidth::MinContent".to_string(),
            Self::MaxContent => "LayoutWidth::MaxContent".to_string(),
            Self::FitContent(px) => format!("LayoutWidth::FitContent({})", format_pixel_value(px)),
            Self::Calc(items) => format!("LayoutWidth::Calc(/* {} items */)", items.len()),
        }
    }
}

impl FormatAsRustCode for LayoutHeight {
    fn format_as_rust_code(&self, _tabs: usize) -> String {
        match self {
            Self::Auto => "LayoutHeight::Auto".to_string(),
            Self::Px(px) => format!("LayoutHeight::Px({})", format_pixel_value(px)),
            Self::MinContent => "LayoutHeight::MinContent".to_string(),
            Self::MaxContent => "LayoutHeight::MaxContent".to_string(),
            Self::FitContent(px) => format!("LayoutHeight::FitContent({})", format_pixel_value(px)),
            Self::Calc(items) => format!("LayoutHeight::Calc(/* {} items */)", items.len()),
        }
    }
}

impl_pixel_value_fmt!(LayoutMinHeight);
impl_pixel_value_fmt!(LayoutMinWidth);
impl_pixel_value_fmt!(LayoutMaxWidth);
impl_pixel_value_fmt!(LayoutMaxHeight);
impl_pixel_value_fmt!(LayoutTop);
impl_pixel_value_fmt!(LayoutInsetBottom);

impl_pixel_value_fmt!(LayoutRight);
impl_pixel_value_fmt!(LayoutLeft);

// LayoutFlexBasis implementation moved to `props/layout/flex.rs`.

impl_pixel_value_fmt!(LayoutColumnGap);
impl_pixel_value_fmt!(LayoutRowGap);

impl FormatAsRustCode for GridTemplate {
    fn format_as_rust_code(&self, tabs: usize) -> String {
        let tracks: Vec<String> = self
            .tracks
            .as_ref()
            .iter()
            .map(|t| t.format_as_rust_code(tabs))
            .collect();
        format!(
            "GridTemplate {{ tracks: GridTrackSizingVec::from_vec(vec![{}]) }}",
            tracks.join(", ")
        )
    }
}

impl FormatAsRustCode for GridPlacement {
    fn format_as_rust_code(&self, tabs: usize) -> String {
        format!(
            "GridPlacement {{ grid_start: {}, grid_end: {} }}",
            format_grid_line(&self.grid_start, tabs),
            format_grid_line(&self.grid_end, tabs),
        )
    }
}

impl_color_value_fmt!(StyleTextColor);
impl_color_value_fmt!(StyleBorderTopColor);
impl_color_value_fmt!(StyleBorderLeftColor);
impl_color_value_fmt!(StyleBorderRightColor);
impl_color_value_fmt!(StyleBorderBottomColor);

impl_enum_fmt!(
    StyleMixBlendMode,
    Normal,
    Multiply,
    Screen,
    Overlay,
    Darken,
    Lighten,
    ColorDodge,
    ColorBurn,
    HardLight,
    SoftLight,
    Difference,
    Exclusion,
    Hue,
    Saturation,
    Color,
    Luminosity
);

impl_enum_fmt!(StyleHyphens, None, Manual, Auto);
impl_enum_fmt!(StyleWordBreak, Normal, BreakAll, KeepAll, BreakWord);
impl_enum_fmt!(StyleOverflowWrap, Normal, Anywhere, BreakWord);
impl_enum_fmt!(StyleLineBreak, Auto, Loose, Normal, Strict, Anywhere);
impl_enum_fmt!(StyleObjectFit, Fill, Contain, Cover, None, ScaleDown);
impl_enum_fmt!(StyleTextOverflow, Clip, Ellipsis);

impl FormatAsRustCode for StyleObjectPosition {
    fn format_as_rust_code(&self, _tabs: usize) -> String {
        format!(
            "StyleObjectPosition {{ horizontal: {}, vertical: {} }}",
            format_background_position_horizontal(&self.horizontal),
            format_background_position_vertical(&self.vertical)
        )
    }
}

impl FormatAsRustCode for StyleAspectRatio {
    fn format_as_rust_code(&self, _tabs: usize) -> String {
        match self {
            Self::Auto => "StyleAspectRatio::Auto".to_string(),
            Self::Ratio(r) => format!(
                "StyleAspectRatio::Ratio(AspectRatioValue {{ width: {}, height: {} }})",
                r.width, r.height
            ),
        }
    }
}

impl_enum_fmt!(StyleTextOrientation, Mixed, Upright, Sideways);
impl_enum_fmt!(
    StyleTextAlignLast,
    Auto,
    Start,
    End,
    Left,
    Right,
    Center,
    Justify
);

impl_enum_fmt!(
    StyleTextTransform,
    None,
    Capitalize,
    Uppercase,
    Lowercase,
    FullWidth
);

impl_enum_fmt!(StyleDirection, Ltr, Rtl);

impl_enum_fmt!(
    StyleWhiteSpace,
    Normal,
    Pre,
    Nowrap,
    PreWrap,
    PreLine,
    BreakSpaces
);

impl_enum_fmt!(StyleVisibility, Visible, Hidden, Collapse);

impl_enum_fmt!(LayoutWritingMode, HorizontalTb, VerticalRl, VerticalLr);

impl_enum_fmt!(LayoutClear, None, Left, Right, Both);

impl_enum_fmt!(
    StyleCursor,
    Alias,
    AllScroll,
    Cell,
    ColResize,
    ContextMenu,
    Copy,
    Crosshair,
    Default,
    EResize,
    EwResize,
    Grab,
    Grabbing,
    Help,
    Move,
    NResize,
    NsResize,
    NeswResize,
    NwseResize,
    Pointer,
    Progress,
    RowResize,
    SResize,
    SeResize,
    Text,
    Unset,
    VerticalText,
    WResize,
    Wait,
    ZoomIn,
    ZoomOut
);

impl_enum_fmt!(
    BorderStyle,
    None,
    Solid,
    Double,
    Dotted,
    Dashed,
    Hidden,
    Groove,
    Ridge,
    Inset,
    Outset
);

impl_enum_fmt!(
    StyleBackgroundRepeat,
    NoRepeat,
    PatternRepeat,
    RepeatX,
    RepeatY
);

impl_enum_fmt!(
    LayoutDisplay,
    None,
    Block,
    Inline,
    InlineBlock,
    Flex,
    InlineFlex,
    Table,
    InlineTable,
    TableRowGroup,
    TableHeaderGroup,
    TableFooterGroup,
    TableRow,
    TableColumnGroup,
    TableColumn,
    TableCell,
    TableCaption,
    ListItem,
    RunIn,
    Marker,
    Grid,
    InlineGrid,
    FlowRoot,
    Contents
);

impl_enum_fmt!(LayoutFloat, Left, Right, None);

impl_enum_fmt!(LayoutBoxSizing, ContentBox, BorderBox);

impl_enum_fmt!(LayoutFlexDirection, Row, RowReverse, Column, ColumnReverse);

impl_enum_fmt!(LayoutFlexWrap, Wrap, NoWrap, WrapReverse);

impl_enum_fmt!(
    LayoutJustifyContent,
    Start,
    End,
    FlexStart,
    FlexEnd,
    Center,
    SpaceBetween,
    SpaceAround,
    SpaceEvenly
);

impl_enum_fmt!(LayoutAlignItems, Stretch, Center, Start, End, Baseline);

impl_enum_fmt!(
    LayoutAlignContent,
    Start,
    End,
    Stretch,
    Center,
    SpaceBetween,
    SpaceAround
);

impl_enum_fmt!(Shape, Circle, Ellipse);

impl_enum_fmt!(LayoutOverflow, Auto, Scroll, Visible, Hidden, Clip);

impl_enum_fmt!(StyleTextAlign, Center, Left, Right, Justify, Start, End);

impl_enum_fmt!(StyleUserSelect, Auto, Text, None, All);

impl_enum_fmt!(StyleTextDecoration, None, Underline, Overline, LineThrough);

impl_enum_fmt!(
    DirectionCorner,
    Right,
    Left,
    Top,
    Bottom,
    TopRight,
    TopLeft,
    BottomRight,
    BottomLeft
);

impl_enum_fmt!(ExtendMode, Clamp, Repeat);

impl_enum_fmt!(StyleBackfaceVisibility, Visible, Hidden);
impl_enum_fmt!(StyleAppRegion, NoDrag, Drag);
impl_enum_fmt!(StyleSpatialNavigationAction, Auto, Focus, Scroll);
impl_enum_fmt!(StyleSpatialNavigationContain, Auto, Contain);

impl_enum_fmt!(
    StyleUnicodeBidi,
    Normal,
    Embed,
    Isolate,
    BidiOverride,
    IsolateOverride,
    Plaintext
);
impl_enum_fmt!(StyleTextBoxTrim, None, TrimStart, TrimEnd, TrimBoth);
impl_enum_fmt!(
    TextBoxEdgeOver,
    Auto,
    Text,
    Cap,
    Ex,
    Ideographic,
    IdeographicInk
);
impl_enum_fmt!(
    TextBoxEdgeUnder,
    Auto,
    Text,
    Alphabetic,
    Ideographic,
    IdeographicInk
);
impl FormatAsRustCode for StyleTextBoxEdge {
    fn format_as_rust_code(&self, tabs: usize) -> String {
        format!(
            "StyleTextBoxEdge {{ over: {}, under: {} }}",
            self.over.format_as_rust_code(tabs),
            self.under.format_as_rust_code(tabs)
        )
    }
}
impl_enum_fmt!(
    StyleDominantBaseline,
    Auto,
    TextBottom,
    Alphabetic,
    Ideographic,
    Middle,
    Central,
    Mathematical,
    Hanging,
    TextTop
);
impl_enum_fmt!(
    StyleAlignmentBaseline,
    Baseline,
    TextBottom,
    Alphabetic,
    Ideographic,
    Middle,
    Central,
    Mathematical,
    TextTop
);
impl_enum_fmt!(StyleBaselineSource, Auto, First, Last);
impl_enum_fmt!(
    StyleLineFitEdge,
    Leading,
    Text,
    Cap,
    Ex,
    Ideographic,
    IdeographicInk,
    Alphabetic
);
impl_enum_fmt!(
    StyleInitialLetterAlign,
    Auto,
    Alphabetic,
    Hanging,
    Ideographic
);
impl_enum_fmt!(StyleInitialLetterWrap, None, First, All, Grid);
impl_enum_fmt!(StyleScrollbarGutter, Auto, Stable, StableBothEdges);

impl FormatAsRustCode for StyleOverflowClipMargin {
    fn format_as_rust_code(&self, tabs: usize) -> String {
        format!(
            "StyleOverflowClipMargin {{ inner: {} }}",
            self.inner.format_as_rust_code(tabs)
        )
    }
}

impl FormatAsRustCode for StyleClipRect {
    fn format_as_rust_code(&self, _tabs: usize) -> String {
        fn fmt_edge(o: OptionF32) -> String {
            match o {
                OptionF32::None => String::from("OptionF32::None"),
                OptionF32::Some(v) => format!("OptionF32::Some({v:?})"),
            }
        }
        format!(
            "StyleClipRect {{ top: {}, right: {}, bottom: {}, left: {} }}",
            fmt_edge(self.top),
            fmt_edge(self.right),
            fmt_edge(self.bottom),
            fmt_edge(self.left),
        )
    }
}

// Complex type implementations

fn format_style_background_size(c: &StyleBackgroundSize) -> String {
    match c {
        StyleBackgroundSize::Contain => String::from("StyleBackgroundSize::Contain"),
        StyleBackgroundSize::Cover => String::from("StyleBackgroundSize::Cover"),
        StyleBackgroundSize::ExactSize(size) => format!(
            "StyleBackgroundSize::ExactSize(PixelValueSize {{ width: {}, height: {} }})",
            format_pixel_value(&size.width),
            format_pixel_value(&size.height)
        ),
    }
}

// Scrollbar-related impls moved to `props/style/scrollbar.rs`

/// Formats a `ScrollbarInfo` as a const-compatible Rust struct literal.
#[must_use]
pub fn format_scrollbar_info(s: &ScrollbarInfo, tabs: usize) -> String {
    let t = String::from("    ").repeat(tabs);
    let t1 = String::from("    ").repeat(tabs + 1);
    format!(
        "ScrollbarInfo {{\r\n{}width: {},\r\n{}padding_left: {},\r\n{}padding_right: \
         {},\r\n{}track: {},\r\n{}thumb: {},\r\n{}button: {},\r\n{}button: {},\r\n{}resizer: \
         {},\r\n{}}}",
        t1,
        s.width.format_as_rust_code(tabs + 1),
        t1,
        s.padding_left.format_as_rust_code(tabs + 1),
        t1,
        s.padding_right.format_as_rust_code(tabs + 1),
        t1,
        format_style_background_content(&s.track, tabs + 1),
        t1,
        format_style_background_content(&s.thumb, tabs + 1),
        t1,
        format_style_background_content(&s.button, tabs + 1),
        t1,
        format_style_background_content(&s.corner, tabs + 1),
        t1,
        format_style_background_content(&s.resizer, tabs + 1),
        t
    )
}

// Background/filter vec impls moved to their respective modules.

fn format_style_background_content(content: &StyleBackgroundContent, tabs: usize) -> String {
    match content {
        StyleBackgroundContent::LinearGradient(l) => format!(
            "StyleBackgroundContent::LinearGradient({})",
            format_linear_gradient(l, tabs)
        ),
        StyleBackgroundContent::RadialGradient(r) => format!(
            "StyleBackgroundContent::RadialGradient({})",
            format_radial_gradient(r, tabs)
        ),
        StyleBackgroundContent::ConicGradient(r) => format!(
            "StyleBackgroundContent::ConicGradient({})",
            format_conic_gradient(r, tabs)
        ),
        StyleBackgroundContent::Image(id) => format!("StyleBackgroundContent::Image({id:?})"),
        StyleBackgroundContent::Color(c) => {
            format!("StyleBackgroundContent::Color({})", format_color_value(c))
        }
        StyleBackgroundContent::SystemColor(s) => {
            use crate::props::basic::color::SystemColorRef;
            let variant = match s {
                SystemColorRef::Text => "Text",
                SystemColorRef::Background => "Background",
                SystemColorRef::Accent => "Accent",
                SystemColorRef::AccentText => "AccentText",
                SystemColorRef::ButtonFace => "ButtonFace",
                SystemColorRef::ButtonText => "ButtonText",
                SystemColorRef::WindowBackground => "WindowBackground",
                SystemColorRef::SelectionBackground => "SelectionBackground",
                SystemColorRef::SelectionText => "SelectionText",
            };
            format!("StyleBackgroundContent::SystemColor(SystemColorRef::{variant})")
        }
    }
}

fn format_direction(d: &Direction, tabs: usize) -> String {
    match d {
        Direction::Angle(fv) => format!("Direction::Angle({})", format_angle_value(fv)),
        Direction::FromTo(DirectionCorners { dir_from, dir_to }) => format!(
            "Direction::FromTo(DirectionCorners {{ dir_from: {}, dir_to: {} }})",
            dir_from.format_as_rust_code(tabs + 1),
            dir_to.format_as_rust_code(tabs + 1)
        ),
    }
}

fn format_linear_gradient(l: &LinearGradient, tabs: usize) -> String {
    let t = String::from("    ").repeat(tabs);
    let t1 = String::from("    ").repeat(tabs + 1);
    format!(
        "LinearGradient {{\r\n{}direction: {},\r\n{}extend_mode: {},\r\n{}stops: \
         NormalizedLinearColorStopVec::from_const_slice(LINEAR_COLOR_STOP_{}_ITEMS),\r\n{}}}",
        t1,
        format_direction(&l.direction, tabs + 1),
        t1,
        l.extend_mode.format_as_rust_code(tabs + 1),
        t1,
        l.stops.get_hash(),
        t,
    )
}

fn format_conic_gradient(r: &ConicGradient, tabs: usize) -> String {
    let t = String::from("    ").repeat(tabs);
    let t1 = String::from("    ").repeat(tabs + 1);

    format!(
        "ConicGradient {{\r\n{}extend_mode: {},\r\n{}center: {},\r\n{}angle: {},\r\n{}stops: \
         NormalizedRadialColorStopVec::from_const_slice(RADIAL_COLOR_STOP_{}_ITEMS),\r\n{}}}",
        t1,
        r.extend_mode.format_as_rust_code(tabs + 1),
        t1,
        format_style_background_position(&r.center, tabs + 1),
        t1,
        format_angle_value(&r.angle),
        t1,
        r.stops.get_hash(),
        t,
    )
}

fn format_radial_gradient(r: &RadialGradient, tabs: usize) -> String {
    let t = String::from("    ").repeat(tabs);
    let t1 = String::from("    ").repeat(tabs + 1);
    format!(
        "RadialGradient {{\r\n{}shape: {},\r\n{}extend_mode: {},\r\n{}position: {},\r\n{}size: \
         RadialGradientSize::{:?},\r\n{}stops: \
         NormalizedLinearColorStopVec::from_const_slice(LINEAR_COLOR_STOP_{}_ITEMS),\r\n{}}}",
        t1,
        r.shape.format_as_rust_code(tabs + 1),
        t1,
        r.extend_mode.format_as_rust_code(tabs + 1),
        t1,
        format_style_background_position(&r.position, tabs + 1),
        t1,
        r.size,
        t1,
        r.stops.get_hash(),
        t,
    )
}

fn format_linear_color_stops(stops: &[NormalizedLinearColorStop], tabs: usize) -> String {
    let t = String::from("    ").repeat(tabs);
    stops
        .iter()
        .map(format_linear_color_stop)
        .collect::<Vec<_>>()
        .join(&format!(",\r\n{t}"))
}

fn format_linear_color_stop(g: &NormalizedLinearColorStop) -> String {
    format!(
        "NormalizedLinearColorStop {{ offset: {}, color: {} }}",
        format_percentage_value(&g.offset),
        format_color_or_system(g.color),
    )
}

fn format_radial_color_stops(stops: &[NormalizedRadialColorStop], tabs: usize) -> String {
    let t = String::from("    ").repeat(tabs);
    stops
        .iter()
        .map(format_radial_color_stop)
        .collect::<Vec<_>>()
        .join(&format!(",\r\n{t}"))
}

fn format_radial_color_stop(g: &NormalizedRadialColorStop) -> String {
    format!(
        "RadialColorStop {{ angle: {}, color: {} }}",
        format_angle_value(&g.angle),
        format_color_or_system(g.color),
    )
}

fn format_style_filter(st: &StyleFilter, tabs: usize) -> String {
    match st {
        StyleFilter::Blend(mb) => format!("StyleFilter::Blend({})", mb.format_as_rust_code(tabs)),
        StyleFilter::Flood(c) => format!("StyleFilter::Flood({})", format_color_value(c)),
        StyleFilter::Blur(m) => format!(
            "StyleFilter::Blur(StyleBlur {{ width: {}, height: {} }})",
            format_pixel_value(&m.width),
            format_pixel_value(&m.height)
        ),
        StyleFilter::Opacity(pct) => {
            format!("StyleFilter::Opacity({})", format_percentage_value(pct))
        }
        StyleFilter::ColorMatrix(cm) => format!(
            "StyleFilter::ColorMatrix(StyleColorMatrix {{ m0: {}, m1: {}, m2: {}, m3: {}, m4: {}, \
             m5: {}, m6: {}, m7: {}, m8: {}, m9: {}, m10: {}, m11: {}, m12: {}, m13: {}, m14: {}, \
             m15: {}, m16: {}, m17: {}, m18: {}, m19: {} }})",
            format_float_value(&cm.m0),
            format_float_value(&cm.m1),
            format_float_value(&cm.m2),
            format_float_value(&cm.m3),
            format_float_value(&cm.m4),
            format_float_value(&cm.m5),
            format_float_value(&cm.m6),
            format_float_value(&cm.m7),
            format_float_value(&cm.m8),
            format_float_value(&cm.m9),
            format_float_value(&cm.m10),
            format_float_value(&cm.m11),
            format_float_value(&cm.m12),
            format_float_value(&cm.m13),
            format_float_value(&cm.m14),
            format_float_value(&cm.m15),
            format_float_value(&cm.m16),
            format_float_value(&cm.m17),
            format_float_value(&cm.m18),
            format_float_value(&cm.m19)
        ),
        StyleFilter::DropShadow(m) => {
            format!("StyleFilter::DropShadow({})", m.format_as_rust_code(tabs))
        }
        StyleFilter::ComponentTransfer => "StyleFilter::ComponentTransfer".to_string(),
        StyleFilter::Offset(o) => format!(
            "StyleFilter::Offset(StyleFilterOffset {{ x: {}, y: {} }})",
            format_pixel_value(&o.x),
            format_pixel_value(&o.y)
        ),
        StyleFilter::Composite(StyleCompositeFilter::Over) => {
            "StyleFilter::Composite(StyleCompositeFilter::Over)".to_string()
        }
        StyleFilter::Composite(StyleCompositeFilter::In) => {
            "StyleFilter::Composite(StyleCompositeFilter::In)".to_string()
        }
        StyleFilter::Composite(StyleCompositeFilter::Atop) => {
            "StyleFilter::Composite(StyleCompositeFilter::Atop)".to_string()
        }
        StyleFilter::Composite(StyleCompositeFilter::Out) => {
            "StyleFilter::Composite(StyleCompositeFilter::Out)".to_string()
        }
        StyleFilter::Composite(StyleCompositeFilter::Xor) => {
            "StyleFilter::Composite(StyleCompositeFilter::Xor)".to_string()
        }
        StyleFilter::Composite(StyleCompositeFilter::Lighter) => {
            "StyleFilter::Composite(StyleCompositeFilter::Lighter)".to_string()
        }
        StyleFilter::Composite(StyleCompositeFilter::Arithmetic(fv)) => format!(
            "StyleFilter::Composite(StyleCompositeFilter::Arithmetic(ArithmeticCoefficients {{ \
             k1: {}, k2: {}, k3: {}, k4: {} }}))",
            format_float_value(&fv.k1),
            format_float_value(&fv.k2),
            format_float_value(&fv.k3),
            format_float_value(&fv.k4)
        ),
        StyleFilter::Brightness(v) => {
            format!("StyleFilter::Brightness({})", format_percentage_value(v))
        }
        StyleFilter::Contrast(v) => {
            format!("StyleFilter::Contrast({})", format_percentage_value(v))
        }
        StyleFilter::Grayscale(v) => {
            format!("StyleFilter::Grayscale({})", format_percentage_value(v))
        }
        StyleFilter::HueRotate(a) => format!("StyleFilter::HueRotate({})", format_angle_value(a)),
        StyleFilter::Invert(v) => format!("StyleFilter::Invert({})", format_percentage_value(v)),
        StyleFilter::Saturate(v) => {
            format!("StyleFilter::Saturate({})", format_percentage_value(v))
        }
        StyleFilter::Sepia(v) => format!("StyleFilter::Sepia({})", format_percentage_value(v)),
    }
}

fn format_style_transforms(stops: &[StyleTransform], tabs: usize) -> String {
    let t = String::from("    ").repeat(tabs);
    stops
        .iter()
        .map(|s| format_style_transform(s, tabs))
        .collect::<Vec<_>>()
        .join(&format!(",\r\n{t}"))
}

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose CSS parser/formatter/dispatch table (one branch per property/variant)
fn format_style_transform(st: &StyleTransform, tabs: usize) -> String {
    let tabs_minus_one = String::from("    ").repeat(tabs);
    let tabs = String::from("    ").repeat(tabs + 1);
    match st {
        StyleTransform::Matrix(m) => format!(
            "StyleTransform::Matrix(StyleTransformMatrix2D {{ a: {}, b: {}, c: {}, d: {}, tx: {}, \
             ty: {} }})",
            format_float_value(&m.a),
            format_float_value(&m.b),
            format_float_value(&m.c),
            format_float_value(&m.d),
            format_float_value(&m.tx),
            format_float_value(&m.ty)
        ),
        StyleTransform::Matrix3D(m) => format!(
            "StyleTransform::Matrix3D(StyleTransformMatrix3D {{\r\n{tabs}m11: {},\r\n{tabs}m12: \
             {},\r\n{tabs}m13: {},\r\n{tabs}m14: {},\r\n{tabs}m21: {},\r\n{tabs}m22: \
             {},\r\n{tabs}m23: {},\r\n{tabs}m24: {},\r\n{tabs}m31: {},\r\n{tabs}m32: \
             {},\r\n{tabs}m33: {},\r\n{tabs}m34: {},\r\n{tabs}m41: {},\r\n{tabs}m42: \
             {},\r\n{tabs}m43: {},\r\n{tabs}m44: {}\r\n{tabs_minus_one}}})",
            format_float_value(&m.m11),
            format_float_value(&m.m12),
            format_float_value(&m.m13),
            format_float_value(&m.m14),
            format_float_value(&m.m21),
            format_float_value(&m.m22),
            format_float_value(&m.m23),
            format_float_value(&m.m24),
            format_float_value(&m.m31),
            format_float_value(&m.m32),
            format_float_value(&m.m33),
            format_float_value(&m.m34),
            format_float_value(&m.m41),
            format_float_value(&m.m42),
            format_float_value(&m.m43),
            format_float_value(&m.m44),
            tabs = tabs,
            tabs_minus_one = tabs_minus_one,
        ),
        StyleTransform::Translate(t) => format!(
            "StyleTransform::Translate(StyleTransformTranslate2D {{ x: {}, y: {} }})",
            format_pixel_value(&t.x),
            format_pixel_value(&t.y)
        ),
        StyleTransform::Translate3D(t) => format!(
            "StyleTransform::Translate3D(StyleTransformTranslate3D {{ x: {}, y: {}, z: {} }})",
            format_pixel_value(&t.x),
            format_pixel_value(&t.y),
            format_pixel_value(&t.z)
        ),
        StyleTransform::TranslateX(x) => {
            format!("StyleTransform::TranslateX({})", format_pixel_value(x))
        }
        StyleTransform::TranslateY(y) => {
            format!("StyleTransform::TranslateY({})", format_pixel_value(y))
        }
        StyleTransform::TranslateZ(z) => {
            format!("StyleTransform::TranslateZ({})", format_pixel_value(z))
        }
        StyleTransform::Rotate(r) => format!("StyleTransform::Rotate({})", format_angle_value(r)),
        StyleTransform::Rotate3D(r) => format!(
            "StyleTransform::Rotate3D(StyleTransformRotate3D {{ {}, {}, {}, {} }})",
            format_float_value(&r.x),
            format_float_value(&r.y),
            format_float_value(&r.z),
            format_angle_value(&r.angle)
        ),
        StyleTransform::RotateX(x) => {
            format!("StyleTransform::RotateX({})", format_angle_value(x))
        }
        StyleTransform::RotateY(y) => {
            format!("StyleTransform::RotateY({})", format_angle_value(y))
        }
        StyleTransform::RotateZ(z) => {
            format!("StyleTransform::RotateZ({})", format_angle_value(z))
        }
        StyleTransform::Scale(s) => format!(
            "StyleTransform::Scale(StyleTransformScale2D {{ x: {}, y: {} }})",
            format_float_value(&s.x),
            format_float_value(&s.y)
        ),
        StyleTransform::Scale3D(s) => format!(
            "StyleTransform::Scale3D(StyleTransformScale3D {{ x: {}, y: {}, z: {} }})",
            format_float_value(&s.x),
            format_float_value(&s.y),
            format_float_value(&s.z)
        ),
        StyleTransform::ScaleX(x) => {
            format!("StyleTransform::ScaleX({})", format_percentage_value(x))
        }
        StyleTransform::ScaleY(y) => {
            format!("StyleTransform::ScaleY({})", format_percentage_value(y))
        }
        StyleTransform::ScaleZ(z) => {
            format!("StyleTransform::ScaleZ({})", format_percentage_value(z))
        }
        StyleTransform::Skew(sk) => format!(
            "StyleTransform::Skew(StyleTransformSkew2D {{ x: {}, y: {} }})",
            format_angle_value(&sk.x),
            format_angle_value(&sk.y)
        ),
        StyleTransform::SkewX(x) => {
            format!("StyleTransform::SkewX({})", format_angle_value(x))
        }
        StyleTransform::SkewY(y) => {
            format!("StyleTransform::SkewY({})", format_angle_value(y))
        }
        StyleTransform::Perspective(dist) => {
            format!("StyleTransform::Perspective({})", format_pixel_value(dist))
        }
    }
}

fn format_font_ids(font_ids: &[StyleFontFamily], tabs: usize) -> String {
    let t = String::from("    ").repeat(tabs);
    font_ids
        .iter()
        .map(|s| s.format_as_rust_code(tabs + 1))
        .collect::<Vec<_>>()
        .join(&format!(",\r\n{t}"))
}

fn format_style_background_position(b: &StyleBackgroundPosition, tabs: usize) -> String {
    let t = String::from("    ").repeat(tabs);
    let t1 = String::from("    ").repeat(tabs + 1);
    format!(
        "StyleBackgroundPosition {{\r\n{}horizontal: {},\r\n{}vertical: {},\r\n{}}}",
        t1,
        format_background_position_horizontal(&b.horizontal),
        t1,
        format_background_position_vertical(&b.vertical),
        t
    )
}

fn format_background_position_horizontal(b: &BackgroundPositionHorizontal) -> String {
    match b {
        BackgroundPositionHorizontal::Left => "BackgroundPositionHorizontal::Left".to_string(),
        BackgroundPositionHorizontal::Center => "BackgroundPositionHorizontal::Center".to_string(),
        BackgroundPositionHorizontal::Right => "BackgroundPositionHorizontal::Right".to_string(),
        BackgroundPositionHorizontal::Exact(p) => format!(
            "BackgroundPositionHorizontal::Exact({})",
            format_pixel_value(p)
        ),
    }
}

fn format_background_position_vertical(b: &BackgroundPositionVertical) -> String {
    match b {
        BackgroundPositionVertical::Top => "BackgroundPositionVertical::Top".to_string(),
        BackgroundPositionVertical::Center => "BackgroundPositionVertical::Center".to_string(),
        BackgroundPositionVertical::Bottom => "BackgroundPositionVertical::Bottom".to_string(),
        BackgroundPositionVertical::Exact(p) => format!(
            "BackgroundPositionVertical::Exact({})",
            format_pixel_value(p)
        ),
    }
}

// Border side style impls moved to `props/style/border.rs`.

// Several small impls were moved to their respective modules.

// StyleTransformOrigin impl moved to `props/style/transform.rs`.

// Implementations for small property types were moved to their respective
// modules to keep the implementations next to the type definitions.