Merge pull request locainin#14 from locainin/dev

see pull request locainin#14 for details

Author: locainin

crates/noticenterctl/src/main/main_css_check_geometry/media/width.rs

@@ -16,8 +16,8 @@ impl GeometryModel {
             // No media widget means no media width pressure
             return None;
         }
-        // Width warnings compare the final shell pressure to the configured panel width
-        let required_panel_width_px = self.media_required_panel_width_px(config);
+        // Width warnings compare the minimum shell pressure to the configured panel width
+        let required_panel_width_px = self.media_minimum_panel_width_px(config);
         width_warning(
             "media row",
             required_panel_width_px,
@@ -42,26 +42,22 @@ impl GeometryModel {
         ))
     }
 
-    fn media_required_panel_width_px(&self, config: &Config) -> i32 {
-        // Stock pressure is used as the baseline because the final warning talks in panel width
-        let pressure = self.media_pressure_px(config);
+    fn media_minimum_panel_width_px(&self, config: &Config) -> i32 {
+        let pressure = self.media_minimum_pressure_px(config);
         let stock = stock_geometry_model();
         let stock_config = stock_config();
-        let stock_pressure = stock.media_pressure_px(stock_config);
+        let stock_pressure = stock.media_minimum_pressure_px(stock_config);
 
-        // The delta from stock is easier to reason about than an absolute guess
         stock_config.panel.width + (pressure - stock_pressure)
     }
 
-    fn media_pressure_px(&self, config: &Config) -> i32 {
+    fn media_minimum_pressure_px(&self, config: &Config) -> i32 {
         // The shell snapshot keeps the width math deterministic across helper calls
         let shell = ModeledMediaShell::from_config(&config.media);
-        let text_width_px = config
-            .panel
-            .width
-            .saturating_sub(media_text_reserve_px(shell))
-            .max(shell.text_width_floor_px.max(MEDIA_TEXT_WIDTH_FLOOR_PX));
-        // The text lane is fixed by the widget builder, but meta padding can still widen it
+        // The runtime title lane grows with the panel, but minimum-width lint must stay
+        // actionable. Using the floor prevents required width from growing with panel.width
+        let text_width_px = shell.text_width_floor_px.max(MEDIA_TEXT_WIDTH_FLOOR_PX);
+        // The text lane has a configured minimum, but meta padding can still widen it
         let meta_width_px = self
             .media_meta
             .outer_width_px(text_width_px)
@@ -192,6 +188,7 @@ impl GeometryModel {
     }
 }
 
+#[cfg(test)]
 pub(super) fn media_text_reserve_px(shell: ModeledMediaShell) -> i32 {
     // Reserve math mirrors the runtime shell so marquee width stays in sync with widget layout
     let mut reserve_px = 0;

crates/noticenterctl/src/main/main_css_check_geometry/model/constants.rs

@@ -2,16 +2,13 @@
 pub(super) const WIDTH_WARNING_TOLERANCE_PX: i32 = 8;
 pub(super) const HEIGHT_WARNING_TOLERANCE_PX: i32 = 12;
 
-// Fixed-grid widgets share column counts, spacing, and fallback content widths
-pub(super) const TOGGLE_GRID_COLUMNS: usize = 4;
+// Fixed-grid widgets share spacing and fallback content widths
 pub(super) const TOGGLE_GRID_SPACING_PX: i32 = 8;
 pub(super) const TOGGLE_FALLBACK_CONTENT_WIDTH_PX: i32 = 80;
 
-pub(super) const STAT_GRID_COLUMNS: usize = 2;
 pub(super) const STAT_GRID_SPACING_PX: i32 = 8;
 pub(super) const STAT_FALLBACK_CONTENT_WIDTH_PX: i32 = 96;
 
-pub(super) const CARD_GRID_COLUMNS: usize = 2;
 pub(super) const CARD_GRID_SPACING_PX: i32 = 8;
 pub(super) const CARD_FALLBACK_CONTENT_WIDTH_PX: i32 = 104;
 

crates/noticenterctl/src/main/main_css_check_geometry/model/fixed_grid.rs

@@ -1,9 +1,8 @@
 use unixnotis_core::Config;
 
 use super::constants::{
-    CARD_FALLBACK_CONTENT_WIDTH_PX, CARD_GRID_COLUMNS, CARD_GRID_SPACING_PX,
-    STAT_FALLBACK_CONTENT_WIDTH_PX, STAT_GRID_COLUMNS, STAT_GRID_SPACING_PX,
-    TOGGLE_FALLBACK_CONTENT_WIDTH_PX, TOGGLE_GRID_COLUMNS, TOGGLE_GRID_SPACING_PX,
+    CARD_FALLBACK_CONTENT_WIDTH_PX, CARD_GRID_SPACING_PX, STAT_FALLBACK_CONTENT_WIDTH_PX,
+    STAT_GRID_SPACING_PX, TOGGLE_FALLBACK_CONTENT_WIDTH_PX, TOGGLE_GRID_SPACING_PX,
 };
 use super::{
     stock_config, stock_geometry_model, width_warning, GeometryModel, HorizontalBoxMetrics,
@@ -27,7 +26,7 @@ impl GeometryModel {
             "stat grid",
             required_panel_width_px,
             config.panel.width,
-            "GTK natural width can still widen the panel when two-column cards ask for more room",
+            "GTK natural width can still widen the panel when configured stat columns ask for more room",
         )
     }
 
@@ -37,7 +36,7 @@ impl GeometryModel {
             "card grid",
             required_panel_width_px,
             config.panel.width,
-            "GTK natural width can still widen the panel when two-column cards ask for more room",
+            "GTK natural width can still widen the panel when configured card columns ask for more room",
         )
     }
 
@@ -49,7 +48,7 @@ impl GeometryModel {
             .iter()
             .filter(|widget| widget.enabled)
             .count()
-            .min(TOGGLE_GRID_COLUMNS);
+            .min(config.widgets.toggle_columns);
         if columns == 0 {
             return None;
         }
@@ -64,38 +63,40 @@ impl GeometryModel {
                 .outer_width_px(TOGGLE_FALLBACK_CONTENT_WIDTH_PX),
         );
 
-        // Compare against the shipped theme so stock CSS stays quiet
-        let stock = stock_geometry_model();
-        let stock_config = stock_config();
-        let stock_columns = stock_config
-            .widgets
-            .toggles
-            .iter()
-            .filter(|widget| widget.enabled)
-            .count()
-            .min(TOGGLE_GRID_COLUMNS);
-        let stock_pressure = stock.fixed_grid_pressure_px(
-            stock_columns,
-            TOGGLE_GRID_SPACING_PX,
-            stock.toggle_section,
-            stock.toggle_grid,
-            stock
-                .toggle_item
-                .outer_width_px(TOGGLE_FALLBACK_CONTENT_WIDTH_PX),
-        );
-
-        Some(stock_config.panel.width + (pressure - stock_pressure))
+        Some(self.required_width_from_pressure(
+            pressure,
+            config.widgets.toggle_columns,
+            stock_config().widgets.toggle_columns,
+            |stock, stock_config| {
+                let stock_columns = stock_config
+                    .widgets
+                    .toggles
+                    .iter()
+                    .filter(|widget| widget.enabled)
+                    .count()
+                    .min(stock_config.widgets.toggle_columns);
+                stock.fixed_grid_pressure_px(
+                    stock_columns,
+                    TOGGLE_GRID_SPACING_PX,
+                    stock.toggle_section,
+                    stock.toggle_grid,
+                    stock
+                        .toggle_item
+                        .outer_width_px(TOGGLE_FALLBACK_CONTENT_WIDTH_PX),
+                )
+            },
+        ))
     }
 
     fn stat_required_panel_width_px(&self, config: &Config) -> Option<i32> {
-        // Stats render as a fixed two-column grid, so enabled items decide the live column count
+        // Enabled stats decide how much of the configured column budget is actually used
         let columns = config
             .widgets
             .stats
             .iter()
             .filter(|widget| widget.enabled)
             .count()
-            .min(STAT_GRID_COLUMNS);
+            .min(config.widgets.stat_columns);
         if columns == 0 {
             return None;
         }
@@ -109,26 +110,29 @@ impl GeometryModel {
                 .outer_width_px(STAT_FALLBACK_CONTENT_WIDTH_PX),
         );
 
-        let stock = stock_geometry_model();
-        let stock_config = stock_config();
-        let stock_columns = stock_config
-            .widgets
-            .stats
-            .iter()
-            .filter(|widget| widget.enabled)
-            .count()
-            .min(STAT_GRID_COLUMNS);
-        let stock_pressure = stock.fixed_grid_pressure_px(
-            stock_columns,
-            STAT_GRID_SPACING_PX,
-            stock.stat_section,
-            stock.stat_grid,
-            stock
-                .stat_item
-                .outer_width_px(STAT_FALLBACK_CONTENT_WIDTH_PX),
-        );
-
-        Some(stock_config.panel.width + (pressure - stock_pressure))
+        Some(self.required_width_from_pressure(
+            pressure,
+            config.widgets.stat_columns,
+            stock_config().widgets.stat_columns,
+            |stock, stock_config| {
+                let stock_columns = stock_config
+                    .widgets
+                    .stats
+                    .iter()
+                    .filter(|widget| widget.enabled)
+                    .count()
+                    .min(stock_config.widgets.stat_columns);
+                stock.fixed_grid_pressure_px(
+                    stock_columns,
+                    STAT_GRID_SPACING_PX,
+                    stock.stat_section,
+                    stock.stat_grid,
+                    stock
+                        .stat_item
+                        .outer_width_px(STAT_FALLBACK_CONTENT_WIDTH_PX),
+                )
+            },
+        ))
     }
 
     fn card_required_panel_width_px(&self, config: &Config) -> Option<i32> {
@@ -139,7 +143,7 @@ impl GeometryModel {
             .iter()
             .filter(|widget| widget.enabled)
             .count()
-            .min(CARD_GRID_COLUMNS);
+            .min(config.widgets.card_columns);
         if columns == 0 {
             return None;
         }
@@ -153,26 +157,29 @@ impl GeometryModel {
                 .outer_width_px(CARD_FALLBACK_CONTENT_WIDTH_PX),
         );
 
-        let stock = stock_geometry_model();
-        let stock_config = stock_config();
-        let stock_columns = stock_config
-            .widgets
-            .cards
-            .iter()
-            .filter(|widget| widget.enabled)
-            .count()
-            .min(CARD_GRID_COLUMNS);
-        let stock_pressure = stock.fixed_grid_pressure_px(
-            stock_columns,
-            CARD_GRID_SPACING_PX,
-            stock.card_section,
-            stock.card_grid,
-            stock
-                .card_item
-                .outer_width_px(CARD_FALLBACK_CONTENT_WIDTH_PX),
-        );
-
-        Some(stock_config.panel.width + (pressure - stock_pressure))
+        Some(self.required_width_from_pressure(
+            pressure,
+            config.widgets.card_columns,
+            stock_config().widgets.card_columns,
+            |stock, stock_config| {
+                let stock_columns = stock_config
+                    .widgets
+                    .cards
+                    .iter()
+                    .filter(|widget| widget.enabled)
+                    .count()
+                    .min(stock_config.widgets.card_columns);
+                stock.fixed_grid_pressure_px(
+                    stock_columns,
+                    CARD_GRID_SPACING_PX,
+                    stock.card_section,
+                    stock.card_grid,
+                    stock
+                        .card_item
+                        .outer_width_px(CARD_FALLBACK_CONTENT_WIDTH_PX),
+                )
+            },
+        ))
     }
 
     fn fixed_grid_pressure_px(
@@ -193,4 +200,24 @@ impl GeometryModel {
             // Spacing only exists between neighbors, never after the last item
             + ((columns.saturating_sub(1)) as i32 * spacing_px)
     }
+
+    fn required_width_from_pressure<F>(
+        &self,
+        pressure: i32,
+        configured_columns: usize,
+        stock_columns: usize,
+        stock_pressure_for_default: F,
+    ) -> i32
+    where
+        F: FnOnce(&GeometryModel, &Config) -> i32,
+    {
+        if configured_columns != stock_columns {
+            return pressure;
+        }
+
+        let stock = stock_geometry_model();
+        let stock_config = stock_config();
+        let stock_pressure = stock_pressure_for_default(stock, stock_config);
+        stock_config.panel.width + (pressure - stock_pressure)
+    }
 }

crates/noticenterctl/src/main/main_css_check_geometry/parse/selectors.rs

@@ -23,6 +23,13 @@ pub(super) fn maybe_warn_for_complex_unixnotis_selector(
         // Shipped complex selectors already have a known baseline and should stay quiet
         return;
     }
+    if selector_targets_descendant(selector) && !selector_target_mentions_unixnotis_class(selector)
+    {
+        // Descendant rules aimed at GTK subnodes usually affect an inner allocation
+        // Rules whose final target is a UnixNotis hook still need a warning because they can
+        // resize a real widget that this lightweight model cannot update from a complex selector
+        return;
+    }
 
     let warning_key = format!("complex:{selector}");
     if !warned_classes.insert(warning_key) {
@@ -36,6 +43,32 @@ pub(super) fn maybe_warn_for_complex_unixnotis_selector(
     ));
 }
 
+fn selector_targets_descendant(selector: &str) -> bool {
+    selector.contains(' ')
+        || selector.contains('>')
+        || selector.contains('+')
+        || selector.contains('~')
+}
+
+fn selector_target_mentions_unixnotis_class(selector: &str) -> bool {
+    selector_mentions_unixnotis_class(rightmost_selector_segment(selector))
+}
+
+fn rightmost_selector_segment(selector: &str) -> &str {
+    let split_at = selector
+        .char_indices()
+        .filter_map(|(index, ch)| {
+            if ch.is_ascii_whitespace() || matches!(ch, '>' | '+' | '~') {
+                Some(index + ch.len_utf8())
+            } else {
+                None
+            }
+        })
+        .next_back()
+        .unwrap_or(0);
+    selector[split_at..].trim()
+}
+
 pub(super) fn simple_class_selector(selector: &str) -> Option<&str> {
     let trimmed = selector.trim();
     if !trimmed.starts_with('.') {

crates/noticenterctl/src/main/main_css_check_geometry/stock/classes.rs

@@ -49,7 +49,7 @@ fn collect_unixnotis_classes(css: &'static str, classes: &mut HashSet<&'static s
     }
 }
 
-fn hook_unixnotis_classes() -> [&'static str; 27] {
+fn hook_unixnotis_classes() -> [&'static str; 33] {
     // Hook-only classes can be real live selectors before the stock theme gives them rules
     [
         ".unixnotis-panel-actions",
@@ -65,6 +65,12 @@ fn hook_unixnotis_classes() -> [&'static str; 27] {
         ".unixnotis-panel-action-close",
         ".unixnotis-panel-action-with-icon",
         ".unixnotis-panel-action-icon",
+        ".unixnotis-panel-subtitle",
+        ".unixnotis-section-header",
+        ".unixnotis-recent-section",
+        ".unixnotis-recent-header",
+        ".unixnotis-recent-header-row",
+        ".unixnotis-panel-footer",
         ".unixnotis-group",
         ".unixnotis-group-row",
         ".unixnotis-group-header",
@@ -94,4 +100,15 @@ mod tests {
         assert!(classes.contains(".unixnotis-media-button-play"));
         assert!(classes.contains(".unixnotis-media-button-next"));
     }
+
+    #[test]
+    fn section_header_hooks_are_treated_as_known_public_classes() {
+        let classes = known_unixnotis_classes();
+
+        assert!(classes.contains(".unixnotis-section-header"));
+        assert!(classes.contains(".unixnotis-recent-section"));
+        assert!(classes.contains(".unixnotis-recent-header"));
+        assert!(classes.contains(".unixnotis-recent-header-row"));
+        assert!(classes.contains(".unixnotis-panel-footer"));
+    }
 }