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

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