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

fmt

Browse Source
This commit is contained in:
galister
2025-12-24 00:58:40 +09:00
parent 6672fb71e4
commit 3f5a363136
23 changed files with 484 additions and 430 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
wayvr-ipc/src/client.rs
View File

@@ -1,8 +1,7 @@
use bytes::BufMut;
use interprocess::local_socket::{
self,
tokio::{prelude::*, Stream},
GenericNamespaced,
self, GenericNamespaced,
tokio::{Stream, prelude::*},
};
use serde::Serialize;
use smallvec::SmallVec;

259
wayvr-ipc/src/util/handle.rs
View File

@@ -1,167 +1,164 @@
#[macro_export]
macro_rules! gen_id {
(
(
$container_name:ident,
$instance_name:ident,
$cell_name:ident,
$handle_name:ident) => {
//ThingCell
pub struct $cell_name {
pub obj: $instance_name,
pub generation: u64,
}
//ThingCell
pub struct $cell_name {
pub obj: $instance_name,
pub generation: u64,
}
//ThingVec
pub struct $container_name {
// Vec<Option<ThingCell>>
pub vec: Vec<Option<$cell_name>>,
//ThingVec
pub struct $container_name {
// Vec<Option<ThingCell>>
pub vec: Vec<Option<$cell_name>>,
cur_generation: u64,
}
cur_generation: u64,
}
//ThingHandle
#[derive(Default, Clone, Copy, PartialEq, Hash, Eq)]
pub struct $handle_name {
idx: u32,
generation: u64,
}
//ThingHandle
#[derive(Default, Clone, Copy, PartialEq, Hash, Eq)]
pub struct $handle_name {
idx: u32,
generation: u64,
}
#[allow(dead_code)]
impl $handle_name {
pub fn reset(&mut self) {
self.generation = 0;
}
#[allow(dead_code)]
impl $handle_name {
pub fn reset(&mut self) {
self.generation = 0;
}
pub fn is_set(&self) -> bool {
self.generation > 0
}
pub fn is_set(&self) -> bool {
self.generation > 0
}
pub fn id(&self) -> u32 {
self.idx
}
pub fn id(&self) -> u32 {
self.idx
}
pub fn new(idx: u32, generation: u64) -> Self {
Self { idx, generation }
}
}
pub fn new(idx: u32, generation: u64) -> Self {
Self { idx, generation }
}
}
//ThingVec
#[allow(dead_code)]
impl $container_name {
pub fn new() -> Self {
Self {
vec: Vec::new(),
cur_generation: 0,
}
}
//ThingVec
#[allow(dead_code)]
impl $container_name {
pub fn new() -> Self {
Self {
vec: Vec::new(),
cur_generation: 0,
}
}
pub fn iter(&self, callback: &dyn Fn($handle_name, &$instance_name)) {
for (idx, opt_cell) in self.vec.iter().enumerate() {
if let Some(cell) = opt_cell {
let handle = $container_name::get_handle(&cell, idx);
callback(handle, &cell.obj);
}
}
}
pub fn iter(&self, callback: &dyn Fn($handle_name, &$instance_name)) {
for (idx, opt_cell) in self.vec.iter().enumerate() {
if let Some(cell) = opt_cell {
let handle = $container_name::get_handle(&cell, idx);
callback(handle, &cell.obj);
}
}
}
pub fn iter_mut(
&mut self,
callback: &mut dyn FnMut($handle_name, &mut $instance_name),
) {
for (idx, opt_cell) in self.vec.iter_mut().enumerate() {
if let Some(cell) = opt_cell {
let handle = $container_name::get_handle(&cell, idx);
callback(handle, &mut cell.obj);
}
}
}
pub fn iter_mut(&mut self, callback: &mut dyn FnMut($handle_name, &mut $instance_name)) {
for (idx, opt_cell) in self.vec.iter_mut().enumerate() {
if let Some(cell) = opt_cell {
let handle = $container_name::get_handle(&cell, idx);
callback(handle, &mut cell.obj);
}
}
}
pub fn get_handle(cell: &$cell_name, idx: usize) -> $handle_name {
$handle_name {
idx: idx as u32,
generation: cell.generation,
}
}
pub fn get_handle(cell: &$cell_name, idx: usize) -> $handle_name {
$handle_name {
idx: idx as u32,
generation: cell.generation,
}
}
fn find_unused_idx(&mut self) -> Option<u32> {
for (num, obj) in self.vec.iter().enumerate() {
if obj.is_none() {
return Some(num as u32);
}
}
None
}
fn find_unused_idx(&mut self) -> Option<u32> {
for (num, obj) in self.vec.iter().enumerate() {
if obj.is_none() {
return Some(num as u32);
}
}
None
}
pub fn add(&mut self, obj: $instance_name) -> $handle_name {
self.cur_generation += 1;
let generation = self.cur_generation;
pub fn add(&mut self, obj: $instance_name) -> $handle_name {
self.cur_generation += 1;
let generation = self.cur_generation;
let unused_idx = self.find_unused_idx();
let unused_idx = self.find_unused_idx();
let idx = if let Some(idx) = unused_idx {
idx
} else {
self.vec.len() as u32
};
let idx = if let Some(idx) = unused_idx {
idx
} else {
self.vec.len() as u32
};
let handle = $handle_name { idx, generation };
let handle = $handle_name { idx, generation };
let cell = $cell_name { obj, generation };
let cell = $cell_name { obj, generation };
if let Some(idx) = unused_idx {
self.vec[idx as usize] = Some(cell);
} else {
self.vec.push(Some(cell))
}
if let Some(idx) = unused_idx {
self.vec[idx as usize] = Some(cell);
} else {
self.vec.push(Some(cell))
}
handle
}
handle
}
pub fn remove(&mut self, handle: &$handle_name) {
// Out of bounds, ignore
if handle.idx as usize >= self.vec.len() {
return;
}
pub fn remove(&mut self, handle: &$handle_name) {
// Out of bounds, ignore
if handle.idx as usize >= self.vec.len() {
return;
}
// Remove only if the generation matches
if let Some(cell) = &self.vec[handle.idx as usize] {
if cell.generation == handle.generation {
self.vec[handle.idx as usize] = None;
}
}
}
// Remove only if the generation matches
if let Some(cell) = &self.vec[handle.idx as usize] {
if cell.generation == handle.generation {
self.vec[handle.idx as usize] = None;
}
}
}
pub fn get(&self, handle: &$handle_name) -> Option<&$instance_name> {
// Out of bounds, ignore
if handle.idx as usize >= self.vec.len() {
return None;
}
pub fn get(&self, handle: &$handle_name) -> Option<&$instance_name> {
// Out of bounds, ignore
if handle.idx as usize >= self.vec.len() {
return None;
}
if let Some(cell) = &self.vec[handle.idx as usize] {
if cell.generation == handle.generation {
return Some(&cell.obj);
}
}
if let Some(cell) = &self.vec[handle.idx as usize] {
if cell.generation == handle.generation {
return Some(&cell.obj);
}
}
None
}
None
}
pub fn get_mut(&mut self, handle: &$handle_name) -> Option<&mut $instance_name> {
// Out of bounds, ignore
if handle.idx as usize >= self.vec.len() {
return None;
}
pub fn get_mut(&mut self, handle: &$handle_name) -> Option<&mut $instance_name> {
// Out of bounds, ignore
if handle.idx as usize >= self.vec.len() {
return None;
}
if let Some(cell) = &mut self.vec[handle.idx as usize] {
if cell.generation == handle.generation {
return Some(&mut cell.obj);
}
}
if let Some(cell) = &mut self.vec[handle.idx as usize] {
if cell.generation == handle.generation {
return Some(&mut cell.obj);
}
}
None
}
}
};
None
}
}
};
}
/* Example usage:

387
wayvrctl/src/helper.rs
View File

@@ -1,246 +1,267 @@
use std::{collections::HashMap};
use std::collections::HashMap;
use anyhow::Context;
use serde::Serialize;
use wayvr_ipc::{client::{WayVRClient, WayVRClientMutex}, ipc, packet_client, packet_server};
use wayvr_ipc::{
client::{WayVRClient, WayVRClientMutex},
ipc, packet_client, packet_server,
};
pub struct WayVRClientState {
pub wayvr_client: WayVRClientMutex,
pub serial_generator: ipc::SerialGenerator,
pub pretty_print: bool,
pub wayvr_client: WayVRClientMutex,
pub serial_generator: ipc::SerialGenerator,
pub pretty_print: bool,
}
fn handle_empty_result(result: anyhow::Result<()>) {
if let Err(e) = result {
log::error!("{e:?}");
}
if let Err(e) = result {
log::error!("{e:?}");
}
}
fn handle_result<T: Serialize>(pretty_print: bool, result: anyhow::Result<T>) {
match result {
Ok(t) => {
let maybe_json = if pretty_print {
serde_json::to_string_pretty(&t)
} else {
serde_json::to_string(&t)
};
match result {
Ok(t) => {
let maybe_json = if pretty_print {
serde_json::to_string_pretty(&t)
} else {
serde_json::to_string(&t)
};
match maybe_json {
Ok(json_string) => println!("{}", json_string),
Err(e) => log::error!("Failed to serialize JSON: {e:?}")
}
}
Err(e) => log::error!("{e:?}")
}
match maybe_json {
Ok(json_string) => println!("{}", json_string),
Err(e) => log::error!("Failed to serialize JSON: {e:?}"),
}
}
Err(e) => log::error!("{e:?}"),
}
}
pub async fn wvr_display_create(
state: &mut WayVRClientState,
width: u16,
height: u16,
name: String,
scale: Option<f32>,
attach_to: packet_client::AttachTo,
state: &mut WayVRClientState,
width: u16,
height: u16,
name: String,
scale: Option<f32>,
attach_to: packet_client::AttachTo,
) {
handle_result(state.pretty_print,
WayVRClient::fn_wvr_display_create(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
packet_client::WvrDisplayCreateParams {
width,
height,
name,
scale,
attach_to,
},
)
.await.context("failed to create display")
);
handle_result(
state.pretty_print,
WayVRClient::fn_wvr_display_create(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
packet_client::WvrDisplayCreateParams {
width,
height,
name,
scale,
attach_to,
},
)
.await
.context("failed to create display"),
);
}
pub async fn wvr_display_list(
state: &mut WayVRClientState,
) {
handle_result(state.pretty_print,
WayVRClient::fn_wvr_display_list(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
)
.await.context("failed to fetch displays")
);
pub async fn wvr_display_list(state: &mut WayVRClientState) {
handle_result(
state.pretty_print,
WayVRClient::fn_wvr_display_list(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
)
.await
.context("failed to fetch displays"),
);
}
pub async fn wvr_display_get(
state: &mut WayVRClientState,
handle: packet_server::WvrDisplayHandle,
state: &mut WayVRClientState,
handle: packet_server::WvrDisplayHandle,
) {
handle_result(state.pretty_print,
WayVRClient::fn_wvr_display_get(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
handle,
)
.await.context("failed to fetch display")
);
handle_result(
state.pretty_print,
WayVRClient::fn_wvr_display_get(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
handle,
)
.await
.context("failed to fetch display"),
);
}
pub async fn wvr_display_window_list(
state: &mut WayVRClientState,
handle: packet_server::WvrDisplayHandle,
state: &mut WayVRClientState,
handle: packet_server::WvrDisplayHandle,
) {
handle_result(state.pretty_print,
WayVRClient::fn_wvr_display_window_list(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
handle,
)
.await.context("failed to list window displays")
);
handle_result(
state.pretty_print,
WayVRClient::fn_wvr_display_window_list(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
handle,
)
.await
.context("failed to list window displays"),
);
}
pub async fn wvr_display_remove(
state: &mut WayVRClientState,
handle: packet_server::WvrDisplayHandle,
state: &mut WayVRClientState,
handle: packet_server::WvrDisplayHandle,
) {
handle_result(state.pretty_print,
WayVRClient::fn_wvr_display_remove(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
handle,
)
.await.context("failed to remove display")
);
handle_result(
state.pretty_print,
WayVRClient::fn_wvr_display_remove(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
handle,
)
.await
.context("failed to remove display"),
);
}
pub async fn wvr_display_set_visible(
state: &mut WayVRClientState,
handle: packet_server::WvrDisplayHandle,
visible: bool,
state: &mut WayVRClientState,
handle: packet_server::WvrDisplayHandle,
visible: bool,
) {
handle_empty_result(
WayVRClient::fn_wvr_display_set_visible(state.wayvr_client.clone(), handle, visible).await.context("failed to set display visibility"),
)
handle_empty_result(
WayVRClient::fn_wvr_display_set_visible(state.wayvr_client.clone(), handle, visible)
.await
.context("failed to set display visibility"),
)
}
pub async fn wvr_window_set_visible(
state: &mut WayVRClientState,
handle: packet_server::WvrWindowHandle,
visible: bool,
state: &mut WayVRClientState,
handle: packet_server::WvrWindowHandle,
visible: bool,
) {
handle_empty_result(
WayVRClient::fn_wvr_window_set_visible(state.wayvr_client.clone(), handle, visible).await.context("failed to set window visibility"),
)
handle_empty_result(
WayVRClient::fn_wvr_window_set_visible(state.wayvr_client.clone(), handle, visible)
.await
.context("failed to set window visibility"),
)
}
pub async fn wvr_process_get(
state: &mut WayVRClientState,
handle: packet_server::WvrProcessHandle,
state: &mut WayVRClientState,
handle: packet_server::WvrProcessHandle,
) {
handle_result(state.pretty_print,
WayVRClient::fn_wvr_process_get(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
handle,
)
.await.context("failed to get process"),
);
handle_result(
state.pretty_print,
WayVRClient::fn_wvr_process_get(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
handle,
)
.await
.context("failed to get process"),
);
}
pub async fn wvr_process_list(
state: &mut WayVRClientState,
) {
handle_result(state.pretty_print,
WayVRClient::fn_wvr_process_list(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
)
.await.context("failed to list processes"),
)
pub async fn wvr_process_list(state: &mut WayVRClientState) {
handle_result(
state.pretty_print,
WayVRClient::fn_wvr_process_list(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
)
.await
.context("failed to list processes"),
)
}
pub async fn wvr_process_terminate(
state: &mut WayVRClientState,
handle: packet_server::WvrProcessHandle,
state: &mut WayVRClientState,
handle: packet_server::WvrProcessHandle,
) {
handle_empty_result(
WayVRClient::fn_wvr_process_terminate(state.wayvr_client.clone(), handle).await.context("failed to terminate process"),
)
handle_empty_result(
WayVRClient::fn_wvr_process_terminate(state.wayvr_client.clone(), handle)
.await
.context("failed to terminate process"),
)
}
pub async fn wvr_process_launch(
state: &mut WayVRClientState,
exec: String,
name: String,
env: Vec<String>,
target_display: packet_server::WvrDisplayHandle,
args: String,
userdata: HashMap<String, String>,
state: &mut WayVRClientState,
exec: String,
name: String,
env: Vec<String>,
target_display: packet_server::WvrDisplayHandle,
args: String,
userdata: HashMap<String, String>,
) {
handle_result(state.pretty_print,
WayVRClient::fn_wvr_process_launch(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
packet_client::WvrProcessLaunchParams {
env,
exec,
name,
target_display,
args,
userdata,
},
)
.await.context("failed to launch process"),
)
handle_result(
state.pretty_print,
WayVRClient::fn_wvr_process_launch(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
packet_client::WvrProcessLaunchParams {
env,
exec,
name,
target_display,
args,
userdata,
},
)
.await
.context("failed to launch process"),
)
}
pub async fn wlx_haptics(
state: &mut WayVRClientState,
intensity: f32,
duration: f32,
frequency: f32,
state: &mut WayVRClientState,
intensity: f32,
duration: f32,
frequency: f32,
) {
handle_empty_result(
WayVRClient::fn_wlx_haptics(
state.wayvr_client.clone(),
packet_client::WlxHapticsParams {
intensity,
duration,
frequency,
},
)
.await.context("failed to trigger haptics"),
)
handle_empty_result(
WayVRClient::fn_wlx_haptics(
state.wayvr_client.clone(),
packet_client::WlxHapticsParams {
intensity,
duration,
frequency,
},
)
.await
.context("failed to trigger haptics"),
)
}
pub async fn wlx_panel_modify(
state: &mut WayVRClientState,
overlay: String,
element: String,
command: packet_client::WlxModifyPanelCommand,
state: &mut WayVRClientState,
overlay: String,
element: String,
command: packet_client::WlxModifyPanelCommand,
) {
handle_empty_result(
WayVRClient::fn_wlx_modify_panel(
state.wayvr_client.clone(),
packet_client::WlxModifyPanelParams {
overlay,
element,
command,
},
)
.await.context("failed to modify panel"),
)
handle_empty_result(
WayVRClient::fn_wlx_modify_panel(
state.wayvr_client.clone(),
packet_client::WlxModifyPanelParams {
overlay,
element,
command,
},
)
.await
.context("failed to modify panel"),
)
}
pub async fn wlx_input_state(
state: &mut WayVRClientState,
) {
handle_result(state.pretty_print,
WayVRClient::fn_wlx_input_state(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
)
.await.context("failed to get input state"),
)
pub async fn wlx_input_state(state: &mut WayVRClientState) {
handle_result(
state.pretty_print,
WayVRClient::fn_wlx_input_state(
state.wayvr_client.clone(),
state.serial_generator.increment_get(),
)
.await
.context("failed to get input state"),
)
}

201
wayvrctl/src/main.rs
View File

@@ -1,36 +1,47 @@
use std::{collections::HashMap, process::{self, ExitCode}, time::Duration};
use std::{
collections::HashMap,
process::{self, ExitCode},
time::Duration,
};
use anyhow::Context;
use clap::Parser;
use env_logger::Env;
use wayvr_ipc::{client::WayVRClient, ipc, packet_client, };
use wayvr_ipc::{client::WayVRClient, ipc, packet_client};
use crate::helper::{wlx_haptics, wlx_input_state, wlx_panel_modify, wvr_display_create, wvr_display_get, wvr_display_list, wvr_display_remove, wvr_display_set_visible, wvr_display_window_list, wvr_process_get, wvr_process_launch, wvr_process_list, wvr_process_terminate, wvr_window_set_visible, WayVRClientState};
use crate::helper::{
WayVRClientState, wlx_haptics, wlx_input_state, wlx_panel_modify, wvr_display_create,
wvr_display_get, wvr_display_list, wvr_display_remove, wvr_display_set_visible,
wvr_display_window_list, wvr_process_get, wvr_process_launch, wvr_process_list,
wvr_process_terminate, wvr_window_set_visible,
};
mod helper;
#[tokio::main(flavor = "current_thread")]
async fn main() -> ExitCode {
env_logger::init_from_env(Env::default().default_filter_or("info"));
let args = Args::parse();
let mut state = WayVRClientState {
wayvr_client : WayVRClient::new(&format!("wayvrctl-{}", process::id())).await.inspect_err(|e| {
log::error!("Failed to initialize WayVR connection: {e:?}");
process::exit(1);
}).unwrap(),
wayvr_client: WayVRClient::new(&format!("wayvrctl-{}", process::id()))
.await
.inspect_err(|e| {
log::error!("Failed to initialize WayVR connection: {e:?}");
process::exit(1);
})
.unwrap(),
serial_generator: ipc::SerialGenerator::new(),
pretty_print: args.pretty,
};
let maybe_err = if let Subcommands::Batch {fail_fast} = args.command {
let maybe_err = if let Subcommands::Batch { fail_fast } = args.command {
run_batch(&mut state, fail_fast).await
} else {
run_once(&mut state, args).await
};
};
if let Err(e) = maybe_err{
if let Err(e) = maybe_err {
log::error!("{e:?}");
return ExitCode::FAILURE;
} else {
@@ -50,30 +61,30 @@ async fn run_batch(state: &mut WayVRClientState, fail_fast: bool) -> anyhow::Res
continue;
}
if let Err(e) = parse_run_line(state, &line).await.with_context(|| format!("error on line {}", line_no + 1)) {
if let Err(e) = parse_run_line(state, &line)
.await
.with_context(|| format!("error on line {}", line_no + 1))
{
if fail_fast {
return Err(e)
return Err(e);
} else {
log::error!("{e:?}");
}
}
}
Ok(())
}
async fn parse_run_line(state: &mut WayVRClientState, line: &str) -> anyhow::Result<()> {
let mut argv = shell_words::split(&line)
.with_context(|| format!("parse error"))
?;
let mut argv = shell_words::split(&line).with_context(|| format!("parse error"))?;
// clap expects argv[0] to be the binary name
argv.insert(0, env!("CARGO_PKG_NAME").to_string());
// clap expects argv[0] to be the binary name
argv.insert(0, env!("CARGO_PKG_NAME").to_string());
let args = Args::try_parse_from(argv).with_context(|| format!("invalid arguments"))?;
run_once(state, args).await?;
let args = Args::try_parse_from(argv).with_context(|| format!("invalid arguments"))?;
run_once(state, args).await?;
Ok(())
Ok(())
}
async fn run_once(state: &mut WayVRClientState, args: Args) -> anyhow::Result<()> {
@@ -84,8 +95,21 @@ async fn run_once(state: &mut WayVRClientState, args: Args) -> anyhow::Result<()
Subcommands::InputState => {
wlx_input_state(state).await;
}
Subcommands::DisplayCreate { width, height, name, scale } => {
wvr_display_create(state, width, height, name, scale, packet_client::AttachTo::None).await;
Subcommands::DisplayCreate {
width,
height,
name,
scale,
} => {
wvr_display_create(
state,
width,
height,
name,
scale,
packet_client::AttachTo::None,
)
.await;
}
Subcommands::DisplayList => {
wvr_display_list(state).await;
@@ -102,11 +126,17 @@ async fn run_once(state: &mut WayVRClientState, args: Args) -> anyhow::Result<()
let handle = serde_json::from_str(&handle).context("Invalid handle")?;
wvr_display_remove(state, handle).await;
}
Subcommands::DisplaySetVisible { handle, visible_0_or_1 } => {
Subcommands::DisplaySetVisible {
handle,
visible_0_or_1,
} => {
let handle = serde_json::from_str(&handle).context("Invalid handle")?;
wvr_display_set_visible(state, handle, visible_0_or_1 != 0).await;
}
Subcommands::WindowSetVisible { handle, visible_0_or_1 } => {
Subcommands::WindowSetVisible {
handle,
visible_0_or_1,
} => {
let handle = serde_json::from_str(&handle).context("Invalid handle")?;
wvr_window_set_visible(state, handle, visible_0_or_1 != 0).await;
}
@@ -121,29 +151,52 @@ async fn run_once(state: &mut WayVRClientState, args: Args) -> anyhow::Result<()
let handle = serde_json::from_str(&handle).context("Invalid handle")?;
wvr_process_terminate(state, handle).await;
}
Subcommands::ProcessLaunch { exec, name, env, target_display, args } => {
Subcommands::ProcessLaunch {
exec,
name,
env,
target_display,
args,
} => {
let handle = serde_json::from_str(&target_display).context("Invalid target_display")?;
wvr_process_launch(state, exec, name, env, handle, args, HashMap::new()).await;
}
Subcommands::Haptics { intensity, duration, frequency } => {
Subcommands::Haptics {
intensity,
duration,
frequency,
} => {
wlx_haptics(state, intensity, duration, frequency).await;
}
Subcommands::PanelModify { overlay, element, command } => {
Subcommands::PanelModify {
overlay,
element,
command,
} => {
let command = match command {
SubcommandPanelModify::SetText { text } => packet_client::WlxModifyPanelCommand::SetText(text),
SubcommandPanelModify::SetColor { hex_color } => packet_client::WlxModifyPanelCommand::SetColor(hex_color),
SubcommandPanelModify::SetImage { absolute_path } => packet_client::WlxModifyPanelCommand::SetImage(absolute_path),
SubcommandPanelModify::SetVisible { visible_0_or_1 } => packet_client::WlxModifyPanelCommand::SetVisible(visible_0_or_1 != 0),
SubcommandPanelModify::SetStickyState { sticky_state_0_or_1 } => packet_client::WlxModifyPanelCommand::SetStickyState(sticky_state_0_or_1 != 0),
SubcommandPanelModify::SetText { text } => {
packet_client::WlxModifyPanelCommand::SetText(text)
}
SubcommandPanelModify::SetColor { hex_color } => {
packet_client::WlxModifyPanelCommand::SetColor(hex_color)
}
SubcommandPanelModify::SetImage { absolute_path } => {
packet_client::WlxModifyPanelCommand::SetImage(absolute_path)
}
SubcommandPanelModify::SetVisible { visible_0_or_1 } => {
packet_client::WlxModifyPanelCommand::SetVisible(visible_0_or_1 != 0)
}
SubcommandPanelModify::SetStickyState {
sticky_state_0_or_1,
} => packet_client::WlxModifyPanelCommand::SetStickyState(sticky_state_0_or_1 != 0),
};
wlx_panel_modify(state, overlay, element, command).await;
}
}
Ok(())
}
/// A command-line interface for WayVR IPC
#[derive(clap::Parser, Debug)]
#[command(version, about, long_about = None)]
@@ -161,96 +214,92 @@ struct Args {
enum Subcommands {
/// Read commands from stdout, one per line.
Batch {
/// Stop on the first error
#[arg(short, long)]
fail_fast: bool,
/// Stop on the first error
#[arg(short, long)]
fail_fast: bool,
},
/// Get the positions of HMD & controllers
InputState,
/// Create a new WayVR display
DisplayCreate{
width: u16,
height: u16,
name: String,
DisplayCreate {
width: u16,
height: u16,
name: String,
#[arg(short, long)]
scale: Option<f32>,
//attach_to: packet_client::AttachTo,
scale: Option<f32>,
//attach_to: packet_client::AttachTo,
},
/// List WayVR displays
DisplayList,
/// Retrieve information about a single WayVR display
DisplayGet {
/// A display handle JSON returned by DisplayList or DisplayCreate
handle: String,
handle: String,
},
/// List windows attached to a WayVR display
DisplayWindowList {
/// A display handle JSON returned by DisplayList or DisplayCreate
handle: String,
handle: String,
},
/// Delete a WayVR display
DisplayRemove {
/// A display handle JSON returned by DisplayList or DisplayCreate
handle: String,
handle: String,
},
/// Change the visibility of a WayVR display
DisplaySetVisible {
/// A display handle JSON returned by DisplayList or DisplayCreate
handle: String,
visible_0_or_1: u8,
handle: String,
visible_0_or_1: u8,
},
// DisplaySetLayout skipped
/// Change the visibility of a window on a WayVR display
WindowSetVisible {
/// A JSON window handle returned by DisplayWindowList
handle: String,
visible_0_or_1: u8,
handle: String,
visible_0_or_1: u8,
},
/// Retrieve information about a WayVR-managed process
ProcessGet {
/// A JSON process handle returned by ProcessList or ProcessLaunch
handle: String,
/// A JSON process handle returned by ProcessList or ProcessLaunch
handle: String,
},
/// List all processes managed by WayVR
ProcessList,
/// Terminate a WayVR-managed process
ProcessTerminate {
/// A JSON process handle returned by ProcessList or ProcessLaunch
handle: String,
handle: String,
},
/// Launch a new process inside WayVR
ProcessLaunch {
exec: String,
name: String,
env: Vec<String>,
exec: String,
name: String,
env: Vec<String>,
/// A display handle JSON returned by DisplayList or DisplayCreate
target_display: String,
args: String,
target_display: String,
args: String,
},
/// Trigger haptics on the user's controller
Haptics {
#[arg(short, long, default_value = "0.25")]
intensity: f32,
#[arg(short, long , default_value = "0.1")]
duration: f32,
intensity: f32,
#[arg(short, long, default_value = "0.1")]
frequency: f32,
duration: f32,
#[arg(short, long, default_value = "0.1")]
frequency: f32,
},
/// Apply a modification to a panel element
PanelModify {
/// The name of the overlay (XML file name without extension)
overlay: String,
overlay: String,
/// The id of the element to modify, as set in the XML
element: String,
element: String,
/// Command to execute
#[command(subcommand)]
command: SubcommandPanelModify,
}
command: SubcommandPanelModify,
},
}
#[derive(clap::Parser, Debug)]
@@ -271,11 +320,7 @@ enum SubcommandPanelModify {
absolute_path: String,
},
/// Set the visibility of a <div>, <rectangle>, <label>, <sprite> or <image>
SetVisible {
visible_0_or_1: u8,
},
SetVisible { visible_0_or_1: u8 },
/// Set the sticky state of a <Button>. Intended for buttons without `sticky="1"`.
SetStickyState {
sticky_state_0_or_1: u8,
}
SetStickyState { sticky_state_0_or_1: u8 },
}

9
wgui/src/components/button.rs
View File

@@ -1,25 +1,24 @@
use crate::{
animation::{Animation, AnimationEasing},
assets::AssetPath,
components::{self, tooltip::ComponentTooltip, Component, ComponentBase, ComponentTrait, RefreshData},
components::{self, Component, ComponentBase, ComponentTrait, RefreshData, tooltip::ComponentTooltip},
drawing::{self, Boundary, Color},
event::{CallbackDataCommon, EventListenerCollection, EventListenerID, EventListenerKind},
i18n::Translation,
layout::{LayoutTask, WidgetID, WidgetPair},
renderer_vk::{
text::{
custom_glyph::{CustomGlyphContent, CustomGlyphData},
FontWeight, TextStyle,
custom_glyph::{CustomGlyphContent, CustomGlyphData},
},
util::centered_matrix,
},
widget::{
self,
self, ConstructEssentials, EventResult, WidgetData,
label::{WidgetLabel, WidgetLabelParams},
rectangle::{WidgetRectangle, WidgetRectangleParams},
sprite::{WidgetSprite, WidgetSpriteParams},
util::WLength,
ConstructEssentials, EventResult, WidgetData,
},
};
use glam::{Mat4, Vec3};
@@ -28,7 +27,7 @@ use std::{
rc::Rc,
time::{Duration, Instant},
};
use taffy::{prelude::length, AlignItems, JustifyContent};
use taffy::{AlignItems, JustifyContent, prelude::length};
pub struct Params<'a> {
pub text: Option<Translation>, // if unset, label will not be populated

4
wgui/src/components/checkbox.rs
View File

@@ -1,7 +1,7 @@
use std::{cell::RefCell, rc::Rc};
use taffy::{
prelude::{length, percent},
AlignItems,
prelude::{length, percent},
};
use crate::{
@@ -13,10 +13,10 @@ use crate::{
layout::{self, WidgetID, WidgetPair},
renderer_vk::text::{FontWeight, TextStyle},
widget::{
ConstructEssentials, EventResult,
label::{WidgetLabel, WidgetLabelParams},
rectangle::{WidgetRectangle, WidgetRectangleParams},
util::WLength,
ConstructEssentials, EventResult,
},
};

2
wgui/src/components/slider.rs
View File

@@ -18,11 +18,11 @@ use crate::{
util,
},
widget::{
ConstructEssentials, EventResult,
div::WidgetDiv,
label::{WidgetLabel, WidgetLabelParams},
rectangle::{WidgetRectangle, WidgetRectangleParams},
util::WLength,
ConstructEssentials, EventResult,
},
};

2
wgui/src/drawing.rs
View File

@@ -10,8 +10,8 @@ use crate::{
globals::Globals,
layout::Widget,
renderer_vk::text::{
custom_glyph::{CustomGlyph, CustomGlyphData},
TextShadow,
custom_glyph::{CustomGlyph, CustomGlyphData},
},
stack::{self, ScissorBoundary, ScissorStack, TransformStack},
widget::{self, ScrollbarInfo, WidgetState},

6
wgui/src/parser/component_button.rs
View File

@@ -1,13 +1,13 @@
use crate::{
assets::AssetPath,
components::{button, tooltip, Component},
components::{Component, button, tooltip},
drawing::Color,
i18n::Translation,
layout::WidgetID,
parser::{
parse_check_f32, parse_check_i32, parse_children, parse_f32, print_invalid_attrib, process_component,
AttribPair, ParserContext, ParserFile, parse_check_f32, parse_check_i32, parse_children, parse_f32,
print_invalid_attrib, process_component,
style::{parse_color_opt, parse_round, parse_style, parse_text_style},
AttribPair, ParserContext, ParserFile,
},
widget::util::WLength,
};

2
wgui/src/parser/mod.rs
View File

@@ -9,7 +9,7 @@ mod widget_rectangle;
mod widget_sprite;
use crate::{
assets::{normalize_path, AssetPath, AssetPathOwned},
assets::{AssetPath, AssetPathOwned, normalize_path},
components::{Component, ComponentWeak},
drawing::{self},
globals::WguiGlobals,

4
wgui/src/parser/style.rs
View File

@@ -6,8 +6,8 @@ use taffy::{
use crate::{
drawing,
parser::{
is_percent, parse_color_hex, parse_f32, parse_percent, parse_size_unit, parse_val, print_invalid_attrib,
print_invalid_value, AttribPair,
AttribPair, is_percent, parse_color_hex, parse_f32, parse_percent, parse_size_unit, parse_val,
print_invalid_attrib, print_invalid_value,
},
renderer_vk::text::{FontWeight, HorizontalAlign, TextStyle},
widget::util::WLength,

3
wgui/src/parser/widget_image.rs
View File

@@ -2,9 +2,8 @@ use crate::{
assets::AssetPath,
layout::WidgetID,
parser::{
parse_children, parse_widget_universal, print_invalid_attrib,
AttribPair, ParserContext, ParserFile, parse_children, parse_widget_universal, print_invalid_attrib,
style::{parse_color, parse_round, parse_style},
AttribPair, ParserContext, ParserFile,
},
renderer_vk::text::custom_glyph::{CustomGlyphContent, CustomGlyphData},
widget::image::{WidgetImage, WidgetImageParams},

3
wgui/src/parser/widget_rectangle.rs
View File

@@ -2,9 +2,8 @@ use crate::{
drawing::GradientMode,
layout::WidgetID,
parser::{
parse_children, parse_widget_universal, print_invalid_attrib,
AttribPair, ParserContext, ParserFile, parse_children, parse_widget_universal, print_invalid_attrib,
style::{parse_color, parse_round, parse_style},
AttribPair, ParserContext, ParserFile,
},
widget::rectangle::{WidgetRectangle, WidgetRectangleParams},
};

2
wgui/src/parser/widget_sprite.rs
View File

@@ -1,7 +1,7 @@
use crate::{
assets::AssetPath,
layout::WidgetID,
parser::{parse_children, parse_widget_universal, style::parse_style, AttribPair, ParserContext, ParserFile},
parser::{AttribPair, ParserContext, ParserFile, parse_children, parse_widget_universal, style::parse_style},
renderer_vk::text::custom_glyph::{CustomGlyphContent, CustomGlyphData},
widget::sprite::{WidgetSprite, WidgetSpriteParams},
};

6
wgui/src/renderer_vk/context.rs
View File

@@ -2,22 +2,22 @@ use std::{cell::RefCell, rc::Rc, sync::Arc};
use cosmic_text::Buffer;
use glam::{Mat4, Vec2, Vec3};
use slotmap::{new_key_type, SlotMap};
use slotmap::{SlotMap, new_key_type};
use vulkano::pipeline::graphics::viewport;
use crate::{
drawing::{self},
font_config,
gfx::{cmd::GfxCommandBuffer, WGfx},
gfx::{WGfx, cmd::GfxCommandBuffer},
renderer_vk::image::{ImagePipeline, ImageRenderer},
};
use super::{
rect::{RectPipeline, RectRenderer},
text::{
DEFAULT_METRICS, SWASH_CACHE, TextArea, TextBounds,
text_atlas::{TextAtlas, TextPipeline},
text_renderer::TextRenderer,
TextArea, TextBounds, DEFAULT_METRICS, SWASH_CACHE,
},
viewport::Viewport,
};

2
wgui/src/renderer_vk/image.rs
View File

@@ -14,10 +14,10 @@ use vulkano::{
use crate::{
drawing::{Boundary, ImagePrimitive},
gfx::{
BLEND_ALPHA, WGfx,
cmd::GfxCommandBuffer,
pass::WGfxPass,
pipeline::{WGfxPipeline, WPipelineCreateInfo},
WGfx, BLEND_ALPHA,
},
renderer_vk::{
model_buffer::ModelBuffer,

2
wgui/src/renderer_vk/rect.rs
View File

@@ -10,10 +10,10 @@ use vulkano::{
use crate::{
drawing::{Boundary, Rectangle},
gfx::{
BLEND_ALPHA, WGfx,
cmd::GfxCommandBuffer,
pass::WGfxPass,
pipeline::{WGfxPipeline, WPipelineCreateInfo},
WGfx, BLEND_ALPHA,
},
renderer_vk::model_buffer::ModelBuffer,
};

2
wgui/src/renderer_vk/text/custom_glyph.rs
View File

@@ -1,8 +1,8 @@
use std::{
f32,
sync::{
atomic::{AtomicUsize, Ordering},
Arc,
atomic::{AtomicUsize, Ordering},
},
};

2
wgui/src/widget/image.rs
View File

@@ -8,7 +8,7 @@ use crate::{
globals::Globals,
layout::WidgetID,
renderer_vk::text::custom_glyph::CustomGlyphData,
widget::{util::WLength, WidgetStateFlags},
widget::{WidgetStateFlags, util::WLength},
};
use super::{WidgetObj, WidgetState};

6
wgui/src/widget/mod.rs
View File

@@ -206,11 +206,7 @@ impl EventResult {
#[must_use]
pub fn merge(self, other: Self) -> Self {
if self > other {
self
} else {
other
}
if self > other { self } else { other }
}
}

2
wgui/src/widget/rectangle.rs
View File

@@ -4,7 +4,7 @@ use crate::{
drawing::{self, GradientMode, PrimitiveExtent},
event::CallbackDataCommon,
layout::WidgetID,
widget::{util::WLength, WidgetStateFlags},
widget::{WidgetStateFlags, util::WLength},
};
use super::{WidgetObj, WidgetState};

2
wgui/src/widget/sprite.rs
View File

@@ -9,8 +9,8 @@ use crate::{
globals::Globals,
layout::WidgetID,
renderer_vk::text::{
custom_glyph::{CustomGlyph, CustomGlyphData},
DEFAULT_METRICS,
custom_glyph::{CustomGlyph, CustomGlyphData},
},
widget::WidgetStateFlags,
};

1
wlx-overlay-s/src/gui/panel/mod.rs
View File

@@ -33,7 +33,6 @@ use crate::{
use super::timer::GuiTimer;
pub mod button;
mod helper;
mod label;
const DEFAULT_MAX_SIZE: f32 = 2048.0;