Struct Theme 

pub struct Theme { /* private fields */ }

Runtime paint theme for implicit widget visuals.

Implementations

impl Theme

pub fn aetna_dark() -> Self

Current default: stock rounded-rect surfaces with the Aetna Dark palette (copied from shadcn/ui zinc dark) and compact desktop metrics.

Examples found in repository

examples/polish_calibration.rs (line 17)

fn main() -> std::io::Result<()> {
    let viewport = Rect::new(0.0, 0.0, 1180.0, 876.0);
    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");

    let name = "polish_calibration";
    let theme = Theme::aetna_dark();
    let mut root = polish_calibration();
    let bundle = render_bundle_themed(&mut root, viewport, &theme);
    let written = write_bundle(&bundle, &out_dir, name)?;
    for p in &written {
        println!("wrote {}", p.display());
    }
    if !bundle.lint.findings.is_empty() {
        eprintln!(
            "\nlint findings for {name} ({}):",
            bundle.lint.findings.len()
        );
        eprint!("{}", bundle.lint.text());
    }

    Ok(())
}

examples/settings_calibration.rs (line 14)

fn main() -> std::io::Result<()> {
    let viewport = Rect::new(0.0, 0.0, 1180.0, 780.0);
    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");

    let name = "settings_calibration";
    let theme = Theme::aetna_dark();
    let mut root = settings_calibration();
    let bundle = render_bundle_themed(&mut root, viewport, &theme);
    let written = write_bundle(&bundle, &out_dir, name)?;
    for p in &written {
        println!("wrote {}", p.display());
    }
    if !bundle.lint.findings.is_empty() {
        eprintln!(
            "\nlint findings for {name} ({}):",
            bundle.lint.findings.len()
        );
        eprint!("{}", bundle.lint.text());
    }

    Ok(())
}

examples/dashboard_01_calibration.rs (line 14)

fn main() -> std::io::Result<()> {
    let viewport = Rect::new(0.0, 0.0, 1180.0, 780.0);
    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");

    let name = "dashboard_01_calibration";
    let theme = Theme::aetna_dark();
    let mut root = dashboard_01_calibration();
    let bundle = render_bundle_themed(&mut root, viewport, &theme);
    let written = write_bundle(&bundle, &out_dir, name)?;
    for p in &written {
        println!("wrote {}", p.display());
    }
    if !bundle.lint.findings.is_empty() {
        eprintln!(
            "\nlint findings for {name} ({}):",
            bundle.lint.findings.len()
        );
        eprint!("{}", bundle.lint.text());
    }

    Ok(())
}

examples/palette_demo.rs (line 19)

fn main() -> std::io::Result<()> {
    let viewport = Rect::new(0.0, 0.0, 1220.0, 1040.0);
    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");

    let variants = [
        ("palette_demo.aetna_dark", "Aetna dark", Theme::aetna_dark()),
        (
            "palette_demo.aetna_light",
            "Aetna light",
            Theme::aetna_light(),
        ),
        (
            "palette_demo.radix_slate_blue_dark",
            "Radix slate + blue dark",
            Theme::radix_slate_blue_dark(),
        ),
        (
            "palette_demo.radix_slate_blue_light",
            "Radix slate + blue light",
            Theme::radix_slate_blue_light(),
        ),
        (
            "palette_demo.radix_sand_amber_dark",
            "Radix sand + amber dark",
            Theme::radix_sand_amber_dark(),
        ),
        (
            "palette_demo.radix_sand_amber_light",
            "Radix sand + amber light",
            Theme::radix_sand_amber_light(),
        ),
        (
            "palette_demo.radix_mauve_violet_dark",
            "Radix mauve + violet dark",
            Theme::radix_mauve_violet_dark(),
        ),
        (
            "palette_demo.radix_mauve_violet_light",
            "Radix mauve + violet light",
            Theme::radix_mauve_violet_light(),
        ),
    ];

    for (file_name, label, theme) in variants {
        let mut root = palette_demo(label, theme.palette());
        let bundle = render_bundle_themed(&mut root, viewport, &theme);
        let written = write_bundle(&bundle, &out_dir, file_name)?;
        for p in &written {
            println!("wrote {}", p.display());
        }

        if !bundle.lint.findings.is_empty() {
            eprintln!(
                "\nlint findings for {file_name} ({}):",
                bundle.lint.findings.len()
            );
            eprint!("{}", bundle.lint.text());
        }
    }

    Ok(())
}

pub fn aetna_light() -> Self

Stock rounded-rect surfaces with the Aetna Light palette (copied from shadcn/ui zinc light). Drop-in alternative to Self::aetna_dark — token references swap rgba at paint time without rebuilding the widget tree.

Examples found in repository

examples/palette_demo.rs (line 23)

fn main() -> std::io::Result<()> {
    let viewport = Rect::new(0.0, 0.0, 1220.0, 1040.0);
    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");

    let variants = [
        ("palette_demo.aetna_dark", "Aetna dark", Theme::aetna_dark()),
        (
            "palette_demo.aetna_light",
            "Aetna light",
            Theme::aetna_light(),
        ),
        (
            "palette_demo.radix_slate_blue_dark",
            "Radix slate + blue dark",
            Theme::radix_slate_blue_dark(),
        ),
        (
            "palette_demo.radix_slate_blue_light",
            "Radix slate + blue light",
            Theme::radix_slate_blue_light(),
        ),
        (
            "palette_demo.radix_sand_amber_dark",
            "Radix sand + amber dark",
            Theme::radix_sand_amber_dark(),
        ),
        (
            "palette_demo.radix_sand_amber_light",
            "Radix sand + amber light",
            Theme::radix_sand_amber_light(),
        ),
        (
            "palette_demo.radix_mauve_violet_dark",
            "Radix mauve + violet dark",
            Theme::radix_mauve_violet_dark(),
        ),
        (
            "palette_demo.radix_mauve_violet_light",
            "Radix mauve + violet light",
            Theme::radix_mauve_violet_light(),
        ),
    ];

    for (file_name, label, theme) in variants {
        let mut root = palette_demo(label, theme.palette());
        let bundle = render_bundle_themed(&mut root, viewport, &theme);
        let written = write_bundle(&bundle, &out_dir, file_name)?;
        for p in &written {
            println!("wrote {}", p.display());
        }

        if !bundle.lint.findings.is_empty() {
            eprintln!(
                "\nlint findings for {file_name} ({}):",
                bundle.lint.findings.len()
            );
            eprint!("{}", bundle.lint.text());
        }
    }

    Ok(())
}

pub fn radix_slate_blue_dark() -> Self

Stock rounded-rect surfaces with a Radix Colors slate + blue dark palette.

Examples found in repository

examples/palette_demo.rs (line 28)

fn main() -> std::io::Result<()> {
    let viewport = Rect::new(0.0, 0.0, 1220.0, 1040.0);
    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");

    let variants = [
        ("palette_demo.aetna_dark", "Aetna dark", Theme::aetna_dark()),
        (
            "palette_demo.aetna_light",
            "Aetna light",
            Theme::aetna_light(),
        ),
        (
            "palette_demo.radix_slate_blue_dark",
            "Radix slate + blue dark",
            Theme::radix_slate_blue_dark(),
        ),
        (
            "palette_demo.radix_slate_blue_light",
            "Radix slate + blue light",
            Theme::radix_slate_blue_light(),
        ),
        (
            "palette_demo.radix_sand_amber_dark",
            "Radix sand + amber dark",
            Theme::radix_sand_amber_dark(),
        ),
        (
            "palette_demo.radix_sand_amber_light",
            "Radix sand + amber light",
            Theme::radix_sand_amber_light(),
        ),
        (
            "palette_demo.radix_mauve_violet_dark",
            "Radix mauve + violet dark",
            Theme::radix_mauve_violet_dark(),
        ),
        (
            "palette_demo.radix_mauve_violet_light",
            "Radix mauve + violet light",
            Theme::radix_mauve_violet_light(),
        ),
    ];

    for (file_name, label, theme) in variants {
        let mut root = palette_demo(label, theme.palette());
        let bundle = render_bundle_themed(&mut root, viewport, &theme);
        let written = write_bundle(&bundle, &out_dir, file_name)?;
        for p in &written {
            println!("wrote {}", p.display());
        }

        if !bundle.lint.findings.is_empty() {
            eprintln!(
                "\nlint findings for {file_name} ({}):",
                bundle.lint.findings.len()
            );
            eprint!("{}", bundle.lint.text());
        }
    }

    Ok(())
}

pub fn radix_slate_blue_light() -> Self

Stock rounded-rect surfaces with a Radix Colors slate + blue light palette.

Examples found in repository

examples/palette_demo.rs (line 33)

fn main() -> std::io::Result<()> {
    let viewport = Rect::new(0.0, 0.0, 1220.0, 1040.0);
    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");

    let variants = [
        ("palette_demo.aetna_dark", "Aetna dark", Theme::aetna_dark()),
        (
            "palette_demo.aetna_light",
            "Aetna light",
            Theme::aetna_light(),
        ),
        (
            "palette_demo.radix_slate_blue_dark",
            "Radix slate + blue dark",
            Theme::radix_slate_blue_dark(),
        ),
        (
            "palette_demo.radix_slate_blue_light",
            "Radix slate + blue light",
            Theme::radix_slate_blue_light(),
        ),
        (
            "palette_demo.radix_sand_amber_dark",
            "Radix sand + amber dark",
            Theme::radix_sand_amber_dark(),
        ),
        (
            "palette_demo.radix_sand_amber_light",
            "Radix sand + amber light",
            Theme::radix_sand_amber_light(),
        ),
        (
            "palette_demo.radix_mauve_violet_dark",
            "Radix mauve + violet dark",
            Theme::radix_mauve_violet_dark(),
        ),
        (
            "palette_demo.radix_mauve_violet_light",
            "Radix mauve + violet light",
            Theme::radix_mauve_violet_light(),
        ),
    ];

    for (file_name, label, theme) in variants {
        let mut root = palette_demo(label, theme.palette());
        let bundle = render_bundle_themed(&mut root, viewport, &theme);
        let written = write_bundle(&bundle, &out_dir, file_name)?;
        for p in &written {
            println!("wrote {}", p.display());
        }

        if !bundle.lint.findings.is_empty() {
            eprintln!(
                "\nlint findings for {file_name} ({}):",
                bundle.lint.findings.len()
            );
            eprint!("{}", bundle.lint.text());
        }
    }

    Ok(())
}

pub fn radix_sand_amber_dark() -> Self

Stock rounded-rect surfaces with a Radix Colors sand + amber dark palette — warm sepia neutrals with a bright amber accent.

Examples found in repository

examples/palette_demo.rs (line 38)

fn main() -> std::io::Result<()> {
    let viewport = Rect::new(0.0, 0.0, 1220.0, 1040.0);
    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");

    let variants = [
        ("palette_demo.aetna_dark", "Aetna dark", Theme::aetna_dark()),
        (
            "palette_demo.aetna_light",
            "Aetna light",
            Theme::aetna_light(),
        ),
        (
            "palette_demo.radix_slate_blue_dark",
            "Radix slate + blue dark",
            Theme::radix_slate_blue_dark(),
        ),
        (
            "palette_demo.radix_slate_blue_light",
            "Radix slate + blue light",
            Theme::radix_slate_blue_light(),
        ),
        (
            "palette_demo.radix_sand_amber_dark",
            "Radix sand + amber dark",
            Theme::radix_sand_amber_dark(),
        ),
        (
            "palette_demo.radix_sand_amber_light",
            "Radix sand + amber light",
            Theme::radix_sand_amber_light(),
        ),
        (
            "palette_demo.radix_mauve_violet_dark",
            "Radix mauve + violet dark",
            Theme::radix_mauve_violet_dark(),
        ),
        (
            "palette_demo.radix_mauve_violet_light",
            "Radix mauve + violet light",
            Theme::radix_mauve_violet_light(),
        ),
    ];

    for (file_name, label, theme) in variants {
        let mut root = palette_demo(label, theme.palette());
        let bundle = render_bundle_themed(&mut root, viewport, &theme);
        let written = write_bundle(&bundle, &out_dir, file_name)?;
        for p in &written {
            println!("wrote {}", p.display());
        }

        if !bundle.lint.findings.is_empty() {
            eprintln!(
                "\nlint findings for {file_name} ({}):",
                bundle.lint.findings.len()
            );
            eprint!("{}", bundle.lint.text());
        }
    }

    Ok(())
}

pub fn radix_sand_amber_light() -> Self

Stock rounded-rect surfaces with a Radix Colors sand + amber light palette.

Examples found in repository

examples/palette_demo.rs (line 43)

fn main() -> std::io::Result<()> {
    let viewport = Rect::new(0.0, 0.0, 1220.0, 1040.0);
    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");

    let variants = [
        ("palette_demo.aetna_dark", "Aetna dark", Theme::aetna_dark()),
        (
            "palette_demo.aetna_light",
            "Aetna light",
            Theme::aetna_light(),
        ),
        (
            "palette_demo.radix_slate_blue_dark",
            "Radix slate + blue dark",
            Theme::radix_slate_blue_dark(),
        ),
        (
            "palette_demo.radix_slate_blue_light",
            "Radix slate + blue light",
            Theme::radix_slate_blue_light(),
        ),
        (
            "palette_demo.radix_sand_amber_dark",
            "Radix sand + amber dark",
            Theme::radix_sand_amber_dark(),
        ),
        (
            "palette_demo.radix_sand_amber_light",
            "Radix sand + amber light",
            Theme::radix_sand_amber_light(),
        ),
        (
            "palette_demo.radix_mauve_violet_dark",
            "Radix mauve + violet dark",
            Theme::radix_mauve_violet_dark(),
        ),
        (
            "palette_demo.radix_mauve_violet_light",
            "Radix mauve + violet light",
            Theme::radix_mauve_violet_light(),
        ),
    ];

    for (file_name, label, theme) in variants {
        let mut root = palette_demo(label, theme.palette());
        let bundle = render_bundle_themed(&mut root, viewport, &theme);
        let written = write_bundle(&bundle, &out_dir, file_name)?;
        for p in &written {
            println!("wrote {}", p.display());
        }

        if !bundle.lint.findings.is_empty() {
            eprintln!(
                "\nlint findings for {file_name} ({}):",
                bundle.lint.findings.len()
            );
            eprint!("{}", bundle.lint.text());
        }
    }

    Ok(())
}

pub fn radix_mauve_violet_dark() -> Self

Stock rounded-rect surfaces with a Radix Colors mauve + violet dark palette — purple-tinged neutrals with a violet accent.

Examples found in repository

examples/palette_demo.rs (line 48)

fn main() -> std::io::Result<()> {
    let viewport = Rect::new(0.0, 0.0, 1220.0, 1040.0);
    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");

    let variants = [
        ("palette_demo.aetna_dark", "Aetna dark", Theme::aetna_dark()),
        (
            "palette_demo.aetna_light",
            "Aetna light",
            Theme::aetna_light(),
        ),
        (
            "palette_demo.radix_slate_blue_dark",
            "Radix slate + blue dark",
            Theme::radix_slate_blue_dark(),
        ),
        (
            "palette_demo.radix_slate_blue_light",
            "Radix slate + blue light",
            Theme::radix_slate_blue_light(),
        ),
        (
            "palette_demo.radix_sand_amber_dark",
            "Radix sand + amber dark",
            Theme::radix_sand_amber_dark(),
        ),
        (
            "palette_demo.radix_sand_amber_light",
            "Radix sand + amber light",
            Theme::radix_sand_amber_light(),
        ),
        (
            "palette_demo.radix_mauve_violet_dark",
            "Radix mauve + violet dark",
            Theme::radix_mauve_violet_dark(),
        ),
        (
            "palette_demo.radix_mauve_violet_light",
            "Radix mauve + violet light",
            Theme::radix_mauve_violet_light(),
        ),
    ];

    for (file_name, label, theme) in variants {
        let mut root = palette_demo(label, theme.palette());
        let bundle = render_bundle_themed(&mut root, viewport, &theme);
        let written = write_bundle(&bundle, &out_dir, file_name)?;
        for p in &written {
            println!("wrote {}", p.display());
        }

        if !bundle.lint.findings.is_empty() {
            eprintln!(
                "\nlint findings for {file_name} ({}):",
                bundle.lint.findings.len()
            );
            eprint!("{}", bundle.lint.text());
        }
    }

    Ok(())
}

pub fn radix_mauve_violet_light() -> Self

Stock rounded-rect surfaces with a Radix Colors mauve + violet light palette.

Examples found in repository

examples/palette_demo.rs (line 53)

fn main() -> std::io::Result<()> {
    let viewport = Rect::new(0.0, 0.0, 1220.0, 1040.0);
    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");

    let variants = [
        ("palette_demo.aetna_dark", "Aetna dark", Theme::aetna_dark()),
        (
            "palette_demo.aetna_light",
            "Aetna light",
            Theme::aetna_light(),
        ),
        (
            "palette_demo.radix_slate_blue_dark",
            "Radix slate + blue dark",
            Theme::radix_slate_blue_dark(),
        ),
        (
            "palette_demo.radix_slate_blue_light",
            "Radix slate + blue light",
            Theme::radix_slate_blue_light(),
        ),
        (
            "palette_demo.radix_sand_amber_dark",
            "Radix sand + amber dark",
            Theme::radix_sand_amber_dark(),
        ),
        (
            "palette_demo.radix_sand_amber_light",
            "Radix sand + amber light",
            Theme::radix_sand_amber_light(),
        ),
        (
            "palette_demo.radix_mauve_violet_dark",
            "Radix mauve + violet dark",
            Theme::radix_mauve_violet_dark(),
        ),
        (
            "palette_demo.radix_mauve_violet_light",
            "Radix mauve + violet light",
            Theme::radix_mauve_violet_light(),
        ),
    ];

    for (file_name, label, theme) in variants {
        let mut root = palette_demo(label, theme.palette());
        let bundle = render_bundle_themed(&mut root, viewport, &theme);
        let written = write_bundle(&bundle, &out_dir, file_name)?;
        for p in &written {
            println!("wrote {}", p.display());
        }

        if !bundle.lint.findings.is_empty() {
            eprintln!(
                "\nlint findings for {file_name} ({}):",
                bundle.lint.findings.len()
            );
            eprint!("{}", bundle.lint.text());
        }
    }

    Ok(())
}

pub fn with_palette(self, palette: Palette) -> Self

Replace the runtime color palette. Token references resolve through the active palette at paint time, so this swaps surface rgba without rebuilding the widget tree.

pub fn palette(&self) -> &Palette

The active runtime palette.

Examples found in repository

examples/palette_demo.rs (line 58)

fn main() -> std::io::Result<()> {
    let viewport = Rect::new(0.0, 0.0, 1220.0, 1040.0);
    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");

    let variants = [
        ("palette_demo.aetna_dark", "Aetna dark", Theme::aetna_dark()),
        (
            "palette_demo.aetna_light",
            "Aetna light",
            Theme::aetna_light(),
        ),
        (
            "palette_demo.radix_slate_blue_dark",
            "Radix slate + blue dark",
            Theme::radix_slate_blue_dark(),
        ),
        (
            "palette_demo.radix_slate_blue_light",
            "Radix slate + blue light",
            Theme::radix_slate_blue_light(),
        ),
        (
            "palette_demo.radix_sand_amber_dark",
            "Radix sand + amber dark",
            Theme::radix_sand_amber_dark(),
        ),
        (
            "palette_demo.radix_sand_amber_light",
            "Radix sand + amber light",
            Theme::radix_sand_amber_light(),
        ),
        (
            "palette_demo.radix_mauve_violet_dark",
            "Radix mauve + violet dark",
            Theme::radix_mauve_violet_dark(),
        ),
        (
            "palette_demo.radix_mauve_violet_light",
            "Radix mauve + violet light",
            Theme::radix_mauve_violet_light(),
        ),
    ];

    for (file_name, label, theme) in variants {
        let mut root = palette_demo(label, theme.palette());
        let bundle = render_bundle_themed(&mut root, viewport, &theme);
        let written = write_bundle(&bundle, &out_dir, file_name)?;
        for p in &written {
            println!("wrote {}", p.display());
        }

        if !bundle.lint.findings.is_empty() {
            eprintln!(
                "\nlint findings for {file_name} ({}):",
                bundle.lint.findings.len()
            );
            eprint!("{}", bundle.lint.text());
        }
    }

    Ok(())
}

pub fn metrics(&self) -> &ThemeMetrics

The active layout metrics used to resolve stock widget defaults.

pub fn font_family(&self) -> FontFamily

The default proportional UI font family applied to text nodes that do not set .font_family(...) themselves.

pub fn with_font_family(self, family: FontFamily) -> Self

Set the default proportional UI font family.

pub fn mono_font_family(&self) -> FontFamily

The default monospace font family applied to text nodes that render as code (font_mono = true, TextRole::Code) and do not set .mono_font_family(...) themselves. Independent of Self::font_family — swapping the proportional face leaves the code face alone, and vice versa.

pub fn with_mono_font_family(self, family: FontFamily) -> Self

Set the default monospace font family for code-tagged text.

pub fn with_metrics(self, metrics: ThemeMetrics) -> Self

Replace the runtime layout metrics.

pub fn with_default_component_size(self, size: ComponentSize) -> Self

Set the default t-shirt size for stock controls.

pub fn with_button_size(self, size: ComponentSize) -> Self

pub fn with_input_size(self, size: ComponentSize) -> Self

pub fn with_badge_size(self, size: ComponentSize) -> Self

pub fn with_tab_size(self, size: ComponentSize) -> Self

pub fn with_choice_size(self, size: ComponentSize) -> Self

pub fn with_slider_size(self, size: ComponentSize) -> Self

pub fn with_progress_size(self, size: ComponentSize) -> Self

pub fn resolve(&self, c: Color) -> Color

Shorthand for self.palette().resolve(c). Library code that derives a color from a token (e.g. via darken/lighten/mix) should resolve through the palette before applying the op so the derivation is computed against the active palette’s rgb, not the token’s compile-time fallback.

pub fn with_surface_shader(self, shader: &'static str) -> Self

Route all implicit surfaces through a custom shader.

The draw-op pass still emits the familiar rounded-rect uniforms (fill, stroke, radius, shadow, focus_color, …). When rounded_rect_slots is enabled, those values are also copied into vec_a..vec_d, matching the cross-backend [crate::paint::QuadInstance] ABI so custom shaders can be drop-in material replacements.

pub fn with_surface_uniform( self, key: &'static str, value: UniformValue, ) -> Self

Add a uniform to every implicit surface draw. Existing node uniforms win, so a local widget override can still specialize a shader parameter.

pub fn with_role_shader(self, role: SurfaceRole, shader: &'static str) -> Self

Route a specific semantic surface role through a custom shader. Roles without an override use the global surface recipe.

pub fn with_role_uniform( self, role: SurfaceRole, key: &'static str, value: UniformValue, ) -> Self

Add a uniform to a specific semantic surface role.

pub fn with_icon_material(self, material: IconMaterial) -> Self

Select the stock material used by native vector icon painters. Backends without vector icon support may ignore this while still preserving the theme value for API parity.

pub fn icon_material(&self) -> IconMaterial

Trait Implementations

impl Clone for Theme

fn clone(&self) -> Theme

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Theme

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Theme

fn default() -> Self

Returns the “default value” for a type.