Libadwaita gui (#19)

Major Update: Functional GUI Frontend!

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