raw-window-handle 0.6.0

Not quite sure how this happened.

.github/workflows/build.yml

@@ -22,7 +22,7 @@ jobs:
       matrix:
         include:
           - { name: ubuntu-20.04,       os: ubuntu-20.04,   cross-target: '' }
-          - { name: macos-universal,    os: macos-11,       cross-target: aarch64-apple-darwin }
+          - { name: macos-universal,    os: macos-12,       cross-target: aarch64-apple-darwin }
           - { name: windows,            os: windows-latest, cross-target: '' }
     name: Package plugin binaries
     runs-on: ${{ matrix.os }}

.github/workflows/test.yml

@@ -15,7 +15,7 @@ jobs:
   test:
     strategy:
       matrix:
-        os: [ubuntu-20.04, macos-11, windows-latest]
+        os: [ubuntu-20.04, macos-12, windows-latest]
     name: Build and test all components
     runs-on: ${{ matrix.os }}
     steps:

CHANGELOG.md

@@ -10,6 +10,13 @@ Since there is no stable release yet, the changes are organized per day in
 reverse chronological order. The main purpose of this document in its current
 state is to list breaking changes.
 
+## [2024-08-18]
+
+### Breaking changes
+
+- The minimum supported Rust version has been bumped to 1.80 to replace the last
+  uses of `lazy_static` with `std::sync::LazyLock`.
+
 ## [2024-05-05]
 
 ### Breaking changes

Cargo.toml

@@ -2,7 +2,7 @@
 name = "nih_plug"
 version = "0.0.0"
 edition = "2021"
-rust-version = "1.70"
+rust-version = "1.80"
 authors = ["Robbert van der Helm <mail@robbertvanderhelm.nl>"]
 license = "ISC"
 
@@ -54,7 +54,14 @@ assert_process_allocs = ["dep:assert_no_alloc"]
 # Enables an export target for standalone binaries through the
 # `nih_export_standalone()` function. Disabled by default as this requires
 # building additional dependencies for audio and MIDI handling.
-standalone = ["dep:baseview", "dep:clap", "dep:cpal", "dep:jack", "dep:midir", "dep:rtrb"]
+standalone = [
+  "dep:baseview",
+  "dep:clap",
+  "dep:cpal",
+  "dep:jack",
+  "dep:midir",
+  "dep:rtrb",
+]
 # Enables the `nih_export_vst3!()` macro. Enabled by default. This feature
 # exists mostly for GPL-compliance reasons, since even if you don't use the VST3
 # wrapper you might otherwise still include a couple (unused) symbols from the
@@ -85,25 +92,32 @@ cfg-if = "1.0"
 # This supports CLAP 1.1.8
 clap-sys = { git = "https://github.com/robbert-vdh/clap-sys.git", branch = "feature/cstr-macro" }
 crossbeam = "0.8"
-lazy_static = "1.4"
 log = { version = "0.4", features = ["std", "release_max_level_info"] }
 midi-consts = "0.1"
 nih_log = "0.3.1"
 parking_lot = "0.12"
-raw-window-handle = "0.5"
+raw-window-handle = "0.6"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 widestring = "1.0.0-beta.1"
 
 # Used for the `assert_process_allocs` feature
-assert_no_alloc = { git = "https://github.com/robbert-vdh/rust-assert-no-alloc.git", branch = "feature/nested-permit-forbid", features = ["backtrace", "log"], optional = true }
+assert_no_alloc = { git = "https://github.com/robbert-vdh/rust-assert-no-alloc.git", branch = "feature/nested-permit-forbid", features = [
+  "backtrace",
+  "log",
+], optional = true }
 
 # Used for the `standalone` feature
 # NOTE: OpenGL support is not needed here, but rust-analyzer gets confused when
 #       some crates do use it and others don't
-baseview = { git = "https://github.com/RustAudio/baseview.git", rev = "2c1b1a7b0fef1a29a5150a6a8f6fef6a0cbab8c4", features = ["opengl"], optional = true }
+baseview = { git = "https://git.alexjanka.com/alex/baseview", rev = "e31a11f1c73c0fdf1463db77105cf9a9b7c9240a", features = [
+  "opengl",
+], optional = true }
 # All the claps!
-clap = { version = "4.1.8", features = ["derive", "wrap_help"], optional = true }
+clap = { version = "4.1.8", features = [
+  "derive",
+  "wrap_help",
+], optional = true }
 cpal = { version = "0.15", optional = true }
 jack = { version = "0.11.4", optional = true }
 midir = { version = "0.9.1", optional = true }

nih_plug_egui/Cargo.toml

@@ -17,11 +17,10 @@ rayon = ["egui-baseview/rayon"]
 
 [dependencies]
 nih_plug = { path = "..", default-features = false }
-raw-window-handle = "0.5"
+raw-window-handle = "0.6.2"
-baseview = { git = "https://github.com/RustAudio/baseview.git", rev = "45465c5f46abed6c6ce370fffde5edc8e4cd5aa3" }
+baseview = { git = "https://git.alexjanka.com/alex/baseview", rev = "e31a11f1c73c0fdf1463db77105cf9a9b7c9240a" }
 crossbeam = "0.8"
 egui-baseview = { git = "https://github.com/BillyDM/egui-baseview.git", rev = "68c4d0e8e5c1c702a888a245f4ac50eddfdfcaed", default-features = false }
-lazy_static = "1.4"
 parking_lot = "0.12"
 # To make the state persistable
 serde = { version = "1.0", features = ["derive"] }

nih_plug_egui/src/widgets/param_slider.rs

@@ -1,10 +1,9 @@
-use std::sync::Arc;
+use std::sync::{Arc, LazyLock};
 
 use egui_baseview::egui::{
     self, emath, vec2, Key, Response, Sense, Stroke, TextEdit, TextStyle, Ui, Vec2, Widget,
     WidgetText,
 };
-use lazy_static::lazy_static;
 use nih_plug::prelude::{Param, ParamSetter};
 use parking_lot::Mutex;
 
@@ -14,11 +13,10 @@ use super::util;
 /// noramlized parameter.
 const GRANULAR_DRAG_MULTIPLIER: f32 = 0.0015;
 
-lazy_static! {
+static DRAG_NORMALIZED_START_VALUE_MEMORY_ID: LazyLock<egui::Id> =
-    static ref DRAG_NORMALIZED_START_VALUE_MEMORY_ID: egui::Id = egui::Id::new((file!(), 0));
+    LazyLock::new(|| egui::Id::new((file!(), 0)));
-    static ref DRAG_AMOUNT_MEMORY_ID: egui::Id = egui::Id::new((file!(), 1));
+static DRAG_AMOUNT_MEMORY_ID: LazyLock<egui::Id> = LazyLock::new(|| egui::Id::new((file!(), 1)));
-    static ref VALUE_ENTRY_MEMORY_ID: egui::Id = egui::Id::new((file!(), 2));
+static VALUE_ENTRY_MEMORY_ID: LazyLock<egui::Id> = LazyLock::new(|| egui::Id::new((file!(), 2)));
-}
 
 /// A slider widget similar to [`egui::widgets::Slider`] that knows about NIH-plug parameters ranges
 /// and can get values for it. The slider supports double click and control click to reset,
@@ -212,7 +210,7 @@ impl<'a, P: Param> ParamSlider<'a, P> {
             self.reset_param();
             response.mark_changed();
         }
-        if response.drag_released() {
+        if response.drag_stopped() {
             self.end_drag();
         }
 

nih_plug_iced/Cargo.toml

@@ -61,10 +61,10 @@ nih_plug_assets = { git = "https://github.com/robbert-vdh/nih_plug_assets.git" }
 
 # The currently targeted version of baseview uses a different version of
 # `raw_window_handle` than NIH-plug, so we need to manually convert between them
-raw-window-handle = "0.4"
+raw-window-handle = "0.6.2"
 
 atomic_refcell = "0.1"
-baseview = { git = "https://github.com/RustAudio/baseview.git", rev = "1d9806d5bd92275d0d8142d9c9c90198757b9b25" }
+baseview = { git = "https://git.alexjanka.com/alex/baseview", rev = "e31a11f1c73c0fdf1463db77105cf9a9b7c9240a" }
 crossbeam = "0.8"
 # This targets iced 0.4
 iced_baseview = { git = "https://github.com/robbert-vdh/iced_baseview.git", branch = "feature/update-baseview", default-features = false }

nih_plug_vizia/Cargo.toml

@@ -11,10 +11,14 @@ description = "An adapter to use VIZIA GUIs with NIH-plug"
 nih_plug = { path = "..", default-features = false }
 nih_plug_assets = { git = "https://github.com/robbert-vdh/nih_plug_assets.git" }
 
-baseview = { git = "https://github.com/RustAudio/baseview.git", rev = "2c1b1a7b0fef1a29a5150a6a8f6fef6a0cbab8c4" }
+baseview = { git = "https://git.alexjanka.com/alex/baseview", rev = "e31a11f1c73c0fdf1463db77105cf9a9b7c9240a" }
 # This contains an as of writing not yet merged patch for rounding errors when
 # resizing, and a workaround for certain events not firing when resizing
-vizia = { git = "https://github.com/robbert-vdh/vizia.git", tag = "patched-2024-05-06", default-features = false, features = ["baseview", "clipboard", "x11"] }
+vizia = { git = "https://github.com/robbert-vdh/vizia.git", tag = "patched-2024-05-06", default-features = false, features = [
+	"baseview",
+	"clipboard",
+	"x11",
+] }
 
 crossbeam = "0.8"
 # To make the state persistable

src/editor.rs

@@ -1,6 +1,6 @@
 //! Traits for working with plugin editors.
 
-use raw_window_handle::{HasRawWindowHandle, RawWindowHandle};
+use raw_window_handle::{HasWindowHandle, RawWindowHandle, WindowHandle};
 use std::any::Any;
 use std::ffi::c_void;
 use std::sync::Arc;
@@ -90,24 +90,33 @@ pub enum ParentWindowHandle {
     Win32Hwnd(*mut c_void),
 }
 
-unsafe impl HasRawWindowHandle for ParentWindowHandle {
+impl HasWindowHandle for ParentWindowHandle {
-    fn raw_window_handle(&self) -> RawWindowHandle {
+    fn window_handle(
-        match *self {
+        &self,
+    ) -> Result<raw_window_handle::WindowHandle<'_>, raw_window_handle::HandleError> {
+        Ok(unsafe {
+            WindowHandle::borrow_raw(match *self {
                 ParentWindowHandle::X11Window(window) => {
-                let mut handle = raw_window_handle::XcbWindowHandle::empty();
+                    RawWindowHandle::Xcb(raw_window_handle::XcbWindowHandle::new(
-                handle.window = window;
+                        window
-                RawWindowHandle::Xcb(handle)
+                            .try_into()
+                            .map_err(|_| raw_window_handle::HandleError::Unavailable)?,
+                    ))
                 }
                 ParentWindowHandle::AppKitNsView(ns_view) => {
-                let mut handle = raw_window_handle::AppKitWindowHandle::empty();
+                    RawWindowHandle::AppKit(raw_window_handle::AppKitWindowHandle::new(
-                handle.ns_view = ns_view;
+                        std::ptr::NonNull::new(ns_view)
-                RawWindowHandle::AppKit(handle)
+                            .ok_or(raw_window_handle::HandleError::Unavailable)?,
+                    ))
                 }
                 ParentWindowHandle::Win32Hwnd(hwnd) => {
-                let mut handle = raw_window_handle::Win32WindowHandle::empty();
+                    RawWindowHandle::Win32(raw_window_handle::Win32WindowHandle::new(
-                handle.hwnd = hwnd;
+                        (hwnd as isize)
-                RawWindowHandle::Win32(handle)
+                            .try_into()
-            }
+                            .map_err(|_| raw_window_handle::HandleError::Unavailable)?,
+                    ))
                 }
+            })
+        })
     }
 }

src/event_loop/background_thread.rs

@@ -6,7 +6,7 @@
 use anymap::Entry;
 use crossbeam::channel;
 use parking_lot::Mutex;
-use std::sync::{Arc, Weak};
+use std::sync::{Arc, LazyLock, Weak};
 use std::thread::{self, JoinHandle};
 
 use super::MainThreadExecutor;
@@ -73,10 +73,8 @@ where
 // Rust does not allow us to use the `T` and `E` type variable in statics, so this is a
 // workaround to have a singleton that also works if for whatever reason there arem ultiple `T`
 // and `E`s in a single process (won't happen with normal plugin usage, but sho knwos).
-lazy_static::lazy_static! {
+static HANDLE_MAP: LazyLock<Mutex<anymap::Map<dyn std::any::Any + Send>>> =
-    static ref HANDLE_MAP: Mutex<anymap::Map<dyn std::any::Any + Send>> =
+    LazyLock::new(|| Mutex::new(anymap::Map::new()));
-        Mutex::new(anymap::Map::new());
-}
 
 impl<T: Send + 'static, E: MainThreadExecutor<T> + 'static> WorkerThread<T, E> {
     fn spawn() -> Self {

src/wrapper/clap.rs

@@ -14,7 +14,6 @@ pub use clap_sys::factory::plugin_factory::{clap_plugin_factory, CLAP_PLUGIN_FAC
 pub use clap_sys::host::clap_host;
 pub use clap_sys::plugin::{clap_plugin, clap_plugin_descriptor};
 pub use clap_sys::version::CLAP_VERSION;
-pub use lazy_static::lazy_static;
 
 /// Export one or more CLAP plugins from this library using the provided plugin types.
 #[macro_export]

src/wrapper/standalone/wrapper.rs

@@ -3,7 +3,7 @@ use baseview::{EventStatus, Window, WindowHandler, WindowOpenOptions};
 use crossbeam::channel::{self, Sender};
 use crossbeam::queue::ArrayQueue;
 use parking_lot::Mutex;
-use raw_window_handle::HasRawWindowHandle;
+use raw_window_handle::HasWindowHandle;
 use std::any::Any;
 use std::collections::{HashMap, HashSet};
 use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
@@ -345,18 +345,20 @@ impl<P: Plugin, B: Backend<P>> Wrapper<P, B> {
                         gl_config: None,
                     },
                     move |window| {
-                        let parent_handle = match window.raw_window_handle() {
+                        let parent_handle = match window.window_handle().unwrap().as_raw() {
                             raw_window_handle::RawWindowHandle::Xlib(handle) => {
                                 ParentWindowHandle::X11Window(handle.window as u32)
                             }
                             raw_window_handle::RawWindowHandle::Xcb(handle) => {
-                                ParentWindowHandle::X11Window(handle.window)
+                                ParentWindowHandle::X11Window(handle.window.into())
                             }
                             raw_window_handle::RawWindowHandle::AppKit(handle) => {
-                                ParentWindowHandle::AppKitNsView(handle.ns_view)
+                                ParentWindowHandle::AppKitNsView(handle.ns_view.as_ptr())
                             }
                             raw_window_handle::RawWindowHandle::Win32(handle) => {
-                                ParentWindowHandle::Win32Hwnd(handle.hwnd)
+                                ParentWindowHandle::Win32Hwnd(
+                                    handle.hwnd.get() as *mut core::ffi::c_void
+                                )
                             }
                             handle => unimplemented!("Unsupported window handle: {handle:?}"),
                         };

src/wrapper/util.rs

@@ -18,7 +18,7 @@ const AARCH64_FTZ_BIT: u64 = 1 << 24;
 
 #[cfg(all(
     debug_assertions,
-    physical_sizefeature = "assert_process_allocs",
+    feature = "assert_process_allocs",
     all(windows, target_env = "gnu")
 ))]
 compile_error!("The 'assert_process_allocs' feature does not work correctly in combination with the 'x86_64-pc-windows-gnu' target, see https://github.com/Windfisch/rust-assert-no-alloc/issues/7");