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

refactors & clippy recommendations

Browse Source
This commit is contained in:
galister
2025-04-07 00:47:57 +09:00
parent 3365aefc13
commit 1deae19f92
57 changed files with 1199 additions and 1316 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/overlays/anchor.rs
View File

@@ -27,7 +27,7 @@ where
relative_to: RelativeTo::Stage,
..Default::default()
},
backend: Box::new(modular_canvas(&config.size, &config.elements, state)?),
backend: Box::new(modular_canvas(config.size, &config.elements, state)?),
..Default::default()
})
}

10
src/overlays/custom.rs
View File

@@ -21,28 +21,28 @@ pub fn create_custom(
match load_custom_ui(&name) {
Ok(config) => config,
Err(e) => {
log::error!("Failed to load custom UI config for {}: {:?}", name, e);
log::error!("Failed to load custom UI config for {name}: {e:?}");
return None;
}
}
};
let canvas = match modular_canvas(&config.size, &config.elements, state) {
let canvas = match modular_canvas(config.size, &config.elements, state) {
Ok(canvas) => canvas,
Err(e) => {
log::error!("Failed to create canvas for {}: {:?}", name, e);
log::error!("Failed to create canvas for {name}: {e:?}");
return None;
}
};
let state = OverlayState {
name: name.clone(),
name,
want_visible: true,
interactable: true,
grabbable: true,
spawn_scale: config.width,
spawn_point: Vec3A::from_array(config.spawn_pos.unwrap_or([0., 0., -0.5])),
interaction_transform: ui_transform(&config.size),
interaction_transform: ui_transform(config.size),
..Default::default()
};
let backend = Box::new(canvas);

89
src/overlays/keyboard.rs
View File

@@ -66,6 +66,7 @@ fn set_modifiers(app: &mut AppState, mods: u8) {
}
}
#[allow(clippy::too_many_lines)]
pub fn create_keyboard<O>(
app: &AppState,
mut keymap: Option<XkbKeymap>,
@@ -106,23 +107,25 @@ where
canvas.fg_color = color_parse("#cad3f5").unwrap(); //safe
canvas.bg_color = color_parse("#1e2030").unwrap(); //safe
let has_altgr = keymap.as_ref().is_some_and(|k| k.has_altgr());
let has_altgr = keymap
.as_ref()
.is_some_and(super::super::hid::XkbKeymap::has_altgr);
if !LAYOUT.auto_labels.unwrap_or(true) {
keymap = None;
}
let unit_size = size.x / LAYOUT.row_size;
let h = unit_size - 2. * BUTTON_PADDING;
let h = 2.0f32.mul_add(-BUTTON_PADDING, unit_size);
for row in 0..LAYOUT.key_sizes.len() {
let y = unit_size * (row as f32) + BUTTON_PADDING;
let y = unit_size.mul_add(row as f32, BUTTON_PADDING);
let mut sum_size = 0f32;
for col in 0..LAYOUT.key_sizes[row].len() {
let my_size = LAYOUT.key_sizes[row][col];
let x = unit_size * sum_size + BUTTON_PADDING;
let w = unit_size * my_size - 2. * BUTTON_PADDING;
let x = unit_size.mul_add(sum_size, BUTTON_PADDING);
let w = unit_size.mul_add(my_size, -(2. * BUTTON_PADDING));
if let Some(key) = LAYOUT.main_layout[row][col].as_ref() {
let mut label = Vec::with_capacity(2);
@@ -136,7 +139,7 @@ where
let label0 = keymap.label_for_key(vk, 0);
let label1 = keymap.label_for_key(vk, SHIFT);
if label0.chars().next().is_some_and(|f| f.is_alphabetic()) {
if label0.chars().next().is_some_and(char::is_alphabetic) {
label.push(label1);
if has_altgr {
cap_type = KeyCapType::RegularAltGr;
@@ -176,7 +179,7 @@ where
});
} else if let Some(exec_args) = LAYOUT.exec_commands.get(key) {
if exec_args.is_empty() {
log::error!("Keyboard: EXEC args empty for {}", key);
log::error!("Keyboard: EXEC args empty for {key}");
continue;
}
let mut iter = exec_args.iter().cloned();
@@ -186,10 +189,10 @@ where
args: iter.by_ref().take_while(|arg| arg[..] != *"null").collect(),
release_program: iter.next(),
release_args: iter.collect(),
})
};
});
}
} else {
log::error!("Unknown key: {}", key);
log::error!("Unknown key: {key}");
}
if let Some(state) = maybe_state {
@@ -240,7 +243,7 @@ fn key_press(
) {
match control.state.as_mut() {
Some(KeyButtonData::Key { vk, pressed }) => {
data.key_click(app);
key_click(app);
data.modifiers |= match mode {
PointerMode::Right => SHIFT,
@@ -256,11 +259,11 @@ fn key_press(
Some(KeyButtonData::Modifier { modifier, sticky }) => {
*sticky = data.modifiers & *modifier == 0;
data.modifiers |= *modifier;
data.key_click(app);
key_click(app);
set_modifiers(app, data.modifiers);
}
Some(KeyButtonData::Macro { verbs }) => {
data.key_click(app);
key_click(app);
for (vk, press) in verbs {
send_key(app, *vk, *press);
}
@@ -270,7 +273,7 @@ fn key_press(
data.processes
.retain_mut(|child| !matches!(child.try_wait(), Ok(Some(_))));
data.key_click(app);
key_click(app);
if let Ok(child) = Command::new(program).args(args).spawn() {
data.processes.push(child);
}
@@ -289,7 +292,7 @@ fn key_release(
send_key(app, *vk, false);
*pressed = false;
for m in AUTO_RELEASE_MODS.iter() {
for m in &AUTO_RELEASE_MODS {
if data.modifiers & *m != 0 {
data.modifiers &= !*m;
set_modifiers(app, data.modifiers);
@@ -349,11 +352,9 @@ struct KeyboardData {
const KEY_AUDIO_WAV: &[u8] = include_bytes!("../res/421581.wav");
impl KeyboardData {
fn key_click(&mut self, app: &mut AppState) {
if app.session.config.keyboard_sound_enabled {
app.audio.play(KEY_AUDIO_WAV);
}
fn key_click(app: &mut AppState) {
if app.session.config.keyboard_sound_enabled {
app.audio.play(KEY_AUDIO_WAV);
}
}
@@ -395,6 +396,7 @@ pub enum AltModifier {
}
#[derive(Debug, Deserialize, Serialize)]
#[allow(clippy::struct_field_names)]
pub struct Layout {
name: String,
row_size: f32,
@@ -408,8 +410,8 @@ pub struct Layout {
}
impl Layout {
fn load_from_disk() -> Layout {
let mut layout = config::load_known_yaml::<Layout>(ConfigType::Keyboard);
fn load_from_disk() -> Self {
let mut layout = config::load_known_yaml::<Self>(ConfigType::Keyboard);
layout.post_load();
layout
}
@@ -418,25 +420,25 @@ impl Layout {
for i in 0..self.key_sizes.len() {
let row = &self.key_sizes[i];
let width: f32 = row.iter().sum();
if (width - self.row_size).abs() > 0.001 {
panic!(
"Row {} has a width of {}, but the row size is {}",
i, width, self.row_size
);
}
assert!(
(width - self.row_size).abs() < 0.001,
"Row {} has a width of {}, but the row size is {}",
i,
width,
self.row_size
);
}
for i in 0..self.main_layout.len() {
let row = &self.main_layout[i];
let width = row.len();
if width != self.key_sizes[i].len() {
panic!(
"Row {} has {} keys, needs to have {} according to key_sizes",
i,
width,
self.key_sizes[i].len()
);
}
assert!(
(width == self.key_sizes[i].len()),
"Row {} has {} keys, needs to have {} according to key_sizes",
i,
width,
self.key_sizes[i].len()
);
}
}
@@ -456,10 +458,7 @@ impl Layout {
}
if key.contains('_') {
key = key.split('_').next().unwrap_or_else(|| {
log::error!(
"keyboard.yaml: Key '{}' must not start or end with '_'!",
key
);
log::error!("keyboard.yaml: Key '{key}' must not start or end with '_'!");
"???"
});
}
@@ -507,10 +506,10 @@ struct KeyboardBackend {
impl OverlayBackend for KeyboardBackend {
fn set_interaction(&mut self, interaction: Box<dyn crate::backend::input::InteractionHandler>) {
self.canvas.set_interaction(interaction)
self.canvas.set_interaction(interaction);
}
fn set_renderer(&mut self, renderer: Box<dyn crate::backend::overlay::OverlayRenderer>) {
self.canvas.set_renderer(renderer)
self.canvas.set_renderer(renderer);
}
}
@@ -521,7 +520,7 @@ impl InteractionHandler for KeyboardBackend {
hit: &crate::backend::input::PointerHit,
pressed: bool,
) {
self.canvas.on_pointer(app, hit, pressed)
self.canvas.on_pointer(app, hit, pressed);
}
fn on_scroll(
&mut self,
@@ -530,10 +529,10 @@ impl InteractionHandler for KeyboardBackend {
delta_y: f32,
delta_x: f32,
) {
self.canvas.on_scroll(app, hit, delta_y, delta_x)
self.canvas.on_scroll(app, hit, delta_y, delta_x);
}
fn on_left(&mut self, app: &mut AppState, pointer: usize) {
self.canvas.on_left(app, pointer)
self.canvas.on_left(app, pointer);
}
fn on_hover(
&mut self,

11
src/overlays/mirror.rs
View File

@@ -50,8 +50,7 @@ impl OverlayRenderer for MirrorRenderer {
fn should_render(&mut self, app: &mut AppState) -> anyhow::Result<ShouldRender> {
self.renderer
.as_mut()
.map(|r| r.should_render(app))
.unwrap_or(Ok(ShouldRender::Unable))
.map_or(Ok(ShouldRender::Unable), |r| r.should_render(app))
}
fn render(
&mut self,
@@ -90,7 +89,7 @@ impl OverlayRenderer for MirrorRenderer {
));
}
Err(e) => {
log::warn!("Failed to create mirror due to PipeWire error: {:?}", e);
log::warn!("Failed to create mirror due to PipeWire error: {e:?}");
self.renderer = None;
// drop self
app.tasks
@@ -112,7 +111,7 @@ impl OverlayRenderer for MirrorRenderer {
app.tasks.enqueue(TaskType::Overlay(
OverlaySelector::Name(self.name.clone()),
Box::new(move |_app, o| {
o.interaction_transform = ui_transform(&[extent[0], extent[1]]);
o.interaction_transform = ui_transform([extent[0], extent[1]]);
}),
));
}
@@ -146,7 +145,7 @@ pub fn new_mirror(
name: Arc<str>,
show_hide: bool,
session: &AppSession,
) -> Option<(OverlayState, Box<dyn OverlayBackend>)> {
) -> (OverlayState, Box<dyn OverlayBackend>) {
let state = OverlayState {
name: name.clone(),
show_hide,
@@ -159,5 +158,5 @@ pub fn new_mirror(
..Default::default()
});
Some((state, backend))
(state, backend)
}

238
src/overlays/screen.rs
View File

@@ -9,6 +9,7 @@ use std::{
};
use vulkano::{
command_buffer::CommandBufferUsage,
format::Format,
image::{sampler::Filter, view::ImageView, Image},
pipeline::graphics::color_blend::AttachmentBlend,
};
@@ -26,7 +27,7 @@ use wlx_capture::{
use {
crate::config_io,
std::error::Error,
std::{ops::Deref, path::PathBuf, task},
std::{path::PathBuf, task},
wlx_capture::pipewire::PipewireCapture,
wlx_capture::pipewire::PipewireSelectScreenResult,
};
@@ -64,7 +65,7 @@ use crate::{
};
#[cfg(feature = "wayland")]
pub(crate) type WlxClientAlias = wlx_capture::wayland::WlxClient;
pub type WlxClientAlias = wlx_capture::wayland::WlxClient;
#[cfg(not(feature = "wayland"))]
pub(crate) type WlxClientAlias = ();
@@ -91,7 +92,7 @@ pub struct ScreenInteractionHandler {
mouse_transform: Affine2,
}
impl ScreenInteractionHandler {
fn new(pos: Vec2, size: Vec2, transform: Transform) -> ScreenInteractionHandler {
fn new(pos: Vec2, size: Vec2, transform: Transform) -> Self {
let transform = match transform {
Transform::_90 | Transform::Flipped90 => Affine2::from_cols(
vec2(0., size.y),
@@ -111,7 +112,7 @@ impl ScreenInteractionHandler {
_ => Affine2::from_cols(vec2(size.x, 0.), vec2(0., size.y), pos),
};
ScreenInteractionHandler {
Self {
mouse_transform: transform,
}
}
@@ -127,7 +128,7 @@ impl InteractionHandler for ScreenInteractionHandler {
{
let pos = self.mouse_transform.transform_point2(hit.uv);
app.hid_provider.mouse_move(pos);
set_next_move(app.session.config.mouse_move_interval_ms as u64);
set_next_move(u64::from(app.session.config.mouse_move_interval_ms));
}
None
}
@@ -139,7 +140,7 @@ impl InteractionHandler for ScreenInteractionHandler {
};
if pressed {
set_next_move(app.session.config.click_freeze_time_ms as u64);
set_next_move(u64::from(app.session.config.click_freeze_time_ms));
}
app.hid_provider.send_button(btn, pressed);
@@ -152,7 +153,7 @@ impl InteractionHandler for ScreenInteractionHandler {
}
fn on_scroll(&mut self, app: &mut AppState, _hit: &PointerHit, delta_y: f32, delta_x: f32) {
app.hid_provider
.wheel((delta_y * 64.) as i32, (delta_x * 64.) as i32)
.wheel((delta_y * 64.) as i32, (delta_x * 64.) as i32);
}
fn on_left(&mut self, _app: &mut AppState, _hand: usize) {}
}
@@ -165,7 +166,7 @@ struct ScreenPipeline {
}
impl ScreenPipeline {
fn new(extent: &[u32; 3], app: &mut AppState) -> anyhow::Result<ScreenPipeline> {
fn new(extent: &[u32; 3], app: &mut AppState) -> anyhow::Result<Self> {
let Ok(shaders) = app.graphics.shared_shaders.read() else {
return Err(anyhow::anyhow!("Could not lock shared shaders for reading"));
};
@@ -179,7 +180,7 @@ impl ScreenPipeline {
let extentf = [extent[0] as f32, extent[1] as f32];
Ok(ScreenPipeline {
Ok(Self {
mouse: None,
pipeline,
extentf,
@@ -236,15 +237,15 @@ impl ScreenPipeline {
let vertex_buffer = app.graphics.upload_verts(
self.extentf[0],
self.extentf[1],
mouse.x * self.extentf[0] - half_size,
mouse.y * self.extentf[1] - half_size,
mouse.x.mul_add(self.extentf[0], -half_size),
mouse.y.mul_add(self.extentf[1], -half_size),
size,
size,
)?;
let set0 = self
.pipeline
.uniform_sampler(0, mouse_view.clone(), Filter::Nearest)?;
.uniform_sampler(0, mouse_view, Filter::Nearest)?;
let pass = self.pipeline.create_pass(
self.extentf,
@@ -275,8 +276,8 @@ impl ScreenRenderer {
pub fn new_raw(
name: Arc<str>,
capture: Box<dyn WlxCapture<WlxCaptureIn, WlxCaptureOut>>,
) -> ScreenRenderer {
ScreenRenderer {
) -> Self {
Self {
name,
capture,
pipeline: None,
@@ -286,11 +287,11 @@ impl ScreenRenderer {
}
#[cfg(feature = "wayland")]
pub fn new_wlr_dmabuf(output: &WlxOutput) -> Option<ScreenRenderer> {
pub fn new_wlr_dmabuf(output: &WlxOutput) -> Option<Self> {
let client = WlxClient::new()?;
let capture = WlrDmabufCapture::new(client, output.id);
Some(ScreenRenderer {
Some(Self {
name: output.name.clone(),
capture: Box::new(capture),
pipeline: None,
@@ -300,11 +301,11 @@ impl ScreenRenderer {
}
#[cfg(feature = "wayland")]
pub fn new_wlr_screencopy(output: &WlxOutput) -> Option<ScreenRenderer> {
pub fn new_wlr_screencopy(output: &WlxOutput) -> Option<Self> {
let client = WlxClient::new()?;
let capture = WlrScreencopyCapture::new(client, output.id);
Some(ScreenRenderer {
Some(Self {
name: output.name.clone(),
capture: Box::new(capture),
pipeline: None,
@@ -318,10 +319,7 @@ impl ScreenRenderer {
output: &WlxOutput,
token: Option<&str>,
session: &AppSession,
) -> anyhow::Result<(
ScreenRenderer,
Option<String>, /* pipewire restore token */
)> {
) -> anyhow::Result<(Self, Option<String> /* pipewire restore token */)> {
let name = output.name.clone();
let embed_mouse = !session.config.double_cursor_fix;
@@ -346,7 +344,7 @@ impl ScreenRenderer {
let capture = PipewireCapture::new(name, node_id);
Ok((
ScreenRenderer {
Self {
name: output.name.clone(),
capture: Box::new(capture),
pipeline: None,
@@ -358,10 +356,10 @@ impl ScreenRenderer {
}
#[cfg(feature = "x11")]
pub fn new_xshm(screen: Arc<XshmScreen>) -> ScreenRenderer {
pub fn new_xshm(screen: Arc<XshmScreen>) -> Self {
let capture = XshmCapture::new(screen.clone());
ScreenRenderer {
Self {
name: screen.name.clone(),
capture: Box::new(capture),
pipeline: None,
@@ -384,6 +382,39 @@ pub struct WlxCaptureOut {
mouse: Option<MouseMeta>,
}
fn upload_image(
me: &WlxCaptureIn,
width: u32,
height: u32,
format: Format,
data: &[u8],
) -> Option<Arc<Image>> {
let mut upload = match me
.graphics
.create_command_buffer(CommandBufferUsage::OneTimeSubmit)
{
Ok(x) => x,
Err(e) => {
log::error!("{}: Could not create vkCommandBuffer: {:?}", me.name, e);
return None;
}
};
let image = match upload.texture2d_raw(width, height, format, data) {
Ok(x) => x,
Err(e) => {
log::error!("{}: Could not create vkImage: {:?}", me.name, e);
return None;
}
};
if let Err(e) = upload.build_and_execute_now() {
log::error!("{}: Could not execute upload: {:?}", me.name, e);
return None;
}
Some(image)
}
fn receive_callback(me: &WlxCaptureIn, frame: wlx_frame::WlxFrame) -> Option<WlxCaptureOut> {
match frame {
WlxFrame::Dmabuf(frame) => {
@@ -400,11 +431,7 @@ fn receive_callback(me: &WlxCaptureIn, frame: wlx_frame::WlxFrame) -> Option<Wlx
mouse: None,
}),
Err(e) => {
log::error!(
"{}: Failed to create DMA-buf vkImage: {}",
me.name,
e.to_string()
);
log::error!("{}: Failed to create DMA-buf vkImage: {}", me.name, e);
None
}
}
@@ -424,7 +451,7 @@ fn receive_callback(me: &WlxCaptureIn, frame: wlx_frame::WlxFrame) -> Option<Wlx
};
let len = frame.plane.stride as usize * frame.format.height as usize;
let offset = frame.plane.offset as i64;
let offset = i64::from(frame.plane.offset);
let map = unsafe {
libc::mmap(
@@ -437,35 +464,15 @@ fn receive_callback(me: &WlxCaptureIn, frame: wlx_frame::WlxFrame) -> Option<Wlx
)
} as *const u8;
let pixels = unsafe { slice::from_raw_parts(map, len) };
let data = unsafe { slice::from_raw_parts(map, len) };
let mut upload = match me
.graphics
.create_command_buffer(CommandBufferUsage::OneTimeSubmit)
{
Ok(x) => x,
Err(e) => {
log::error!("{}: Could not create vkCommandBuffer: {:?}", me.name, e);
return None;
}
};
let image = {
let maybe_image =
upload_image(me, frame.format.width, frame.format.height, format, data);
let image =
match upload.texture2d_raw(frame.format.width, frame.format.height, format, pixels)
{
Ok(x) => x,
Err(e) => {
log::error!("{}: Could not create vkImage: {:?}", me.name, e);
return None;
}
};
if let Err(e) = upload.build_and_execute_now() {
log::error!("{}: Could not execute upload: {:?}", me.name, e);
return None;
}
unsafe { libc::munmap(map as *mut _, len) };
unsafe { libc::munmap(map as *mut _, len) };
maybe_image
}?;
Some(WlxCaptureOut {
image,
@@ -484,33 +491,8 @@ fn receive_callback(me: &WlxCaptureIn, frame: wlx_frame::WlxFrame) -> Option<Wlx
}
};
let mut upload = match me
.graphics
.create_command_buffer(CommandBufferUsage::OneTimeSubmit)
{
Ok(x) => x,
Err(e) => {
log::error!("{}: Could not create vkCommandBuffer: {:?}", me.name, e);
return None;
}
};
let pixels = unsafe { slice::from_raw_parts(frame.ptr as *const u8, frame.size) };
let image =
match upload.texture2d_raw(frame.format.width, frame.format.height, format, pixels)
{
Ok(x) => x,
Err(e) => {
log::error!("{}: Could not create vkImage: {:?}", me.name, e);
return None;
}
};
if let Err(e) = upload.build_and_execute_now() {
log::error!("{}: Could not execute upload: {:?}", me.name, e);
return None;
}
let data = unsafe { slice::from_raw_parts(frame.ptr as *const u8, frame.size) };
let image = upload_image(me, frame.format.width, frame.format.height, format, data)?;
Some(WlxCaptureOut {
image,
@@ -547,7 +529,7 @@ impl OverlayRenderer for ScreenRenderer {
return vec![];
}
if !allow_dmabuf {
log::info!("Not using DMA-buf capture due to {}", capture_method);
log::info!("Not using DMA-buf capture due to {capture_method}");
return vec![];
}
log::warn!("Using DMA-buf capture. If screens are blank for you, switch to SHM using:");
@@ -604,7 +586,7 @@ impl OverlayRenderer for ScreenRenderer {
return Ok(ShouldRender::Unable);
}
for frame in self.capture.receive().into_iter() {
if let Some(frame) = self.capture.receive() {
self.cur_frame = Some(frame);
}
@@ -623,7 +605,7 @@ impl OverlayRenderer for ScreenRenderer {
upload.build_and_execute_now()?;
pipeline
});
};
}
if self.cur_frame.is_some() {
Ok(ShouldRender::Should)
@@ -669,6 +651,7 @@ impl OverlayRenderer for ScreenRenderer {
}
#[cfg(feature = "wayland")]
#[allow(clippy::useless_let_if_seq)]
pub fn create_screen_renderer_wl(
output: &WlxOutput,
has_wlr_dmabuf: bool,
@@ -690,17 +673,15 @@ pub fn create_screen_renderer_wl(
if capture.is_none() {
log::info!("{}: Using Pipewire capture", &output.name);
let display_name = output.name.deref();
let display_name = &*output.name;
// Find existing token by display
let token = pw_token_store.arc_get(display_name).map(|s| s.as_str());
let token = pw_token_store
.arc_get(display_name)
.map(std::string::String::as_str);
if let Some(t) = token {
log::info!(
"Found existing Pipewire token for display {}: {}",
display_name,
t
);
log::info!("Found existing Pipewire token for display {display_name}: {t}");
}
match ScreenRenderer::new_pw(output, token, session) {
@@ -709,7 +690,7 @@ pub fn create_screen_renderer_wl(
if let Some(token) = restore_token {
if pw_token_store.arc_set(display_name.into(), token.clone()) {
log::info!("Adding Pipewire token {}", token);
log::info!("Adding Pipewire token {token}");
}
}
}
@@ -773,7 +754,7 @@ fn create_screen_state(
};
OverlayState {
name: name.clone(),
name,
keyboard_focus: Some(KeyboardFocus::PhysicalScreen),
grabbable: true,
recenter: true,
@@ -816,23 +797,19 @@ pub fn load_pw_token_config() -> Result<PwTokenMap, Box<dyn Error>> {
Ok(conf.pw_tokens)
}
pub(crate) struct ScreenCreateData {
pub struct ScreenCreateData {
pub screens: Vec<(ScreenMeta, OverlayState, Box<SplitOverlayBackend>)>,
}
#[cfg(not(feature = "wayland"))]
pub fn create_screens_wayland(
_wl: &mut WlxClientAlias,
_app: &AppState,
) -> anyhow::Result<ScreenCreateData> {
anyhow::bail!("Wayland support not enabled")
pub fn create_screens_wayland(_wl: &mut WlxClientAlias, _app: &AppState) -> ScreenCreateData {
ScreenCreateData {
screens: Vec::default(),
}
}
#[cfg(feature = "wayland")]
pub fn create_screens_wayland(
wl: &mut WlxClientAlias,
app: &mut AppState,
) -> anyhow::Result<ScreenCreateData> {
pub fn create_screens_wayland(wl: &mut WlxClientAlias, app: &mut AppState) -> ScreenCreateData {
let mut screens = vec![];
// Load existing Pipewire tokens from file
@@ -842,7 +819,7 @@ pub fn create_screens_wayland(
let has_wlr_dmabuf = wl.maybe_wlr_dmabuf_mgr.is_some();
let has_wlr_screencopy = wl.maybe_wlr_screencopy_mgr.is_some();
for (id, output) in wl.outputs.iter() {
for (id, output) in &wl.outputs {
if app.screens.iter().any(|s| s.name == output.name) {
continue;
}
@@ -886,7 +863,7 @@ pub fn create_screens_wayland(
if pw_tokens_copy != pw_tokens {
// Token list changed, re-create token config file
if let Err(err) = save_pw_token_config(pw_tokens) {
log::error!("Failed to save Pipewire token config: {}", err);
log::error!("Failed to save Pipewire token config: {err}");
}
}
@@ -898,7 +875,7 @@ pub fn create_screens_wayland(
app.hid_provider
.set_desktop_origin(vec2(origin.0 as f32, origin.1 as f32));
Ok(ScreenCreateData { screens })
ScreenCreateData { screens }
}
#[cfg(not(feature = "x11"))]
@@ -918,7 +895,7 @@ pub fn create_screens_x11pw(app: &mut AppState) -> anyhow::Result<ScreenCreateDa
// Load existing Pipewire tokens from file
let mut pw_tokens: PwTokenMap = load_pw_token_config().unwrap_or_default();
let pw_tokens_copy = pw_tokens.clone();
let token = pw_tokens.arc_get("x11").map(|s| s.as_str());
let token = pw_tokens.arc_get("x11").map(std::string::String::as_str);
let embed_mouse = !app.session.config.double_cursor_fix;
let select_screen_result = select_pw_screen(
@@ -932,13 +909,13 @@ pub fn create_screens_x11pw(app: &mut AppState) -> anyhow::Result<ScreenCreateDa
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);
log::info!("Adding Pipewire token {restore_token}");
}
}
if pw_tokens_copy != pw_tokens {
// Token list changed, re-create token config file
if let Err(err) = save_pw_token_config(pw_tokens) {
log::error!("Failed to save Pipewire token config: {}", err);
log::error!("Failed to save Pipewire token config: {err}");
}
}
@@ -1064,6 +1041,7 @@ pub enum Transform {
_90,
_180,
_270,
Flipped,
Flipped90,
Flipped180,
Flipped270,
@@ -1071,17 +1049,16 @@ pub enum Transform {
#[cfg(feature = "wayland")]
impl From<wl_output::Transform> for Transform {
fn from(t: wl_output::Transform) -> Transform {
fn from(t: wl_output::Transform) -> Self {
match t {
wl_output::Transform::Normal => Transform::Normal,
wl_output::Transform::_90 => Transform::_90,
wl_output::Transform::_180 => Transform::_180,
wl_output::Transform::_270 => Transform::_270,
wl_output::Transform::Flipped => Transform::Flipped180,
wl_output::Transform::Flipped90 => Transform::Flipped90,
wl_output::Transform::Flipped180 => Transform::Flipped180,
wl_output::Transform::Flipped270 => Transform::Flipped270,
_ => Transform::Normal,
wl_output::Transform::_90 => Self::_90,
wl_output::Transform::_180 => Self::_180,
wl_output::Transform::_270 => Self::_270,
wl_output::Transform::Flipped => Self::Flipped,
wl_output::Transform::Flipped90 => Self::Flipped90,
wl_output::Transform::Flipped180 => Self::Flipped180,
wl_output::Transform::Flipped270 => Self::Flipped270,
_ => Self::Normal,
}
}
}
@@ -1093,7 +1070,7 @@ fn extent_from_format(fmt: FrameFormat, config: &GeneralConfig) -> [u32; 3] {
fn extent_from_res(width: u32, height: u32, config: &GeneralConfig) -> [u32; 3] {
// screens above a certain resolution will have severe aliasing
let height_limit = if config.screen_render_down {
config.screen_max_height.min(2560) as u32
u32::from(config.screen_max_height.min(2560))
} else {
2560
};
@@ -1111,7 +1088,6 @@ fn affine_from_format(format: &FrameFormat) -> Affine3A {
};
match format.transform {
wlx_frame::Transform::Normal => Affine3A::IDENTITY,
wlx_frame::Transform::Rotated90 => Affine3A::from_rotation_z(-PI / 2.0),
wlx_frame::Transform::Rotated180 => Affine3A::from_rotation_z(PI),
wlx_frame::Transform::Rotated270 => Affine3A::from_rotation_z(PI / 2.0),
@@ -1125,7 +1101,7 @@ fn affine_from_format(format: &FrameFormat) -> Affine3A {
wlx_frame::Transform::Flipped270 => {
Affine3A::from_scale(FLIP_X) * Affine3A::from_rotation_z(PI / 2.0)
}
wlx_frame::Transform::Undefined => Affine3A::IDENTITY,
_ => Affine3A::IDENTITY,
}
}
@@ -1141,9 +1117,9 @@ fn best_match<'a>(
return best;
};
let mut best_dist = best
.map(|b| (b.monitor.x() - position.0).abs() + (b.monitor.y() - position.1).abs())
.unwrap_or(i32::MAX);
let mut best_dist = best.map_or(i32::MAX, |b| {
(b.monitor.x() - position.0).abs() + (b.monitor.y() - position.1).abs()
});
for stream in streams {
log::debug!("checking: {:?}", stream.monitor);
let dist =
@@ -1158,6 +1134,7 @@ fn best_match<'a>(
}
#[cfg(feature = "pipewire")]
#[allow(clippy::fn_params_excessive_bools)]
fn select_pw_screen(
instructions: &str,
token: Option<&str>,
@@ -1181,7 +1158,7 @@ fn select_pw_screen(
task::Poll::Ready(result) => return result,
task::Poll::Pending => {
if Instant::now() >= print_at {
log::info!("{}", instructions);
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));
@@ -1193,7 +1170,6 @@ fn select_pw_screen(
std::thread::sleep(Duration::from_millis(10));
})
.await;
continue;
}
}
}

44
src/overlays/toast.rs
View File

@@ -46,8 +46,8 @@ pub struct Toast {
#[allow(dead_code)]
impl Toast {
pub fn new(topic: ToastTopic, title: Arc<str>, body: Arc<str>) -> Self {
Toast {
pub const fn new(topic: ToastTopic, title: Arc<str>, body: Arc<str>) -> Self {
Self {
title,
body,
opacity: 1.0,
@@ -56,15 +56,15 @@ impl Toast {
topic,
}
}
pub fn with_timeout(mut self, timeout: f32) -> Self {
pub const fn with_timeout(mut self, timeout: f32) -> Self {
self.timeout = timeout;
self
}
pub fn with_opacity(mut self, opacity: f32) -> Self {
pub const fn with_opacity(mut self, opacity: f32) -> Self {
self.opacity = opacity;
self
}
pub fn with_sound(mut self, sound: bool) -> Self {
pub const fn with_sound(mut self, sound: bool) -> Self {
self.sound = sound;
self
}
@@ -93,7 +93,7 @@ impl Toast {
// frame, only the first one gets created
app.tasks.enqueue_at(
TaskType::CreateOverlay(
selector.clone(),
selector,
Box::new(move |app| {
let mut maybe_toast = new_toast(self, app);
if let Some((state, _)) = maybe_toast.as_mut() {
@@ -139,13 +139,19 @@ fn new_toast(toast: Toast, app: &mut AppState) -> Option<(OverlayState, Box<dyn
}
};
let title = if !toast.title.is_empty() {
toast.title
} else {
let title = if toast.title.is_empty() {
"Notification".into()
} else {
toast.title
};
let mut size = if !toast.body.is_empty() {
let mut size = if toast.body.is_empty() {
let (w, h) = app
.fc
.get_text_size(&title, FONT_SIZE, app.graphics.clone())
.ok()?;
(w, h + 20.)
} else {
let (w0, _) = app
.fc
.get_text_size(&title, FONT_SIZE, app.graphics.clone())
@@ -155,12 +161,6 @@ fn new_toast(toast: Toast, app: &mut AppState) -> Option<(OverlayState, Box<dyn
.get_text_size(&toast.body, FONT_SIZE, app.graphics.clone())
.ok()?;
(w0.max(w1), h1 + 50.)
} else {
let (w, h) = app
.fc
.get_text_size(&title, FONT_SIZE, app.graphics.clone())
.ok()?;
(w, h + 20.)
};
let og_width = size.0;
@@ -180,15 +180,15 @@ fn new_toast(toast: Toast, app: &mut AppState) -> Option<(OverlayState, Box<dyn
canvas.bg_color = color_parse("#1e2030").unwrap(); // want panic
canvas.panel(0., 0., size.0, size.1, 16.);
if !toast.body.is_empty() {
if toast.body.is_empty() {
canvas.label_centered(PADDING.0, 0., og_width, size.1, 16., title);
} else {
canvas.label(PADDING.0, 54., og_width, size.1 - 54., 3., toast.body);
canvas.fg_color = color_parse("#b8c0e0").unwrap(); // want panic
canvas.bg_color = color_parse("#24273a").unwrap(); // want panic
canvas.panel(0., 0., size.0, 30., 16.);
canvas.label_centered(PADDING.0, 16., og_width, FONT_SIZE as f32 + 2., 16., title);
} else {
canvas.label_centered(PADDING.0, 0., og_width, size.1, 16., title);
}
let state = OverlayState {
@@ -218,13 +218,13 @@ pub fn error_toast<ErrorType>(app: &mut AppState, title: &str, err: ErrorType)
where
ErrorType: std::fmt::Display + std::fmt::Debug,
{
log::error!("{}: {:?}", title, err); // More detailed version (use Debug)
log::error!("{title}: {err:?}"); // More detailed version (use Debug)
// Brief version (use Display)
msg_err(app, &format!("{}: {}", title, err));
msg_err(app, &format!("{title}: {err}"));
}
pub fn error_toast_str(app: &mut AppState, message: &str) {
log::error!("{}", message);
log::error!("{message}");
msg_err(app, message);
}

4
src/overlays/watch.rs
View File

@@ -29,7 +29,7 @@ where
spawn_scale: config.width,
spawn_point: state.session.config.watch_pos,
spawn_rotation: state.session.config.watch_rot,
interaction_transform: ui_transform(&config.size),
interaction_transform: ui_transform(config.size),
relative_to,
..Default::default()
},
@@ -44,7 +44,7 @@ pub fn create_watch_canvas(
) -> anyhow::Result<Canvas<(), ModularData>> {
let config = config.unwrap_or_else(|| load_known_yaml::<ModularUiConfig>(ConfigType::Watch));
modular_canvas(&config.size, &config.elements, state)
modular_canvas(config.size, &config.elements, state)
}
pub fn watch_fade<D>(app: &mut AppState, watch: &mut OverlayData<D>)

145
src/overlays/wayvr.rs
View File

@@ -41,14 +41,11 @@ pub struct WayVRContext {
}
impl WayVRContext {
pub fn new(
wvr: Rc<RefCell<WayVRData>>,
display: wayvr::display::DisplayHandle,
) -> anyhow::Result<Self> {
Ok(Self {
wayvr: wvr.clone(),
pub const fn new(wvr: Rc<RefCell<WayVRData>>, display: wayvr::display::DisplayHandle) -> Self {
Self {
wayvr: wvr,
display,
})
}
}
}
@@ -67,7 +64,7 @@ pub struct WayVRData {
impl WayVRData {
pub fn new(config: wayvr::Config) -> anyhow::Result<Self> {
Ok(Self {
display_handle_map: Default::default(),
display_handle_map: HashMap::default(),
data: WayVR::new(config)?,
overlays_to_create: Vec::new(),
dashboard_executed: false,
@@ -87,7 +84,7 @@ impl WayVRData {
.any(|d| d.obj.name == candidate)
{
if num > 0 {
candidate = format!("{} ({})", candidate, num);
candidate = format!("{candidate} ({num})");
}
num += 1;
}
@@ -102,7 +99,7 @@ pub struct WayVRInteractionHandler {
}
impl WayVRInteractionHandler {
pub fn new(context: Rc<RefCell<WayVRContext>>, mouse_transform: Affine2) -> Self {
pub const fn new(context: Rc<RefCell<WayVRContext>>, mouse_transform: Affine2) -> Self {
Self {
context,
mouse_transform,
@@ -122,8 +119,8 @@ impl InteractionHandler for WayVRInteractionHandler {
if let Some(disp) = wayvr.state.displays.get(&ctx.display) {
let pos = self.mouse_transform.transform_point2(hit.uv);
let x = ((pos.x * disp.width as f32) as i32).max(0);
let y = ((pos.y * disp.height as f32) as i32).max(0);
let x = ((pos.x * f32::from(disp.width)) as i32).max(0);
let y = ((pos.y * f32::from(disp.height)) as i32).max(0);
let ctx = self.context.borrow();
wayvr.state.send_mouse_move(ctx.display, x as u32, y as u32);
@@ -151,7 +148,7 @@ impl InteractionHandler for WayVRInteractionHandler {
if pressed {
wayvr.state.send_mouse_down(ctx.display, index);
} else {
wayvr.state.send_mouse_up(ctx.display, index);
wayvr.state.send_mouse_up(index);
}
}
}
@@ -168,7 +165,7 @@ impl InteractionHandler for WayVRInteractionHandler {
.borrow_mut()
.data
.state
.send_mouse_scroll(ctx.display, delta_y, delta_x);
.send_mouse_scroll(delta_y, delta_x);
}
}
@@ -199,7 +196,7 @@ impl WayVRRenderer {
Ok(Self {
pipeline,
context: Rc::new(RefCell::new(WayVRContext::new(wvr, display)?)),
context: Rc::new(RefCell::new(WayVRContext::new(wvr, display))),
vk_image: None,
vk_image_view: None,
graphics: app.graphics.clone(),
@@ -220,10 +217,7 @@ fn get_or_create_display_by_name(
.session
.wayvr_config
.get_display(disp_name)
.ok_or(anyhow::anyhow!(
"Cannot find display named \"{}\"",
disp_name
))?
.ok_or_else(|| anyhow::anyhow!("Cannot find display named \"{}\"", disp_name))?
.clone();
let disp_handle = wayvr.data.state.create_display(
@@ -302,6 +296,7 @@ where
},
)?;
overlay.state.curvature = Some(0.15);
overlay.state.want_visible = true;
overlay.state.spawn_scale = 2.0;
overlay.state.spawn_point = vec3a(0.0, -0.35, -1.75);
@@ -312,25 +307,17 @@ where
unreachable!(); /* safe, not possible to trigger */
};
// FIXME: overlay curvature needs to be dispatched for some unknown reason, this value is not set otherwise
app.tasks.enqueue(TaskType::Overlay(
OverlaySelector::Id(overlay.state.id),
Box::new(move |_app, o| {
o.curvature = Some(0.15);
}),
));
overlays.add(overlay);
let args_vec = match &conf_dash.args {
Some(args) => gen_args_vec(args),
None => vec![],
};
let args_vec = &conf_dash
.args
.as_ref()
.map_or_else(Vec::new, |args| gen_args_vec(args.as_str()));
let env_vec = match &conf_dash.env {
Some(env) => gen_env_vec(env),
None => vec![],
};
let env_vec = &conf_dash
.env
.as_ref()
.map_or_else(Vec::new, |env| gen_env_vec(env));
let mut userdata = HashMap::new();
userdata.insert(String::from("type"), String::from("dashboard"));
@@ -339,8 +326,8 @@ where
let _process_handle_unused = wayvr.data.state.spawn_process(
disp_handle,
&conf_dash.exec,
&args_vec,
&env_vec,
args_vec,
env_vec,
userdata,
)?;
@@ -446,6 +433,7 @@ where
Ok(())
}
#[allow(clippy::too_many_lines)]
pub fn tick_events<O>(app: &mut AppState, overlays: &mut OverlayContainer<O>) -> anyhow::Result<()>
where
O: Default,
@@ -490,36 +478,42 @@ where
for result in res {
match result {
wayvr::TickTask::NewExternalProcess(req) => {
wayvr::TickTask::NewExternalProcess(request) => {
let config = &app.session.wayvr_config;
let disp_name = if let Some(display_name) = req.env.display_name {
config
.get_display(display_name.as_str())
.map(|_| display_name)
} else {
config
.get_default_display()
.map(|(display_name, _)| display_name)
};
let disp_name = request.env.display_name.map_or_else(
|| {
config
.get_default_display()
.map(|(display_name, _)| display_name)
},
|display_name| {
config
.get_display(display_name.as_str())
.map(|_| display_name)
},
);
if let Some(disp_name) = disp_name {
let mut wayvr = r_wayvr.borrow_mut();
log::info!("Registering external process with PID {}", req.pid);
log::info!("Registering external process with PID {}", request.pid);
let disp_handle = get_or_create_display_by_name(app, &mut wayvr, &disp_name)?;
wayvr.data.state.add_external_process(disp_handle, req.pid);
wayvr
.data
.state
.add_external_process(disp_handle, request.pid);
wayvr
.data
.state
.manager
.add_client(wayvr::client::WayVRClient {
client: req.client,
client: request.client,
display_handle: disp_handle,
pid: req.pid,
pid: request.pid,
});
}
}
@@ -576,8 +570,8 @@ impl WayVRRenderer {
.create_command_buffer(CommandBufferUsage::OneTimeSubmit)?;
let tex = upload.texture2d_raw(
data.width as u32,
data.height as u32,
u32::from(data.width),
u32::from(data.height),
vulkano::format::Format::R8G8B8A8_UNORM,
&data.data,
)?;
@@ -615,8 +609,8 @@ impl WayVRRenderer {
let frame = DmabufFrame {
format: FrameFormat {
width: disp.width as u32,
height: disp.height as u32,
width: u32::from(disp.width),
height: u32::from(disp.height),
fourcc: FourCC {
value: data.mod_info.fourcc,
},
@@ -674,7 +668,7 @@ impl OverlayRenderer for WayVRRenderer {
let redrawn = match wayvr.data.tick_display(ctx.display) {
Ok(r) => r,
Err(e) => {
log::error!("tick_display failed: {}", e);
log::error!("tick_display failed: {e}");
return Ok(ShouldRender::Unable);
}
};
@@ -699,7 +693,7 @@ impl OverlayRenderer for WayVRRenderer {
.data
.state
.get_render_data(ctx.display)
.ok_or(anyhow::anyhow!("Failed to fetch render data"))?
.ok_or_else(|| anyhow::anyhow!("Failed to fetch render data"))?
.clone();
drop(wayvr);
@@ -712,7 +706,7 @@ impl OverlayRenderer for WayVRRenderer {
}
wayvr::egl_data::RenderData::Software(data) => {
if let Some(new_frame) = &data {
self.ensure_software_data(new_frame)?
self.ensure_software_data(new_frame)?;
}
}
}
@@ -762,10 +756,10 @@ pub fn create_wayvr_display_overlay<O>(
where
O: Default,
{
let transform = ui_transform(&[display_width as u32, display_height as u32]);
let transform = ui_transform([u32::from(display_width), u32::from(display_height)]);
let state = OverlayState {
name: format!("WayVR - {}", name).into(),
name: format!("WayVR - {name}").into(),
keyboard_focus: Some(KeyboardFocus::WayVR),
want_visible: true,
interactable: true,
@@ -817,16 +811,13 @@ fn action_app_click<O>(
where
O: Default,
{
let wayvr = app.get_wayvr()?.clone();
let wayvr = app.get_wayvr()?;
let catalog = app
.session
.wayvr_config
.get_catalog(catalog_name)
.ok_or(anyhow::anyhow!(
"Failed to get catalog \"{}\"",
catalog_name
))?
.ok_or_else(|| anyhow::anyhow!("Failed to get catalog \"{}\"", catalog_name))?
.clone();
if let Some(app_entry) = catalog.get_app(app_name) {
@@ -838,22 +829,22 @@ where
&app_entry.target_display.to_lowercase(),
)?;
let args_vec = match &app_entry.args {
Some(args) => gen_args_vec(args),
None => vec![],
};
let args_vec = &app_entry
.args
.as_ref()
.map_or_else(Vec::new, |args| gen_args_vec(args.as_str()));
let env_vec = match &app_entry.env {
Some(env) => gen_env_vec(env),
None => vec![],
};
let env_vec = &app_entry
.env
.as_ref()
.map_or_else(Vec::new, |env| gen_env_vec(env));
// Terminate existing process if required
if let Some(process_handle) =
wayvr
.data
.state
.process_query(disp_handle, &app_entry.exec, &args_vec, &env_vec)
.process_query(disp_handle, &app_entry.exec, args_vec, env_vec)
{
// Terminate process
wayvr.data.terminate_process(process_handle);
@@ -862,9 +853,9 @@ where
wayvr.data.state.spawn_process(
disp_handle,
&app_entry.exec,
&args_vec,
&env_vec,
Default::default(),
args_vec,
env_vec,
HashMap::default(),
)?;
show_display::<O>(&mut wayvr, overlays, app_entry.target_display.as_str());