autocommit 2022-03-09 17:51:17 CET

src/backends/metal/input.rs

@@ -1,9 +1,36 @@
 use crate::async_engine::FdStatus;
-use crate::libinput::consts::LIBINPUT_EVENT_KEYBOARD_KEY;
 use crate::libinput::event::LibInputEvent;
 use crate::metal::MetalBackend;
 use crate::ErrorFmt;
 use std::rc::Rc;
+use crate::backend::{InputEvent, KeyState};
+use crate::libinput::consts::LIBINPUT_KEY_STATE_PRESSED;
+
+macro_rules! unpack {
+    ($slf:expr, $ev:expr) => {
+        {
+            let slot = match $ev.device().slot() {
+                Some(s) => s,
+                _ => return,
+            };
+            let data = match $slf.device_holder.input_devices_.borrow_mut().get(slot).cloned().and_then(|v| v) {
+                Some(d) => d,
+                _ => return,
+            };
+            data
+        }
+    };
+    ($slf:expr, $ev:expr, $conv:ident) => {
+        {
+            let event = match $ev.$conv() {
+                Some(e) => e,
+                _ => return,
+            };
+            let data = unpack!($slf, $ev);
+            (event, data)
+        }
+    };
+}
 
 impl MetalBackend {
     pub async fn handle_libinput_events(self: Rc<Self>) {
@@ -34,22 +61,40 @@ impl MetalBackend {
     }
 
     fn handle_event(self: &Rc<Self>, event: LibInputEvent) {
+        use crate::libinput::consts as c;
+
         match event.ty() {
-            LIBINPUT_EVENT_KEYBOARD_KEY => self.handle_keyboard_event(event),
+            c::LIBINPUT_EVENT_DEVICE_ADDED => self.handle_device_added(event),
+            c::LIBINPUT_EVENT_DEVICE_REMOVED => self.handle_device_removed(event),
+            c::LIBINPUT_EVENT_KEYBOARD_KEY => self.handle_keyboard_key(event),
+            c::LIBINPUT_EVENT_POINTER_MOTION => self.handle_pointer_motion(event),
             _ => {}
         }
     }
 
-    fn handle_keyboard_event(self: &Rc<Self>, event: LibInputEvent) {
-        let event = match event.keyboard_event() {
-            Some(event) => event,
-            _ => return,
+    fn handle_device_added(self: &Rc<Self>, _event: LibInputEvent) {
+        // let dev = unpack!(self, event);
+    }
+
+    fn handle_device_removed(self: &Rc<Self>, event: LibInputEvent) {
+        let dev = unpack!(self, event);
+        self.device_holder.input_devices.remove(&dev.devnum);
+        self.device_holder.input_devices_.borrow_mut()[dev.slot] = None;
+        event.device().unset_slot();
+    }
+
+    fn handle_keyboard_key(self: &Rc<Self>, event: LibInputEvent) {
+        let (event, dev) = unpack!(self, event, keyboard_event);
+        let state = if event.key_state() == LIBINPUT_KEY_STATE_PRESSED {
+            KeyState::Pressed
+        } else {
+            KeyState::Released
         };
-        log::info!(
-            "key: {}, state: {:?}, time: {}",
-            event.key(),
-            event.key_state(),
-            event.time_usec()
-        );
+        dev.event(InputEvent::Key(event.key(), state));
+    }
+
+    fn handle_pointer_motion(self: &Rc<Self>, event: LibInputEvent) {
+        let (event, dev) = unpack!(self, event, pointer_event);
+        dev.event(InputEvent::Motion(event.dx().into(), event.dy().into()));
     }
 }

src/backends/metal/monitor.rs

@@ -1,9 +1,11 @@
+use std::cell::Cell;
 use crate::async_engine::FdStatus;
 use crate::dbus::TRUE;
 use crate::metal::{MetalBackend, MetalDevice, MetalError};
 use crate::udev::UdevDevice;
 use crate::ErrorFmt;
 use std::rc::Rc;
+use crate::backend::BackendEvent;
 
 impl MetalBackend {
     pub async fn monitor_devices(self: Rc<Self>) {
@@ -54,8 +56,11 @@ impl MetalBackend {
     }
 
     fn add_input_device(self: &Rc<Self>, dev: &UdevDevice) {
+        if !dev.is_initialized() {
+            return;
+        }
         let slf = self.clone();
-        let device_id = self.id();
+        let device_id = self.state.input_device_ids.next();
         let devnum = dev.devnum();
         let devnode = match dev.devnode() {
             Ok(n) => n,
@@ -83,12 +88,15 @@ impl MetalBackend {
         };
         let dev = Rc::new(MetalDevice {
             slot,
-            device_id,
+            id: device_id,
             devnum,
             fd: Default::default(),
             inputdev: Default::default(),
             devnode: devnode.to_owned(),
-            sysname: sysname.to_owned(),
+            _sysname: sysname.to_owned(),
+            removed: Cell::new(false),
+            events: Default::default(),
+            cb: Default::default(),
         });
         slots[slot] = Some(dev.clone());
         self.device_holder.input_devices.set(devnum, dev);
@@ -97,7 +105,7 @@ impl MetalBackend {
             let mut slots = slf.device_holder.input_devices_.borrow_mut();
             let dev = 'dev: {
                 if let Some(dev) = id.get(&devnum) {
-                    if dev.device_id == device_id {
+                    if dev.id == device_id {
                         break 'dev dev;
                     }
                 }
@@ -126,6 +134,7 @@ impl MetalBackend {
             };
             inputdev.device().set_slot(slot);
             dev.inputdev.set(Some(inputdev));
+            slf.state.backend_events.push(BackendEvent::NewInputDevice(dev.clone()));
         });
     }
 }