TheLanc3/lan-mouse
1
0
Fork 0
mirror of https://github.com/feschber/lan-mouse.git synced 2026-03-26 22:50:56 +03:00
Code Issues Packages Projects Releases Wiki Activity

Libadwaita gui (#19)

Browse Source 
Major Update: Functional GUI Frontend!
This commit is contained in:
Ferdinand Schober
2023-09-20 15:23:33 +02:00
committed by GitHub
parent c50b746816
commit d042c0aa4a
28 changed files with 1202 additions and 187 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/backend/producer/wayland.rs
View File

@@ -129,6 +129,15 @@ impl Window {
}
}
impl Drop for Window {
fn drop(&mut self) {
log::debug!("destroying window!");
self.layer_surface.destroy();
self.surface.destroy();
self.buffer.destroy();
}
}
fn draw(f: &mut File, (width, height): (u32, u32)) {
let mut buf = BufWriter::new(f);
for _ in 0..height {
@@ -301,6 +310,7 @@ impl State {
fn add_client(&mut self, client: ClientHandle, pos: Position) {
let window = Rc::new(Window::new(&self.g, &self.qh, pos));
assert!(Rc::strong_count(&window) == 1);
self.client_for_window.push((window, client));
}
}
@@ -414,8 +424,15 @@ impl EventProducer for WaylandEventProducer {
fn notify(&mut self, client_event: ClientEvent) {
if let ClientEvent::Create(handle, pos) = client_event {
self.state.add_client(handle, pos);
self.flush_events();
}
if let ClientEvent::Destroy(handle) = client_event {
if let Some(i) = self.state.client_for_window.iter().position(|(_,c)| *c == handle) {
let w = self.state.client_for_window.remove(i);
self.state.focused = None;
assert!(Rc::strong_count(&w.0) == 1);
}
}
self.flush_events();
}
fn release(&mut self) {
@@ -466,15 +483,16 @@ impl Dispatch<wl_pointer::WlPointer, ()> for State {
} => {
// get client corresponding to the focused surface
log::trace!("produce: enter()");
{
let (window, client) = app
if let Some((window, client)) = app
.client_for_window
.iter()
.find(|(w, _c)| w.surface == surface)
.unwrap();
app.focused = Some((window.clone(), *client));
app.grab(&surface, pointer, serial.clone(), qh);
.find(|(w, _c)| w.surface == surface) {
app.focused = Some((window.clone(), *client));
app.grab(&surface, pointer, serial.clone(), qh);
} else {
return;
}
}
let (_, client) = app
.client_for_window
@@ -641,17 +659,17 @@ impl Dispatch<ZwlrLayerSurfaceV1, ()> for State {
_: &QueueHandle<Self>,
) {
if let zwlr_layer_surface_v1::Event::Configure { serial, .. } = event {
let (window, _client) = app
if let Some((window, _client)) = app
.client_for_window
.iter()
.find(|(w, _c)| &w.layer_surface == layer_surface)
.unwrap();
// client corresponding to the layer_surface
let surface = &window.surface;
let buffer = &window.buffer;
surface.attach(Some(&buffer), 0, 0);
layer_surface.ack_configure(serial);
surface.commit();
.find(|(w, _c)| &w.layer_surface == layer_surface) {
// client corresponding to the layer_surface
let surface = &window.surface;
let buffer = &window.buffer;
surface.attach(Some(&buffer), 0, 0);
layer_surface.ack_configure(serial);
surface.commit();
}
}
}
}

39
src/client.rs
View File

@@ -121,46 +121,46 @@ impl ClientManager {
pub fn last_ping(&self, client: ClientHandle) -> Option<Duration> {
let last_ping = self.last_ping
.iter()
.find(|(c,_)| *c == client)
.unwrap().1;
.find(|(c,_)| *c == client)?.1;
last_ping.map(|p| p.elapsed())
}
pub fn last_seen(&self, client: ClientHandle) -> Option<Duration> {
let last_seen = self.last_seen
.iter()
.find(|(c, _)| *c == client)
.unwrap().1;
.find(|(c, _)| *c == client)?.1;
last_seen.map(|t| t.elapsed())
}
pub fn last_replied(&self, client: ClientHandle) -> Option<Duration> {
let last_replied = self.last_replied
.iter()
.find(|(c, _)| *c == client)
.unwrap().1;
.find(|(c, _)| *c == client)?.1;
last_replied.map(|t| t.elapsed())
}
pub fn reset_last_ping(&mut self, client: ClientHandle) {
self.last_ping
if let Some(c) = self.last_ping
.iter_mut()
.find(|(c, _)| *c == client)
.unwrap().1 = Some(Instant::now());
.find(|(c, _)| *c == client) {
c.1 = Some(Instant::now());
}
}
pub fn reset_last_seen(&mut self, client: ClientHandle) {
self.last_seen
if let Some(c) = self.last_seen
.iter_mut()
.find(|(c, _)| *c == client)
.unwrap().1 = Some(Instant::now());
.find(|(c, _)| *c == client) {
c.1 = Some(Instant::now());
}
}
pub fn reset_last_replied(&mut self, client: ClientHandle) {
self.last_replied
if let Some(c) = self.last_replied
.iter_mut()
.find(|(c, _)| *c == client)
.unwrap().1 = Some(Instant::now());
.find(|(c, _)| *c == client) {
c.1 = Some(Instant::now());
}
}
pub fn get_client(&self, addr: SocketAddr) -> Option<ClientHandle> {
@@ -170,6 +170,15 @@ impl ClientManager {
.map(|c| c.handle)
}
pub fn remove_client(&mut self, client: ClientHandle) {
if let Some(i) = self.clients.iter().position(|c| c.handle == client) {
self.clients.remove(i);
self.last_ping.remove(i);
self.last_seen.remove(i);
self.last_replied.remove(i);
}
}
fn next_id(&mut self) -> ClientHandle {
let handle = self.next_client_id;
self.next_client_id += 1;

4
src/config.rs
View File

@@ -64,6 +64,7 @@ fn find_arg(key: &'static str) -> Result<Option<String>, MissingParameter> {
Ok(None)
}
#[derive(PartialEq, Eq)]
pub enum Frontend {
Gtk,
Cli,
@@ -96,6 +97,9 @@ impl Config {
};
let frontend = match frontend {
#[cfg(all(unix, feature = "gtk"))]
None => Frontend::Gtk,
#[cfg(any(not(feature = "gtk"), not(unix)))]
None => Frontend::Cli,
Some(s) => match s.as_str() {
"cli" => Frontend::Cli,

54
src/event/server.rs
View File

@@ -6,7 +6,7 @@ use mio_signals::{Signals, Signal, SignalSet};
use std::{net::SocketAddr, io::ErrorKind};
use crate::{client::{ClientEvent, ClientManager, Position}, consumer::EventConsumer, producer::EventProducer, frontend::{FrontendEvent, FrontendAdapter}};
use crate::{client::{ClientEvent, ClientManager, Position}, consumer::EventConsumer, producer::EventProducer, frontend::{FrontendEvent, FrontendAdapter}, dns};
use super::Event;
/// keeps track of state to prevent a feedback loop
@@ -94,10 +94,25 @@ impl Server {
pub fn add_client(&mut self, addr: HashSet<SocketAddr>, pos: Position) {
let client = self.client_manager.add_client(addr, pos);
log::debug!("add_client {client}");
self.producer.notify(ClientEvent::Create(client, pos));
self.consumer.notify(ClientEvent::Create(client, pos));
}
pub fn remove_client(&mut self, host: String, port: u16) {
if let Ok(ips) = dns::resolve(host.as_str()) {
if let Some(ip) = ips.iter().next() {
let addr = SocketAddr::new(*ip, port);
if let Some(handle) = self.client_manager.get_client(addr) {
log::debug!("remove_client {handle}");
self.client_manager.remove_client(handle);
self.producer.notify(ClientEvent::Destroy(handle));
self.consumer.notify(ClientEvent::Destroy(handle));
}
}
}
}
fn handle_udp_rx(&mut self) {
loop {
let (event, addr) = match self.receive_event() {
@@ -134,6 +149,9 @@ impl Server {
if let Err(e) = Self::send_event(&self.socket, Event::Pong(), addr) {
log::error!("udp send: {}", e);
}
// we release the mouse here,
// since its very likely, that we wont get a release event
self.producer.release();
}
(event, addr) => {
match self.state {
@@ -171,6 +189,7 @@ impl Server {
fn handle_producer_rx(&mut self) {
let events = self.producer.read_events();
let mut should_release = false;
for (c, e) in events.into_iter() {
// in receiving state, only release events
// must be transmitted
@@ -200,6 +219,11 @@ impl Server {
continue
}
// release mouse if client didnt respond to the first ping
if last_ping.is_some() && last_ping.unwrap() < Duration::from_secs(1) {
should_release = true;
}
// last ping > 500ms ago -> ping all interfaces
self.client_manager.reset_last_ping(c);
if let Some(iter) = self.client_manager.get_addrs(c) {
@@ -210,27 +234,43 @@ impl Server {
log::error!("udp send: {}", e);
}
}
// send additional release event, in case client is still in sending mode
if let Err(e) = Self::send_event(&self.socket, Event::Release(), addr) {
if e.kind() != ErrorKind::WouldBlock {
log::error!("udp send: {}", e);
}
}
}
} else {
// TODO should repeat dns lookup
}
}
if should_release && self.state != State::Receiving {
log::info!("client not responding - releasing pointer");
self.producer.release();
self.state = State::Receiving;
}
}
fn handle_frontend_rx(&mut self) -> bool {
loop {
match self.frontend.read_event() {
Ok(event) => match event {
FrontendEvent::RequestPortChange(_) => todo!(),
FrontendEvent::RequestClientAdd(addr, pos) => {
self.add_client(HashSet::from_iter(&mut [addr].into_iter()), pos);
FrontendEvent::AddClient(host, port, pos) => {
if let Ok(ips) = dns::resolve(host.as_str()) {
let addrs = ips.iter().map(|i| SocketAddr::new(*i, port));
self.add_client(HashSet::from_iter(addrs), pos);
}
}
FrontendEvent::RequestClientDelete(_) => todo!(),
FrontendEvent::RequestClientUpdate(_) => todo!(),
FrontendEvent::RequestShutdown() => {
FrontendEvent::DelClient(host, port) => self.remove_client(host, port),
FrontendEvent::Shutdown() => {
log::info!("terminating gracefully...");
return true;
},
FrontendEvent::ChangePort(_) => todo!(),
FrontendEvent::AddIp(_, _) => todo!(),
}
Err(e) if e.kind() == ErrorKind::WouldBlock => return false,
Err(e) => {

16
src/frontend.rs
View File

@@ -1,5 +1,6 @@
use std::io::{Read, Result};
use std::{str, net::SocketAddr};
use std::net::IpAddr;
use std::str;
#[cfg(unix)]
use std::{env, path::{Path, PathBuf}};
@@ -24,11 +25,11 @@ pub mod gtk;
#[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
pub enum FrontendEvent {
RequestPortChange(u16),
RequestClientAdd(SocketAddr, Position),
RequestClientDelete(Client),
RequestClientUpdate(Client),
RequestShutdown(),
ChangePort(u16),
AddClient(String, u16, Position),
DelClient(String, u16),
AddIp(String, Option<IpAddr>),
Shutdown(),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
@@ -78,6 +79,7 @@ impl FrontendAdapter {
let json = str::from_utf8(&buf)
.unwrap()
.trim_end_matches(char::from(0)); // remove trailing 0-bytes
log::debug!("{json}");
let event = serde_json::from_str(json).unwrap();
log::debug!("{:?}", event);
Ok(event)
@@ -117,5 +119,3 @@ impl Drop for FrontendAdapter {
std::fs::remove_file(&self.socket_path).unwrap();
}
}
pub trait Frontend { }

116
src/frontend/cli.rs
View File

@@ -1,5 +1,5 @@
use anyhow::Result;
use std::{thread, io::Write, net::SocketAddr};
use std::{thread::{self, JoinHandle}, io::Write};
#[cfg(windows)]
use std::net::SocketAddrV4;
@@ -8,74 +8,88 @@ use std::{os::unix::net::UnixStream, path::Path, env};
#[cfg(windows)]
use std::net::TcpStream;
use crate::client::Position;
use crate::{client::Position, config::DEFAULT_PORT};
use super::{FrontendEvent, Frontend};
use super::FrontendEvent;
pub struct CliFrontend;
impl Frontend for CliFrontend {}
impl CliFrontend {
pub fn new() -> Result<CliFrontend> {
#[cfg(unix)]
let socket_path = Path::new(env::var("XDG_RUNTIME_DIR")?.as_str()).join("lan-mouse-socket.sock");
thread::Builder::new()
.name("cli-frontend".to_string())
.spawn(move || {
loop {
eprint!("lan-mouse > ");
std::io::stderr().flush().unwrap();
let mut buf = String::new();
match std::io::stdin().read_line(&mut buf) {
Ok(len) => {
if let Some(event) = parse_event(buf, len) {
#[cfg(unix)]
let Ok(mut stream) = UnixStream::connect(&socket_path) else {
log::error!("Could not connect to lan-mouse-socket");
continue;
};
#[cfg(windows)]
let Ok(mut stream) = TcpStream::connect("127.0.0.1:5252".parse::<SocketAddrV4>().unwrap()) else {
log::error!("Could not connect to lan-mouse-server");
continue;
};
let json = serde_json::to_string(&event).unwrap();
if let Err(e) = stream.write(json.as_bytes()) {
log::error!("error sending message: {e}");
};
if event == FrontendEvent::RequestShutdown() {
break;
}
pub fn start() -> Result<JoinHandle<()>> {
#[cfg(unix)]
let socket_path = Path::new(env::var("XDG_RUNTIME_DIR")?.as_str()).join("lan-mouse-socket.sock");
Ok(thread::Builder::new()
.name("cli-frontend".to_string())
.spawn(move || {
loop {
eprint!("lan-mouse > ");
std::io::stderr().flush().unwrap();
let mut buf = String::new();
match std::io::stdin().read_line(&mut buf) {
Ok(len) => {
if let Some(event) = parse_cmd(buf, len) {
#[cfg(unix)]
let Ok(mut stream) = UnixStream::connect(&socket_path) else {
log::error!("Could not connect to lan-mouse-socket");
continue;
};
#[cfg(windows)]
let Ok(mut stream) = TcpStream::connect("127.0.0.1:5252".parse::<SocketAddrV4>().unwrap()) else {
log::error!("Could not connect to lan-mouse-server");
continue;
};
let json = serde_json::to_string(&event).unwrap();
if let Err(e) = stream.write(json.as_bytes()) {
log::error!("error sending message: {e}");
};
if event == FrontendEvent::Shutdown() {
break;
}
}
Err(e) => {
log::error!("{e:?}");
break
}
}
Err(e) => {
log::error!("{e:?}");
break
}
}
}).unwrap();
Ok(Self {})
}
}
})?)
}
fn parse_event(s: String, len: usize) -> Option<FrontendEvent> {
fn parse_cmd(s: String, len: usize) -> Option<FrontendEvent> {
if len == 0 {
return Some(FrontendEvent::RequestShutdown())
return Some(FrontendEvent::Shutdown())
}
let mut l = s.split_whitespace();
let cmd = l.next()?;
match cmd {
"connect" => {
let addr = match l.next()?.parse() {
Ok(addr) => SocketAddr::V4(addr),
let host = l.next()?.to_owned();
let pos = match l.next()? {
"right" => Position::Right,
"top" => Position::Top,
"bottom" => Position::Bottom,
_ => Position::Left,
};
let port = match l.next() {
Some(p) => match p.parse() {
Ok(p) => p,
Err(e) => {
log::error!("{e}");
return None;
}
}
None => DEFAULT_PORT,
};
Some(FrontendEvent::AddClient(host, port, pos))
}
"disconnect" => {
let host = l.next()?.to_owned();
let port = match l.next()?.parse() {
Ok(p) => p,
Err(e) => {
log::error!("parse error: {e}");
log::error!("{e}");
return None;
}
};
Some(FrontendEvent::RequestClientAdd(addr, Position::Left ))
Some(FrontendEvent::DelClient(host, port))
}
_ => {
log::error!("unknown command: {s}");

93
src/frontend/gtk.rs Normal file
View File

@@ -0,0 +1,93 @@
mod window;
mod client_object;
mod client_row;
use std::{io::Result, thread::{self, JoinHandle}};
use crate::frontend::gtk::window::Window;
use gtk::{prelude::*, IconTheme, gdk::Display, gio::{SimpleAction, SimpleActionGroup}, glib::clone, CssProvider};
use adw::Application;
use gtk::{gio, glib, prelude::ApplicationExt};
use self::client_object::ClientObject;
pub fn start() -> Result<JoinHandle<glib::ExitCode>> {
thread::Builder::new()
.name("gtk-thread".into())
.spawn(gtk_main)
}
fn gtk_main() -> glib::ExitCode {
gio::resources_register_include!("lan-mouse.gresource")
.expect("Failed to register resources.");
let app = Application::builder()
.application_id("de.feschber.lan-mouse")
.build();
app.connect_startup(|_| load_icons());
app.connect_startup(|_| load_css());
app.connect_activate(build_ui);
app.run()
}
fn load_css() {
let provider = CssProvider::new();
provider.load_from_resource("de/feschber/LanMouse/style.css");
gtk::style_context_add_provider_for_display(
&Display::default().expect("Could not connect to a display."),
&provider,
gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
);
}
fn load_icons() {
let icon_theme = IconTheme::for_display(&Display::default().expect("Could not connect to a display."));
icon_theme.add_resource_path("/de/feschber/LanMouse/icons");
}
fn build_ui(app: &Application) {
let window = Window::new(app);
let action_client_activate = SimpleAction::new(
"activate-client",
Some(&i32::static_variant_type()),
);
let action_client_delete = SimpleAction::new(
"delete-client",
Some(&i32::static_variant_type()),
);
action_client_activate.connect_activate(clone!(@weak window => move |_action, param| {
log::debug!("activate-client");
let index = param.unwrap()
.get::<i32>()
.unwrap();
let Some(client) = window.clients().item(index as u32) else {
return;
};
let client = client.downcast_ref::<ClientObject>().unwrap();
window.update_client(client);
}));
action_client_delete.connect_activate(clone!(@weak window => move |_action, param| {
log::debug!("delete-client");
let index = param.unwrap()
.get::<i32>()
.unwrap();
let Some(client) = window.clients().item(index as u32) else {
return;
};
let client = client.downcast_ref::<ClientObject>().unwrap();
window.update_client(client);
window.clients().remove(index as u32);
if window.clients().n_items() == 0 {
window.set_placeholder_visible(true);
}
}));
let actions = SimpleActionGroup::new();
window.insert_action_group("win", Some(&actions));
actions.add_action(&action_client_activate);
actions.add_action(&action_client_delete);
window.present();
}

31
src/frontend/gtk/client_object.rs Normal file
View File

@@ -0,0 +1,31 @@
mod imp;
use gtk::glib::{self, Object};
use adw::subclass::prelude::*;
glib::wrapper! {
pub struct ClientObject(ObjectSubclass<imp::ClientObject>);
}
impl ClientObject {
pub fn new(hostname: String, port: u32, active: bool, position: String) -> Self {
Object::builder()
.property("hostname", hostname)
.property("port", port)
.property("active", active)
.property("position", position)
.build()
}
pub fn get_data(&self) -> ClientData {
self.imp().data.borrow().clone()
}
}
#[derive(Default, Clone)]
pub struct ClientData {
pub hostname: String,
pub port: u32,
pub active: bool,
pub position: String,
}

27
src/frontend/gtk/client_object/imp.rs Normal file
View File

@@ -0,0 +1,27 @@
use std::cell::RefCell;
use glib::Properties;
use gtk::glib;
use gtk::prelude::*;
use gtk::subclass::prelude::*;
use super::ClientData;
#[derive(Properties, Default)]
#[properties(wrapper_type = super::ClientObject)]
pub struct ClientObject {
#[property(name = "hostname", get, set, type = String, member = hostname)]
#[property(name = "port", get, set, type = u32, member = port, maximum = u16::MAX as u32)]
#[property(name = "active", get, set, type = bool, member = active)]
#[property(name = "position", get, set, type = String, member = position)]
pub data: RefCell<ClientData>,
}
#[glib::object_subclass]
impl ObjectSubclass for ClientObject {
const NAME: &'static str = "ClientObject";
type Type = super::ClientObject;
}
#[glib::derived_properties]
impl ObjectImpl for ClientObject {}

98
src/frontend/gtk/client_row.rs Normal file
View File

@@ -0,0 +1,98 @@
mod imp;
use adw::prelude::*;
use adw::subclass::prelude::*;
use gtk::glib::{self, Object};
use crate::config::DEFAULT_PORT;
use super::ClientObject;
glib::wrapper! {
pub struct ClientRow(ObjectSubclass<imp::ClientRow>)
@extends gtk::ListBoxRow, gtk::Widget, adw::PreferencesRow, adw::ExpanderRow,
@implements gtk::Accessible, gtk::Actionable, gtk::Buildable, gtk::ConstraintTarget;
}
impl ClientRow {
pub fn new(_client_object: &ClientObject) -> Self {
Object::builder()
.build()
}
pub fn bind(&self, client_object: &ClientObject) {
let mut bindings = self.imp().bindings.borrow_mut();
let active_binding = client_object
.bind_property("active", &self.imp().enable_switch.get(), "state")
.bidirectional()
.sync_create()
.build();
let hostname_binding = client_object
.bind_property("hostname", &self.imp().hostname.get(), "text")
.transform_from(|_, v: String| {
if v == "" { Some("hostname".into()) } else { Some(v) }
})
.bidirectional()
.sync_create()
.build();
let title_binding = client_object
.bind_property("hostname", self, "title")
.build();
let port_binding = client_object
.bind_property("port", &self.imp().port.get(), "text")
.transform_from(|_, v: String| {
if v == "" {
Some(4242)
} else {
Some(v.parse::<u16>().unwrap_or(DEFAULT_PORT) as u32)
}
})
.bidirectional()
.build();
let subtitle_binding = client_object
.bind_property("port", self, "subtitle")
.sync_create()
.build();
let position_binding = client_object
.bind_property("position", &self.imp().position.get(), "selected")
.transform_from(|_, v: u32| {
match v {
1 => Some("right"),
2 => Some("top"),
3 => Some("bottom"),
_ => Some("left"),
}
})
.transform_to(|_, v: String| {
match v.as_str() {
"right" => Some(1),
"top" => Some(2u32),
"bottom" => Some(3u32),
_ => Some(0u32),
}
})
.bidirectional()
.sync_create()
.build();
bindings.push(active_binding);
bindings.push(hostname_binding);
bindings.push(title_binding);
bindings.push(port_binding);
bindings.push(subtitle_binding);
bindings.push(position_binding);
}
pub fn unbind(&self) {
for binding in self.imp().bindings.borrow_mut().drain(..) {
binding.unbind();
}
}
}

76
src/frontend/gtk/client_row/imp.rs Normal file
View File

@@ -0,0 +1,76 @@
use std::cell::RefCell;
use glib::{Binding, subclass::InitializingObject};
use adw::{prelude::*, ComboRow, ActionRow};
use adw::subclass::prelude::*;
use gtk::glib::clone;
use gtk::{glib, CompositeTemplate, Switch, Button};
#[derive(CompositeTemplate, Default)]
#[template(resource = "/de/feschber/LanMouse/client_row.ui")]
pub struct ClientRow {
#[template_child]
pub enable_switch: TemplateChild<gtk::Switch>,
#[template_child]
pub hostname: TemplateChild<gtk::Entry>,
#[template_child]
pub port: TemplateChild<gtk::Entry>,
#[template_child]
pub position: TemplateChild<ComboRow>,
#[template_child]
pub delete_row: TemplateChild<ActionRow>,
#[template_child]
pub delete_button: TemplateChild<gtk::Button>,
pub bindings: RefCell<Vec<Binding>>,
}
#[glib::object_subclass]
impl ObjectSubclass for ClientRow {
// `NAME` needs to match `class` attribute of template
const NAME: &'static str = "ClientRow";
type Type = super::ClientRow;
type ParentType = adw::ExpanderRow;
fn class_init(klass: &mut Self::Class) {
klass.bind_template();
klass.bind_template_callbacks();
}
fn instance_init(obj: &InitializingObject<Self>) {
obj.init_template();
}
}
impl ObjectImpl for ClientRow {
fn constructed(&self) {
self.parent_constructed();
self.delete_button.connect_clicked(clone!(@weak self as row => move |button| {
row.handle_client_delete(button);
}));
}
}
#[gtk::template_callbacks]
impl ClientRow {
#[template_callback]
fn handle_client_set_state(&self, state: bool, switch: &Switch) -> bool {
let idx = self.obj().index();
switch.activate_action("win.activate-client", Some(&idx.to_variant())).unwrap();
switch.set_state(state);
true // dont run default handler
}
#[template_callback]
fn handle_client_delete(&self, button: &Button) {
log::debug!("delete button pressed");
let idx = self.obj().index();
button.activate_action("win.delete-client", Some(&idx.to_variant())).unwrap();
}
}
impl WidgetImpl for ClientRow {}
impl BoxImpl for ClientRow {}
impl ListBoxRowImpl for ClientRow {}
impl PreferencesRowImpl for ClientRow {}
impl ExpanderRowImpl for ClientRow {}

127
src/frontend/gtk/window.rs Normal file
View File

@@ -0,0 +1,127 @@
mod imp;
use std::{path::{Path, PathBuf}, env, process, os::unix::net::UnixStream, io::Write};
use adw::prelude::*;
use adw::subclass::prelude::*;
use gtk::{glib, gio, NoSelection};
use glib::{clone, Object};
use crate::{frontend::{gtk::client_object::ClientObject, FrontendEvent}, config::DEFAULT_PORT, client::Position};
use super::client_row::ClientRow;
glib::wrapper! {
pub struct Window(ObjectSubclass<imp::Window>)
@extends adw::ApplicationWindow, gtk::Window, gtk::Widget,
@implements gio::ActionGroup, gio::ActionMap, gtk::Accessible, gtk::Buildable,
gtk::ConstraintTarget, gtk::Native, gtk::Root, gtk::ShortcutManager;
}
impl Window {
pub(crate) fn new(app: &adw::Application) -> Self {
Object::builder().property("application", app).build()
}
pub fn clients(&self) -> gio::ListStore {
self.imp()
.clients
.borrow()
.clone()
.expect("Could not get clients")
}
fn setup_clients(&self) {
let model = gio::ListStore::new::<ClientObject>();
self.imp().clients.replace(Some(model));
let selection_model = NoSelection::new(Some(self.clients()));
self.imp().client_list.bind_model(
Some(&selection_model),
clone!(@weak self as window => @default-panic, move |obj| {
let client_object = obj.downcast_ref().expect("Expected object of type `ClientObject`.");
let row = window.create_client_row(client_object);
row.upcast()
})
);
}
/// workaround for a bug in libadwaita that shows an ugly line beneath
/// the last element if a placeholder is set.
/// https://gitlab.gnome.org/GNOME/gtk/-/merge_requests/6308
pub fn set_placeholder_visible(&self, visible: bool) {
let placeholder = self.imp().client_placeholder.get();
self.imp().client_list.set_placeholder(match visible {
true => Some(&placeholder),
false => None,
});
}
fn setup_icon(&self) {
self.set_icon_name(Some("mouse-icon"));
}
fn create_client_row(&self, client_object: &ClientObject) -> ClientRow {
let row = ClientRow::new(client_object);
row.bind(client_object);
row
}
fn new_client(&self) {
let client = ClientObject::new(String::from(""), DEFAULT_PORT as u32, false, "left".into());
self.clients().append(&client);
}
pub fn update_client(&self, client: &ClientObject) {
let data = client.get_data();
let socket_path = self.imp().socket_path.borrow();
let socket_path = socket_path.as_ref().unwrap().as_path();
let host_name = data.hostname;
let position = match data.position.as_str() {
"left" => Position::Left,
"right" => Position::Right,
"top" => Position::Top,
"bottom" => Position::Bottom,
_ => {
log::error!("invalid position: {}", data.position);
return
}
};
let port = data.port;
let event = if client.active() {
FrontendEvent::DelClient(host_name, port as u16)
} else {
FrontendEvent::AddClient(host_name, port as u16, position)
};
let json = serde_json::to_string(&event).unwrap();
let Ok(mut stream) = UnixStream::connect(socket_path) else {
log::error!("Could not connect to lan-mouse-socket @ {socket_path:?}");
return;
};
if let Err(e) = stream.write(json.as_bytes()) {
log::error!("error sending message: {e}");
};
}
fn setup_callbacks(&self) {
self.imp()
.add_client_button
.connect_clicked(clone!(@weak self as window => move |_| {
window.new_client();
window.set_placeholder_visible(false);
}));
}
fn connect_stream(&self) {
let xdg_runtime_dir = match env::var("XDG_RUNTIME_DIR") {
Ok(v) => v,
Err(e) => {
log::error!("{e}");
process::exit(1);
}
};
let socket_path = Path::new(xdg_runtime_dir.as_str())
.join("lan-mouse-socket.sock");
self.imp().socket_path.borrow_mut().replace(PathBuf::from(socket_path));
}
}

63
src/frontend/gtk/window/imp.rs Normal file
View File

@@ -0,0 +1,63 @@
use std::{cell::{Cell, RefCell}, path::PathBuf};
use glib::subclass::InitializingObject;
use adw::{prelude::*, ActionRow};
use adw::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate, ListBox, gio};
#[derive(CompositeTemplate, Default)]
#[template(resource = "/de/feschber/LanMouse/window.ui")]
pub struct Window {
pub number: Cell<i32>,
#[template_child]
pub add_client_button: TemplateChild<Button>,
#[template_child]
pub client_list: TemplateChild<ListBox>,
#[template_child]
pub client_placeholder: TemplateChild<ActionRow>,
pub clients: RefCell<Option<gio::ListStore>>,
pub socket_path: RefCell<Option<PathBuf>>,
}
#[glib::object_subclass]
impl ObjectSubclass for Window {
// `NAME` needs to match `class` attribute of template
const NAME: &'static str = "LanMouseWindow";
type Type = super::Window;
type ParentType = gtk::ApplicationWindow;
fn class_init(klass: &mut Self::Class) {
klass.bind_template();
klass.bind_template_callbacks();
}
fn instance_init(obj: &InitializingObject<Self>) {
obj.init_template();
}
}
#[gtk::template_callbacks]
impl Window {
#[template_callback]
fn handle_button_clicked(&self, button: &Button) {
let number_increased = self.number.get() + 1;
self.number.set(number_increased);
button.set_label(&number_increased.to_string())
}
}
impl ObjectImpl for Window {
fn constructed(&self) {
self.parent_constructed();
let obj = self.obj();
obj.setup_icon();
obj.setup_clients();
obj.setup_callbacks();
obj.connect_stream();
}
}
impl WidgetImpl for Window {}
impl WindowImpl for Window {}
impl ApplicationWindowImpl for Window {}

51
src/main.rs
View File

@@ -3,10 +3,13 @@ use std::{process, error::Error};
use env_logger::Env;
use lan_mouse::{
consumer, producer,
config::{Config, Frontend::{Gtk, Cli}}, event::server::Server,
frontend::{FrontendAdapter, cli::CliFrontend},
config::{Config, Frontend::{Cli, Gtk}}, event::server::Server,
frontend::{FrontendAdapter, cli},
};
#[cfg(all(unix, feature = "gtk"))]
use lan_mouse::frontend::gtk;
pub fn main() {
// init logging
@@ -33,30 +36,34 @@ pub fn run() -> Result<(), Box<dyn Error>> {
// start sending and receiving events
let mut event_server = Server::new(config.port, producer, consumer, frontend_adapter)?;
// add clients form config
config.get_clients().into_iter().for_each(|(c, h, p)| {
let host_name = match h {
Some(h) => format!(" '{}'", h),
None => "".to_owned(),
};
if c.len() == 0 {
log::warn!("ignoring client{} with 0 assigned ips!", host_name);
}
log::info!("adding client [{}]{} @ {:?}", p, host_name, c);
event_server.add_client(c, p);
});
// any threads need to be started after event_server sets up signal handling
match config.frontend {
Gtk => {
#[cfg(all(unix, feature = "gtk"))]
frontend::gtk::create();
#[cfg(not(feature = "gtk"))]
panic!("gtk frontend requested but feature not enabled!");
},
Cli => Box::new(CliFrontend::new()?),
#[cfg(all(unix, feature = "gtk"))]
Gtk => { gtk::start()?; }
#[cfg(any(not(feature = "gtk"), not(unix)))]
Gtk => panic!("gtk frontend requested but feature not enabled!"),
Cli => { cli::start()?; }
};
// this currently causes issues, because the clients from
// the config arent communicated to gtk yet.
if config.frontend == Gtk {
log::warn!("clients defined in config currently have no effect with the gtk frontend");
} else {
// add clients from config
config.get_clients().into_iter().for_each(|(c, h, p)| {
let host_name = match h {
Some(h) => format!(" '{}'", h),
None => "".to_owned(),
};
if c.len() == 0 {
log::warn!("ignoring client{} with 0 assigned ips!", host_name);
}
log::info!("adding client [{}]{} @ {:?}", p, host_name, c);
event_server.add_client(c, p);
});
}
log::info!("Press Ctrl+Alt+Shift+Super to release the mouse");
// run event loop
event_server.run()?;