native-theme 0.7.0

Cross-platform native theme detection and loading for Rust GUI applications
Documentation
// Theme validation: orchestrate defaults extraction, per-widget dispatch, range checks,
// and ResolvedTheme construction.
// Helper functions, range-check utilities, and ValidateNested trait live in validate_helpers.rs.

use super::validate_helpers::{self, DEFAULT_FONT_DPI, validate_defaults, validate_text_scale};
use crate::model::ThemeMode;
use crate::model::resolved::ResolvedTheme;

impl ThemeMode {
    /// Convert this ThemeMode into a [`ResolvedTheme`] using the default DPI (96.0).
    ///
    /// Convenience wrapper around [`validate_with_dpi(DEFAULT_FONT_DPI)`](Self::validate_with_dpi).
    #[doc(hidden)]
    pub fn validate(&self) -> crate::Result<ResolvedTheme> {
        self.validate_with_dpi(DEFAULT_FONT_DPI)
    }

    /// Convert this ThemeMode into a [`ResolvedTheme`] with all fields guaranteed.
    ///
    /// Should be called after [`resolve()`](ThemeMode::resolve). Walks every field
    /// and collects missing (None) field paths, then validates that numeric values
    /// are within legal ranges (e.g., spacing >= 0, opacity 0..=1, font weight
    /// 100..=900). Returns `Ok(ResolvedTheme)` if all fields are populated
    /// and in range.
    ///
    /// # Arguments
    ///
    /// * `font_dpi` -- Font DPI for pt-to-px conversion (e.g. 96.0 on
    ///   Linux/Windows, 72.0 on macOS); finite and positive.
    ///
    /// # Errors
    ///
    /// Returns [`crate::Error::ResolutionInvalid`] with the one path
    /// `context.font_dpi` if `font_dpi` is not finite and positive, before
    /// any field is read. Returns [`crate::Error::ResolutionIncomplete`] if
    /// any required fields are still `None` after resolution. Returns
    /// [`crate::Error::ResolutionInvalid`] if all fields are present but
    /// some numeric values fall outside allowed ranges.
    #[doc(hidden)]
    pub fn validate_with_dpi(&self, font_dpi: f32) -> crate::Result<ResolvedTheme> {
        validate_helpers::check_font_dpi(font_dpi)?;
        let mut missing = Vec::new();
        let dpi = font_dpi;

        // --- defaults + text_scale extraction (macro-generated) ---
        let defaults = validate_defaults!(
            self, dpi, &mut missing;
            font { font, mono_font }
            option_color {
                background_color,
                text_color,
                accent_color,
                accent_text_color,
                surface_color,
                muted_color,
                shadow_color,
                link_color,
                selection_background,
                selection_text_color,
                selection_inactive_background,
                text_selection_background,
                text_selection_color,
                disabled_text_color,
                danger_color,
                danger_text_color,
                warning_color,
                warning_text_color,
                success_color,
                success_text_color,
                info_color,
                info_text_color,
                focus_ring_color,
            }
            option_f32 {
                line_height,
                disabled_opacity,
                focus_ring_width,
                focus_ring_offset,
            }
            border_required {
                color: crate::color::Rgba::TRANSPARENT,
                corner_radius: 0.0f32,
                corner_radius_lg: 0.0f32,
                line_width: 0.0f32,
                opacity: 0.0f32,
                shadow_enabled: false,
            }
            icon_sizes { toolbar, small, large, dialog, panel }
        );
        let text_scale = validate_text_scale!(
            self, dpi, &mut missing;
            caption, section_heading, dialog_title, display,
        );

        // --- per-widget extraction (generated by define_widget_pair!) ---
        use crate::model::widgets::*;
        let window =
            ResolvedWindowTheme::validate_widget(&self.window, "window", dpi, &mut missing);
        let button =
            ResolvedButtonTheme::validate_widget(&self.button, "button", dpi, &mut missing);
        let input = ResolvedInputTheme::validate_widget(&self.input, "input", dpi, &mut missing);
        let text_area =
            ResolvedTextAreaTheme::validate_widget(&self.text_area, "text_area", dpi, &mut missing);
        let checkbox =
            ResolvedCheckboxTheme::validate_widget(&self.checkbox, "checkbox", dpi, &mut missing);
        let menu = ResolvedMenuTheme::validate_widget(&self.menu, "menu", dpi, &mut missing);
        let tooltip =
            ResolvedTooltipTheme::validate_widget(&self.tooltip, "tooltip", dpi, &mut missing);
        let scrollbar = ResolvedScrollbarTheme::validate_widget(
            &self.scrollbar,
            "scrollbar",
            dpi,
            &mut missing,
        );
        let slider =
            ResolvedSliderTheme::validate_widget(&self.slider, "slider", dpi, &mut missing);
        let progress_bar = ResolvedProgressBarTheme::validate_widget(
            &self.progress_bar,
            "progress_bar",
            dpi,
            &mut missing,
        );
        let tab = ResolvedTabTheme::validate_widget(&self.tab, "tab", dpi, &mut missing);
        let sidebar =
            ResolvedSidebarTheme::validate_widget(&self.sidebar, "sidebar", dpi, &mut missing);
        let toolbar =
            ResolvedToolbarTheme::validate_widget(&self.toolbar, "toolbar", dpi, &mut missing);
        let status_bar = ResolvedStatusBarTheme::validate_widget(
            &self.status_bar,
            "status_bar",
            dpi,
            &mut missing,
        );
        let list = ResolvedListTheme::validate_widget(&self.list, "list", dpi, &mut missing);
        let popover =
            ResolvedPopoverTheme::validate_widget(&self.popover, "popover", dpi, &mut missing);
        let splitter =
            ResolvedSplitterTheme::validate_widget(&self.splitter, "splitter", dpi, &mut missing);
        let separator = ResolvedSeparatorTheme::validate_widget(
            &self.separator,
            "separator",
            dpi,
            &mut missing,
        );
        let switch =
            ResolvedSwitchTheme::validate_widget(&self.switch, "switch", dpi, &mut missing);
        let dialog =
            ResolvedDialogTheme::validate_widget(&self.dialog, "dialog", dpi, &mut missing);
        let spinner =
            ResolvedSpinnerTheme::validate_widget(&self.spinner, "spinner", dpi, &mut missing);
        let combo_box =
            ResolvedComboBoxTheme::validate_widget(&self.combo_box, "combo_box", dpi, &mut missing);
        let segmented_control = ResolvedSegmentedControlTheme::validate_widget(
            &self.segmented_control,
            "segmented_control",
            dpi,
            &mut missing,
        );
        let card = ResolvedCardTheme::validate_widget(&self.card, "card", dpi, &mut missing);
        let expander =
            ResolvedExpanderTheme::validate_widget(&self.expander, "expander", dpi, &mut missing);
        let link = ResolvedLinkTheme::validate_widget(&self.link, "link", dpi, &mut missing);

        // --- Phase 1 short-circuit: if any fields are missing, return immediately ---
        // This is the BUG-01 fix: check_ranges never runs on placeholder data.
        if !missing.is_empty() {
            return Err(crate::Error::ResolutionIncomplete { missing });
        }

        // --- Phase 2: range checks on fully-validated data (separate Vec) ---
        let mut range_errors: Vec<crate::error::RangeViolation> = Vec::new();
        validate_helpers::check_defaults_ranges(
            &defaults,
            &text_scale,
            &self.text_scale,
            &mut range_errors,
        );
        window.check_ranges("window", &mut range_errors);
        button.check_ranges("button", &mut range_errors);
        input.check_ranges("input", &mut range_errors);
        text_area.check_ranges("text_area", &mut range_errors);
        checkbox.check_ranges("checkbox", &mut range_errors);
        menu.check_ranges("menu", &mut range_errors);
        tooltip.check_ranges("tooltip", &mut range_errors);
        scrollbar.check_ranges("scrollbar", &mut range_errors);
        slider.check_ranges("slider", &mut range_errors);
        progress_bar.check_ranges("progress_bar", &mut range_errors);
        tab.check_ranges("tab", &mut range_errors);
        sidebar.check_ranges("sidebar", &mut range_errors);
        toolbar.check_ranges("toolbar", &mut range_errors);
        status_bar.check_ranges("status_bar", &mut range_errors);
        list.check_ranges("list", &mut range_errors);
        popover.check_ranges("popover", &mut range_errors);
        splitter.check_ranges("splitter", &mut range_errors);
        separator.check_ranges("separator", &mut range_errors);
        switch.check_ranges("switch", &mut range_errors);
        dialog.check_ranges("dialog", &mut range_errors);
        spinner.check_ranges("spinner", &mut range_errors);
        combo_box.check_ranges("combo_box", &mut range_errors);
        segmented_control.check_ranges("segmented_control", &mut range_errors);
        card.check_ranges("card", &mut range_errors);
        expander.check_ranges("expander", &mut range_errors);
        link.check_ranges("link", &mut range_errors);

        if !range_errors.is_empty() {
            return Err(crate::Error::ResolutionInvalid {
                errors: range_errors,
            });
        }

        Ok(ResolvedTheme {
            defaults,
            text_scale,
            window,
            button,
            input,
            text_area,
            checkbox,
            menu,
            tooltip,
            scrollbar,
            slider,
            progress_bar,
            tab,
            sidebar,
            toolbar,
            status_bar,
            list,
            popover,
            splitter,
            separator,
            switch,
            dialog,
            spinner,
            combo_box,
            segmented_control,
            card,
            expander,
            link,
        })
    }
}