kossLAN/wry
1
0
Fork 0
forked from wry/wry
Code Pull requests Activity

autocommit 2022-02-15 22:53:12 CET

Browse source
This commit is contained in:
Julian Orth 2022-02-15 22:53:12 +01:00
parent 290225190a
commit cacd49d15a
33 changed files with 884 additions and 220 deletions
Download patch file Download diff file Expand all files Collapse all files

186
src/config/handler.rs
View file

@ -1,16 +1,3 @@
use std::cell::{Cell};
use std::rc::Rc;
use bincode::error::DecodeError;
use libloading::Library;
use log::Level;
use thiserror::Error;
use i4config::_private::bincode_ops;
use i4config::_private::ipc::{Request, Response};
use i4config::keyboard::keymap::Keymap;
use i4config::{Axis, Direction, InputDevice, Keyboard, LogLevel, Mouse, Seat};
use i4config::keyboard::mods::Modifiers;
use i4config::keyboard::syms::KeySym;
use crate::{ErrorFmt, NumCell, State};
use crate::backend::{KeyboardId, MouseId};
use crate::ifs::wl_seat::WlSeatGlobal;
use crate::state::DeviceHandlerData;
@ -19,6 +6,19 @@ use crate::utils::copyhashmap::CopyHashMap;
use crate::utils::debug_fn::debug_fn;
use crate::utils::stack::Stack;
use crate::xkbcommon::XkbKeymap;
use crate::{ErrorFmt, NumCell, State};
use bincode::error::DecodeError;
use i4config::_private::bincode_ops;
use i4config::_private::ipc::{ClientMessage, Response, ServerMessage};
use i4config::keyboard::keymap::Keymap;
use i4config::keyboard::mods::Modifiers;
use i4config::keyboard::syms::KeySym;
use i4config::{Axis, Direction, InputDevice, Keyboard, LogLevel, Mouse, Seat};
use libloading::Library;
use log::Level;
use std::cell::Cell;
use std::rc::Rc;
use thiserror::Error;
pub(super) struct ConfigProxyHandler {
pub client_data: Cell<*const u8>,
@ -34,7 +34,7 @@ pub(super) struct ConfigProxyHandler {
}
impl ConfigProxyHandler {
pub fn send(&self, msg: &Request) {
pub fn send(&self, msg: &ServerMessage) {
let mut buf = self.bufs.pop().unwrap_or_default();
buf.clear();
bincode::encode_into_std_write(msg, &mut buf, bincode_ops()).unwrap();
@ -48,7 +48,13 @@ impl ConfigProxyHandler {
self.next_id.fetch_add(1)
}
fn handle_log_request(&self, level: LogLevel, msg: &str, file: Option<&str>, line: Option<u32>) -> Result<(), LogError> {
fn handle_log_request(
&self,
level: LogLevel,
msg: &str,
file: Option<&str>,
line: Option<u32>,
) -> Result<(), LogError> {
let level = match level {
LogLevel::Error => Level::Error,
LogLevel::Warn => Level::Warn,
@ -75,10 +81,10 @@ impl ConfigProxyHandler {
let global_name = self.state.globals.name();
let seat = WlSeatGlobal::new(global_name, name, &self.state);
self.state.globals.add_global(&self.state, &seat);
self.send(&Request::Response {
self.send(&ServerMessage::Response {
response: Response::CreateSeat {
seat: Seat(seat.id().raw() as _),
}
},
});
Ok(())
}
@ -90,11 +96,11 @@ impl ConfigProxyHandler {
self.keymaps.set(id, keymap);
(id, Ok(()))
}
_ => {
(Keymap::INVALID, Err(ParseKeymapError::ParsingFailed))
}
_ => (Keymap::INVALID, Err(ParseKeymapError::ParsingFailed)),
};
self.send(&Request::Response { response: Response::ParseKeymap { keymap } });
self.send(&ServerMessage::Response {
response: Response::ParseKeymap { keymap },
});
res
}
@ -118,16 +124,18 @@ impl ConfigProxyHandler {
fn handle_get_repeat_rate(&self, seat: Seat) -> Result<(), SeatGetRepeatRateError> {
let seat = self.get_seat(seat)?;
let (rate, delay) = seat.get_rate();
self.send(&Request::Response {
response: Response::GetRepeatRate {
rate,
delay,
},
self.send(&ServerMessage::Response {
response: Response::GetRepeatRate { rate, delay },
});
Ok(())
}
fn handle_set_repeat_rate(&self, seat: Seat, rate: i32, delay: i32) -> Result<(), SeatSetRepeatRateError> {
fn handle_set_repeat_rate(
&self,
seat: Seat,
rate: i32,
delay: i32,
) -> Result<(), SeatSetRepeatRateError> {
let seat = self.get_seat(seat)?;
if rate < 0 {
return Err(SeatSetRepeatRateError::NegativeRate);
@ -139,14 +147,23 @@ impl ConfigProxyHandler {
Ok(())
}
fn get_device_handler_data(&self, device: InputDevice) -> Result<Rc<DeviceHandlerData>, CphError> {
fn get_device_handler_data(
&self,
device: InputDevice,
) -> Result<Rc<DeviceHandlerData>, CphError> {
let data = match device {
InputDevice::Keyboard(kb) => {
self.state.kb_handlers.borrow_mut().get(&KeyboardId::from_raw(kb.0 as _)).map(|d| d.data.clone())
},
InputDevice::Mouse(mouse) => {
self.state.mouse_handlers.borrow_mut().get(&MouseId::from_raw(mouse.0 as _)).map(|d| d.data.clone())
}
InputDevice::Keyboard(kb) => self
.state
.kb_handlers
.borrow_mut()
.get(&KeyboardId::from_raw(kb.0 as _))
.map(|d| d.data.clone()),
InputDevice::Mouse(mouse) => self
.state
.mouse_handlers
.borrow_mut()
.get(&MouseId::from_raw(mouse.0 as _))
.map(|d| d.data.clone()),
};
match data {
Some(d) => Ok(d),
@ -184,10 +201,13 @@ impl ConfigProxyHandler {
fn handle_get_split(&self, seat: Seat) -> Result<(), GetSplitError> {
let seat = self.get_seat(seat)?;
self.send(&Request::Response {
self.send(&ServerMessage::Response {
response: Response::GetSplit {
axis: seat.get_split().unwrap_or(ContainerSplit::Horizontal).into(),
}
axis: seat
.get_split()
.unwrap_or(ContainerSplit::Horizontal)
.into(),
},
});
Ok(())
}
@ -198,14 +218,19 @@ impl ConfigProxyHandler {
Ok(())
}
fn handle_add_shortcut(&self, seat: Seat, mods: Modifiers, sym: KeySym) -> Result<(), AddShortcutError> {
fn handle_add_shortcut(
&self,
seat: Seat,
mods: Modifiers,
sym: KeySym,
) -> Result<(), AddShortcutError> {
let seat = self.get_seat(seat)?;
seat.add_shortcut(mods, sym);
Ok(())
}
fn handle_get_input_devices(&self) -> Result<(), GetInputDevicesError> {
let mut res = vec!();
let mut res = vec![];
{
let devs = self.state.kb_handlers.borrow_mut();
for dev in devs.values() {
@ -218,7 +243,7 @@ impl ConfigProxyHandler {
res.push(InputDevice::Mouse(Mouse(dev.id.raw() as _)));
}
}
self.send(&Request::Response {
self.send(&ServerMessage::Response {
response: Response::GetInputDevices { devices: res },
});
Ok(())
@ -232,12 +257,21 @@ impl ConfigProxyHandler {
.map(|seat| Seat::from_raw(seat.id().raw() as _))
.collect()
};
self.send(&Request::Response {
self.send(&ServerMessage::Response {
response: Response::GetSeats { seats },
});
Ok(())
}
fn handle_run(&self, prog: &str, args: Vec<String>, env: Vec<(String, String)>) -> Result<(), RunError> {
let forker = match self.state.forker.get() {
Some(f) => f,
_ => return Err(RunError::NoForker),
};
forker.spawn(prog.to_string(), args, env);
Ok(())
}
pub fn handle_request(&self, msg: &[u8]) {
if let Err(e) = self.handle_request_(msg) {
log::error!("Could not handle client request: {}", ErrorFmt(e));
@ -245,36 +279,40 @@ impl ConfigProxyHandler {
}
fn handle_request_(&self, msg: &[u8]) -> Result<(), CphError> {
let (request, _) = match bincode::decode_from_slice::<Request, _>(msg, bincode_ops()) {
let (request, _) = match bincode::decode_from_slice::<ClientMessage, _>(msg, bincode_ops())
{
Ok(msg) => msg,
Err(e) => return Err(CphError::ParsingFailed(e)),
};
match request {
Request::Log {
ClientMessage::Log {
level,
msg,
file,
line,
} => self.handle_log_request(level, msg, file, line)?,
Request::CreateSeat { name } => self.handle_create_seat(name)?,
Request::ParseKeymap { keymap } => self.handle_parse_keymap(keymap)?,
Request::SeatSetKeymap { seat, keymap } => self.handle_set_keymap(seat, keymap)?,
Request::SeatGetRepeatRate { seat } => self.handle_get_repeat_rate(seat)?,
Request::SeatSetRepeatRate { seat, rate, delay } => self.handle_set_repeat_rate(seat, rate, delay)?,
Request::SetSeat { device, seat } => self.handle_set_seat(device, seat)?,
Request::GetSplit { seat } => self.handle_get_split(seat)?,
Request::SetSplit { seat, axis } => self.handle_set_split(seat, axis)?,
Request::AddShortcut {
seat,
mods,
sym,
} => self.handle_add_shortcut(seat, mods, sym)?,
Request::RemoveShortcut { .. } => {}
Request::Focus { seat, direction } => self.handle_focus(seat, direction)?,
Request::Move { seat, direction } => {}
Request::GetInputDevices => self.handle_get_input_devices()?,
Request::GetSeats => self.handle_get_seats()?,
m => return Err(CphError::UnexpectedMessage(format!("{:?}", m))),
ClientMessage::CreateSeat { name } => self.handle_create_seat(name)?,
ClientMessage::ParseKeymap { keymap } => self.handle_parse_keymap(keymap)?,
ClientMessage::SeatSetKeymap { seat, keymap } => {
self.handle_set_keymap(seat, keymap)?
}
ClientMessage::SeatGetRepeatRate { seat } => self.handle_get_repeat_rate(seat)?,
ClientMessage::SeatSetRepeatRate { seat, rate, delay } => {
self.handle_set_repeat_rate(seat, rate, delay)?
}
ClientMessage::SetSeat { device, seat } => self.handle_set_seat(device, seat)?,
ClientMessage::GetSplit { seat } => self.handle_get_split(seat)?,
ClientMessage::SetSplit { seat, axis } => self.handle_set_split(seat, axis)?,
ClientMessage::AddShortcut { seat, mods, sym } => {
self.handle_add_shortcut(seat, mods, sym)?
}
ClientMessage::RemoveShortcut { .. } => {}
ClientMessage::Focus { seat, direction } => self.handle_focus(seat, direction)?,
ClientMessage::Move { seat, direction } => {}
ClientMessage::GetInputDevices => self.handle_get_input_devices()?,
ClientMessage::GetSeats => self.handle_get_seats()?,
ClientMessage::RemoveSeat { .. } => {}
ClientMessage::Run { prog, args, env } => self.handle_run(prog, args, env)?,
}
Ok(())
}
@ -308,6 +346,8 @@ enum CphError {
SetSplitError(#[from] SetSplitError),
#[error("Could not process a `get_split` request")]
GetSplitError(#[from] GetSplitError),
#[error("Could not process a `run` request")]
RunError(#[from] RunError),
#[error("Device {0:?} does not exist")]
DeviceDoesNotExist(InputDevice),
#[error("Device {0:?} does not exist")]
@ -321,14 +361,10 @@ enum CphError {
}
#[derive(Debug, Error)]
enum LogError {
}
enum LogError {}
#[derive(Debug, Error)]
enum CreateSeatError {
}
enum CreateSeatError {}
#[derive(Debug, Error)]
enum ParseKeymapError {
@ -351,14 +387,10 @@ enum AddShortcutError {
efrom!(AddShortcutError, CphError);
#[derive(Debug, Error)]
enum GetInputDevicesError {
}
enum GetInputDevicesError {}
#[derive(Debug, Error)]
enum GetSeatsError {
}
enum GetSeatsError {}
#[derive(Debug, Error)]
enum SeatSetKeymapError {
@ -405,3 +437,9 @@ enum GetSplitError {
CphError(#[from] Box<CphError>),
}
efrom!(GetSplitError, CphError);
#[derive(Debug, Error)]
enum RunError {
#[error("The ol' forker is not available")]
NoForker,
}