raw-window-handle 0.6.0

Cargo.toml

@@ -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
@@ -90,20 +97,28 @@ 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://github.com/RustAudio/baseview.git", 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 }

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/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:?}"),
                         };