WIP winit git

I wanted to see how the changes in Winit git would work here. So of
course this depends on that being released.

Depends on #1514. It doesn't seem
to pose a particular challenge beyond that. Updating compositors for
that change will be needed to test this...

Anvil changes broken in rebase; needs update...

Author: ids1024

Cargo.toml

@@ -62,7 +62,7 @@ wayland-protocols-misc = { version = "0.3.1", features = ["server"], optional =
 wayland-server = { version = "0.31.0", optional = true }
 wayland-sys = { version = "0.31", optional = true }
 wayland-backend = { version = "0.3.5", optional = true }
-winit = { version = "0.30.0", default-features = false, features = ["wayland", "wayland-dlopen", "x11", "rwh_06"], optional = true }
+winit = { git = "https://github.com/rust-windowing/winit", default-features = false, features = ["wayland", "wayland-dlopen", "x11"], optional = true }
 x11rb = { version = "0.13.0", optional = true }
 xkbcommon = { version = "0.8.0", features = ["wayland"]}
 encoding_rs = { version = "0.8.33", optional = true }

anvil/src/winit.rs

@@ -99,93 +99,13 @@ pub fn run_winit() {
     let mut display_handle = display.handle();
 
     #[cfg_attr(not(feature = "egl"), allow(unused_mut))]
-    let (mut backend, mut winit) = match winit::init::<GlesRenderer>() {
+    let mut winit = match winit::init::<GlesRenderer>() {
         Ok(ret) => ret,
         Err(err) => {
             error!("Failed to initialize Winit backend: {}", err);
             return;
         }
     };
-    let size = backend.window_size();
-
-    let mode = Mode {
-        size,
-        refresh: 60_000,
-    };
-    let output = Output::new(
-        OUTPUT_NAME.to_string(),
-        PhysicalProperties {
-            size: (0, 0).into(),
-            subpixel: Subpixel::Unknown,
-            make: "Smithay".into(),
-            model: "Winit".into(),
-        },
-    );
-    let _global = output.create_global::<AnvilState<WinitData>>(&display.handle());
-    output.change_current_state(Some(mode), Some(Transform::Flipped180), None, Some((0, 0).into()));
-    output.set_preferred(mode);
-
-    #[cfg(feature = "debug")]
-    #[allow(deprecated)]
-    let fps_image =
-        image::io::Reader::with_format(std::io::Cursor::new(FPS_NUMBERS_PNG), image::ImageFormat::Png)
-            .decode()
-            .unwrap();
-    #[cfg(feature = "debug")]
-    let fps_texture = backend
-        .renderer()
-        .import_memory(
-            &fps_image.to_rgba8(),
-            Fourcc::Abgr8888,
-            (fps_image.width() as i32, fps_image.height() as i32).into(),
-            false,
-        )
-        .expect("Unable to upload FPS texture");
-    #[cfg(feature = "debug")]
-    let mut fps_element = FpsElement::new(fps_texture);
-
-    let render_node = EGLDevice::device_for_display(backend.renderer().egl_context().display())
-        .and_then(|device| device.try_get_render_node());
-
-    let dmabuf_default_feedback = match render_node {
-        Ok(Some(node)) => {
-            let dmabuf_formats = backend.renderer().dmabuf_formats();
-            let dmabuf_default_feedback = DmabufFeedbackBuilder::new(node.dev_id(), dmabuf_formats)
-                .build()
-                .unwrap();
-            Some(dmabuf_default_feedback)
-        }
-        Ok(None) => {
-            warn!("failed to query render node, dmabuf will use v3");
-            None
-        }
-        Err(err) => {
-            warn!(?err, "failed to egl device for display, dmabuf will use v3");
-            None
-        }
-    };
-
-    // if we failed to build dmabuf feedback we fall back to dmabuf v3
-    // Note: egl on Mesa requires either v4 or wl_drm (initialized with bind_wl_display)
-    let dmabuf_state = if let Some(default_feedback) = dmabuf_default_feedback {
-        let mut dmabuf_state = DmabufState::new();
-        let dmabuf_global = dmabuf_state.create_global_with_default_feedback::<AnvilState<WinitData>>(
-            &display.handle(),
-            &default_feedback,
-        );
-        (dmabuf_state, dmabuf_global, Some(default_feedback))
-    } else {
-        let dmabuf_formats = backend.renderer().dmabuf_formats();
-        let mut dmabuf_state = DmabufState::new();
-        let dmabuf_global =
-            dmabuf_state.create_global::<AnvilState<WinitData>>(&display.handle(), dmabuf_formats);
-        (dmabuf_state, dmabuf_global, None)
-    };
-
-    #[cfg(feature = "egl")]
-    if backend.renderer().bind_wl_display(&display.handle()).is_ok() {
-        info!("EGL hardware-acceleration enabled");
-    };
 
     let data = {
         let damage_tracker = OutputDamageTracker::from_output(&output);
@@ -214,6 +134,96 @@ pub fn run_winit() {
 
     while state.running.load(Ordering::SeqCst) {
         let status = winit.dispatch_new_events(|event| match event {
+            WinitEvent::WindowCreated(backend) => {
+                let size = backend.window_size();
+
+                let mode = Mode {
+                    size,
+                    refresh: 60_000,
+                };
+                let output = Output::new(
+                    OUTPUT_NAME.to_string(),
+                    PhysicalProperties {
+                        size: (0, 0).into(),
+                        subpixel: Subpixel::Unknown,
+                        make: "Smithay".into(),
+                        model: "Winit".into(),
+                    },
+                );
+                let _global = output.create_global::<AnvilState<WinitData>>(&display.handle());
+                output.change_current_state(
+                    Some(mode),
+                    Some(Transform::Flipped180),
+                    None,
+                    Some((0, 0).into()),
+                );
+                output.set_preferred(mode);
+
+                #[cfg(feature = "debug")]
+                let fps_image = image::ImageReader::with_format(
+                    std::io::Cursor::new(FPS_NUMBERS_PNG),
+                    image::ImageFormat::Png,
+                )
+                .decode()
+                .unwrap();
+                #[cfg(feature = "debug")]
+                let fps_texture = backend
+                    .renderer()
+                    .import_memory(
+                        &fps_image.to_rgba8(),
+                        Fourcc::Abgr8888,
+                        (fps_image.width() as i32, fps_image.height() as i32).into(),
+                        false,
+                    )
+                    .expect("Unable to upload FPS texture");
+                #[cfg(feature = "debug")]
+                let mut fps_element = FpsElement::new(fps_texture);
+
+                let render_node = EGLDevice::device_for_display(backend.renderer().egl_context().display())
+                    .and_then(|device| device.try_get_render_node());
+
+                let dmabuf_default_feedback = match render_node {
+                    Ok(Some(node)) => {
+                        let dmabuf_formats = backend.renderer().dmabuf_formats();
+                        let dmabuf_default_feedback =
+                            DmabufFeedbackBuilder::new(node.dev_id(), dmabuf_formats)
+                                .build()
+                                .unwrap();
+                        Some(dmabuf_default_feedback)
+                    }
+                    Ok(None) => {
+                        warn!("failed to query render node, dmabuf will use v3");
+                        None
+                    }
+                    Err(err) => {
+                        warn!(?err, "failed to egl device for display, dmabuf will use v3");
+                        None
+                    }
+                };
+
+                // if we failed to build dmabuf feedback we fall back to dmabuf v3
+                // Note: egl on Mesa requires either v4 or wl_drm (initialized with bind_wl_display)
+                let dmabuf_state = if let Some(default_feedback) = dmabuf_default_feedback {
+                    let mut dmabuf_state = DmabufState::new();
+                    let dmabuf_global = dmabuf_state
+                        .create_global_with_default_feedback::<AnvilState<WinitData>>(
+                            &display.handle(),
+                            &default_feedback,
+                        );
+                    (dmabuf_state, dmabuf_global, Some(default_feedback))
+                } else {
+                    let dmabuf_formats = backend.renderer().dmabuf_formats();
+                    let mut dmabuf_state = DmabufState::new();
+                    let dmabuf_global = dmabuf_state
+                        .create_global::<AnvilState<WinitData>>(&display.handle(), dmabuf_formats);
+                    (dmabuf_state, dmabuf_global, None)
+                };
+
+                #[cfg(feature = "egl")]
+                if backend.renderer().bind_wl_display(&display.handle()).is_ok() {
+                    info!("EGL hardware-acceleration enabled");
+                };
+            }
             WinitEvent::Resized { size, .. } => {
                 // We only have one output
                 let output = state.space.outputs().next().unwrap().clone();

src/backend/egl/native.rs

@@ -160,7 +160,7 @@ impl<A: AsFd + Send + 'static> EGLNativeDisplay for GbmDevice<A> {
 }
 
 #[cfg(feature = "backend_winit")]
-impl EGLNativeDisplay for Arc<WinitWindow> {
+impl EGLNativeDisplay for Arc<dyn WinitWindow> {
     fn supported_platforms(&self) -> Vec<EGLPlatform<'_>> {
         use winit::raw_window_handle::{self, HasDisplayHandle};