The Great Refactoring

raumklang-gui/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "gui"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [[bin]]
 name = "raumklang"

raumklang-gui/fonts/icons.toml

@@ -1,8 +1,9 @@
 module = "icon" 
 
 [glyphs]
-delete = "fontawesome-trash"
+plus = "fontawesome-plus"
 record = "typicons-record"
+delete = "fontawesome-trash"
 download = "typicons-download"
 settings = "fontawesome-cog-alt"
 reset = "fontawesome-ccw"

raumklang-gui/src/audio.rs

@@ -20,8 +20,8 @@ use tokio::sync::mpsc;
 use tokio::sync::mpsc::error::TryRecvError;
 use tokio_stream::wrappers::ReceiverStream;
 
-use std::sync::atomic::{self, AtomicBool};
 use std::sync::Arc;
+use std::sync::atomic::{self, AtomicBool};
 use std::thread;
 use std::time::Duration;
 

raumklang-gui/src/audio/loudness.rs

@@ -4,7 +4,7 @@ use tokio::sync::mpsc::error::TrySendError;
 
 use std::time::{Duration, Instant};
 
-use super::{process::Control, Process};
+use super::{Process, process::Control};
 
 #[derive(Debug, Clone, Copy)]
 pub struct Loudness {

raumklang-gui/src/audio/measurement.rs

@@ -1,16 +1,16 @@
 use crate::log;
 
-use super::{loudness, process::Control, Process};
+use super::{Process, loudness, process::Control};
 
 use ringbuf::{
-    traits::{Consumer as _, Producer as _, Split as _},
     HeapCons, HeapProd, HeapRb,
+    traits::{Consumer as _, Producer as _, Split as _},
 };
 
 use std::{
     sync::{
-        atomic::{self, AtomicBool},
         Arc,
+        atomic::{self, AtomicBool},
     },
     time::Duration,
 };

raumklang-gui/src/data.rs

@@ -21,8 +21,8 @@ pub use spectral_decay::SpectralDecay;
 pub use spectrogram::Spectrogram;
 pub use window::Window;
 
-use ndarray::{concatenate, Array, Array1, ArrayView, Axis};
-use ndarray_interp::interp1d::{cubic_spline::CubicSpline, Interp1DBuilder};
+use ndarray::{Array, Array1, ArrayView, Axis, concatenate};
+use ndarray_interp::interp1d::{Interp1DBuilder, cubic_spline::CubicSpline};
 use ndarray_stats::SummaryStatisticsExt;
 
 use std::{io, sync::Arc};

raumklang-gui/src/data/impulse_response.rs

@@ -1,26 +1,71 @@
-#[derive(Debug, Clone)]
-pub struct ImpulseResponse {
-    pub origin: raumklang_core::ImpulseResponse,
+use std::sync::Arc;
+
+use iced::task::{Sipper, sipper};
+
+#[derive(Debug, Clone, Default)]
+pub struct ImpulseResponse(State);
+
+#[derive(Debug, Clone, Default)]
+enum State {
+    #[default]
+    None,
+    Computing,
+    Computed(Arc<raumklang_core::ImpulseResponse>),
 }
 
 impl ImpulseResponse {
-    pub fn from_data(impulse_response: raumklang_core::ImpulseResponse) -> Self {
-        Self {
-            origin: impulse_response,
+    pub fn compute(
+        self,
+        loopback: &raumklang_core::Loopback,
+        measurement: &raumklang_core::Measurement,
+    ) -> Option<impl Sipper<Self, Self> + use<>> {
+        if let State::Computing = self.0 {
+            return None;
+        }
+
+        if let State::Computed(_) = self.0 {
+            return None;
+        }
+
+        let loopback = loopback.clone();
+        let measurement = measurement.clone();
+
+        let sipper = sipper(async move |mut progress| {
+            progress.send(ImpulseResponse(State::Computing)).await;
+
+            let impulse_response = tokio::task::spawn_blocking(move || {
+                raumklang_core::ImpulseResponse::from_signals(&loopback, &measurement)
+            })
+            .await
+            .unwrap()
+            .unwrap();
+
+            ImpulseResponse(State::Computed(Arc::new(impulse_response)))
+        });
+
+        Some(sipper)
+    }
+
+    pub fn result(&self) -> Option<&raumklang_core::ImpulseResponse> {
+        match self.0 {
+            State::None => None,
+            State::Computing => None,
+            State::Computed(ref impulse_response) => Some(impulse_response),
+        }
+    }
+
+    pub fn progress(&self) -> Progress {
+        match self.0 {
+            State::None => Progress::None,
+            State::Computing => Progress::Computing,
+            State::Computed(_) => Progress::Computed,
         }
     }
 }
 
-pub async fn compute(
-    loopback: raumklang_core::Loopback,
-    measurement: raumklang_core::Measurement,
-) -> ImpulseResponse {
-    let impulse_response = tokio::task::spawn_blocking(move || {
-        raumklang_core::ImpulseResponse::from_signals(&loopback, &measurement)
-    })
-    .await
-    .unwrap()
-    .unwrap();
-
-    ImpulseResponse::from_data(impulse_response)
+#[derive(Debug, Clone)]
+pub enum Progress {
+    None,
+    Computing,
+    Computed,
 }

raumklang-gui/src/data/recent_projects.rs

@@ -1,7 +1,7 @@
 use super::Error;
 
 use std::{
-    collections::{vec_deque, VecDeque},
+    collections::{VecDeque, vec_deque},
     io,
     path::{Path, PathBuf},
 };