Jayden/wayvr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

📦📎-fixes, typo fixes

Browse Source
This commit is contained in:
Aleksander
2025-09-20 12:17:17 +02:00
parent cfb733de09
commit b9e5541971
41 changed files with 494 additions and 498 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
wlx-overlay-s/src/backend/common.rs
View File

@@ -12,9 +12,9 @@ use crate::{
config::AStrSetExt,
overlays::{
anchor::create_anchor,
keyboard::{builder::create_keyboard, KEYBOARD_NAME},
keyboard::{KEYBOARD_NAME, builder::create_keyboard},
screen::create_screens,
watch::{create_watch, WATCH_NAME},
watch::{WATCH_NAME, create_watch},
},
state::AppState,
};
@@ -57,10 +57,10 @@ where
} else {
match create_screens(app) {
Ok((data, keymap)) => {
if show_screens.is_empty() {
if let Some((_, s, _)) = data.screens.first() {
show_screens.arc_set(s.name.clone());
}
if show_screens.is_empty()
&& let Some((_, s, _)) = data.screens.first()
{
show_screens.arc_set(s.name.clone());
}
for (meta, mut state, backend) in data.screens {
if show_screens.arc_get(state.name.as_ref()) {

81
wlx-overlay-s/src/backend/input.rs
View File

@@ -115,10 +115,10 @@ impl InputState {
session.config.alt_click_up.iter()
};
if let Some(program) = args.next() {
if let Ok(child) = Command::new(program).args(args).spawn() {
self.processes.push(child);
}
if let Some(program) = args.next()
&& let Ok(child) = Command::new(program).args(args).spawn()
{
self.processes.push(child);
}
}
}
@@ -283,11 +283,11 @@ pub enum PointerMode {
}
fn update_focus(focus: &mut KeyboardFocus, state: &OverlayState) {
if let Some(f) = &state.keyboard_focus {
if *focus != *f {
log::info!("Setting keyboard focus to {:?}", *f);
*focus = *f;
}
if let Some(f) = &state.keyboard_focus
&& *focus != *f
{
log::info!("Setting keyboard focus to {:?}", *f);
*focus = *f;
}
}
@@ -337,32 +337,31 @@ where
pointer = &mut app.input_state.pointers[idx];
pointer.interaction.hovered_id = None;
}
if !pointer.now.click && pointer.before.click {
if let Some(clicked_id) = pointer.interaction.clicked_id.take() {
if let Some(clicked) = overlays.mut_by_id(clicked_id) {
let hit = PointerHit {
pointer: pointer.idx,
overlay: clicked_id,
mode: pointer.interaction.mode,
..Default::default()
};
clicked.backend.on_pointer(app, &hit, false);
}
}
if !pointer.now.click
&& pointer.before.click
&& let Some(clicked_id) = pointer.interaction.clicked_id.take()
&& let Some(clicked) = overlays.mut_by_id(clicked_id)
{
let hit = PointerHit {
pointer: pointer.idx,
overlay: clicked_id,
mode: pointer.interaction.mode,
..Default::default()
};
clicked.backend.on_pointer(app, &hit, false);
}
return (0.0, None); // no hit
};
if let Some(hovered_id) = pointer.interaction.hovered_id {
if hovered_id != hit.overlay {
if let Some(old_hovered) = overlays.mut_by_id(hovered_id) {
if Some(pointer.idx) == old_hovered.primary_pointer {
old_hovered.primary_pointer = None;
}
old_hovered.backend.on_left(app, idx);
pointer = &mut app.input_state.pointers[idx];
}
if let Some(hovered_id) = pointer.interaction.hovered_id
&& hovered_id != hit.overlay
&& let Some(old_hovered) = overlays.mut_by_id(hovered_id)
{
if Some(pointer.idx) == old_hovered.primary_pointer {
old_hovered.primary_pointer = None;
}
old_hovered.backend.on_left(app, idx);
pointer = &mut app.input_state.pointers[idx];
}
let Some(hovered) = overlays.mut_by_id(hit.overlay) else {
log::warn!("Hit overlay {} does not exist", hit.overlay.0);
@@ -589,17 +588,17 @@ impl Pointer {
pointer = &mut app.input_state.pointers[idx];
if save_success {
if let Some(grab_data) = pointer.interaction.grabbed.as_ref() {
if overlay.state.curvature != grab_data.old_curvature {
if let Some(val) = overlay.state.curvature {
app.session
.config
.curve_values
.arc_set(overlay.state.name.clone(), val);
} else {
let ref_name = overlay.state.name.as_ref();
app.session.config.curve_values.arc_rm(ref_name);
}
if let Some(grab_data) = pointer.interaction.grabbed.as_ref()
&& overlay.state.curvature != grab_data.old_curvature
{
if let Some(val) = overlay.state.curvature {
app.session
.config
.curve_values
.arc_set(overlay.state.name.clone(), val);
} else {
let ref_name = overlay.state.name.as_ref();
app.session.config.curve_values.arc_rm(ref_name);
}
}
app.session.config.transform_values.arc_set(

18
wlx-overlay-s/src/backend/openvr/manifest.rs
View File

@@ -21,15 +21,15 @@ pub(super) fn install_manifest(app_mgr: &mut ApplicationsManager) -> anyhow::Res
.ok_or_else(|| anyhow::anyhow!("Invalid executable path"))?,
};
if app_mgr.is_application_installed(APP_KEY) == Ok(true) {
if let Ok(mut file) = File::open(&manifest_path) {
let mut buf = String::new();
if file.read_to_string(&mut buf).is_ok() {
let manifest: json::JsonValue = json::parse(&buf)?;
if manifest["applications"][0]["binary_path_linux"] == executable_path {
log::info!("Manifest already up to date");
return Ok(());
}
if app_mgr.is_application_installed(APP_KEY) == Ok(true)
&& let Ok(mut file) = File::open(&manifest_path)
{
let mut buf = String::new();
if file.read_to_string(&mut buf).is_ok() {
let manifest: json::JsonValue = json::parse(&buf)?;
if manifest["applications"][0]["binary_path_linux"] == executable_path {
log::info!("Manifest already up to date");
return Ok(());
}
}
}

24
wlx-overlay-s/src/backend/openvr/mod.rs
View File

@@ -2,18 +2,18 @@ use std::{
collections::VecDeque,
ops::Add,
sync::{
atomic::{AtomicBool, AtomicUsize, Ordering},
Arc,
atomic::{AtomicBool, AtomicUsize, Ordering},
},
time::{Duration, Instant},
};
use anyhow::{anyhow, Result};
use anyhow::{Result, anyhow};
use ovr_overlay::{
sys::{ETrackedDeviceProperty, EVRApplicationType, EVREventType},
TrackedDeviceIndex,
sys::{ETrackedDeviceProperty, EVRApplicationType, EVREventType},
};
use vulkano::{device::physical::PhysicalDevice, Handle, VulkanObject};
use vulkano::{Handle, VulkanObject, device::physical::PhysicalDevice};
use crate::{
backend::{
@@ -21,7 +21,7 @@ use crate::{
input::interact,
openvr::{
helpers::adjust_gain,
input::{set_action_manifest, OpenVrInputSource},
input::{OpenVrInputSource, set_action_manifest},
lines::LinePool,
manifest::{install_manifest, uninstall_manifest},
overlay::OpenVrOverlayData,
@@ -29,10 +29,10 @@ use crate::{
overlay::{OverlayData, ShouldRender},
task::{SystemTask, TaskType},
},
graphics::{init_openvr_graphics, CommandBuffers},
graphics::{CommandBuffers, init_openvr_graphics},
overlays::{
toast::{Toast, ToastTopic},
watch::{watch_fade, WATCH_NAME},
watch::{WATCH_NAME, watch_fade},
},
state::AppState,
subsystem::notifications::NotificationManager,
@@ -229,11 +229,11 @@ pub fn openvr_run(
});
}
TaskType::DropOverlay(sel) => {
if let Some(o) = overlays.mut_by_selector(&sel) {
if o.state.birthframe < cur_frame {
o.destroy(&mut overlay_mgr);
overlays.remove_by_selector(&sel);
}
if let Some(o) = overlays.mut_by_selector(&sel)
&& o.state.birthframe < cur_frame
{
o.destroy(&mut overlay_mgr);
overlays.remove_by_selector(&sel);
}
}
TaskType::System(task) => match task {

9
wlx-overlay-s/src/backend/openxr/blocker.rs
View File

@@ -61,10 +61,11 @@ fn set_clients_io_active(monado: &mut Monado, active: bool) {
}
};
if name != "wlx-overlay-s" && state.contains(ClientState::ClientSessionVisible) {
if let Err(e) = client.set_io_active(active) {
warn!("Failed to set io active for client: {e}");
}
if name != "wlx-overlay-s"
&& state.contains(ClientState::ClientSessionVisible)
&& let Err(e) = client.set_io_active(active)
{
warn!("Failed to set io active for client: {e}");
}
}
}

44
wlx-overlay-s/src/backend/openxr/input.rs
View File

@@ -4,7 +4,7 @@ use std::{
time::{Duration, Instant},
};
use glam::{bool, Affine3A, Quat, Vec3};
use glam::{Affine3A, Quat, Vec3, bool};
use libmonado as mnd;
use openxr::{self as xr, Quaternionf, Vector2f, Vector3f};
use serde::{Deserialize, Serialize};
@@ -15,7 +15,7 @@ use crate::{
state::{AppSession, AppState},
};
use super::{helpers::posef_to_transform, XrState};
use super::{XrState, helpers::posef_to_transform};
static CLICK_TIMES: [Duration; 3] = [
Duration::ZERO,
@@ -229,21 +229,21 @@ impl OpenXrInputSource {
role: TrackedDeviceRole,
app: &mut AppState,
) {
if let Ok(status) = device.battery_status() {
if status.present {
app.input_state.devices.push(TrackedDevice {
soc: Some(status.charge),
charging: status.charging,
role,
});
log::debug!(
"Device {} role {:#?}: {:.0}% (charging {})",
device.index,
role,
status.charge * 100.0f32,
status.charging
);
}
if let Ok(status) = device.battery_status()
&& status.present
{
app.input_state.devices.push(TrackedDevice {
soc: Some(status.charge),
charging: status.charging,
role,
});
log::debug!(
"Device {} role {:#?}: {:.0}% (charging {})",
device.index,
role,
status.charge * 100.0f32,
status.charging
);
}
}
@@ -268,11 +268,11 @@ impl OpenXrInputSource {
let mut seen = Vec::<u32>::with_capacity(32);
for (mnd_role, wlx_role) in roles {
let device = monado.device_from_role(mnd_role);
if let Ok(mut device) = device {
if !seen.contains(&device.index) {
seen.push(device.index);
Self::update_device_battery_status(&mut device, wlx_role, app);
}
if let Ok(mut device) = device
&& !seen.contains(&device.index)
{
seen.push(device.index);
Self::update_device_battery_status(&mut device, wlx_role, app);
}
}
if let Ok(devices) = monado.devices() {

44
wlx-overlay-s/src/backend/openxr/mod.rs
View File

@@ -2,8 +2,8 @@ use std::{
collections::VecDeque,
ops::Add,
sync::{
atomic::{AtomicBool, AtomicUsize, Ordering},
Arc,
atomic::{AtomicBool, AtomicUsize, Ordering},
},
time::{Duration, Instant},
};
@@ -23,10 +23,10 @@ use crate::{
overlay::{OverlayData, ShouldRender},
task::{SystemTask, TaskType},
},
graphics::{init_openxr_graphics, CommandBuffers},
graphics::{CommandBuffers, init_openxr_graphics},
overlays::{
toast::{Toast, ToastTopic},
watch::{watch_fade, WATCH_NAME},
watch::{WATCH_NAME, watch_fade},
},
state::AppState,
subsystem::notifications::NotificationManager,
@@ -228,11 +228,11 @@ pub fn openxr_run(
}
}
if next_device_update <= Instant::now() {
if let Some(monado) = &mut monado {
OpenXrInputSource::update_devices(&mut app, monado);
next_device_update = Instant::now() + Duration::from_secs(30);
}
if next_device_update <= Instant::now()
&& let Some(monado) = &mut monado
{
OpenXrInputSource::update_devices(&mut app, monado);
next_device_update = Instant::now() + Duration::from_secs(30);
}
if !session_running {
@@ -375,10 +375,8 @@ pub fn openxr_run(
// Begin rendering
let mut buffers = CommandBuffers::default();
if !main_session_visible {
if let Some(skybox) = skybox.as_mut() {
skybox.render(&xr_state, &app, &mut buffers)?;
}
if !main_session_visible && let Some(skybox) = skybox.as_mut() {
skybox.render(&xr_state, &app, &mut buffers)?;
}
for o in overlays.iter_mut() {
@@ -427,11 +425,9 @@ pub fn openxr_run(
// Layer composition
let mut layers = vec![];
if !main_session_visible {
if let Some(skybox) = skybox.as_mut() {
for (idx, layer) in skybox.present(&xr_state, &app)?.into_iter().enumerate() {
layers.push(((idx as f32).mul_add(-50.0, 200.0), layer));
}
if !main_session_visible && let Some(skybox) = skybox.as_mut() {
for (idx, layer) in skybox.present(&xr_state, &app)?.into_iter().enumerate() {
layers.push(((idx as f32).mul_add(-50.0, 200.0), layer));
}
}
@@ -514,13 +510,13 @@ pub fn openxr_run(
});
}
TaskType::DropOverlay(sel) => {
if let Some(o) = overlays.mut_by_selector(&sel) {
if o.state.birthframe < cur_frame {
log::debug!("{}: destroy", o.state.name);
if let Some(o) = overlays.remove_by_selector(&sel) {
// set for deletion after all images are done showing
delete_queue.push((o, cur_frame + 5));
}
if let Some(o) = overlays.mut_by_selector(&sel)
&& o.state.birthframe < cur_frame
{
log::debug!("{}: destroy", o.state.name);
if let Some(o) = overlays.remove_by_selector(&sel) {
// set for deletion after all images are done showing
delete_queue.push((o, cur_frame + 5));
}
}
}

4
wlx-overlay-s/src/backend/openxr/swapchain.rs
View File

@@ -5,8 +5,8 @@ use openxr as xr;
use smallvec::SmallVec;
use vulkano::{
image::{sys::RawImage, view::ImageView, ImageCreateInfo, ImageUsage},
Handle,
image::{ImageCreateInfo, ImageUsage, sys::RawImage, view::ImageView},
};
use wgui::gfx::WGfx;
@@ -109,7 +109,7 @@ impl WlxSwapchain {
Ok(())
}
pub(super) fn get_subimage(&self) -> xr::SwapchainSubImage<xr::Vulkan> {
pub(super) fn get_subimage(&self) -> xr::SwapchainSubImage<'_, xr::Vulkan> {
debug_assert!(self.ever_acquired, "swapchain was never acquired!");
xr::SwapchainSubImage::new()
.swapchain(&self.swapchain)

9
wlx-overlay-s/src/backend/overlay.rs
View File

@@ -247,18 +247,17 @@ where
self.state.positioning,
Positioning::Floating | Positioning::Anchored
) {
let hard_reset;
if let Some(transform) = app
let hard_reset = if let Some(transform) = app
.session
.config
.transform_values
.arc_get(self.state.name.as_ref())
{
self.state.saved_transform = Some(*transform);
hard_reset = false;
false
} else {
hard_reset = true;
}
true
};
self.state.reset(app, hard_reset);
}
self.backend.init(app)

39
wlx-overlay-s/src/backend/wayvr/client.rs
View File

@@ -10,8 +10,9 @@ use smithay::{
use crate::backend::wayvr::{ExternalProcessRequest, WayVRTask};
use super::{
ProcessWayVREnv,
comp::{self, ClientState},
display, process, ProcessWayVREnv,
display, process,
};
pub struct WayVRClient {
@@ -118,20 +119,20 @@ impl WayVRCompositor {
// Find suitable auth key from the process list
for p in processes.vec.iter().flatten() {
if let process::Process::Managed(process) = &p.obj {
if let Some(auth_key) = &process_env.display_auth {
// Find process with matching auth key
if process.auth_key.as_str() == auth_key {
// Check if display handle is valid
if displays.get(&process.display_handle).is_some() {
// Add client
self.add_client(WayVRClient {
client,
display_handle: process.display_handle,
pid: creds.pid as u32,
});
return Ok(());
}
if let process::Process::Managed(process) = &p.obj
&& let Some(auth_key) = &process_env.display_auth
{
// Find process with matching auth key
if process.auth_key.as_str() == auth_key {
// Check if display handle is valid
if displays.get(&process.display_handle).is_some() {
// Add client
self.add_client(WayVRClient {
client,
display_handle: process.display_handle,
pid: creds.pid as u32,
});
return Ok(());
}
}
}
@@ -160,10 +161,10 @@ impl WayVRCompositor {
displays: &mut display::DisplayVec,
processes: &mut process::ProcessVec,
) -> anyhow::Result<()> {
if let Some(stream) = self.listener.accept()? {
if let Err(e) = self.accept_connection(stream, displays, processes) {
log::error!("Failed to accept connection: {e}");
}
if let Some(stream) = self.listener.accept()?
&& let Err(e) = self.accept_connection(stream, displays, processes)
{
log::error!("Failed to accept connection: {e}");
}
Ok(())

41
wlx-overlay-s/src/backend/wayvr/display.rs
View File

@@ -2,13 +2,13 @@ use std::{cell::RefCell, rc::Rc, sync::Arc};
use smithay::{
backend::renderer::{
element::{
surface::{render_elements_from_surface_tree, WaylandSurfaceRenderElement},
Kind,
},
gles::{ffi, GlesRenderer, GlesTexture},
utils::draw_render_elements,
Bind, Color32F, Frame, Renderer,
element::{
Kind,
surface::{WaylandSurfaceRenderElement, render_elements_from_surface_tree},
},
gles::{GlesRenderer, GlesTexture, ffi},
utils::draw_render_elements,
},
input,
utils::{Logical, Point, Rectangle, Size, Transform},
@@ -22,8 +22,8 @@ use crate::{
};
use super::{
client::WayVRCompositor, comp::send_frames_surface_tree, egl_data, event_queue::SyncEventQueue,
process, smithay_wrapper, time, window, BlitMethod, WayVRSignal,
BlitMethod, WayVRSignal, client::WayVRCompositor, comp::send_frames_surface_tree, egl_data,
event_queue::SyncEventQueue, process, smithay_wrapper, time, window,
};
fn generate_auth_key() -> String {
@@ -136,7 +136,9 @@ impl Display {
BlitMethod::Dmabuf => match params.egl_data.create_dmabuf_data(&egl_image) {
Ok(dmabuf_data) => egl_data::RenderData::Dmabuf(dmabuf_data),
Err(e) => {
log::error!("create_dmabuf_data failed: {e:?}. Using software blitting (This will be slow!)");
log::error!(
"create_dmabuf_data failed: {e:?}. Using software blitting (This will be slow!)"
);
egl_data::RenderData::Software(None)
}
},
@@ -271,13 +273,12 @@ impl Display {
if self.visible {
if !self.displayed_windows.is_empty() {
self.no_windows_since = None;
} else if let Some(auto_hide_delay) = config.auto_hide_delay {
if let Some(s) = self.no_windows_since {
if s + u64::from(auto_hide_delay) < get_millis() {
// Auto-hide after specific time
signals.send(WayVRSignal::DisplayVisibility(*handle, false));
}
}
} else if let Some(auto_hide_delay) = config.auto_hide_delay
&& let Some(s) = self.no_windows_since
&& s + u64::from(auto_hide_delay) < get_millis()
{
// Auto-hide after specific time
signals.send(WayVRSignal::DisplayVisibility(*handle, false));
}
}
@@ -577,10 +578,10 @@ impl Display {
Ok(child) => Ok(SpawnProcessResult { auth_key, child }),
Err(e) => {
anyhow::bail!(
"Failed to launch process with path \"{}\": {}. Make sure your exec path exists.",
exec_path,
e
);
"Failed to launch process with path \"{}\": {}. Make sure your exec path exists.",
exec_path,
e
);
}
}
}

44
wlx-overlay-s/src/backend/wayvr/mod.rs
View File

@@ -436,7 +436,7 @@ impl WayVR {
.manager
.tick_wayland(&mut self.state.displays, &mut self.state.processes)?;
if self.state.ticks % 200 == 0 {
if self.state.ticks.is_multiple_of(200) {
self.state.manager.cleanup_clients();
}
@@ -460,10 +460,10 @@ impl WayVR {
#[allow(dead_code)]
pub fn get_primary_display(displays: &DisplayVec) -> Option<display::DisplayHandle> {
for (idx, cell) in displays.vec.iter().enumerate() {
if let Some(cell) = cell {
if cell.obj.primary {
return Some(DisplayVec::get_handle(cell, idx));
}
if let Some(cell) = cell
&& cell.obj.primary
{
return Some(DisplayVec::get_handle(cell, idx));
}
}
None
@@ -474,10 +474,10 @@ impl WayVR {
name: &str,
) -> Option<display::DisplayHandle> {
for (idx, cell) in displays.vec.iter().enumerate() {
if let Some(cell) = cell {
if cell.obj.name == name {
return Some(DisplayVec::get_handle(cell, idx));
}
if let Some(cell) = cell
&& cell.obj.name == name
{
return Some(DisplayVec::get_handle(cell, idx));
}
}
None
@@ -519,10 +519,10 @@ impl WayVRState {
let changed = self.cur_modifiers ^ modifiers;
for i in 0..8 {
let m = 1 << i;
if changed & m != 0 {
if let Some(vk) = MODS_TO_KEYS.get(m).into_iter().flatten().next() {
self.send_key(*vk as u32, modifiers & m != 0);
}
if changed & m != 0
&& let Some(vk) = MODS_TO_KEYS.get(m).into_iter().flatten().next()
{
self.send_key(*vk as u32, modifiers & m != 0);
}
}
self.cur_modifiers = modifiers;
@@ -652,16 +652,16 @@ impl WayVRState {
_env: &[(&str, &str)],
) -> Option<process::ProcessHandle> {
for (idx, cell) in self.processes.vec.iter().enumerate() {
if let Some(cell) = &cell {
if let process::Process::Managed(process) = &cell.obj {
if process.display_handle != display_handle
|| process.exec_path != exec_path
|| process.args != args
{
continue;
}
return Some(process::ProcessVec::get_handle(cell, idx));
if let Some(cell) = &cell
&& let process::Process::Managed(process) = &cell.obj
{
if process.display_handle != display_handle
|| process.exec_path != exec_path
|| process.args != args
{
continue;
}
return Some(process::ProcessVec::get_handle(cell, idx));
}
}

16
wlx-overlay-s/src/backend/wayvr/process.rs
View File

@@ -97,10 +97,10 @@ fn get_process_env_value(pid: i32, key: &str) -> anyhow::Result<Option<String>>
let lines: Vec<&str> = env_data.split('\0').filter(|s| !s.is_empty()).collect();
for line in lines {
if let Some(cell) = line.split_once('=') {
if cell.0 == key {
return Ok(Some(String::from(cell.1)));
}
if let Some(cell) = line.split_once('=')
&& cell.0 == key
{
return Ok(Some(String::from(cell.1)));
}
}
@@ -199,10 +199,10 @@ pub fn find_by_pid(processes: &ProcessVec, pid: u32) -> Option<ProcessHandle> {
let Some(cell) = cell else {
continue;
};
if let Process::Managed(wayvr_process) = &cell.obj {
if wayvr_process.auth_key == value {
return Some(ProcessVec::get_handle(cell, idx));
}
if let Process::Managed(wayvr_process) = &cell.obj
&& wayvr_process.auth_key == value
{
return Some(ProcessVec::get_handle(cell, idx));
}
}
}

20
wlx-overlay-s/src/backend/wayvr/server_ipc.rs
View File

@@ -329,9 +329,7 @@ impl Connection {
handle: packet_server::WvrWindowHandle,
visible: bool,
) {
let mut to_resize = None;
if let Some(window) = params
let to_resize = if let Some(window) = params
.state
.wm
.borrow_mut()
@@ -339,14 +337,16 @@ impl Connection {
.get_mut(&window::WindowHandle::from_packet(handle))
{
window.visible = visible;
to_resize = Some(window.display_handle);
}
Some(window.display_handle)
} else {
None
};
if let Some(to_resize) = to_resize {
if let Some(display) = params.state.displays.get_mut(&to_resize) {
display.reposition_windows();
display.trigger_rerender();
}
if let Some(to_resize) = to_resize
&& let Some(display) = params.state.displays.get_mut(&to_resize)
{
display.reposition_windows();
display.trigger_rerender();
}
}

16
wlx-overlay-s/src/config_wayvr.rs
View File

@@ -18,7 +18,7 @@ use crate::{
},
config::load_config_with_conf_d,
config_io,
overlays::wayvr::{executable_exists_in_path, WayVRData},
overlays::wayvr::{WayVRData, executable_exists_in_path},
};
// Flat version of RelativeTo
@@ -211,13 +211,13 @@ impl WayVRConfig {
for (catalog_name, catalog) in &self.catalogs {
for app in &catalog.apps {
if let Some(b) = app.shown_at_start {
if b {
tasks.enqueue(TaskType::WayVR(WayVRAction::AppClick {
catalog_name: Arc::from(catalog_name.as_str()),
app_name: Arc::from(app.name.as_str()),
}));
}
if let Some(b) = app.shown_at_start
&& b
{
tasks.enqueue(TaskType::WayVR(WayVRAction::AppClick {
catalog_name: Arc::from(catalog_name.as_str()),
app_name: Arc::from(app.name.as_str()),
}));
}
}
}

44
wlx-overlay-s/src/gui/panel/button.rs
View File

@@ -11,7 +11,7 @@ use wgui::{
use crate::{
backend::{common::OverlaySelector, overlay::OverlayID, task::TaskType, wayvr::WayVRAction},
config::{save_layout, AStrSetExt},
config::{AStrSetExt, save_layout},
state::AppState,
};
@@ -21,14 +21,14 @@ pub(super) fn setup_custom_button<S>(
attribs: &CustomAttribsInfoOwned,
listeners: &mut EventListenerCollection<AppState, S>,
listener_handles: &mut ListenerHandleVec,
app: &AppState,
_app: &AppState,
) {
const EVENTS: [(&str, EventListenerKind); 2] = [
("press", EventListenerKind::MousePress),
("release", EventListenerKind::MouseRelease),
];
for (name, kind) in EVENTS.iter() {
for (name, kind) in &EVENTS {
let Some(action) = attribs.get_value(name) else {
continue;
};
@@ -47,14 +47,14 @@ pub(super) fn setup_custom_button<S>(
}),
"::OverlayToggle" => {
let Some(selector) = args.next() else {
log::warn!("Missing argument for {}", command);
log::warn!("Missing argument for {command}");
continue;
};
let selector = selector
.parse::<usize>()
.map(|id| OverlaySelector::Id(OverlayID { 0: id }))
.unwrap_or_else(|_| OverlaySelector::Name(selector.into()));
let selector = selector.parse::<usize>().map_or_else(
|_| OverlaySelector::Name(selector.into()),
|id| OverlaySelector::Id(OverlayID(id)),
);
Box::new(move |_common, _data, app, _| {
app.tasks.enqueue(TaskType::Overlay(
@@ -90,7 +90,11 @@ pub(super) fn setup_custom_button<S>(
}
"::WatchHide" => todo!(),
"::WatchSwapHand" => todo!(),
// TODO
#[allow(clippy::match_same_arms)]
"::EditToggle" => return,
// TODO
#[allow(clippy::match_same_arms)]
"::OscSend" => return,
// shell
_ => todo!(),
@@ -110,18 +114,20 @@ struct ShellButtonState {
carry_over: RefCell<Option<String>>,
}
// TODO
#[allow(clippy::missing_const_for_fn)]
fn shell_on_action(
state: &ShellButtonState,
common: &mut event::CallbackDataCommon,
data: &mut event::CallbackData,
_state: &ShellButtonState,
_common: &mut event::CallbackDataCommon,
_data: &mut event::CallbackData,
) {
let mut mut_state = state.mut_state.borrow_mut();
//let mut mut_state = state.mut_state.borrow_mut();
}
fn shell_on_tick(
state: &ShellButtonState,
common: &mut event::CallbackDataCommon,
data: &mut event::CallbackData,
_common: &mut event::CallbackDataCommon,
_data: &mut event::CallbackData,
) {
let mut mut_state = state.mut_state.borrow_mut();
@@ -129,8 +135,8 @@ fn shell_on_tick(
match child.try_wait() {
// not exited yet
Ok(None) => {
if let Some(text) = mut_state.reader.as_mut().and_then(|r| {
read_label_from_pipe("child process", r, &mut *state.carry_over.borrow_mut())
if let Some(_text) = mut_state.reader.as_mut().and_then(|r| {
read_label_from_pipe("child process", r, &mut state.carry_over.borrow_mut())
}) {
//TODO update label
}
@@ -138,8 +144,8 @@ fn shell_on_tick(
}
// exited successfully
Ok(Some(code)) if code.success() => {
if let Some(text) = mut_state.reader.as_mut().and_then(|r| {
read_label_from_pipe("child process", r, &mut *state.carry_over.borrow_mut())
if let Some(_text) = mut_state.reader.as_mut().and_then(|r| {
read_label_from_pipe("child process", r, &mut state.carry_over.borrow_mut())
}) {
//TODO update label
}
@@ -148,7 +154,7 @@ fn shell_on_tick(
// exited with failure
Ok(Some(code)) => {
mut_state.child = None;
log::warn!("Label process exited with code {}", code);
log::warn!("Label process exited with code {code}");
}
// lost
Err(_) => {

8
wlx-overlay-s/src/gui/panel/helper.rs
View File

@@ -11,7 +11,7 @@ static ENV_VAR_REGEX: LazyLock<Regex> = LazyLock::new(|| {
pub(super) fn expand_env_vars(template: &str) -> String {
ENV_VAR_REGEX
.replace_all(template, |caps: &regex::Captures| {
let var_name = caps.get(1).or(caps.get(2)).unwrap().as_str();
let var_name = caps.get(1).or_else(|| caps.get(2)).unwrap().as_str();
std::env::var(var_name)
.inspect_err(|e| log::warn!("Unable to substitute env var {var_name}: {e:?}"))
.unwrap_or_default()
@@ -45,9 +45,5 @@ where
carry_over.replace(cur);
if prev.len() > 0 {
Some(prev)
} else {
None
}
if prev.is_empty() { None } else { Some(prev) }
}

120
wlx-overlay-s/src/gui/panel/label.rs
View File

@@ -15,7 +15,7 @@ use wgui::{
event::{self, EventCallback, EventListenerCollection, ListenerHandleVec},
i18n::Translation,
layout::Layout,
parser::{parse_color_hex, CustomAttribsInfoOwned},
parser::{CustomAttribsInfoOwned, parse_color_hex},
widget::label::WidgetLabel,
};
@@ -23,6 +23,7 @@ use crate::state::AppState;
use super::helper::{expand_env_vars, read_label_from_pipe};
#[allow(clippy::too_many_lines)]
pub(super) fn setup_custom_label<S>(
layout: &mut Layout,
attribs: &CustomAttribsInfoOwned,
@@ -85,15 +86,15 @@ pub(super) fn setup_custom_label<S>(
let state = BatteryLabelState {
low_color: attribs
.get_value("low_color")
.and_then(|s| parse_color_hex(s))
.and_then(parse_color_hex)
.unwrap_or(BAT_LOW),
normal_color: attribs
.get_value("normal_color")
.and_then(|s| parse_color_hex(s))
.and_then(parse_color_hex)
.unwrap_or(BAT_NORMAL),
charging_color: attribs
.get_value("charging_color")
.and_then(|s| parse_color_hex(s))
.and_then(parse_color_hex)
.unwrap_or(BAT_CHARGING),
low_threshold: attribs
.get_value("low_threshold")
@@ -122,10 +123,7 @@ pub(super) fn setup_custom_label<S>(
tz_name.split('/').next_back().map(|x| x.replace('_', " "))
});
let pretty_tz = match maybe_pretty_tz.as_ref() {
Some(x) => x.as_str(),
None => "Local",
};
let pretty_tz = maybe_pretty_tz.as_ref().map_or("Local", |x| x.as_str());
let mut i18n = layout.state.globals.i18n();
layout
@@ -133,7 +131,7 @@ pub(super) fn setup_custom_label<S>(
.widgets
.get_as::<WidgetLabel>(attribs.widget_id)
.unwrap()
.set_text_simple(&mut *i18n, Translation::from_raw_text(&pretty_tz));
.set_text_simple(&mut i18n, Translation::from_raw_text(pretty_tz));
// does not need to be dynamic
return;
@@ -202,6 +200,7 @@ struct ShellLabelState {
carry_over: RefCell<Option<String>>,
}
#[allow(clippy::redundant_else)]
fn shell_on_tick(
state: &ShellLabelState,
common: &mut event::CallbackDataCommon,
@@ -214,7 +213,7 @@ fn shell_on_tick(
// not exited yet
Ok(None) => {
if let Some(text) = mut_state.reader.as_mut().and_then(|r| {
read_label_from_pipe("child process", r, &mut *state.carry_over.borrow_mut())
read_label_from_pipe("child process", r, &mut state.carry_over.borrow_mut())
}) {
let label = data.obj.get_as_mut::<WidgetLabel>().unwrap();
label.set_text(common, Translation::from_raw_text(&text));
@@ -225,7 +224,7 @@ fn shell_on_tick(
// exited successfully
Ok(Some(code)) if code.success() => {
if let Some(text) = mut_state.reader.as_mut().and_then(|r| {
read_label_from_pipe("child process", r, &mut *state.carry_over.borrow_mut())
read_label_from_pipe("child process", r, &mut state.carry_over.borrow_mut())
}) {
let label = data.obj.get_as_mut::<WidgetLabel>().unwrap();
label.set_text(common, Translation::from_raw_text(&text));
@@ -237,7 +236,7 @@ fn shell_on_tick(
Ok(Some(code)) => {
mut_state.child = None;
mut_state.next_try = Instant::now() + Duration::from_secs(15);
log::warn!("Label process exited with code {}", code);
log::warn!("Label process exited with code {code}");
return;
}
// lost
@@ -248,10 +247,8 @@ fn shell_on_tick(
return;
}
}
} else {
if mut_state.next_try > Instant::now() {
return;
}
} else if mut_state.next_try > Instant::now() {
return;
}
match Command::new("sh")
@@ -266,7 +263,7 @@ fn shell_on_tick(
mut_state.reader = Some(io::BufReader::new(stdout));
}
Err(e) => {
log::warn!("Failed to run shell script '{}': {e:?}", &state.exec)
log::warn!("Failed to run shell script '{}': {e:?}", &state.exec);
}
}
}
@@ -300,7 +297,7 @@ impl FifoLabelState {
if let Err(e) = fs::remove_file(&self.path) {
anyhow::bail!("Unable to remove existing FIFO at {}: {e:?}", &self.path);
};
}
Ok(())
}
@@ -321,39 +318,38 @@ fn pipe_on_tick(
) {
let mut mut_state = state.mut_state.borrow_mut();
let reader = match mut_state.reader.as_mut() {
Some(f) => f,
None => {
if mut_state.next_try > Instant::now() {
return;
}
if let Err(e) = state.try_remove_fifo() {
mut_state.next_try = Instant::now() + Duration::from_secs(15);
log::warn!("Requested FIFO path is taken: {e:?}");
return;
}
if let Err(e) = create_fifo(&state.path, 0o777) {
mut_state.next_try = Instant::now() + Duration::from_secs(15);
log::warn!("Failed to create FIFO: {e:?}");
return;
}
mut_state.reader = fs::File::open(&state.path)
.inspect_err(|e| {
log::warn!("Failed to open FIFO: {e:?}");
mut_state.next_try = Instant::now() + Duration::from_secs(15);
})
.map(|f| io::BufReader::new(f))
.ok();
mut_state.reader.as_mut().unwrap()
let reader = if let Some(f) = mut_state.reader.as_mut() {
f
} else {
if mut_state.next_try > Instant::now() {
return;
}
if let Err(e) = state.try_remove_fifo() {
mut_state.next_try = Instant::now() + Duration::from_secs(15);
log::warn!("Requested FIFO path is taken: {e:?}");
return;
}
if let Err(e) = create_fifo(&state.path, 0o777) {
mut_state.next_try = Instant::now() + Duration::from_secs(15);
log::warn!("Failed to create FIFO: {e:?}");
return;
}
mut_state.reader = fs::File::open(&state.path)
.inspect_err(|e| {
log::warn!("Failed to open FIFO: {e:?}");
mut_state.next_try = Instant::now() + Duration::from_secs(15);
})
.map(io::BufReader::new)
.ok();
mut_state.reader.as_mut().unwrap()
};
if let Some(text) =
read_label_from_pipe(&state.path, reader, &mut *state.carry_over.borrow_mut())
read_label_from_pipe(&state.path, reader, &mut state.carry_over.borrow_mut())
{
let label = data.obj.get_as_mut::<WidgetLabel>().unwrap();
label.set_text(common, Translation::from_raw_text(&text));
@@ -385,21 +381,21 @@ fn battery_on_tick(
let label = data.obj.get_as_mut::<WidgetLabel>().unwrap();
if let Some(device) = device {
if let Some(soc) = device.soc {
let soc = (soc * 100.).min(99.) as u32;
let text = format!("{}{}", tags[device.role as usize], soc);
let color = if device.charging {
state.charging_color
} else if soc < state.low_threshold {
state.low_color
} else {
state.normal_color
};
label.set_color(common, color, false);
label.set_text(common, Translation::from_raw_text(&text));
return;
}
if let Some(device) = device
&& let Some(soc) = device.soc
{
let soc = (soc * 100.).min(99.) as u32;
let text = format!("{}{}", tags[device.role as usize], soc);
let color = if device.charging {
state.charging_color
} else if soc < state.low_threshold {
state.low_color
} else {
state.normal_color
};
label.set_color(common, color, false);
label.set_text(common, Translation::from_raw_text(&text));
return;
}
label.set_text(common, Translation::default());
}

28
wlx-overlay-s/src/main.rs
View File

@@ -269,20 +269,20 @@ fn ensure_single_instance(replace: bool) -> bool {
if path.exists() {
// load contents
if let Ok(pid_str) = std::fs::read_to_string(&path) {
if let Ok(pid) = pid_str.trim().parse::<u32>() {
let mut system = sysinfo::System::new();
system.refresh_processes(
sysinfo::ProcessesToUpdate::Some(&[Pid::from_u32(pid)]),
false,
);
if let Some(proc) = system.process(sysinfo::Pid::from_u32(pid)) {
if replace {
proc.kill_with(sysinfo::Signal::Term);
proc.wait();
} else {
return false;
}
if let Ok(pid_str) = std::fs::read_to_string(&path)
&& let Ok(pid) = pid_str.trim().parse::<u32>()
{
let mut system = sysinfo::System::new();
system.refresh_processes(
sysinfo::ProcessesToUpdate::Some(&[Pid::from_u32(pid)]),
false,
);
if let Some(proc) = system.process(sysinfo::Pid::from_u32(pid)) {
if replace {
proc.kill_with(sysinfo::Signal::Term);
proc.wait();
} else {
return false;
}
}
}

8
wlx-overlay-s/src/overlays/keyboard/mod.rs
View File

@@ -204,10 +204,10 @@ fn handle_release(app: &mut AppState, key: &KeyState, keyboard: &mut KeyboardSta
.processes
.retain_mut(|child| !matches!(child.try_wait(), Ok(Some(_))));
if let Some(program) = release_program {
if let Ok(child) = Command::new(program).args(release_args).spawn() {
keyboard.processes.push(child);
}
if let Some(program) = release_program
&& let Ok(child) = Command::new(program).args(release_args).spawn()
{
keyboard.processes.push(child);
}
true
}

8
wlx-overlay-s/src/overlays/screen/pw.rs
View File

@@ -83,10 +83,10 @@ pub(super) fn select_pw_screen(
task::Poll::Pending => {
if Instant::now() >= print_at {
log::info!("{instructions}");
if let Ok(sender) = DbusNotificationSender::new() {
if let Ok(id) = sender.notify_send(instructions, "", 2, 0, 0, true) {
notify = Some((sender, id));
}
if let Ok(sender) = DbusNotificationSender::new()
&& let Ok(id) = sender.notify_send(instructions, "", 2, 0, 0, true)
{
notify = Some((sender, id));
}
break;
}

16
wlx-overlay-s/src/overlays/screen/wl.rs
View File

@@ -1,9 +1,9 @@
use glam::vec2;
use wlx_capture::{
WlxCapture,
wayland::{WlxClient, WlxOutput},
wlr_dmabuf::WlrDmabufCapture,
wlr_screencopy::WlrScreencopyCapture,
WlxCapture,
};
use crate::{
@@ -13,10 +13,10 @@ use crate::{
};
use super::{
backend::ScreenBackend,
capture::{new_wlx_capture, MainThreadWlxCapture},
pw::{load_pw_token_config, save_pw_token_config},
ScreenCreateData,
backend::ScreenBackend,
capture::{MainThreadWlxCapture, new_wlx_capture},
pw::{load_pw_token_config, save_pw_token_config},
};
impl ScreenBackend {
@@ -76,10 +76,10 @@ pub fn create_screen_renderer_wl(
Ok((renderer, restore_token)) => {
capture = Some(renderer);
if let Some(token) = restore_token {
if pw_token_store.arc_set(display_name.into(), token.clone()) {
log::info!("Adding Pipewire token {token}");
}
if let Some(token) = restore_token
&& pw_token_store.arc_set(display_name.into(), token.clone())
{
log::info!("Adding Pipewire token {token}");
}
}
Err(e) => {

14
wlx-overlay-s/src/overlays/screen/x11.rs
View File

@@ -2,9 +2,9 @@ use std::sync::Arc;
use glam::vec2;
use wlx_capture::{
WlxCapture,
frame::Transform,
xshm::{XshmCapture, XshmScreen},
WlxCapture,
};
use crate::{
@@ -13,9 +13,9 @@ use crate::{
};
use super::{
backend::ScreenBackend,
capture::{new_wlx_capture, MainThreadWlxCapture},
ScreenCreateData,
backend::ScreenBackend,
capture::{MainThreadWlxCapture, new_wlx_capture},
};
#[cfg(feature = "pipewire")]
@@ -62,10 +62,10 @@ pub fn create_screens_x11pw(app: &mut AppState) -> anyhow::Result<ScreenCreateDa
true,
)?;
if let Some(restore_token) = select_screen_result.restore_token {
if pw_tokens.arc_set("x11".into(), restore_token.clone()) {
log::info!("Adding Pipewire token {restore_token}");
}
if let Some(restore_token) = select_screen_result.restore_token
&& pw_tokens.arc_set("x11".into(), restore_token.clone())
{
log::info!("Adding Pipewire token {restore_token}");
}
if pw_tokens_copy != pw_tokens {
// Token list changed, re-create token config file

8
wlx-overlay-s/src/overlays/wayvr.rs
View File

@@ -809,10 +809,10 @@ where
O: Default,
{
if let Some(display) = WayVR::get_display_by_name(&wayvr.data.state.displays, display_name) {
if let Some(overlay_id) = wayvr.display_handle_map.get(&display) {
if let Some(overlay) = overlays.mut_by_id(*overlay_id) {
overlay.state.want_visible = true;
}
if let Some(overlay_id) = wayvr.display_handle_map.get(&display)
&& let Some(overlay) = overlays.mut_by_id(*overlay_id)
{
overlay.state.want_visible = true;
}
wayvr.data.state.set_display_visible(display, true);

22
wlx-overlay-s/src/subsystem/hid/mod.rs
View File

@@ -218,10 +218,10 @@ impl HidProvider for UInputProvider {
let changed = self.cur_modifiers ^ modifiers;
for i in 0..8 {
let m = 1 << i;
if changed & m != 0 {
if let Some(vk) = MODS_TO_KEYS.get(m).into_iter().flatten().next() {
self.send_key(*vk, modifiers & m != 0);
}
if changed & m != 0
&& let Some(vk) = MODS_TO_KEYS.get(m).into_iter().flatten().next()
{
self.send_key(*vk, modifiers & m != 0);
}
}
self.cur_modifiers = modifiers;
@@ -564,13 +564,13 @@ pub struct XkbKeymap {
impl XkbKeymap {
pub fn label_for_key(&self, key: VirtualKey, modifier: KeyModifier) -> String {
let mut state = xkb::State::new(&self.keymap);
if modifier > 0 {
if let Some(mod_key) = MODS_TO_KEYS.get(modifier) {
state.update_key(
xkb::Keycode::from(mod_key[0] as u32),
xkb::KeyDirection::Down,
);
}
if modifier > 0
&& let Some(mod_key) = MODS_TO_KEYS.get(modifier)
{
state.update_key(
xkb::Keycode::from(mod_key[0] as u32),
xkb::KeyDirection::Down,
);
}
state.key_get_utf8(xkb::Keycode::from(key as u32))
}

6
wlx-overlay-s/src/subsystem/hid/wayland.rs
View File

@@ -1,11 +1,11 @@
use wlx_capture::wayland::wayland_client::{
globals::{registry_queue_init, GlobalListContents},
Connection, Dispatch, Proxy, QueueHandle,
globals::{GlobalListContents, registry_queue_init},
protocol::{
wl_keyboard::{self, WlKeyboard},
wl_registry::WlRegistry,
wl_seat::{self, Capability, WlSeat},
},
Connection, Dispatch, Proxy, QueueHandle,
};
use xkbcommon::xkb;
@@ -32,7 +32,7 @@ pub fn get_keymap_wl() -> anyhow::Result<XkbKeymap> {
let qh = queue.handle();
let seat: WlSeat = globals
.bind(&qh, 4..=9, ())
.expect(WlSeat::interface().name);
.unwrap_or_else(|_| panic!("{}", WlSeat::interface().name));
let mut me = WlKeymapHandler {
seat,