autocommit 2022-02-14 21:13:42 CET

src/tasks/backend.rs

@@ -1,10 +1,8 @@
-use crate::backend::{BackendEvent, Output, Seat};
-use crate::state::SeatData;
+use crate::backend::{BackendEvent, Output};
 use crate::tasks::output::OutputHandler;
-use crate::tasks::seat::SeatHandler;
-use crate::utils::asyncevent::AsyncEvent;
 use crate::State;
 use std::rc::Rc;
+use crate::tasks::device;
 
 pub struct BackendEventHandler {
     pub state: Rc<State>,
@@ -21,7 +19,8 @@ impl BackendEventHandler {
     fn handle_event(&mut self, event: BackendEvent) {
         match event {
             BackendEvent::NewOutput(output) => self.handle_new_output(output),
-            BackendEvent::NewSeat(seat) => self.handle_new_seat(seat),
+            BackendEvent::NewMouse(s) => device::handle(&self.state, s),
+            BackendEvent::NewKeyboard(s) => device::handle(&self.state, s),
         }
     }
 
@@ -34,22 +33,4 @@ impl BackendEventHandler {
         let future = self.state.eng.spawn(oh.handle());
         self.state.output_handlers.borrow_mut().insert(id, future);
     }
-
-    fn handle_new_seat(&mut self, seat: Rc<dyn Seat>) {
-        let id = seat.id();
-        let tree_changed = Rc::new(AsyncEvent::default());
-        let oh = SeatHandler {
-            state: self.state.clone(),
-            seat,
-            tree_changed: tree_changed.clone(),
-        };
-        let handler = self.state.eng.spawn(oh.handle());
-        self.state.seats.borrow_mut().insert(
-            id,
-            SeatData {
-                handler,
-                tree_changed,
-            },
-        );
-    }
 }

src/tasks/device.rs

@@ -0,0 +1,157 @@
+use crate::backend::{Keyboard, KeyboardEvent, Mouse, MouseEvent};
+use crate::ifs::wl_seat::WlSeatGlobal;
+use crate::utils::asyncevent::AsyncEvent;
+use crate::State;
+use std::rc::Rc;
+use crate::async_engine::SpawnedFuture;
+use crate::config::ConfigProxy;
+use crate::state::{DeviceHandlerData, KeyboardData, MouseData};
+
+pub trait DeviceApi: 'static {
+    type Event;
+
+    fn on_change(&self, cb: Rc<dyn Fn()>);
+    fn announce(&self, config: &ConfigProxy);
+    fn announce_del(&self, config: &ConfigProxy);
+    fn removed(&self) -> bool;
+    fn add(&self, state: &State, handler: SpawnedFuture<()>, data: Rc<DeviceHandlerData>);
+    fn remove(&self, state: &State);
+    fn event(&self) -> Option<Self::Event>;
+    fn send(seat: &Rc<WlSeatGlobal>, event: Self::Event);
+}
+
+impl DeviceApi for dyn Keyboard {
+    type Event = KeyboardEvent;
+
+    fn on_change(&self, cb: Rc<dyn Fn()>) {
+        self.on_change(cb);
+    }
+
+    fn announce(&self, config: &ConfigProxy) {
+        config.new_keyboard(self.id());
+    }
+
+    fn announce_del(&self, config: &ConfigProxy) {
+        config.del_keyboard(self.id());
+    }
+
+    fn removed(&self) -> bool {
+        self.removed()
+    }
+
+    fn add(&self, state: &State, handler: SpawnedFuture<()>, data: Rc<DeviceHandlerData>) {
+        state.kb_handlers.borrow_mut().insert(self.id(), KeyboardData {
+            handler,
+            id: self.id(),
+            data,
+        });
+    }
+
+    fn remove(&self, state: &State) {
+        state.kb_handlers.borrow_mut().remove(&self.id());
+    }
+
+    fn event(&self) -> Option<Self::Event> {
+        self.event()
+    }
+
+    fn send(seat: &Rc<WlSeatGlobal>, event: Self::Event) {
+        seat.kb_event(event);
+    }
+}
+
+impl DeviceApi for dyn Mouse {
+    type Event = MouseEvent;
+
+    fn on_change(&self, cb: Rc<dyn Fn()>) {
+        self.on_change(cb);
+    }
+
+    fn announce(&self, config: &ConfigProxy) {
+        config.new_mouse(self.id());
+    }
+
+    fn announce_del(&self, config: &ConfigProxy) {
+        config.del_mouse(self.id());
+    }
+
+    fn removed(&self) -> bool {
+        self.removed()
+    }
+
+    fn add(&self, state: &State, handler: SpawnedFuture<()>, data: Rc<DeviceHandlerData>) {
+        state.mouse_handlers.borrow_mut().insert(self.id(), MouseData {
+            handler,
+            id: self.id(),
+            data,
+        });
+    }
+
+    fn remove(&self, state: &State) {
+        state.mouse_handlers.borrow_mut().remove(&self.id());
+    }
+
+    fn event(&self) -> Option<Self::Event> {
+        self.event()
+    }
+
+    fn send(seat: &Rc<WlSeatGlobal>, event: Self::Event) {
+        seat.mouse_event(event);
+    }
+}
+
+pub fn handle<T: DeviceApi + ?Sized>(state: &Rc<State>, dev: Rc<T>) {
+    let data = Rc::new(DeviceHandlerData {
+        seat: Default::default(),
+    });
+    let oh = DeviceHandler {
+        state: state.clone(),
+        dev: dev.clone(),
+        data: data.clone(),
+    };
+    let handler = state.eng.spawn(oh.handle());
+    dev.add(&state, handler, data);
+}
+
+pub struct DeviceHandler<T: DeviceApi + ?Sized> {
+    pub state: Rc<State>,
+    pub dev: Rc<T>,
+    pub data: Rc<DeviceHandlerData>,
+}
+
+impl<T: DeviceApi + ?Sized> DeviceHandler<T> {
+    pub async fn handle(self) {
+        let ae = Rc::new(AsyncEvent::default());
+        {
+            let ae = ae.clone();
+            self.dev.on_change(Rc::new(move || ae.trigger()));
+        }
+        if let Some(config) = self.state.config.get() {
+            self.dev.announce(&config);
+        }
+        loop {
+            if self.dev.removed() {
+                break;
+            }
+            if let Some(seat) = self.data.seat.get() {
+                let mut any_events = false;
+                while let Some(event) = self.dev.event() {
+                    T::send(&seat, event);
+                    any_events = true;
+                }
+                if any_events {
+                    seat.mark_last_active();
+                }
+            } else {
+                while self.dev.event().is_some() {
+                    // nothing
+                }
+            }
+            ae.triggered().await;
+        }
+        if let Some(config) = self.state.config.get() {
+            self.dev.announce_del(&config);
+        }
+        self.dev.remove(&self.state);
+    }
+}

src/tasks/mod.rs

@@ -1,7 +1,7 @@
 mod backend;
 mod output;
-mod seat;
 mod slow_clients;
+mod device;
 
 use crate::tasks::backend::BackendEventHandler;
 use crate::tasks::slow_clients::SlowClientHandler;

src/tasks/seat.rs

@@ -1,60 +0,0 @@
-use crate::backend::Seat;
-use crate::ifs::wl_seat::WlSeatGlobal;
-use crate::utils::asyncevent::AsyncEvent;
-use crate::State;
-use std::rc::Rc;
-
-pub struct SeatHandler {
-    pub state: Rc<State>,
-    pub seat: Rc<dyn Seat>,
-    pub tree_changed: Rc<AsyncEvent>,
-}
-
-impl SeatHandler {
-    pub async fn handle(self) {
-        let ae = Rc::new(AsyncEvent::default());
-        {
-            let ae = ae.clone();
-            self.seat.on_change(Rc::new(move || ae.trigger()));
-        }
-        let name = self.state.globals.name();
-        let global = Rc::new(WlSeatGlobal::new(
-            name,
-            &self.state,
-            &self.seat,
-            &self.tree_changed,
-        ));
-        let _tree_changed = self.state.eng.spawn(tree_changed(
-            self.state.clone(),
-            global.clone(),
-            self.tree_changed.clone(),
-        ));
-        let mut _node = self.state.seat_queue.add_last(global.clone());
-        self.state.add_global(&global);
-        loop {
-            if self.seat.removed() {
-                break;
-            }
-            let mut any_events = false;
-            while let Some(event) = self.seat.event() {
-                global.event(event);
-                any_events = true;
-            }
-            if any_events {
-                _node = self.state.seat_queue.add_last(global.clone());
-            }
-            ae.triggered().await;
-        }
-        global.set_cursor(None);
-        let _ = self.state.remove_global(&*global);
-        self.state.seats.borrow_mut().remove(&self.seat.id());
-    }
-}
-
-async fn tree_changed(state: Rc<State>, global: Rc<WlSeatGlobal>, tree_changed: Rc<AsyncEvent>) {
-    loop {
-        tree_changed.triggered().await;
-        state.tree_changed_sent.set(false);
-        global.tree_changed();
-    }
-}