TheLanc3/lan-mouse
1
0
Fork 0
mirror of https://github.com/feschber/lan-mouse.git synced 2026-04-01 01:20:55 +03:00
Code Issues Packages Projects Releases Wiki Activity

formatting

Browse Source
This commit is contained in:
Ferdinand Schober
2023-12-09 00:43:54 +01:00
parent 56e5f7a30d
commit 5a7e0cf89c
26 changed files with 881 additions and 497 deletions
Download Patch File Download Diff File Expand all files Collapse all files

213
src/backend/consumer/libei.rs
View File

@@ -1,13 +1,29 @@
use std::{os::{fd::{RawFd, FromRawFd}, unix::net::UnixStream}, collections::HashMap, time::{UNIX_EPOCH, SystemTime}, io};
use std::{
collections::HashMap,
io,
os::{
fd::{FromRawFd, RawFd},
unix::net::UnixStream,
},
time::{SystemTime, UNIX_EPOCH},
};
use anyhow::{anyhow, Result};
use futures::StreamExt;
use ashpd::desktop::remote_desktop::{RemoteDesktop, DeviceType};
use ashpd::desktop::remote_desktop::{DeviceType, RemoteDesktop};
use async_trait::async_trait;
use futures::StreamExt;
use reis::{ei::{self, handshake::ContextType, keyboard::KeyState, button::ButtonState}, tokio::EiEventStream, PendingRequestResult};
use reis::{
ei::{self, button::ButtonState, handshake::ContextType, keyboard::KeyState},
tokio::EiEventStream,
PendingRequestResult,
};
use crate::{consumer::EventConsumer, event::Event, client::{ClientHandle, ClientEvent}};
use crate::{
client::{ClientEvent, ClientHandle},
consumer::EventConsumer,
event::Event,
};
pub struct LibeiConsumer {
handshake: bool,
@@ -32,10 +48,17 @@ async fn get_ei_fd() -> Result<RawFd, ashpd::Error> {
let session = proxy.create_session().await?;
// I HATE EVERYTHING, THIS TOOK 8 HOURS OF DEBUGGING
proxy.select_devices(&session,
DeviceType::Pointer | DeviceType::Keyboard |DeviceType::Touchscreen).await?;
proxy
.select_devices(
&session,
DeviceType::Pointer | DeviceType::Keyboard | DeviceType::Touchscreen,
)
.await?;
proxy.start(&session, &ashpd::WindowIdentifier::default()).await?.response()?;
proxy
.start(&session, &ashpd::WindowIdentifier::default())
.await?
.response()?;
proxy.connect_to_eis(&session).await
}
@@ -59,7 +82,8 @@ impl LibeiConsumer {
let events = EiEventStream::new(context.clone())?;
return Ok(Self {
handshake: false,
context, events,
context,
events,
pointer: None,
button: None,
scroll: None,
@@ -72,32 +96,59 @@ impl LibeiConsumer {
capability_mask: 0,
sequence: 0,
serial: 0,
})
});
}
}
#[async_trait]
impl EventConsumer for LibeiConsumer {
async fn consume(&mut self, event: Event, _client_handle: ClientHandle) {
let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_micros() as u64;
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_micros() as u64;
match event {
Event::Pointer(p) => match p {
crate::event::PointerEvent::Motion { time:_, relative_x, relative_y } => {
if !self.has_pointer { return }
crate::event::PointerEvent::Motion {
time: _,
relative_x,
relative_y,
} => {
if !self.has_pointer {
return;
}
if let Some((d, p)) = self.pointer.as_mut() {
p.motion_relative(relative_x as f32, relative_y as f32);
d.frame(self.serial, now);
}
},
crate::event::PointerEvent::Button { time: _, button, state } => {
if !self.has_button { return }
}
crate::event::PointerEvent::Button {
time: _,
button,
state,
} => {
if !self.has_button {
return;
}
if let Some((d, b)) = self.button.as_mut() {
b.button(button, match state { 0 => ButtonState::Released, _ => ButtonState::Press });
b.button(
button,
match state {
0 => ButtonState::Released,
_ => ButtonState::Press,
},
);
d.frame(self.serial, now);
}
},
crate::event::PointerEvent::Axis { time: _, axis, value } => {
if !self.has_scroll { return }
}
crate::event::PointerEvent::Axis {
time: _,
axis,
value,
} => {
if !self.has_scroll {
return;
}
if let Some((d, s)) = self.scroll.as_mut() {
match axis {
0 => s.scroll(0., value as f32),
@@ -105,18 +156,30 @@ impl EventConsumer for LibeiConsumer {
}
d.frame(self.serial, now);
}
},
crate::event::PointerEvent::Frame { } => {},
}
crate::event::PointerEvent::Frame {} => {}
},
Event::Keyboard(k) => match k {
crate::event::KeyboardEvent::Key { time: _, key, state } => {
if !self.has_keyboard { return }
crate::event::KeyboardEvent::Key {
time: _,
key,
state,
} => {
if !self.has_keyboard {
return;
}
if let Some((d, k)) = &mut self.keyboard {
k.key(key, match state { 0 => KeyState::Released, _ => KeyState::Press });
k.key(
key,
match state {
0 => KeyState::Released,
_ => KeyState::Press,
},
);
d.frame(self.serial, now);
}
},
crate::event::KeyboardEvent::Modifiers { .. } => { },
}
crate::event::KeyboardEvent::Modifiers { .. } => {}
},
_ => {}
}
@@ -130,13 +193,17 @@ impl EventConsumer for LibeiConsumer {
};
let event = match event {
PendingRequestResult::Request(result) => result,
PendingRequestResult::ProtocolError(e) => return Err(anyhow!("libei protocol violation: {e}")),
PendingRequestResult::ProtocolError(e) => {
return Err(anyhow!("libei protocol violation: {e}"))
}
PendingRequestResult::InvalidObject(e) => return Err(anyhow!("invalid object {e}")),
};
match event {
ei::Event::Handshake(handshake, request) => match request {
ei::handshake::Event::HandshakeVersion { version } => {
if self.handshake { return Ok(()) }
if self.handshake {
return Ok(());
}
log::info!("libei version {}", version);
// sender means we are sending events _to_ the eis server
handshake.handshake_version(version); // FIXME
@@ -163,8 +230,8 @@ impl EventConsumer for LibeiConsumer {
connection.sync(1);
self.serial = serial;
}
_ => unreachable!()
}
_ => unreachable!(),
},
ei::Event::Connection(_connection, request) => match request {
ei::connection::Event::Seat { seat } => {
log::debug!("connected to seat: {seat:?}");
@@ -172,20 +239,45 @@ impl EventConsumer for LibeiConsumer {
ei::connection::Event::Ping { ping } => {
ping.done(0);
}
ei::connection::Event::Disconnected { last_serial: _, reason, explanation } => {
ei::connection::Event::Disconnected {
last_serial: _,
reason,
explanation,
} => {
log::debug!("ei - disconnected: reason: {reason:?}: {explanation}")
}
ei::connection::Event::InvalidObject { last_serial, invalid_id } => {
return Err(anyhow!("invalid object: id: {invalid_id}, serial: {last_serial}"));
ei::connection::Event::InvalidObject {
last_serial,
invalid_id,
} => {
return Err(anyhow!(
"invalid object: id: {invalid_id}, serial: {last_serial}"
));
}
_ => unreachable!()
}
_ => unreachable!(),
},
ei::Event::Device(device, request) => match request {
ei::device::Event::Destroyed { serial } => { log::debug!("device destroyed: {device:?} - serial: {serial}") },
ei::device::Event::Name { name } => {log::debug!("device name: {name}")},
ei::device::Event::DeviceType { device_type } => log::debug!("device type: {device_type:?}"),
ei::device::Event::Dimensions { width, height } => log::debug!("device dimensions: {width}x{height}"),
ei::device::Event::Region { offset_x, offset_y, width, hight, scale } => log::debug!("device region: {width}x{hight} @ ({offset_x},{offset_y}), scale: {scale}"),
ei::device::Event::Destroyed { serial } => {
log::debug!("device destroyed: {device:?} - serial: {serial}")
}
ei::device::Event::Name { name } => {
log::debug!("device name: {name}")
}
ei::device::Event::DeviceType { device_type } => {
log::debug!("device type: {device_type:?}")
}
ei::device::Event::Dimensions { width, height } => {
log::debug!("device dimensions: {width}x{height}")
}
ei::device::Event::Region {
offset_x,
offset_y,
width,
hight,
scale,
} => log::debug!(
"device region: {width}x{hight} @ ({offset_x},{offset_y}), scale: {scale}"
),
ei::device::Event::Interface { object } => {
log::debug!("device interface: {object:?}");
if object.interface().eq("ei_pointer") {
@@ -204,31 +296,31 @@ impl EventConsumer for LibeiConsumer {
}
ei::device::Event::Done => {
log::debug!("device: done {device:?}");
},
}
ei::device::Event::Resumed { serial } => {
self.serial = serial;
device.start_emulating(serial, self.sequence);
self.sequence += 1;
log::debug!("resumed: {device:?}");
if let Some((d,_)) = &mut self.pointer {
if let Some((d, _)) = &mut self.pointer {
if d == &device {
log::debug!("pointer resumed {serial}");
self.has_pointer = true;
}
}
if let Some((d,_)) = &mut self.button {
if let Some((d, _)) = &mut self.button {
if d == &device {
log::debug!("button resumed {serial}");
self.has_button = true;
}
}
if let Some((d,_)) = &mut self.scroll {
if let Some((d, _)) = &mut self.scroll {
if d == &device {
log::debug!("scroll resumed {serial}");
self.has_scroll = true;
}
}
if let Some((d,_)) = &mut self.keyboard {
if let Some((d, _)) = &mut self.keyboard {
if d == &device {
log::debug!("keyboard resumed {serial}");
self.has_keyboard = true;
@@ -239,38 +331,44 @@ impl EventConsumer for LibeiConsumer {
self.has_pointer = false;
self.has_button = false;
self.serial = serial;
},
ei::device::Event::StartEmulating { serial, sequence } => log::debug!("start emulating {serial}, {sequence}"),
ei::device::Event::StopEmulating { serial } => log::debug!("stop emulating {serial}"),
}
ei::device::Event::StartEmulating { serial, sequence } => {
log::debug!("start emulating {serial}, {sequence}")
}
ei::device::Event::StopEmulating { serial } => {
log::debug!("stop emulating {serial}")
}
ei::device::Event::Frame { serial, timestamp } => {
log::debug!("frame: {serial}, {timestamp}");
}
ei::device::Event::RegionMappingId { mapping_id } => log::debug!("RegionMappingId {mapping_id}"),
ei::device::Event::RegionMappingId { mapping_id } => {
log::debug!("RegionMappingId {mapping_id}")
}
e => log::debug!("invalid event: {e:?}"),
}
},
ei::Event::Seat(seat, request) => match request {
ei::seat::Event::Destroyed { serial } => {
self.serial = serial;
log::debug!("seat destroyed: {seat:?}");
},
}
ei::seat::Event::Name { name } => {
log::debug!("seat name: {name}");
},
}
ei::seat::Event::Capability { mask, interface } => {
log::debug!("seat capabilities: {mask}, interface: {interface:?}");
self.capabilities.insert(interface, mask);
self.capability_mask |= mask;
},
}
ei::seat::Event::Done => {
log::debug!("seat done");
log::debug!("binding capabilities: {}", self.capability_mask);
seat.bind(self.capability_mask);
},
}
ei::seat::Event::Device { device } => {
log::debug!("seat: new device - {device:?}");
},
}
_ => todo!(),
}
},
e => log::debug!("unhandled event: {e:?}"),
}
self.context.flush()?;
@@ -281,4 +379,3 @@ impl EventConsumer for LibeiConsumer {
async fn destroy(&mut self) {}
}

73
src/backend/consumer/windows.rs
View File

@@ -1,16 +1,15 @@
use crate::{
consumer::EventConsumer,
event::{KeyboardEvent, PointerEvent},
};
use async_trait::async_trait;
use crate::{event::{KeyboardEvent, PointerEvent}, consumer::EventConsumer};
use winapi::{
self,
um::winuser::{INPUT, INPUT_MOUSE, LPINPUT, MOUSEEVENTF_MOVE, MOUSEINPUT,
MOUSEEVENTF_LEFTDOWN,
MOUSEEVENTF_RIGHTDOWN,
MOUSEEVENTF_MIDDLEDOWN,
MOUSEEVENTF_LEFTUP,
MOUSEEVENTF_RIGHTUP,
MOUSEEVENTF_MIDDLEUP,
MOUSEEVENTF_WHEEL,
MOUSEEVENTF_HWHEEL, INPUT_KEYBOARD, KEYBDINPUT, KEYEVENTF_SCANCODE, KEYEVENTF_KEYUP,
um::winuser::{
INPUT, INPUT_KEYBOARD, INPUT_MOUSE, KEYBDINPUT, KEYEVENTF_KEYUP, KEYEVENTF_SCANCODE,
LPINPUT, MOUSEEVENTF_HWHEEL, MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_LEFTUP,
MOUSEEVENTF_MIDDLEDOWN, MOUSEEVENTF_MIDDLEUP, MOUSEEVENTF_MOVE, MOUSEEVENTF_RIGHTDOWN,
MOUSEEVENTF_RIGHTUP, MOUSEEVENTF_WHEEL, MOUSEINPUT,
},
};
@@ -19,11 +18,12 @@ use crate::{
event::Event,
};
pub struct WindowsConsumer {}
impl WindowsConsumer {
pub fn new() -> Self { Self { } }
pub fn new() -> Self {
Self {}
}
}
#[async_trait]
@@ -38,12 +38,24 @@ impl EventConsumer for WindowsConsumer {
} => {
rel_mouse(relative_x as i32, relative_y as i32);
}
PointerEvent::Button { time:_, button, state } => { mouse_button(button, state)}
PointerEvent::Axis { time:_, axis, value } => { scroll(axis, value) }
PointerEvent::Button {
time: _,
button,
state,
} => mouse_button(button, state),
PointerEvent::Axis {
time: _,
axis,
value,
} => scroll(axis, value),
PointerEvent::Frame {} => {}
},
Event::Keyboard(keyboard_event) => match keyboard_event {
KeyboardEvent::Key { time:_, key, state } => { key_event(key, state) }
KeyboardEvent::Key {
time: _,
key,
state,
} => key_event(key, state),
KeyboardEvent::Modifiers { .. } => {}
},
_ => {}
@@ -53,7 +65,7 @@ impl EventConsumer for WindowsConsumer {
async fn notify(&mut self, _: ClientEvent) {
// nothing to do
}
async fn destroy(&mut self) {}
}
@@ -90,18 +102,19 @@ fn mouse_button(button: u32, state: u32) {
0x110 => MOUSEEVENTF_LEFTUP,
0x111 => MOUSEEVENTF_RIGHTUP,
0x112 => MOUSEEVENTF_MIDDLEUP,
_ => return
}
_ => return,
},
1 => match button {
0x110 => MOUSEEVENTF_LEFTDOWN,
0x111 => MOUSEEVENTF_RIGHTDOWN,
0x112 => MOUSEEVENTF_MIDDLEDOWN,
_ => return
}
_ => return
_ => return,
},
_ => return,
};
let mi = MOUSEINPUT {
dx: 0, dy: 0, // no movement
dx: 0,
dy: 0, // no movement
mouseData: 0,
dwFlags: dw_flags,
time: 0,
@@ -114,10 +127,11 @@ fn scroll(axis: u8, value: f64) {
let event_type = match axis {
0 => MOUSEEVENTF_WHEEL,
1 => MOUSEEVENTF_HWHEEL,
_ => return
_ => return,
};
let mi = MOUSEINPUT {
dx: 0, dy: 0,
dx: 0,
dy: 0,
mouseData: (-value * 15.0) as i32 as u32,
dwFlags: event_type,
time: 0,
@@ -130,11 +144,12 @@ fn key_event(key: u32, state: u8) {
let ki = KEYBDINPUT {
wVk: 0,
wScan: key as u16,
dwFlags: KEYEVENTF_SCANCODE | match state {
0 => KEYEVENTF_KEYUP,
1 => 0u32,
_ => return
},
dwFlags: KEYEVENTF_SCANCODE
| match state {
0 => KEYEVENTF_KEYUP,
1 => 0u32,
_ => return,
},
time: 0,
dwExtraInfo: 0,
};

40
src/backend/consumer/wlroots.rs
View File

@@ -1,17 +1,17 @@
use async_trait::async_trait;
use wayland_client::WEnum;
use wayland_client::backend::WaylandError;
use crate::client::{ClientHandle, ClientEvent};
use crate::client::{ClientEvent, ClientHandle};
use crate::consumer::EventConsumer;
use async_trait::async_trait;
use std::collections::HashMap;
use std::io;
use std::os::fd::OwnedFd;
use std::os::unix::prelude::AsRawFd;
use wayland_client::backend::WaylandError;
use wayland_client::WEnum;
use anyhow::{Result, anyhow};
use anyhow::{anyhow, Result};
use wayland_client::globals::BindError;
use wayland_client::protocol::wl_pointer::{Axis, ButtonState};
use wayland_client::protocol::wl_keyboard::{self, WlKeyboard};
use wayland_client::protocol::wl_pointer::{Axis, ButtonState};
use wayland_client::protocol::wl_seat::WlSeat;
use wayland_protocols_wlr::virtual_pointer::v1::client::{
zwlr_virtual_pointer_manager_v1::ZwlrVirtualPointerManagerV1 as VpManager,
@@ -104,7 +104,10 @@ impl WlrootsConsumer {
queue,
};
while consumer.state.keymap.is_none() {
consumer.queue.blocking_dispatch(&mut consumer.state).unwrap();
consumer
.queue
.blocking_dispatch(&mut consumer.state)
.unwrap();
}
// let fd = unsafe { &File::from_raw_fd(consumer.state.keymap.unwrap().1.as_raw_fd()) };
// let mmap = unsafe { MmapOptions::new().map_copy(fd).unwrap() };
@@ -153,8 +156,10 @@ impl EventConsumer for WlrootsConsumer {
* will overwhelm the output buffer and leave the
* wayland connection in a broken state
*/
log::warn!("can't keep up, discarding event: ({client_handle}) - {event:?}");
return
log::warn!(
"can't keep up, discarding event: ({client_handle}) - {event:?}"
);
return;
}
}
}
@@ -166,13 +171,13 @@ impl EventConsumer for WlrootsConsumer {
}
Err(WaylandError::Io(e)) => {
log::error!("{e}")
},
}
Err(WaylandError::Protocol(e)) => {
panic!("wayland protocol violation: {e}")
}
Ok(()) => {
self.last_flush_failed = false;
},
}
}
}
}
@@ -186,17 +191,16 @@ impl EventConsumer for WlrootsConsumer {
}
}
async fn destroy(&mut self) { }
async fn destroy(&mut self) {}
}
enum VirtualInput {
Wlroots { pointer: Vp, keyboard: Vk },
Kde { fake_input: OrgKdeKwinFakeInput },
}
impl VirtualInput {
fn consume_event(&self, event: Event) -> Result<(),()> {
fn consume_event(&self, event: Event) -> Result<(), ()> {
match event {
Event::Pointer(e) => {
match e {
@@ -263,9 +267,9 @@ impl VirtualInput {
// insert a frame event after each mouse event
pointer.frame();
}
_ => {},
_ => {}
}
},
}
Event::Keyboard(e) => match e {
KeyboardEvent::Key { time, key, state } => match self {
VirtualInput::Wlroots {
@@ -293,7 +297,7 @@ impl VirtualInput {
VirtualInput::Kde { fake_input: _ } => {}
},
},
_ => {},
_ => {}
}
Ok(())
}
@@ -330,7 +334,7 @@ impl Dispatch<WlKeyboard, ()> for State {
wl_keyboard::Event::Keymap { format, fd, size } => {
state.keymap = Some((u32::from(format), fd, size));
}
_ => {},
_ => {}
}
}
}

8
src/backend/consumer/x11.rs
View File

@@ -1,11 +1,8 @@
use std::ptr;
use async_trait::async_trait;
use std::ptr;
use x11::{xlib, xtest};
use crate::{
client::ClientHandle,
event::Event, consumer::EventConsumer,
};
use crate::{client::ClientHandle, consumer::EventConsumer, event::Event};
pub struct X11Consumer {
display: *mut xlib::Display,
@@ -60,4 +57,3 @@ impl EventConsumer for X11Consumer {
async fn destroy(&mut self) {}
}

79
src/backend/consumer/xdg_desktop_portal.rs
View File

@@ -1,6 +1,12 @@
use async_trait::async_trait;
use anyhow::Result;
use ashpd::{desktop::{remote_desktop::{RemoteDesktop, DeviceType, KeyState, Axis}, Session}, WindowIdentifier};
use ashpd::{
desktop::{
remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop},
Session,
},
WindowIdentifier,
};
use async_trait::async_trait;
use crate::consumer::EventConsumer;
@@ -32,55 +38,86 @@ impl<'a> EventConsumer for DesktopPortalConsumer<'a> {
match event {
crate::event::Event::Pointer(p) => {
match p {
crate::event::PointerEvent::Motion { time: _, relative_x, relative_y } => {
if let Err(e) = self.proxy.notify_pointer_motion(&self.session, relative_x, relative_y).await {
crate::event::PointerEvent::Motion {
time: _,
relative_x,
relative_y,
} => {
if let Err(e) = self
.proxy
.notify_pointer_motion(&self.session, relative_x, relative_y)
.await
{
log::warn!("{e}");
}
},
crate::event::PointerEvent::Button { time: _, button, state } => {
}
crate::event::PointerEvent::Button {
time: _,
button,
state,
} => {
let state = match state {
0 => KeyState::Released,
_ => KeyState::Pressed,
};
if let Err(e) = self.proxy.notify_pointer_button(&self.session, button as i32, state).await {
if let Err(e) = self
.proxy
.notify_pointer_button(&self.session, button as i32, state)
.await
{
log::warn!("{e}");
}
},
crate::event::PointerEvent::Axis { time: _, axis, value } => {
}
crate::event::PointerEvent::Axis {
time: _,
axis,
value,
} => {
let axis = match axis {
0 => Axis::Vertical,
_ => Axis::Horizontal,
};
// TODO smooth scrolling
if let Err(e) = self.proxy.notify_pointer_axis_discrete(&self.session, axis, value as i32).await {
if let Err(e) = self
.proxy
.notify_pointer_axis_discrete(&self.session, axis, value as i32)
.await
{
log::warn!("{e}");
}
},
crate::event::PointerEvent::Frame { } => {},
}
crate::event::PointerEvent::Frame {} => {}
}
},
}
crate::event::Event::Keyboard(k) => {
match k {
crate::event::KeyboardEvent::Key { time: _, key, state } => {
crate::event::KeyboardEvent::Key {
time: _,
key,
state,
} => {
let state = match state {
0 => KeyState::Released,
_ => KeyState::Pressed,
};
if let Err(e) = self.proxy.notify_keyboard_keycode(&self.session, key as i32, state).await {
if let Err(e) = self
.proxy
.notify_keyboard_keycode(&self.session, key as i32, state)
.await
{
log::warn!("{e}");
}
},
}
crate::event::KeyboardEvent::Modifiers { .. } => {
// ignore
},
}
}
},
_ => {},
}
_ => {}
}
}
async fn notify(&mut self, _client: crate::client::ClientEvent) { }
async fn notify(&mut self, _client: crate::client::ClientEvent) {}
async fn destroy(&mut self) {
log::debug!("closing remote desktop session");