Release 25.3

Wlx: Fix various Clippy warnings

Cargo.lock

@@ -4655,7 +4655,7 @@ dependencies = [
 [[package]]
 name = "wayvr_ipc"
 version = "0.1.0"
-source = "git+https://github.com/olekolek1000/wayvr-ipc.git?rev=3c411d09ba1bba2609288e29739c0f1ec736b012#3c411d09ba1bba2609288e29739c0f1ec736b012"
+source = "git+https://github.com/olekolek1000/wayvr-ipc.git?rev=a72587d23f3bb8624d9aeb1f13c0a21e65350f51#a72587d23f3bb8624d9aeb1f13c0a21e65350f51"
 dependencies = [
  "anyhow",
  "bytes",
@@ -5121,7 +5121,7 @@ dependencies = [
 
 [[package]]
 name = "wlx-overlay-s"
-version = "25.2.0"
+version = "25.3.0"
 dependencies = [
  "anyhow",
  "ash",

Cargo.toml

@@ -4,7 +4,7 @@ debug = true
 
 [package]
 name = "wlx-overlay-s"
-version = "25.2.0"
+version = "25.3.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -86,7 +86,7 @@ wayland-client = { version = "0.31.6", optional = true }
 wayland-egl = { version = "0.32.4", optional = true }
 interprocess = { version = "2.2.2", optional = true }
 bytes = { version = "1.9.0", optional = true }
-wayvr_ipc = { git = "https://github.com/olekolek1000/wayvr-ipc.git", rev = "3c411d09ba1bba2609288e29739c0f1ec736b012", default-features = false, optional = true }
+wayvr_ipc = { git = "https://github.com/olekolek1000/wayvr-ipc.git", rev = "a72587d23f3bb8624d9aeb1f13c0a21e65350f51", default-features = false, optional = true }
 ################################
 
 [build-dependencies]

contrib/wayvr/watch_wayvr_example.yaml

@@ -28,9 +28,21 @@ elements:
         target: settings
         action: Destroy # only triggers if exists since before current frame
 
+  # Dashboard toggle button
+  - type: Button
+    rect: [32, 162, 48, 36]
+    corner_radius: 4
+    font_size: 15
+    bg_color: "#2288FF"
+    fg_color: "#24273a"
+    text: "Dash"
+    click_up:
+      - type: WayVR
+        action: ToggleDashboard
+
   # Keyboard button
   - type: Button
-    rect: [32, 162, 60, 36]
+    rect: [84, 162, 48, 36]
     corner_radius: 4
     font_size: 15
     fg_color: "#24273a"
@@ -65,7 +77,7 @@ elements:
 
   # bottom row, of keyboard + overlays
   - type: OverlayList
-    rect: [94, 160, 306, 40]
+    rect: [134, 160, 266, 40]
     corner_radius: 4
     font_size: 15
     fg_color: "#cad3f5"

src/backend/osc.rs

@@ -146,24 +146,24 @@ impl OscSender {
 
                 // send device battery parameters
                 self.send_message(
-                    format!("/avatar/parameters/{parameter}Battery").into(),
+                    format!("/avatar/parameters/{parameter}Battery"),
                     vec![OscType::Float(level)],
                 )?;
                 self.send_message(
-                    format!("/avatar/parameters/{parameter}Charging").into(),
+                    format!("/avatar/parameters/{parameter}Charging"),
                     vec![OscType::Bool(device.charging)],
                 )?;
             }
 
             // send average controller and tracker battery parameters
             self.send_message(
-                format!("/avatar/parameters/averageControllerBattery").into(),
+                String::from("/avatar/parameters/averageControllerBattery"),
                 vec![OscType::Float(
                     controller_total_bat / controller_count as f32,
                 )],
             )?;
             self.send_message(
-                format!("/avatar/parameters/averageTrackerBattery").into(),
+                String::from("/avatar/parameters/averageTrackerBattery"),
                 vec![OscType::Float(tracker_total_bat / tracker_count as f32)],
             )?;
         }

src/backend/wayvr/display.rs

@@ -291,8 +291,7 @@ impl Display {
         renderer.bind(self.gles_texture.clone())?;
 
         let size = Size::from((self.width as i32, self.height as i32));
-        let damage: Rectangle<i32, smithay::utils::Physical> =
-            Rectangle::from_loc_and_size((0, 0), size);
+        let damage: Rectangle<i32, smithay::utils::Physical> = Rectangle::from_size(size);
 
         let elements: Vec<WaylandSurfaceRenderElement<GlesRenderer>> = self
             .displayed_windows

src/backend/wayvr/mod.rs

@@ -40,6 +40,8 @@ use std::{
 use time::get_millis;
 use wayvr_ipc::{packet_client, packet_server};
 
+use crate::state::AppState;
+
 const STR_INVALID_HANDLE_DISP: &str = "Invalid display handle";
 const STR_INVALID_HANDLE_PROCESS: &str = "Invalid process handle";
 
@@ -185,12 +187,10 @@ impl WayVR {
             }
             Ok(None) => {
                 log::warn!("dmabuf: Failed to query render node");
-                debug_assert!(false);
                 None
             }
             Err(err) => {
                 log::warn!("dmabuf: Failed to get egl device for display: {}", err);
-                debug_assert!(false);
                 None
             }
         };
@@ -279,12 +279,13 @@ impl WayVR {
         Ok(())
     }
 
-    pub fn tick_events(&mut self) -> anyhow::Result<Vec<TickTask>> {
+    pub fn tick_events(&mut self, app: &AppState) -> anyhow::Result<Vec<TickTask>> {
         let mut tasks: Vec<TickTask> = Vec::new();
 
         self.ipc_server.tick(&mut server_ipc::TickParams {
             state: &mut self.state,
             tasks: &mut tasks,
+            app,
         })?;
 
         // Check for redraw events

src/backend/wayvr/server_ipc.rs

@@ -1,12 +1,15 @@
+use crate::state::AppState;
+
 use super::{display, process, window, TickTask, WayVRSignal};
 use bytes::BufMut;
+use glam::Vec3A;
 use interprocess::local_socket::{self, traits::Listener, ToNsName};
 use smallvec::SmallVec;
 use std::io::{Read, Write};
 use wayvr_ipc::{
     ipc::{self},
     packet_client::{self, PacketClient},
-    packet_server::{self, PacketServer},
+    packet_server::{self, PacketServer, WlxInputStatePointer},
 };
 
 pub struct AuthInfo {
@@ -70,6 +73,7 @@ fn read_payload(conn: &mut local_socket::Stream, size: u32) -> Option<Payload> {
 pub struct TickParams<'a> {
     pub state: &'a mut super::WayVRState,
     pub tasks: &'a mut Vec<TickTask>,
+    pub app: &'a AppState,
 }
 
 pub fn gen_args_vec(input: &str) -> Vec<&str> {
@@ -177,6 +181,34 @@ impl Connection {
         Ok(())
     }
 
+    fn handle_wlx_input_state(
+        &mut self,
+        params: &TickParams,
+        serial: ipc::Serial,
+    ) -> anyhow::Result<()> {
+        let input_state = &params.app.input_state;
+
+        let to_arr = |vec: &Vec3A| -> [f32; 3] { [vec.x, vec.y, vec.z] };
+
+        send_packet(
+            &mut self.conn,
+            &ipc::data_encode(&PacketServer::WlxInputStateResponse(
+                serial,
+                packet_server::WlxInputState {
+                    hmd_pos: to_arr(&input_state.hmd.translation),
+                    left: WlxInputStatePointer {
+                        pos: to_arr(&input_state.pointers[0].raw_pose.translation),
+                    },
+                    right: WlxInputStatePointer {
+                        pos: to_arr(&input_state.pointers[0].raw_pose.translation),
+                    },
+                },
+            )),
+        )?;
+
+        Ok(())
+    }
+
     fn handle_wvr_display_create(
         &mut self,
         params: &mut TickParams,
@@ -471,6 +503,9 @@ impl Connection {
 
         match packet {
             PacketClient::Handshake(_) => unreachable!(), // handled previously
+            PacketClient::WlxInputState(serial) => {
+                self.handle_wlx_input_state(params, serial)?;
+            }
             PacketClient::WvrDisplayList(serial) => {
                 self.handle_wvr_display_list(params, serial)?;
             }
@@ -633,10 +668,11 @@ impl WayVRServer {
         Ok(())
     }
 
-    pub fn broadcast(&mut self, packet: packet_server::PacketServer) -> anyhow::Result<()> {
+    pub fn broadcast(&mut self, packet: packet_server::PacketServer) {
         for connection in &mut self.connections {
-            send_packet(&mut connection.conn, &ipc::data_encode(&packet))?;
+            if let Err(e) = send_packet(&mut connection.conn, &ipc::data_encode(&packet)) {
+                log::error!("failed to broadcast packet: {:?}", e);
+            }
         }
-        Ok(())
     }
 }

src/graphics/mod.rs

@@ -942,6 +942,7 @@ impl WlxGraphics {
         )?))
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn create_pipeline_with_layouts(
         self: &Arc<Self>,
         render_target: Arc<ImageView>,
@@ -1304,6 +1305,7 @@ impl WlxPipeline<WlxPipelineLegacy> {
         )
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn new_with_layout(
         render_target: Arc<ImageView>,
         graphics: Arc<WlxGraphics>,

src/gui/canvas/builder.rs

@@ -153,6 +153,7 @@ impl<D, S> CanvasBuilder<D, S> {
         &mut self.canvas.controls[idx]
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn key_button(
         &mut self,
         x: f32,

src/gui/canvas/control.rs

@@ -19,6 +19,7 @@ pub type ControlRendererHl<D, S> = fn(
     Vec4,
 ) -> anyhow::Result<()>;
 
+#[allow(clippy::type_complexity)]
 pub(crate) struct Control<D, S> {
     pub state: Option<S>,
     pub rect: Rect,

src/hid/mod.rs

@@ -68,7 +68,8 @@ struct MouseAction {
 }
 
 pub struct UInputProvider {
-    handle: UInputHandle<File>,
+    keyboard_handle: UInputHandle<File>,
+    mouse_handle: UInputHandle<File>,
     desktop_extent: Vec2,
     desktop_origin: Vec2,
     cur_modifiers: u8,
@@ -90,97 +91,89 @@ const EV_ABS: u16 = 0x3;
 
 impl UInputProvider {
     fn try_new() -> Option<Self> {
-        if let Ok(file) = File::create("/dev/uinput") {
-            let handle = UInputHandle::new(file);
+        let keyboard_file = File::create("/dev/uinput").ok()?;
+        let keyboard_handle = UInputHandle::new(keyboard_file);
 
-            let id = InputId {
-                bustype: 0x03,
-                vendor: 0x4711,
-                product: 0x0829,
-                version: 5,
-            };
+        let mouse_file = File::create("/dev/uinput").ok()?;
+        let mouse_handle = UInputHandle::new(mouse_file);
 
-            let name = b"WlxOverlay-S Keyboard-Mouse Hybrid Thing\0";
+        let kbd_id = InputId {
+            bustype: 0x03,
+            vendor: 0x4711,
+            product: 0x0829,
+            version: 5,
+        };
+        let mouse_id = InputId {
+            bustype: 0x03,
+            vendor: 0x4711,
+            product: 0x0830,
+            version: 5,
+        };
+        let kbd_name = b"WlxOverlay-S Keyboard\0";
+        let mouse_name = b"WlxOverlay-S Mouse\0";
 
-            let abs_info = vec![
-                AbsoluteInfoSetup {
-                    axis: input_linux::AbsoluteAxis::X,
-                    info: AbsoluteInfo {
-                        value: 0,
-                        minimum: 0,
-                        maximum: MOUSE_EXTENT as _,
-                        fuzz: 0,
-                        flat: 0,
-                        resolution: 10,
-                    },
+        let abs_info = vec![
+            AbsoluteInfoSetup {
+                axis: input_linux::AbsoluteAxis::X,
+                info: AbsoluteInfo {
+                    value: 0,
+                    minimum: 0,
+                    maximum: MOUSE_EXTENT as _,
+                    fuzz: 0,
+                    flat: 0,
+                    resolution: 10,
                 },
-                AbsoluteInfoSetup {
-                    axis: input_linux::AbsoluteAxis::Y,
-                    info: AbsoluteInfo {
-                        value: 0,
-                        minimum: 0,
-                        maximum: MOUSE_EXTENT as _,
-                        fuzz: 0,
-                        flat: 0,
-                        resolution: 10,
-                    },
+            },
+            AbsoluteInfoSetup {
+                axis: input_linux::AbsoluteAxis::Y,
+                info: AbsoluteInfo {
+                    value: 0,
+                    minimum: 0,
+                    maximum: MOUSE_EXTENT as _,
+                    fuzz: 0,
+                    flat: 0,
+                    resolution: 10,
                 },
-            ];
+            },
+        ];
 
-            if handle.set_evbit(EventKind::Key).is_err() {
-                return None;
-            }
-            if handle.set_evbit(EventKind::Absolute).is_err() {
-                return None;
-            }
-            if handle.set_evbit(EventKind::Relative).is_err() {
-                return None;
-            }
-
-            for btn in MOUSE_LEFT..=MOUSE_MIDDLE {
-                let key: Key = unsafe { transmute(btn) };
-                if handle.set_keybit(key).is_err() {
-                    return None;
-                }
-            }
-
-            for key in VirtualKey::iter() {
-                let key: Key = unsafe { transmute((key as u16) - 8) };
-                if handle.set_keybit(key).is_err() {
-                    return None;
-                }
-            }
-
-            if handle.set_absbit(AbsoluteAxis::X).is_err() {
-                return None;
-            }
-            if handle.set_absbit(AbsoluteAxis::Y).is_err() {
-                return None;
-            }
-            if handle.set_relbit(RelativeAxis::Wheel).is_err() {
-                return None;
-            }
-
-            if handle.create(&id, name, 0, &abs_info).is_ok() {
-                return Some(UInputProvider {
-                    handle,
-                    desktop_extent: Vec2::ZERO,
-                    desktop_origin: Vec2::ZERO,
-                    current_action: Default::default(),
-                    cur_modifiers: 0,
-                });
-            }
+        keyboard_handle.set_evbit(EventKind::Key).ok()?;
+        for key in VirtualKey::iter() {
+            let mapped_key: Key = unsafe { std::mem::transmute((key as u16) - 8) };
+            keyboard_handle.set_keybit(mapped_key).ok()?;
         }
-        None
-    }
 
+        keyboard_handle.create(&kbd_id, kbd_name, 0, &[]).ok()?;
+
+        mouse_handle.set_evbit(EventKind::Absolute).ok()?;
+        mouse_handle.set_evbit(EventKind::Relative).ok()?;
+        mouse_handle.set_absbit(AbsoluteAxis::X).ok()?;
+        mouse_handle.set_absbit(AbsoluteAxis::Y).ok()?;
+        mouse_handle.set_relbit(RelativeAxis::Wheel).ok()?;
+        mouse_handle.set_evbit(EventKind::Key).ok()?;
+
+        for btn in MOUSE_LEFT..=MOUSE_MIDDLE {
+            let mouse_btn: Key = unsafe { transmute(btn) };
+            mouse_handle.set_keybit(mouse_btn).ok()?;
+        }
+        mouse_handle.create(&mouse_id, mouse_name, 0, &abs_info).ok()?;
+
+        Some(UInputProvider {
+            keyboard_handle,
+            mouse_handle,
+            desktop_extent: Vec2::ZERO,
+            desktop_origin: Vec2::ZERO,
+            current_action: Default::default(),
+            cur_modifiers: 0,
+        })
+    }
     fn send_button_internal(&self, button: u16, down: bool) {
         let time = get_time();
         let events = [
             new_event(time, EV_KEY, button, down as _),
             new_event(time, EV_SYN, 0, 0),
         ];
-        if let Err(res) = self.handle.write(&events) {
+        if let Err(res) = self.mouse_handle.write(&events) {
             log::error!("send_button: {}", res.to_string());
         }
     }
@@ -196,7 +189,7 @@ impl UInputProvider {
             new_event(time, EV_ABS, AbsoluteAxis::Y as _, pos.y as i32),
             new_event(time, EV_SYN, 0, 0),
         ];
-        if let Err(res) = self.handle.write(&events) {
+        if let Err(res) = self.mouse_handle.write(&events) {
             log::error!("{}", res.to_string());
         }
     }
@@ -206,7 +199,7 @@ impl UInputProvider {
             new_event(time, EV_REL, RelativeAxis::Wheel as _, delta),
             new_event(time, EV_SYN, 0, 0),
         ];
-        if let Err(res) = self.handle.write(&events) {
+        if let Err(res) = self.mouse_handle.write(&events) {
             log::error!("wheel: {}", res.to_string());
         }
     }
@@ -232,7 +225,7 @@ impl HidProvider for UInputProvider {
             new_event(time, EV_KEY, (key as u16) - 8, down as _),
             new_event(time, EV_SYN, 0, 0),
         ];
-        if let Err(res) = self.handle.write(&events) {
+        if let Err(res) = self.keyboard_handle.write(&events) {
             log::error!("send_key: {}", res.to_string());
         }
     }

src/overlays/keyboard.rs

@@ -95,7 +95,7 @@ where
     canvas.fg_color = color_parse("#cad3f5").unwrap(); //safe
     canvas.bg_color = color_parse("#1e2030").unwrap(); //safe
 
-    let has_altgr = keymap.as_ref().map_or(false, |k| k.has_altgr());
+    let has_altgr = keymap.as_ref().is_some_and(|k| k.has_altgr());
 
     if !LAYOUT.auto_labels.unwrap_or(true) {
         keymap = None;
@@ -125,7 +125,7 @@ where
                                 let label0 = keymap.label_for_key(vk, 0);
                                 let label1 = keymap.label_for_key(vk, SHIFT);
 
-                                if label0.chars().next().map_or(false, |f| f.is_alphabetic()) {
+                                if label0.chars().next().is_some_and(|f| f.is_alphabetic()) {
                                     label.push(label1);
                                     if has_altgr {
                                         cap_type = KeyCapType::RegularAltGr;

src/overlays/wayvr.rs

@@ -1,7 +1,7 @@
 use glam::{vec3a, Affine2, Vec3, Vec3A};
 use std::{cell::RefCell, collections::HashMap, rc::Rc, sync::Arc};
 use vulkano::image::SubresourceLayout;
-use wayvr_ipc::packet_server;
+use wayvr_ipc::packet_server::{self, PacketServer, WvrStateChanged};
 use wlx_capture::frame::{DmabufFrame, FourCC, FrameFormat, FramePlane};
 
 use crate::{
@@ -332,12 +332,23 @@ where
         anyhow::bail!("Overlay ID not set for dashboard display");
     };
 
+    let cur_visibility = !display.visible;
+
+    wayvr
+        .data
+        .ipc_server
+        .broadcast(PacketServer::WvrStateChanged(if cur_visibility {
+            WvrStateChanged::DashboardShown
+        } else {
+            WvrStateChanged::DashboardHidden
+        }));
+
     app.tasks.enqueue(TaskType::Overlay(
         OverlaySelector::Id(overlay_id),
         Box::new(move |app, o| {
             // Toggle visibility
-            o.want_visible = !o.want_visible;
-            if o.want_visible {
+            o.want_visible = cur_visibility;
+            if cur_visibility {
                 o.reset(app, true);
             }
         }),
@@ -447,12 +458,12 @@ where
                 wayvr
                     .data
                     .ipc_server
-                    .broadcast(packet_server::PacketServer::WvrStateChanged(packet))?;
+                    .broadcast(packet_server::PacketServer::WvrStateChanged(packet));
             }
         }
     }
 
-    let res = wayvr.data.tick_events()?;
+    let res = wayvr.data.tick_events(app)?;
     drop(wayvr);
 
     for result in res {