refactor: simplify internal invariants and processing paths

Signed-off-by: Maika Namuo <httpworldview@gmail.com>

Author: httpsworldview

src/meter.rs

@@ -37,35 +37,26 @@ impl DspBatcher {
         }
     }
 
-    fn push(
-        &mut self,
-        manager: &mut VisualManager,
-        mut samples: &[f32],
-        format: AudioFormat,
-    ) -> usize {
+    fn push(&mut self, manager: &mut VisualManager, mut samples: &[f32], format: AudioFormat) {
         if self.format.is_some_and(|current| current != format) {
             self.samples.clear();
         }
         self.format = Some(format);
         let batch = scaled_samples(DSP_BATCH_FRAMES_AT_48K, format);
-        let mut count = 0;
         if !self.samples.is_empty() {
             let take = (batch - self.samples.len()).min(samples.len());
             self.samples.extend_from_slice(&samples[..take]);
             samples = &samples[take..];
             if self.samples.len() == batch {
                 manager.ingest_samples(&self.samples, format);
                 self.samples.clear();
-                count += 1;
             }
         }
         let ready = samples.len() / batch * batch;
         for chunk in samples[..ready].chunks(scaled_samples(MAX_DSP_INGEST_FRAMES_AT_48K, format)) {
             manager.ingest_samples(chunk, format);
-            count += 1;
         }
         self.samples.extend_from_slice(&samples[ready..]);
-        count
     }
 
     fn reset(&mut self, manager: &mut VisualManager) {
@@ -214,11 +205,8 @@ mod tests {
         let format = format(2, 48_000.0, 1);
         let block = [0.25; 64 * 2];
         let storage = (batcher.samples.as_ptr(), batcher.samples.capacity());
-        for index in 0..4 {
-            assert_eq!(
-                batcher.push(&mut manager, &block, format),
-                usize::from(index == 3)
-            );
+        for _ in 0..4 {
+            batcher.push(&mut manager, &block, format);
         }
         assert!(batcher.samples.is_empty());
         assert_eq!(
@@ -230,43 +218,26 @@ mod tests {
             sample_rate: 96_000.0,
             ..format
         };
-        for index in 0..8 {
-            assert_eq!(
-                batcher.push(&mut manager, &block, high_rate),
-                usize::from(index == 7)
-            );
+        for _ in 0..8 {
+            batcher.push(&mut manager, &block, high_rate);
         }
         assert_eq!(
             (batcher.samples.as_ptr(), batcher.samples.capacity()),
             storage
         );
     }
 
-    #[test]
-    fn dsp_batches_coalesce_large_capture_backlogs() {
-        let mut manager = VisualManager::default();
-        let mut batcher = DspBatcher::new();
-        let format = format(2, 48_000.0, 1);
-        assert_eq!(
-            batcher.push(&mut manager, &[0.25; (256 * 6 + 17) * 2], format),
-            2
-        );
-        assert_eq!(batcher.samples.len(), 17 * 2);
-        assert_eq!(batcher.push(&mut manager, &[0.25; 239 * 2], format), 1);
-        assert!(batcher.samples.is_empty());
-    }
-
     #[test]
     fn dsp_batches_never_mix_format_generations() {
         let mut manager = VisualManager::default();
         let mut batcher = DspBatcher::new();
         let old = format(2, 48_000.0, 1);
-        assert_eq!(batcher.push(&mut manager, &[0.25; 128 * 2], old), 0);
+        batcher.push(&mut manager, &[0.25; 128 * 2], old);
         let new = AudioFormat {
             generation: 2,
             ..old
         };
-        assert_eq!(batcher.push(&mut manager, &[0.5; 2], new), 0);
+        batcher.push(&mut manager, &[0.5; 2], new);
         assert_eq!(batcher.samples.as_slice(), &[0.5, 0.5]);
         assert_eq!(batcher.format, Some(new));
     }
@@ -276,10 +247,7 @@ mod tests {
         let mut manager = VisualManager::default();
         let mut batcher = DspBatcher::new();
         let format = format(MAX_CAPTURE_CHANNELS, 192_000.0, 1);
-        assert_eq!(
-            batcher.push(&mut manager, &[0.25; 128 * MAX_CAPTURE_CHANNELS], format),
-            0
-        );
+        batcher.push(&mut manager, &[0.25; 128 * MAX_CAPTURE_CHANNELS], format);
         let scratch = [0.0; SILENCE_CHUNK_FRAMES * MAX_CAPTURE_CHANNELS];
         ingest_silence(
             &mut manager,

src/persistence/palette.rs

@@ -48,8 +48,7 @@ impl PaletteSettings {
     pub fn if_differs_from(colors: &[Color], defaults: &[Color]) -> Option<Self> {
         color_stops_if_differ(colors, defaults).map(|stops| Self {
             stops,
-            stop_positions: None,
-            stop_spreads: None,
+            ..Default::default()
         })
     }
 
@@ -61,7 +60,6 @@ impl PaletteSettings {
         spreads: &[f32],
     ) -> Option<Self> {
         let count = defaults.len();
-        debug_assert_eq!(positions.len(), default_positions.len());
         let stops = color_stops_if_differ(colors, defaults);
         let positions_differ = positions
             .iter()

src/persistence/store.rs

@@ -148,11 +148,10 @@ impl SettingsHandle {
     pub fn borrow(&self) -> Ref<'_, SettingsManager> {
         self.0.borrow()
     }
-    pub fn update<F: FnOnce(&mut SettingsManager) -> R, R>(&self, mutate: F) -> R {
+    pub fn update(&self, mutate: impl FnOnce(&mut SettingsManager)) {
         let mut manager = self.0.borrow_mut();
-        let result = mutate(&mut manager);
+        mutate(&mut manager);
         schedule_persist(manager.path.clone(), manager.data.clone());
-        result
     }
 
     pub fn flush() {

src/ui/app.rs

@@ -116,6 +116,7 @@ struct UiApp {
     use_layershell: bool,
     settings_window: Option<(window::Id, ActiveSettings)>,
     settings_scroll: ScrollGlow,
+    // at most one popout exists for each VisualKind
     popout_windows: HashMap<window::Id, PopoutWindow>,
     exit_warning_until: Option<Instant>,
 }

src/ui/app/message.rs

@@ -96,39 +96,30 @@ pub(super) fn update(app: &mut UiApp, msg: Message) -> Task<Message> {
                 ConfigMessage::DecorationsToggled(enabled) => app.recreate_windows(*enabled),
                 _ => Task::none(),
             };
-            let restore_popout = match &config_msg {
-                ConfigMessage::VisualToggled {
-                    kind,
-                    enabled: true,
-                } => Some(*kind),
+            let toggled = match &config_msg {
+                ConfigMessage::VisualToggled { kind, enabled } => Some((*kind, *enabled)),
                 _ => None,
             };
             let bar_task = app.handle_bar_config_message(&config_msg);
             let theme_changed = matches!(&config_msg, ConfigMessage::ThemeChanged(_));
-            let topology_changed = matches!(&config_msg, ConfigMessage::VisualToggled { .. });
-            let frame_rate = match &config_msg {
-                ConfigMessage::VisualFrameRateChanged(rate) => Some(*rate),
-                _ => None,
-            };
-            app.config_page.update(config_msg);
-            if let Some(rate) = frame_rate {
-                app.frames.borrow_mut().set_rate(rate);
+            if let ConfigMessage::VisualFrameRateChanged(rate) = &config_msg {
+                app.frames.borrow_mut().set_rate(*rate);
             }
-            if topology_changed {
+            app.config_page.update(config_msg);
+            let topology_task = toggled.map_or_else(Task::none, |(kind, enabled)| {
                 let active = app.visuals_active();
                 app.frames.borrow_mut().set_active(active);
+                let restore = if enabled {
+                    app.restore_popout_window(kind)
+                } else {
+                    Task::none()
+                };
+                Task::batch([restore, app.sync_all_windows()])
+            });
+            if theme_changed && let Some((_, panel)) = app.settings_window.as_mut() {
+                *panel = super::ActiveSettings::new(panel.kind(), &app.visual_manager);
             }
-            if theme_changed {
-                app.refresh_settings_panel();
-            }
-            let restore_task =
-                restore_popout.map_or_else(Task::none, |kind| app.restore_popout_window(kind));
-            let topology_task = if topology_changed {
-                app.sync_all_windows()
-            } else {
-                Task::none()
-            };
-            Task::batch([decoration_task, bar_task, restore_task, topology_task])
+            Task::batch([decoration_task, bar_task, topology_task])
         }
         Message::Visuals(VisualsMessage::SettingsRequested(kind)) => {
             app.open_settings_window(kind, false)

src/ui/app/windowing.rs

@@ -186,13 +186,6 @@ impl UiApp {
         }
     }
 
-    pub(super) fn refresh_settings_panel(&mut self) {
-        let Some((_, panel)) = self.settings_window.as_mut() else {
-            return;
-        };
-        *panel = ActiveSettings::new(panel.kind(), &self.visual_manager);
-    }
-
     pub(super) fn open_settings_window(
         &mut self,
         kind: VisualKind,
@@ -505,9 +498,6 @@ impl UiApp {
     }
 
     pub(super) fn request_main_output_snapshot(&self) -> Task<Message> {
-        if !self.main_window_is_layer {
-            return Task::none();
-        }
         let id = self.main_window_id;
         let (sender, receiver) = async_channel::bounded(1);
         Task::batch([

src/ui/config.rs

@@ -176,12 +176,12 @@ impl ConfigPage {
             }
             ConfigMessage::BgPalette(event) => {
                 if self.bg_palette.update(event) {
-                    let color = self.bg_palette.colors().first().copied();
+                    let color = self.bg_palette.colors()[0];
                     self.settings.update(|s| {
-                        s.data.background_color = color.map(Into::into);
-                        s.update_active_theme(|theme| theme.background = color.map(Into::into));
+                        s.data.background_color = Some(color.into());
+                        s.update_active_theme(|theme| theme.background = Some(color.into()));
                     });
-                    self.window_themes = theme::window_themes(color);
+                    self.window_themes = theme::window_themes(Some(color));
                     self.refresh_theme_choices_if_needed();
                 }
             }

src/ui/settings.rs

@@ -139,7 +139,7 @@ use crate::persistence::settings::{
     BUILTIN_THEME, ModuleSettings, PaletteSettings, SettingsConfig, SettingsHandle,
 };
 use crate::ui::theme::Palette;
-use crate::ui::widgets::{SliderRange, palette_editor::PaletteEditor};
+use crate::ui::widgets::palette_editor::PaletteEditor;
 use crate::visuals::registry::{VisualKind, VisualManagerHandle};
 use iced::{Color, Element};
 
@@ -155,29 +155,19 @@ fn set<T: PartialEq>(target: &mut T, value: T) -> bool {
 }
 
 // Compare bits to avoid spurious writes for identical NaN payloads.
-fn set_f32(target: &mut f32, value: f32, range: SliderRange) -> bool {
-    let value = range.snap(value);
+fn set_f32(target: &mut f32, value: f32) -> bool {
     if target.to_bits() == value.to_bits() {
         return false;
     }
     *target = value;
     true
 }
 
-fn set_usize(target: &mut usize, value: f32, range: SliderRange) -> bool {
-    debug_assert!(
-        [range.min, range.max, range.step]
-            .into_iter()
-            .all(|value| value.fract().abs() <= f32::EPSILON),
-        "set_usize expects integral slider bounds"
-    );
-    set(target, range.snap(value).round() as usize)
+fn set_usize(target: &mut usize, value: f32) -> bool {
+    set(target, value.round() as usize)
 }
 
 fn get_closest_hop_divisor(fft_size: usize, hop_size: usize) -> usize {
-    if fft_size == 0 || hop_size == 0 {
-        return 8;
-    }
     let ratio = fft_size as f32 / hop_size as f32;
     HOP_DIVISORS
         .into_iter()
@@ -186,7 +176,7 @@ fn get_closest_hop_divisor(fft_size: usize, hop_size: usize) -> usize {
                 .abs()
                 .total_cmp(&(ratio - right as f32).abs())
         })
-        .unwrap_or(8)
+        .unwrap()
 }
 
 // Preserve the hop:fft ratio when fft_size changes.
@@ -195,12 +185,12 @@ fn update_fft_size(fft_size: &mut usize, hop_size: &mut usize, new_size: usize)
     if !set(fft_size, new_size) {
         return false;
     }
-    *hop_size = (new_size / hop_divisor).max(1);
+    *hop_size = new_size / hop_divisor;
     true
 }
 
 fn update_hop_divisor(fft_size: usize, hop_size: &mut usize, divisor: usize) -> bool {
-    set(hop_size, (fft_size / divisor.max(1)).max(1))
+    set(hop_size, (fft_size / divisor).max(1))
 }
 
 settings_modules! {

src/ui/settings/oscilloscope.rs

@@ -45,8 +45,8 @@ impl fmt::Display for TriggerSourceChoice {
 }
 
 settings_messages!(pane, settings, value {
-    SegmentDuration(f32) => set_f32(&mut settings.segment_duration, value, DURATION_RANGE);
-    Persistence(f32) => set_f32(&mut settings.persistence, value, PERSISTENCE_RANGE);
+    SegmentDuration(f32) => set_f32(&mut settings.segment_duration, value);
+    Persistence(f32) => set_f32(&mut settings.persistence, value);
     Preset(TriggerPreset) => {
         let mode = match value {
             TriggerPreset::Stable => TriggerMode::Stable { num_cycles: pane.num_cycles },
@@ -56,9 +56,8 @@ settings_messages!(pane, settings, value {
     };
     NumCycles(usize) => match settings.trigger_mode {
         TriggerMode::Stable { .. } => {
-            let cycles = value.clamp(CYCLES_RANGE.min as usize, CYCLES_RANGE.max as usize);
-            pane.num_cycles = cycles;
-            set(&mut settings.trigger_mode, TriggerMode::Stable { num_cycles: cycles })
+            pane.num_cycles = value;
+            set(&mut settings.trigger_mode, TriggerMode::Stable { num_cycles: value })
         }
         TriggerMode::ZeroCrossing => false,
     };

src/ui/settings/spectrogram.rs

@@ -25,9 +25,9 @@ settings_messages!(pane, settings, value {
     Window(WindowKind) => set(&mut settings.window, value);
     Scale(FrequencyScale) => set(&mut settings.frequency_scale, value);
     UseReassignment(bool) => set(&mut settings.use_reassignment, value);
-    FloorDb(f32) => set_f32(&mut settings.floor_db, value, FLOOR_RANGE);
-    TiltDb(f32) => set_f32(&mut settings.tilt_db, value, TILT_RANGE);
-    Rotation(f32) => set(&mut settings.rotation, ROTATION_RANGE.snap(value).round() as i8);
+    FloorDb(f32) => set_f32(&mut settings.floor_db, value);
+    TiltDb(f32) => set_f32(&mut settings.tilt_db, value);
+    Rotation(f32) => set(&mut settings.rotation, value.round() as i8);
     ZeroPadding(usize) => set(&mut settings.zero_padding_factor, value);
     PianoRoll(PianoRollOverlay) => set(&mut settings.piano_roll_overlay, value);
 });