Use the new iced generic UI for Crisp

plugins/crisp/Cargo.toml

@@ -10,4 +10,4 @@ crate-type = ["cdylib"]
 
 [dependencies]
 nih_plug = { path = "../../", features = ["assert_process_allocs"] }
-nih_plug_egui = { path = "../../nih_plug_egui" }
+nih_plug_iced = { path = "../../nih_plug_iced" }

plugins/crisp/src/editor.rs

@@ -14,26 +14,92 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-use nih_plug::prelude::Editor;
+use nih_plug::prelude::{Editor, GuiContext};
-use nih_plug_egui::widgets::generic_ui;
+use nih_plug_iced::widgets as nih_widgets;
-use nih_plug_egui::{create_egui_editor, egui, EguiState};
+use nih_plug_iced::widgets::generic_ui::GenericUi;
+use nih_plug_iced::*;
 use std::pin::Pin;
 use std::sync::Arc;
 
 use crate::CrispParams;
 
 // Makes sense to also define this here, makes it a bit easier to keep track of
-pub fn default_state() -> Arc<EguiState> {
+pub(crate) fn default_state() -> Arc<IcedState> {
-    EguiState::from_size(250, 350)
+    // We have a scroll bar, so we should proudly show off that we have a scroll bar
+    IcedState::from_size(370, 330)
 }
 
-pub fn create(
+pub(crate) fn create(
     params: Pin<Arc<CrispParams>>,
-    editor_state: Arc<EguiState>,
+    editor_state: Arc<IcedState>,
 ) -> Option<Box<dyn Editor>> {
-    create_egui_editor(editor_state, (), move |egui_ctx, setter, _state| {
+    create_iced_editor::<CrispEditor>(editor_state, params)
-        egui::CentralPanel::default().show(egui_ctx, |ui| {
+}
-            generic_ui::create(ui, params.as_ref(), setter, generic_ui::GenericSlider);
+
-        });
+struct CrispEditor {
-    })
+    params: Pin<Arc<CrispParams>>,
+    context: Arc<dyn GuiContext>,
+
+    generic_ui_state: nih_widgets::generic_ui::State<nih_widgets::generic_ui::GenericSlider>,
+}
+
+#[derive(Debug, Clone, Copy)]
+enum Message {
+    /// Update a parameter's value.
+    ParamUpdate(nih_widgets::ParamMessage),
+}
+
+impl IcedEditor for CrispEditor {
+    type Executor = executor::Default;
+    type Message = Message;
+    type InitializationFlags = Pin<Arc<CrispParams>>;
+
+    fn new(
+        params: Self::InitializationFlags,
+        context: Arc<dyn GuiContext>,
+    ) -> (Self, Command<Self::Message>) {
+        let editor = CrispEditor {
+            params,
+            context,
+
+            generic_ui_state: Default::default(),
+        };
+
+        (editor, Command::none())
+    }
+
+    fn context(&self) -> &dyn GuiContext {
+        self.context.as_ref()
+    }
+
+    fn update(
+        &mut self,
+        _window: &mut WindowQueue,
+        message: Self::Message,
+    ) -> Command<Self::Message> {
+        match message {
+            Message::ParamUpdate(message) => self.handle_param_message(message),
+        }
+
+        Command::none()
+    }
+
+    fn view(&mut self) -> Element<'_, Self::Message> {
+        GenericUi::new(
+            &mut self.generic_ui_state,
+            self.params.as_ref(),
+            self.context.as_ref(),
+        )
+        .pad_scrollbar()
+        .map(Message::ParamUpdate)
+    }
+
+    fn background_color(&self) -> nih_plug_iced::Color {
+        nih_plug_iced::Color {
+            r: 0.98,
+            g: 0.98,
+            b: 0.98,
+            a: 1.0,
+        }
+    }
 }

plugins/crisp/src/lib.rs

@@ -18,7 +18,7 @@
 extern crate nih_plug;
 
 use nih_plug::prelude::*;
-use nih_plug_egui::EguiState;
+use nih_plug_iced::IcedState;
 use pcg::Pcg32iState;
 use std::pin::Pin;
 use std::sync::Arc;
@@ -45,7 +45,7 @@ const MAX_FILTER_FREQUENCY: f32 = 22_000.0;
 /// since this effect just turns into literal noise at high frequencies.
 struct Crisp {
     params: Pin<Arc<CrispParams>>,
-    editor_state: Arc<EguiState>,
+    editor_state: Arc<IcedState>,
 
     /// Needed for computing the filter coefficients.
     sample_rate: f32,