extract frontend crate (#186)

lan-mouse-gtk/src/client_object.rs

@@ -0,0 +1,46 @@
+mod imp;
+
+use adw::subclass::prelude::*;
+use gtk::glib::{self, Object};
+
+use lan_mouse_ipc::{ClientConfig, ClientHandle, ClientState};
+
+glib::wrapper! {
+    pub struct ClientObject(ObjectSubclass<imp::ClientObject>);
+}
+
+impl ClientObject {
+    pub fn new(handle: ClientHandle, client: ClientConfig, state: ClientState) -> Self {
+        Object::builder()
+            .property("handle", handle)
+            .property("hostname", client.hostname)
+            .property("port", client.port as u32)
+            .property("position", client.pos.to_string())
+            .property("active", state.active)
+            .property(
+                "ips",
+                state
+                    .ips
+                    .iter()
+                    .map(|ip| ip.to_string())
+                    .collect::<Vec<_>>(),
+            )
+            .property("resolving", state.resolving)
+            .build()
+    }
+
+    pub fn get_data(&self) -> ClientData {
+        self.imp().data.borrow().clone()
+    }
+}
+
+#[derive(Default, Clone)]
+pub struct ClientData {
+    pub handle: ClientHandle,
+    pub hostname: Option<String>,
+    pub port: u32,
+    pub active: bool,
+    pub position: String,
+    pub resolving: bool,
+    pub ips: Vec<String>,
+}

lan-mouse-gtk/src/client_object/imp.rs

@@ -0,0 +1,32 @@
+use std::cell::RefCell;
+
+use glib::Properties;
+use gtk::glib;
+use gtk::prelude::*;
+use gtk::subclass::prelude::*;
+
+use lan_mouse_ipc::ClientHandle;
+
+use super::ClientData;
+
+#[derive(Properties, Default)]
+#[properties(wrapper_type = super::ClientObject)]
+pub struct ClientObject {
+    #[property(name = "handle", get, set, type = ClientHandle, member = handle)]
+    #[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)]
+    #[property(name = "resolving", get, set, type = bool, member = resolving)]
+    #[property(name = "ips", get, set, type = Vec<String>, member = ips)]
+    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 {}

lan-mouse-gtk/src/client_row.rs

@@ -0,0 +1,149 @@
+mod imp;
+
+use adw::prelude::*;
+use adw::subclass::prelude::*;
+use gtk::glib::{self, Object};
+
+use lan_mouse_ipc::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 switch_position_binding = client_object
+            .bind_property("active", &self.imp().enable_switch.get(), "active")
+            .bidirectional()
+            .sync_create()
+            .build();
+
+        let hostname_binding = client_object
+            .bind_property("hostname", &self.imp().hostname.get(), "text")
+            .transform_to(|_, v: Option<String>| {
+                if let Some(hostname) = v {
+                    Some(hostname)
+                } else {
+                    Some("".to_string())
+                }
+            })
+            .transform_from(|_, v: String| {
+                if v.as_str().trim() == "" {
+                    Some(None)
+                } else {
+                    Some(Some(v))
+                }
+            })
+            .bidirectional()
+            .sync_create()
+            .build();
+
+        let title_binding = client_object
+            .bind_property("hostname", self, "title")
+            .transform_to(|_, v: Option<String>| {
+                if let Some(hostname) = v {
+                    Some(hostname)
+                } else {
+                    Some("<span font_style=\"italic\" font_weight=\"light\" foreground=\"darkgrey\">no hostname!</span>".to_string())
+                }
+            })
+            .sync_create()
+            .build();
+
+        let port_binding = client_object
+            .bind_property("port", &self.imp().port.get(), "text")
+            .transform_from(|_, v: String| {
+                if v.is_empty() {
+                    Some(DEFAULT_PORT as u32)
+                } else {
+                    Some(v.parse::<u16>().unwrap_or(DEFAULT_PORT) as u32)
+                }
+            })
+            .transform_to(|_, v: u32| {
+                if v == 4242 {
+                    Some("".to_string())
+                } else {
+                    Some(v.to_string())
+                }
+            })
+            .bidirectional()
+            .sync_create()
+            .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();
+
+        let resolve_binding = client_object
+            .bind_property(
+                "resolving",
+                &self.imp().dns_loading_indicator.get(),
+                "spinning",
+            )
+            .sync_create()
+            .build();
+
+        let ip_binding = client_object
+            .bind_property("ips", &self.imp().dns_button.get(), "tooltip-text")
+            .transform_to(|_, ips: Vec<String>| {
+                if ips.is_empty() {
+                    Some("no ip addresses associated with this client".into())
+                } else {
+                    Some(ips.join("\n"))
+                }
+            })
+            .sync_create()
+            .build();
+
+        bindings.push(active_binding);
+        bindings.push(switch_position_binding);
+        bindings.push(hostname_binding);
+        bindings.push(title_binding);
+        bindings.push(port_binding);
+        bindings.push(subtitle_binding);
+        bindings.push(position_binding);
+        bindings.push(resolve_binding);
+        bindings.push(ip_binding);
+    }
+
+    pub fn unbind(&self) {
+        for binding in self.imp().bindings.borrow_mut().drain(..) {
+            binding.unbind();
+        }
+    }
+}

lan-mouse-gtk/src/client_row/imp.rs

@@ -0,0 +1,103 @@
+use std::cell::RefCell;
+
+use adw::subclass::prelude::*;
+use adw::{prelude::*, ActionRow, ComboRow};
+use glib::{subclass::InitializingObject, Binding};
+use gtk::glib::clone;
+use gtk::glib::subclass::Signal;
+use gtk::{glib, Button, CompositeTemplate, Switch};
+use std::sync::OnceLock;
+
+#[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 dns_button: TemplateChild<gtk::Button>,
+    #[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>,
+    #[template_child]
+    pub dns_loading_indicator: TemplateChild<gtk::Spinner>,
+    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";
+    const ABSTRACT: bool = false;
+
+    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(rename_to = row)]
+            self,
+            move |button| {
+                row.handle_client_delete(button);
+            }
+        ));
+    }
+
+    fn signals() -> &'static [glib::subclass::Signal] {
+        static SIGNALS: OnceLock<Vec<Signal>> = OnceLock::new();
+        SIGNALS.get_or_init(|| {
+            vec![
+                Signal::builder("request-dns").build(),
+                Signal::builder("request-update")
+                    .param_types([bool::static_type()])
+                    .build(),
+                Signal::builder("request-delete").build(),
+            ]
+        })
+    }
+}
+
+#[gtk::template_callbacks]
+impl ClientRow {
+    #[template_callback]
+    fn handle_client_set_state(&self, state: bool, _switch: &Switch) -> bool {
+        log::debug!("state change -> requesting update");
+        self.obj().emit_by_name::<()>("request-update", &[&state]);
+        true // dont run default handler
+    }
+
+    #[template_callback]
+    fn handle_request_dns(&self, _: Button) {
+        self.obj().emit_by_name::<()>("request-dns", &[]);
+    }
+
+    #[template_callback]
+    fn handle_client_delete(&self, _button: &Button) {
+        log::debug!("delete button pressed -> requesting delete");
+        self.obj().emit_by_name::<()>("request-delete", &[]);
+    }
+}
+
+impl WidgetImpl for ClientRow {}
+impl BoxImpl for ClientRow {}
+impl ListBoxRowImpl for ClientRow {}
+impl PreferencesRowImpl for ClientRow {}
+impl ExpanderRowImpl for ClientRow {}

lan-mouse-gtk/src/lib.rs

@@ -0,0 +1,138 @@
+mod client_object;
+mod client_row;
+mod window;
+
+use std::{env, process, str};
+
+use window::Window;
+
+use lan_mouse_ipc::FrontendEvent;
+
+use adw::Application;
+use gtk::{
+    gdk::Display, glib::clone, prelude::*, subclass::prelude::ObjectSubclassIsExt, IconTheme,
+};
+use gtk::{gio, glib, prelude::ApplicationExt};
+
+use self::client_object::ClientObject;
+
+pub fn run() -> glib::ExitCode {
+    log::debug!("running gtk frontend");
+    #[cfg(windows)]
+    let ret = std::thread::Builder::new()
+        .stack_size(8 * 1024 * 1024) // https://gitlab.gnome.org/GNOME/gtk/-/commit/52dbb3f372b2c3ea339e879689c1de535ba2c2c3 -> caused crash on windows
+        .name("gtk".into())
+        .spawn(gtk_main)
+        .unwrap()
+        .join()
+        .unwrap();
+    #[cfg(not(windows))]
+    let ret = gtk_main();
+
+    if ret == glib::ExitCode::FAILURE {
+        log::error!("frontend exited with failure");
+    } else {
+        log::info!("frontend exited successfully");
+    }
+
+    ret
+}
+
+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.LanMouse")
+        .build();
+
+    app.connect_startup(|_| load_icons());
+    app.connect_activate(build_ui);
+
+    let args: Vec<&'static str> = vec![];
+    app.run_with_args(&args)
+}
+
+fn load_icons() {
+    let display = &Display::default().expect("Could not connect to a display.");
+    let icon_theme = IconTheme::for_display(display);
+    icon_theme.add_resource_path("/de/feschber/LanMouse/icons");
+}
+
+fn build_ui(app: &Application) {
+    log::debug!("connecting to lan-mouse-socket");
+    let (mut frontend_rx, frontend_tx) = match lan_mouse_ipc::connect() {
+        Ok(conn) => conn,
+        Err(e) => {
+            log::error!("{e}");
+            process::exit(1);
+        }
+    };
+    log::debug!("connected to lan-mouse-socket");
+
+    let (sender, receiver) = async_channel::bounded(10);
+
+    gio::spawn_blocking(move || {
+        while let Some(e) = frontend_rx.next_event() {
+            match e {
+                Ok(e) => sender.send_blocking(e).unwrap(),
+                Err(e) => {
+                    log::error!("{e}");
+                    break;
+                }
+            }
+        }
+    });
+
+    let window = Window::new(app, frontend_tx);
+
+    glib::spawn_future_local(clone!(
+        #[weak]
+        window,
+        async move {
+            loop {
+                let notify = receiver.recv().await.unwrap_or_else(|_| process::exit(1));
+                match notify {
+                    FrontendEvent::Created(handle, client, state) => {
+                        window.new_client(handle, client, state);
+                    }
+                    FrontendEvent::Deleted(client) => {
+                        window.delete_client(client);
+                    }
+                    FrontendEvent::State(handle, config, state) => {
+                        window.update_client_config(handle, config);
+                        window.update_client_state(handle, state);
+                    }
+                    FrontendEvent::NoSuchClient(_) => {}
+                    FrontendEvent::Error(e) => {
+                        window.show_toast(e.as_str());
+                    }
+                    FrontendEvent::Enumerate(clients) => {
+                        for (handle, client, state) in clients {
+                            if window.client_idx(handle).is_some() {
+                                window.update_client_config(handle, client);
+                                window.update_client_state(handle, state);
+                            } else {
+                                window.new_client(handle, client, state);
+                            }
+                        }
+                    }
+                    FrontendEvent::PortChanged(port, msg) => {
+                        match msg {
+                            None => window.show_toast(format!("port changed: {port}").as_str()),
+                            Some(msg) => window.show_toast(msg.as_str()),
+                        }
+                        window.imp().set_port(port);
+                    }
+                    FrontendEvent::CaptureStatus(s) => {
+                        window.set_capture(s.into());
+                    }
+                    FrontendEvent::EmulationStatus(s) => {
+                        window.set_emulation(s.into());
+                    }
+                }
+            }
+        }
+    ));
+
+    window.present();
+}

lan-mouse-gtk/src/window.rs

@@ -0,0 +1,318 @@
+mod imp;
+
+use adw::prelude::*;
+use adw::subclass::prelude::*;
+use glib::{clone, Object};
+use gtk::{
+    gio,
+    glib::{self, closure_local},
+    ListBox, NoSelection,
+};
+
+use lan_mouse_ipc::{
+    ClientConfig, ClientHandle, ClientState, FrontendRequest, FrontendRequestWriter, Position,
+    DEFAULT_PORT,
+};
+
+use super::{client_object::ClientObject, 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, conn: FrontendRequestWriter) -> Self {
+        let window: Self = Object::builder().property("application", app).build();
+        window
+            .imp()
+            .frontend_request_writer
+            .borrow_mut()
+            .replace(conn);
+        window
+    }
+
+    pub fn clients(&self) -> gio::ListStore {
+        self.imp()
+            .clients
+            .borrow()
+            .clone()
+            .expect("Could not get clients")
+    }
+
+    fn client_by_idx(&self, idx: u32) -> Option<ClientObject> {
+        self.clients().item(idx).map(|o| o.downcast().unwrap())
+    }
+
+    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(rename_to = window)]
+                self,
+                #[upgrade_or_panic]
+                move |obj| {
+                    let client_object = obj
+                        .downcast_ref()
+                        .expect("Expected object of type `ClientObject`.");
+                    let row = window.create_client_row(client_object);
+                    row.connect_closure(
+                        "request-update",
+                        false,
+                        closure_local!(
+                            #[strong]
+                            window,
+                            move |row: ClientRow, active: bool| {
+                                if let Some(client) = window.client_by_idx(row.index() as u32) {
+                                    window.request_client_activate(&client, active);
+                                    window.request_client_update(&client);
+                                    window.request_client_state(&client);
+                                }
+                            }
+                        ),
+                    );
+                    row.connect_closure(
+                        "request-delete",
+                        false,
+                        closure_local!(
+                            #[strong]
+                            window,
+                            move |row: ClientRow| {
+                                if let Some(client) = window.client_by_idx(row.index() as u32) {
+                                    window.request_client_delete(&client);
+                                }
+                            }
+                        ),
+                    );
+                    row.connect_closure(
+                        "request-dns",
+                        false,
+                        closure_local!(
+                            #[strong]
+                            window,
+                            move |row: ClientRow| {
+                                if let Some(client) = window.client_by_idx(row.index() as u32) {
+                                    window.request_client_update(&client);
+                                    window.request_dns(&client);
+                                    window.request_client_state(&client);
+                                }
+                            }
+                        ),
+                    );
+                    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("de.feschber.LanMouse"));
+    }
+
+    fn create_client_row(&self, client_object: &ClientObject) -> ClientRow {
+        let row = ClientRow::new(client_object);
+        row.bind(client_object);
+        row
+    }
+
+    pub fn new_client(&self, handle: ClientHandle, client: ClientConfig, state: ClientState) {
+        let client = ClientObject::new(handle, client, state.clone());
+        self.clients().append(&client);
+        self.set_placeholder_visible(false);
+        self.update_dns_state(handle, !state.ips.is_empty());
+    }
+
+    pub fn client_idx(&self, handle: ClientHandle) -> Option<usize> {
+        self.clients().iter::<ClientObject>().position(|c| {
+            if let Ok(c) = c {
+                c.handle() == handle
+            } else {
+                false
+            }
+        })
+    }
+
+    pub fn delete_client(&self, handle: ClientHandle) {
+        let Some(idx) = self.client_idx(handle) else {
+            log::warn!("could not find client with handle {handle}");
+            return;
+        };
+
+        self.clients().remove(idx as u32);
+        if self.clients().n_items() == 0 {
+            self.set_placeholder_visible(true);
+        }
+    }
+
+    pub fn update_client_config(&self, handle: ClientHandle, client: ClientConfig) {
+        let Some(idx) = self.client_idx(handle) else {
+            log::warn!("could not find client with handle {}", handle);
+            return;
+        };
+        let client_object = self.clients().item(idx as u32).unwrap();
+        let client_object: &ClientObject = client_object.downcast_ref().unwrap();
+        let data = client_object.get_data();
+
+        /* only change if it actually has changed, otherwise
+         * the update signal is triggered */
+        if data.hostname != client.hostname {
+            client_object.set_hostname(client.hostname.unwrap_or("".into()));
+        }
+        if data.port != client.port as u32 {
+            client_object.set_port(client.port as u32);
+        }
+        if data.position != client.pos.to_string() {
+            client_object.set_position(client.pos.to_string());
+        }
+    }
+
+    pub fn update_client_state(&self, handle: ClientHandle, state: ClientState) {
+        let Some(idx) = self.client_idx(handle) else {
+            log::warn!("could not find client with handle {}", handle);
+            return;
+        };
+        let client_object = self.clients().item(idx as u32).unwrap();
+        let client_object: &ClientObject = client_object.downcast_ref().unwrap();
+        let data = client_object.get_data();
+
+        if state.active != data.active {
+            client_object.set_active(state.active);
+            log::debug!("set active to {}", state.active);
+        }
+
+        if state.resolving != data.resolving {
+            client_object.set_resolving(state.resolving);
+            log::debug!("resolving {}: {}", data.handle, state.resolving);
+        }
+
+        self.update_dns_state(handle, !state.ips.is_empty());
+        let ips = state
+            .ips
+            .into_iter()
+            .map(|ip| ip.to_string())
+            .collect::<Vec<_>>();
+        client_object.set_ips(ips);
+    }
+
+    pub fn update_dns_state(&self, handle: ClientHandle, resolved: bool) {
+        let Some(idx) = self.client_idx(handle) else {
+            log::warn!("could not find client with handle {}", handle);
+            return;
+        };
+        let list_box: ListBox = self.imp().client_list.get();
+        let row = list_box.row_at_index(idx as i32).unwrap();
+        let client_row: ClientRow = row.downcast().expect("expected ClientRow Object");
+        if resolved {
+            client_row.imp().dns_button.set_css_classes(&["success"])
+        } else {
+            client_row.imp().dns_button.set_css_classes(&["warning"])
+        }
+    }
+
+    pub fn request_port_change(&self) {
+        let port = self
+            .imp()
+            .port_entry
+            .get()
+            .text()
+            .as_str()
+            .parse::<u16>()
+            .unwrap_or(DEFAULT_PORT);
+        self.request(FrontendRequest::ChangePort(port));
+    }
+
+    pub fn request_capture(&self) {
+        self.request(FrontendRequest::EnableCapture);
+    }
+
+    pub fn request_emulation(&self) {
+        self.request(FrontendRequest::EnableEmulation);
+    }
+
+    pub fn request_client_state(&self, client: &ClientObject) {
+        self.request(FrontendRequest::GetState(client.handle()));
+    }
+
+    pub fn request_client_create(&self) {
+        self.request(FrontendRequest::Create);
+    }
+
+    pub fn request_dns(&self, client: &ClientObject) {
+        self.request(FrontendRequest::ResolveDns(client.get_data().handle));
+    }
+
+    pub fn request_client_update(&self, client: &ClientObject) {
+        let handle = client.handle();
+        let data = client.get_data();
+        let position = Position::try_from(data.position.as_str()).expect("invalid position");
+        let hostname = data.hostname;
+        let port = data.port as u16;
+
+        for event in [
+            FrontendRequest::UpdateHostname(handle, hostname),
+            FrontendRequest::UpdatePosition(handle, position),
+            FrontendRequest::UpdatePort(handle, port),
+        ] {
+            self.request(event);
+        }
+    }
+
+    pub fn request_client_activate(&self, client: &ClientObject, active: bool) {
+        self.request(FrontendRequest::Activate(client.handle(), active));
+    }
+
+    pub fn request_client_delete(&self, client: &ClientObject) {
+        self.request(FrontendRequest::Delete(client.handle()));
+    }
+
+    pub fn request(&self, request: FrontendRequest) {
+        let mut requester = self.imp().frontend_request_writer.borrow_mut();
+        let requester = requester.as_mut().unwrap();
+        if let Err(e) = requester.request(request) {
+            log::error!("error sending message: {e}");
+        };
+    }
+
+    pub fn show_toast(&self, msg: &str) {
+        let toast = adw::Toast::new(msg);
+        let toast_overlay = &self.imp().toast_overlay;
+        toast_overlay.add_toast(toast);
+    }
+
+    pub fn set_capture(&self, active: bool) {
+        self.imp().capture_active.replace(active);
+        self.update_capture_emulation_status();
+    }
+
+    pub fn set_emulation(&self, active: bool) {
+        self.imp().emulation_active.replace(active);
+        self.update_capture_emulation_status();
+    }
+
+    fn update_capture_emulation_status(&self) {
+        let capture = self.imp().capture_active.get();
+        let emulation = self.imp().emulation_active.get();
+        self.imp().capture_status_row.set_visible(!capture);
+        self.imp().emulation_status_row.set_visible(!emulation);
+        self.imp()
+            .capture_emulation_group
+            .set_visible(!capture || !emulation);
+    }
+}

lan-mouse-gtk/src/window/imp.rs

@@ -0,0 +1,150 @@
+use std::cell::{Cell, RefCell};
+
+use adw::subclass::prelude::*;
+use adw::{prelude::*, ActionRow, PreferencesGroup, ToastOverlay};
+use glib::subclass::InitializingObject;
+use gtk::glib::clone;
+use gtk::{gdk, gio, glib, Button, CompositeTemplate, Entry, Label, ListBox};
+
+use lan_mouse_ipc::{FrontendRequestWriter, DEFAULT_PORT};
+
+#[derive(CompositeTemplate, Default)]
+#[template(resource = "/de/feschber/LanMouse/window.ui")]
+pub struct Window {
+    #[template_child]
+    pub port_edit_apply: TemplateChild<Button>,
+    #[template_child]
+    pub port_edit_cancel: TemplateChild<Button>,
+    #[template_child]
+    pub client_list: TemplateChild<ListBox>,
+    #[template_child]
+    pub client_placeholder: TemplateChild<ActionRow>,
+    #[template_child]
+    pub port_entry: TemplateChild<Entry>,
+    #[template_child]
+    pub hostname_label: TemplateChild<Label>,
+    #[template_child]
+    pub toast_overlay: TemplateChild<ToastOverlay>,
+    #[template_child]
+    pub capture_emulation_group: TemplateChild<PreferencesGroup>,
+    #[template_child]
+    pub capture_status_row: TemplateChild<ActionRow>,
+    #[template_child]
+    pub emulation_status_row: TemplateChild<ActionRow>,
+    #[template_child]
+    pub input_emulation_button: TemplateChild<Button>,
+    #[template_child]
+    pub input_capture_button: TemplateChild<Button>,
+    pub clients: RefCell<Option<gio::ListStore>>,
+    pub frontend_request_writer: RefCell<Option<FrontendRequestWriter>>,
+    pub port: Cell<u16>,
+    pub capture_active: Cell<bool>,
+    pub emulation_active: Cell<bool>,
+}
+
+#[glib::object_subclass]
+impl ObjectSubclass for Window {
+    // `NAME` needs to match `class` attribute of template
+    const NAME: &'static str = "LanMouseWindow";
+    const ABSTRACT: bool = false;
+
+    type Type = super::Window;
+    type ParentType = adw::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_add_client_pressed(&self, _button: &Button) {
+        self.obj().request_client_create();
+    }
+
+    #[template_callback]
+    fn handle_copy_hostname(&self, button: &Button) {
+        if let Ok(hostname) = hostname::get() {
+            let display = gdk::Display::default().unwrap();
+            let clipboard = display.clipboard();
+            clipboard.set_text(hostname.to_str().expect("hostname: invalid utf8"));
+            button.set_icon_name("emblem-ok-symbolic");
+            button.set_css_classes(&["success"]);
+            glib::spawn_future_local(clone!(
+                #[weak]
+                button,
+                async move {
+                    glib::timeout_future_seconds(1).await;
+                    button.set_icon_name("edit-copy-symbolic");
+                    button.set_css_classes(&[]);
+                }
+            ));
+        }
+    }
+
+    #[template_callback]
+    fn handle_port_changed(&self, _entry: &Entry) {
+        self.port_edit_apply.set_visible(true);
+        self.port_edit_cancel.set_visible(true);
+    }
+
+    #[template_callback]
+    fn handle_port_edit_apply(&self) {
+        self.obj().request_port_change();
+    }
+
+    #[template_callback]
+    fn handle_port_edit_cancel(&self) {
+        log::debug!("cancel port edit");
+        self.port_entry
+            .set_text(self.port.get().to_string().as_str());
+        self.port_edit_apply.set_visible(false);
+        self.port_edit_cancel.set_visible(false);
+    }
+
+    #[template_callback]
+    fn handle_emulation(&self) {
+        self.obj().request_emulation();
+    }
+
+    #[template_callback]
+    fn handle_capture(&self) {
+        self.obj().request_capture();
+    }
+
+    pub fn set_port(&self, port: u16) {
+        self.port.set(port);
+        if port == DEFAULT_PORT {
+            self.port_entry.set_text("");
+        } else {
+            self.port_entry.set_text(format!("{port}").as_str());
+        }
+        self.port_edit_apply.set_visible(false);
+        self.port_edit_cancel.set_visible(false);
+    }
+}
+
+impl ObjectImpl for Window {
+    fn constructed(&self) {
+        if let Ok(hostname) = hostname::get() {
+            self.hostname_label
+                .set_text(hostname.to_str().expect("hostname: invalid utf8"));
+        }
+        self.parent_constructed();
+        self.set_port(DEFAULT_PORT);
+        let obj = self.obj();
+        obj.setup_icon();
+        obj.setup_clients();
+    }
+}
+
+impl WidgetImpl for Window {}
+impl WindowImpl for Window {}
+impl ApplicationWindowImpl for Window {}
+impl AdwApplicationWindowImpl for Window {}