Libadwaita gui (#19)

Major Update: Functional GUI Frontend!

src/frontend/cli.rs

@@ -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}");

src/frontend/gtk.rs

@@ -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();
+}

src/frontend/gtk/client_object.rs

@@ -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,
+}

src/frontend/gtk/client_object/imp.rs

@@ -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 {}

src/frontend/gtk/client_row.rs

@@ -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();
+        }
+    }
+}

src/frontend/gtk/client_row/imp.rs

@@ -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 {}

src/frontend/gtk/window.rs

@@ -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));
+    }
+}

src/frontend/gtk/window/imp.rs

@@ -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 {}