Squashed:

Port X11 backend to x11rb

Fix macOS build

Win32 refactor

Make the added with_scale_factor fn pub(crate) for now

Remove unneeded internal HasRawWindowHandle implementation

Simplify everything by making the public Window/GlContext types hold the Weak themselves

Remove lifetime from Window type, refactor and split X11 backend

Added functional open_parented example

Author: prokopyl

examples/open_parented.rs

@@ -14,9 +14,9 @@ struct ParentWindowHandler {
 }
 
 impl ParentWindowHandler {
-    pub fn new(window: &mut Window) -> Self {
-        let ctx = unsafe { softbuffer::Context::new(window) }.unwrap();
-        let mut surface = unsafe { softbuffer::Surface::new(&ctx, window) }.unwrap();
+    pub fn new(window: Window) -> Self {
+        let ctx = unsafe { softbuffer::Context::new(&window) }.unwrap();
+        let mut surface = unsafe { softbuffer::Surface::new(&ctx, &window) }.unwrap();
         surface.resize(NonZeroU32::new(512).unwrap(), NonZeroU32::new(512).unwrap()).unwrap();
 
         let window_open_options = baseview::WindowOpenOptions {
@@ -28,8 +28,9 @@ impl ParentWindowHandler {
             #[cfg(feature = "opengl")]
             gl_config: None,
         };
+
         let child_window =
-            Window::open_parented(window, window_open_options, ChildWindowHandler::new);
+            Window::open_parented(&window, window_open_options, ChildWindowHandler::new);
 
         // TODO: no way to query physical size initially?
         Self {
@@ -43,7 +44,7 @@ impl ParentWindowHandler {
 }
 
 impl WindowHandler for ParentWindowHandler {
-    fn on_frame(&mut self, _window: &mut Window) {
+    fn on_frame(&mut self) {
         let mut buf = self.surface.buffer_mut().unwrap();
         if self.damaged {
             buf.fill(0xFFAAAAAA);
@@ -52,7 +53,7 @@ impl WindowHandler for ParentWindowHandler {
         buf.present().unwrap();
     }
 
-    fn on_event(&mut self, _window: &mut Window, event: Event) -> EventStatus {
+    fn on_event(&mut self, event: Event) -> EventStatus {
         match event {
             Event::Window(WindowEvent::Resized(info)) => {
                 println!("Parent Resized: {:?}", info);
@@ -83,9 +84,9 @@ struct ChildWindowHandler {
 }
 
 impl ChildWindowHandler {
-    pub fn new(window: &mut Window) -> Self {
-        let ctx = unsafe { softbuffer::Context::new(window) }.unwrap();
-        let mut surface = unsafe { softbuffer::Surface::new(&ctx, window) }.unwrap();
+    pub fn new(window: Window) -> Self {
+        let ctx = unsafe { softbuffer::Context::new(&window) }.unwrap();
+        let mut surface = unsafe { softbuffer::Surface::new(&ctx, &window) }.unwrap();
         surface.resize(NonZeroU32::new(512).unwrap(), NonZeroU32::new(512).unwrap()).unwrap();
 
         // TODO: no way to query physical size initially?
@@ -94,7 +95,7 @@ impl ChildWindowHandler {
 }
 
 impl WindowHandler for ChildWindowHandler {
-    fn on_frame(&mut self, _window: &mut Window) {
+    fn on_frame(&mut self) {
         let mut buf = self.surface.buffer_mut().unwrap();
         if self.damaged {
             buf.fill(0xFFAA0000);
@@ -103,7 +104,7 @@ impl WindowHandler for ChildWindowHandler {
         buf.present().unwrap();
     }
 
-    fn on_event(&mut self, _window: &mut Window, event: Event) -> EventStatus {
+    fn on_event(&mut self, event: Event) -> EventStatus {
         match event {
             Event::Window(WindowEvent::Resized(info)) => {
                 println!("Child Resized: {:?}", info);

examples/open_window.rs

@@ -1,10 +1,13 @@
+use std::num::NonZeroU32;
 use std::time::Duration;
 
 use rtrb::{Consumer, RingBuffer};
 
 #[cfg(target_os = "macos")]
 use baseview::copy_to_clipboard;
-use baseview::{Event, EventStatus, MouseEvent, Window, WindowHandler, WindowScalePolicy};
+use baseview::{
+    Event, EventStatus, MouseEvent, PhySize, Window, WindowEvent, WindowHandler, WindowScalePolicy,
+};
 
 #[derive(Debug, Clone)]
 enum Message {
@@ -13,28 +16,50 @@ enum Message {
 
 struct OpenWindowExample {
     rx: Consumer<Message>,
+
+    ctx: softbuffer::Context,
+    surface: softbuffer::Surface,
+    current_size: PhySize,
+    damaged: bool,
 }
 
 impl WindowHandler for OpenWindowExample {
-    fn on_frame(&mut self, _window: &mut Window) {
+    fn on_frame(&mut self) {
+        let mut buf = self.surface.buffer_mut().unwrap();
+        if self.damaged {
+            buf.fill(0xFFAAAAAA);
+            self.damaged = false;
+        }
+        buf.present().unwrap();
+
         while let Ok(message) = self.rx.pop() {
             println!("Message: {:?}", message);
         }
     }
 
-    fn on_event(&mut self, _window: &mut Window, event: Event) -> EventStatus {
+    fn on_event(&mut self, event: Event) -> EventStatus {
         match event {
             Event::Mouse(e) => {
                 println!("Mouse event: {:?}", e);
 
                 #[cfg(target_os = "macos")]
                 match e {
-                    MouseEvent::ButtonPressed { .. } => {
-                        copy_to_clipboard(&"This is a test!")
-                    }
+                    MouseEvent::ButtonPressed { .. } => copy_to_clipboard(&"This is a test!"),
                     _ => (),
                 }
             }
+            Event::Window(WindowEvent::Resized(info)) => {
+                println!("Resized: {:?}", info);
+                let new_size = info.physical_size();
+                self.current_size = new_size;
+
+                if let (Some(width), Some(height)) =
+                    (NonZeroU32::new(new_size.width), NonZeroU32::new(new_size.height))
+                {
+                    self.surface.resize(width, height).unwrap();
+                    self.damaged = true;
+                }
+            }
             Event::Keyboard(e) => println!("Keyboard event: {:?}", e),
             Event::Window(e) => println!("Window event: {:?}", e),
         }
@@ -64,5 +89,11 @@ fn main() {
         }
     });
 
-    Window::open_blocking(window_open_options, |_| OpenWindowExample { rx });
+    Window::open_blocking(window_open_options, |window| {
+        let ctx = unsafe { softbuffer::Context::new(&window) }.unwrap();
+        let mut surface = unsafe { softbuffer::Surface::new(&ctx, &window) }.unwrap();
+        surface.resize(NonZeroU32::new(512).unwrap(), NonZeroU32::new(512).unwrap()).unwrap();
+
+        OpenWindowExample { ctx, surface, rx, current_size: PhySize::new(512, 512), damaged: true }
+    });
 }

src/gl/mod.rs

@@ -1,25 +1,20 @@
 use std::ffi::c_void;
-use std::marker::PhantomData;
-
-// On X11 creating the context is a two step process
-#[cfg(not(target_os = "linux"))]
-use raw_window_handle::RawWindowHandle;
+use std::rc::{Rc, Weak};
 
 #[cfg(target_os = "windows")]
-mod win;
+pub(crate) mod win;
 #[cfg(target_os = "windows")]
-use win as platform;
+pub(crate) use win as platform;
 
-// We need to use this directly within the X11 window creation to negotiate the correct visual
 #[cfg(target_os = "linux")]
 pub(crate) mod x11;
 #[cfg(target_os = "linux")]
-pub(crate) use self::x11 as platform;
+pub(crate) use x11 as platform;
 
 #[cfg(target_os = "macos")]
-mod macos;
+pub(crate) mod macos;
 #[cfg(target_os = "macos")]
-use macos as platform;
+pub(crate) use macos as platform;
 
 #[derive(Clone, Debug)]
 pub struct GlConfig {
@@ -70,46 +65,37 @@ pub enum GlError {
 }
 
 pub struct GlContext {
-    context: platform::GlContext,
-    phantom: PhantomData<*mut ()>,
+    context: Weak<platform::GlContext>,
 }
 
 impl GlContext {
-    #[cfg(not(target_os = "linux"))]
-    pub(crate) unsafe fn create(
-        parent: &RawWindowHandle, config: GlConfig,
-    ) -> Result<GlContext, GlError> {
-        platform::GlContext::create(parent, config)
-            .map(|context| GlContext { context, phantom: PhantomData })
+    pub(crate) fn new(context: Weak<platform::GlContext>) -> GlContext {
+        GlContext { context }
     }
 
-    /// The X11 version needs to be set up in a different way compared to the Windows and macOS
-    /// versions. So the platform-specific versions should be used to construct the context within
-    /// baseview, and then this object can be passed to the user.
-    #[cfg(target_os = "linux")]
-    pub(crate) fn new(context: platform::GlContext) -> GlContext {
-        GlContext { context, phantom: PhantomData }
+    fn context(&self) -> Rc<platform::GlContext> {
+        self.context.upgrade().expect("GL context has been destroyed")
     }
 
     pub unsafe fn make_current(&self) {
-        self.context.make_current();
+        self.context().make_current();
     }
 
     pub unsafe fn make_not_current(&self) {
-        self.context.make_not_current();
+        self.context().make_not_current();
     }
 
     pub fn get_proc_address(&self, symbol: &str) -> *const c_void {
-        self.context.get_proc_address(symbol)
+        self.context().get_proc_address(symbol)
     }
 
     pub fn swap_buffers(&self) {
-        self.context.swap_buffers();
+        self.context().swap_buffers();
     }
 
     /// On macOS the `NSOpenGLView` needs to be resized separtely from our main view.
     #[cfg(target_os = "macos")]
     pub(crate) fn resize(&self, size: cocoa::foundation::NSSize) {
-        self.context.resize(size);
+        self.context().resize(size);
     }
 }