Raw window handle 0.6

Cargo.toml

@@ -12,11 +12,11 @@ keywords = ["clipboard", "window", "ui", "gui", "raw-window-handle"]
 categories = ["gui"]
 
 [dependencies]
-raw-window-handle = "0.5"
+raw-window-handle = { version = "0.6", features = ["std"] }
 thiserror = "1.0"
 
 [target.'cfg(windows)'.dependencies]
-clipboard-win = { version = "4.0", features = ["std"] }
+clipboard-win = { version = "5.0", features = ["std"] }
 
 [target.'cfg(target_os = "macos")'.dependencies]
 clipboard_macos = { version = "0.1", path = "./macos" }
@@ -27,7 +27,7 @@ clipboard_wayland = { version = "0.2", path = "./wayland" }
 
 [dev-dependencies]
 rand = "0.8"
-winit = "0.28"
+winit = "0.29"
 
 [workspace]
 members = [

examples/big_file.rs

@@ -1,12 +1,14 @@
 use rand::distributions::{Alphanumeric, Distribution};
 use window_clipboard::Clipboard;
 use winit::{
-    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    error::EventLoopError,
+    event::{ElementState, Event, KeyEvent, WindowEvent},
+    event_loop::EventLoop,
+    keyboard::Key,
     window::WindowBuilder,
 };
 
-fn main() {
+fn main() -> Result<(), EventLoopError> {
     let mut rng = rand::thread_rng();
 
     let data: String = Alphanumeric
@@ -15,40 +17,40 @@ fn main() {
         .map(char::from)
         .collect();
 
-    let event_loop = EventLoop::new();
+    let event_loop = EventLoop::new().unwrap();
 
     let window = WindowBuilder::new()
         .with_title("Press G to start the test!")
         .build(&event_loop)
         .unwrap();
 
     let mut clipboard =
-        Clipboard::connect(&window).expect("Connect to clipboard");
+        unsafe { Clipboard::connect(&window) }.expect("Connect to clipboard");
 
     clipboard.write(data.clone()).unwrap();
 
-    event_loop.run(move |event, _, control_flow| match event {
+    event_loop.run(move |event, elwt| match event {
         Event::WindowEvent {
             event:
                 WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
-                            virtual_keycode: Some(VirtualKeyCode::G),
+                    event:
+                        KeyEvent {
+                            logical_key: Key::Character(c),
                             state: ElementState::Released,
                             ..
                         },
                     ..
                 },
             ..
-        } => {
+        } if c == "G" => {
             let new_data = clipboard.read().expect("Read data");
             assert_eq!(data, new_data, "Data is equal");
             println!("Data copied successfully!");
         }
         Event::WindowEvent {
             event: WindowEvent::CloseRequested,
             window_id,
-        } if window_id == window.id() => *control_flow = ControlFlow::Exit,
-        _ => *control_flow = ControlFlow::Wait,
-    });
+        } if window_id == window.id() => elwt.exit(),
+        _ => {}
+    })
 }

examples/read.rs

@@ -1,28 +1,30 @@
 use window_clipboard::Clipboard;
 use winit::{
+    error::EventLoopError,
     event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
-fn main() {
-    let event_loop = EventLoop::new();
+fn main() -> Result<(), EventLoopError> {
+    let event_loop = EventLoop::new().unwrap();
 
     let window = WindowBuilder::new()
         .with_title("A fantastic window!")
         .build(&event_loop)
         .unwrap();
 
-    let clipboard = Clipboard::connect(&window).expect("Connect to clipboard");
+    let clipboard =
+        unsafe { Clipboard::connect(&window) }.expect("Connect to clipboard");
 
-    event_loop.run(move |event, _, control_flow| match event {
-        Event::MainEventsCleared => {
+    event_loop.run(move |event, elwt| match event {
+        Event::AboutToWait => {
             println!("{:?}", clipboard.read());
         }
         Event::WindowEvent {
             event: WindowEvent::CloseRequested,
             window_id,
-        } if window_id == window.id() => *control_flow = ControlFlow::Exit,
-        _ => *control_flow = ControlFlow::Wait,
-    });
+        } if window_id == window.id() => elwt.exit(),
+        _ => {}
+    })
 }

examples/write.rs

@@ -1,31 +1,31 @@
 use window_clipboard::Clipboard;
 use winit::{
+    error::EventLoopError,
     event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
-fn main() {
-    let event_loop = EventLoop::new();
+fn main() -> Result<(), EventLoopError> {
+    let event_loop = EventLoop::new().unwrap();
 
     let window = WindowBuilder::new()
         .with_title("A fantastic window!")
         .build(&event_loop)
         .unwrap();
 
     let mut clipboard =
-        Clipboard::connect(&window).expect("Connect to clipboard");
+        unsafe { Clipboard::connect(&window) }.expect("Connect to clipboard");
 
     clipboard
         .write(String::from("Hello, world!"))
         .expect("Write to clipboard");
 
-    event_loop.run(move |event, _, control_flow| match event {
-        Event::MainEventsCleared => {}
+    event_loop.run(move |event, elwt| match event {
         Event::WindowEvent {
             event: WindowEvent::CloseRequested,
             window_id,
-        } if window_id == window.id() => *control_flow = ControlFlow::Exit,
-        _ => *control_flow = ControlFlow::Wait,
-    });
+        } if window_id == window.id() => elwt.exit(),
+        _ => {}
+    })
 }

src/lib.rs

@@ -46,15 +46,16 @@ mod platform;
 #[path = "platform/dummy.rs"]
 mod platform;
 
-use raw_window_handle::HasRawDisplayHandle;
+use raw_window_handle::HasDisplayHandle;
 use std::error::Error;
 
 pub struct Clipboard {
     raw: Box<dyn ClipboardProvider>,
 }
 
 impl Clipboard {
-    pub fn connect<W: HasRawDisplayHandle>(
+    /// Safety: the display handle must be valid for the lifetime of `Clipboard`
+    pub unsafe fn connect<W: HasDisplayHandle>(
         window: &W,
     ) -> Result<Self, Box<dyn Error>> {
         let raw = platform::connect(window)?;

src/platform/android.rs

@@ -1,9 +1,9 @@
 use crate::ClipboardProvider;
 
-use raw_window_handle::HasRawDisplayHandle;
+use raw_window_handle::HasDisplayHandle;
 use std::error::Error;
 
-pub fn connect<W: HasRawDisplayHandle>(
+pub fn connect<W: HasDisplayHandle>(
     _window: &W,
 ) -> Result<Box<dyn ClipboardProvider>, Box<dyn Error>> {
     Ok(Box::new(Clipboard::new()?))

src/platform/dummy.rs

@@ -1,10 +1,10 @@
 use crate::ClipboardProvider;
 
-use raw_window_handle::HasRawDisplayHandle;
+use raw_window_handle::HasDisplayHandle;
 
 struct Dummy;
 
-pub fn connect<W: HasRawDisplayHandle>(
+pub fn connect<W: HasDisplayHandle>(
     _window: &W,
 ) -> Result<Box<dyn ClipboardProvider>, Box<dyn std::error::Error>> {
     Ok(Box::new(Dummy))

src/platform/ios.rs

@@ -1,9 +1,9 @@
 use crate::ClipboardProvider;
 
-use raw_window_handle::HasRawDisplayHandle;
+use raw_window_handle::HasDisplayHandle;
 use std::error::Error;
 
-pub fn connect<W: HasRawDisplayHandle>(
+pub fn connect<W: HasDisplayHandle>(
     _window: &W,
 ) -> Result<Box<dyn ClipboardProvider>, Box<dyn Error>> {
     Ok(Box::new(Clipboard::new()?))

src/platform/linux.rs

@@ -1,21 +1,17 @@
 use crate::ClipboardProvider;
 
-use raw_window_handle::{HasRawDisplayHandle, RawDisplayHandle};
+use raw_window_handle::{HasDisplayHandle, RawDisplayHandle};
 use std::error::Error;
 
 pub use clipboard_wayland as wayland;
 pub use clipboard_x11 as x11;
 
-pub fn connect<W: HasRawDisplayHandle>(
+pub unsafe fn connect<W: HasDisplayHandle>(
     window: &W,
 ) -> Result<Box<dyn ClipboardProvider>, Box<dyn Error>> {
-    let clipboard = match window.raw_display_handle() {
+    let clipboard = match window.display_handle()?.as_raw() {
         RawDisplayHandle::Wayland(handle) => {
-            assert!(!handle.display.is_null());
-
-            Box::new(unsafe {
-                wayland::Clipboard::connect(handle.display as *mut _)
-            }) as _
+            Box::new(wayland::Clipboard::connect(handle.display.as_ptr())) as _
         }
         _ => Box::new(x11::Clipboard::connect()?) as _,
     };

src/platform/macos.rs

@@ -1,9 +1,9 @@
 use crate::ClipboardProvider;
 
-use raw_window_handle::HasRawDisplayHandle;
+use raw_window_handle::HasDisplayHandle;
 use std::error::Error;
 
-pub fn connect<W: HasRawDisplayHandle>(
+pub fn connect<W: HasDisplayHandle>(
     _window: &W,
 ) -> Result<Box<dyn ClipboardProvider>, Box<dyn Error>> {
     Ok(Box::new(clipboard_macos::Clipboard::new()?))

src/platform/windows.rs

@@ -1,11 +1,11 @@
 use crate::ClipboardProvider;
 
 use clipboard_win::{get_clipboard_string, set_clipboard_string};
-use raw_window_handle::HasRawDisplayHandle;
+use raw_window_handle::HasDisplayHandle;
 
 use std::error::Error;
 
-pub fn connect<W: HasRawDisplayHandle>(
+pub fn connect<W: HasDisplayHandle>(
     _window: &W,
 ) -> Result<Box<dyn ClipboardProvider>, Box<dyn Error>> {
     Ok(Box::new(Clipboard))

wayland/Cargo.toml

@@ -10,4 +10,4 @@ documentation = "https://docs.rs/clipboard_wayland"
 keywords = ["clipboard", "wayland"]
 
 [dependencies]
-smithay-clipboard = "0.6"
+smithay-clipboard = "0.7"

x11/Cargo.toml

@@ -10,5 +10,5 @@ documentation = "https://docs.rs/clipboard_x11"
 keywords = ["clipboard", "x11"]
 
 [dependencies]
-x11rb = "0.11"
+x11rb = "0.13"
 thiserror = "1.0"