Merge pull request #307 from wash2/kbd_repeat

feat: keyboard repetition

Author: wash2

examples/simple_window.rs

@@ -1,9 +1,11 @@
-use std::convert::TryInto;
+use std::{convert::TryInto, time::Duration};
 
+use calloop::{EventLoop, LoopHandle};
 use smithay_client_toolkit::{
     compositor::{CompositorHandler, CompositorState},
     delegate_compositor, delegate_keyboard, delegate_output, delegate_pointer, delegate_registry,
     delegate_seat, delegate_shm, delegate_xdg_shell, delegate_xdg_window,
+    event_loop::WaylandSource,
     output::{OutputHandler, OutputState},
     registry::{ProvidesRegistryState, RegistryState},
     registry_handlers,
@@ -32,8 +34,12 @@ fn main() {
 
     let conn = Connection::connect_to_env().unwrap();
 
-    let (globals, mut event_queue) = registry_queue_init(&conn).unwrap();
+    let (globals, event_queue) = registry_queue_init(&conn).unwrap();
     let qh = event_queue.handle();
+    let mut event_loop: EventLoop<SimpleWindow> =
+        EventLoop::try_new().expect("Failed to initialize the event loop!");
+    let loop_handle = event_loop.handle();
+    WaylandSource::new(event_queue).unwrap().insert(loop_handle).unwrap();
 
     let mut simple_window = SimpleWindow {
         registry_state: RegistryState::new(&globals),
@@ -56,6 +62,7 @@ fn main() {
         keyboard: None,
         keyboard_focus: false,
         pointer: None,
+        loop_handle: event_loop.handle(),
     };
 
     let pool = SlotPool::new(
@@ -80,7 +87,7 @@ fn main() {
     // We don't draw immediately, the configure will notify us when to first draw.
 
     loop {
-        event_queue.blocking_dispatch(&mut simple_window).unwrap();
+        event_loop.dispatch(Duration::from_millis(16), &mut simple_window).unwrap();
 
         if simple_window.exit {
             println!("exiting example");
@@ -109,6 +116,7 @@ struct SimpleWindow {
     keyboard: Option<wl_keyboard::WlKeyboard>,
     keyboard_focus: bool,
     pointer: Option<wl_pointer::WlPointer>,
+    loop_handle: LoopHandle<'static, SimpleWindow>,
 }
 
 impl CompositorHandler for SimpleWindow {
@@ -213,8 +221,15 @@ impl SeatHandler for SimpleWindow {
     ) {
         if capability == Capability::Keyboard && self.keyboard.is_none() {
             println!("Set keyboard capability");
-            let keyboard =
-                self.seat_state.get_keyboard(qh, &seat, None).expect("Failed to create keyboard");
+            let (keyboard, source) = self
+                .seat_state
+                .get_keyboard_with_repeat(qh, &seat, None)
+                .expect("Failed to create keyboard");
+            self.loop_handle
+                .insert_source(source, |e, _, _state| {
+                    dbg!(e);
+                })
+                .expect("Failed to insert the repeating keyboard into the event loop");
             self.keyboard = Some(keyboard);
         }
 

src/seat/keyboard/mod.rs

@@ -21,7 +21,13 @@ use xkbcommon::xkb;
 
 use super::{Capability, SeatError, SeatHandler, SeatState};
 
+#[cfg(feature = "calloop")]
+pub mod repeat;
+#[cfg(feature = "calloop")]
+use repeat::RepeatMessage;
+
 /// Error when creating a keyboard.
+#[must_use]
 #[derive(Debug, thiserror::Error)]
 pub enum KeyboardError {
     /// Seat error.
@@ -210,7 +216,7 @@ pub trait KeyboardHandler: Sized {
 }
 
 /// The rate at which a pressed key is repeated.
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy)]
 pub enum RepeatInfo {
     /// Keys will be repeated at the specified rate and delay.
     Repeat {
@@ -308,6 +314,9 @@ pub struct KeyboardData {
     user_specified_rmlvo: bool,
     xkb_state: Mutex<Option<xkb::State>>,
     xkb_compose: Mutex<Option<xkb::compose::State>>,
+    #[cfg(feature = "calloop")]
+    repeat_sender: Option<calloop::channel::Sender<RepeatMessage>>,
+    current_repeat: Mutex<Option<KeyEvent>>,
 }
 
 impl Debug for KeyboardData {
@@ -350,6 +359,8 @@ impl Default for KeyboardData {
             xkb_state: Mutex::new(None),
             user_specified_rmlvo: false,
             xkb_compose: Mutex::new(None),
+            repeat_sender: None,
+            current_repeat: Mutex::new(None),
         };
 
         udata.init_compose();
@@ -383,6 +394,8 @@ impl KeyboardData {
             xkb_state: Mutex::new(xkb_state),
             user_specified_rmlvo: true,
             xkb_compose: Mutex::new(None),
+            repeat_sender: None,
+            current_repeat: Mutex::new(None),
         };
 
         udata.init_compose();
@@ -432,12 +445,17 @@ impl KeyboardData {
 
 pub trait KeyboardDataExt: Send + Sync {
     fn keyboard_data(&self) -> &KeyboardData;
+    fn keyboard_data_mut(&mut self) -> &mut KeyboardData;
 }
 
 impl KeyboardDataExt for KeyboardData {
     fn keyboard_data(&self) -> &KeyboardData {
         self
     }
+
+    fn keyboard_data_mut(&mut self) -> &mut KeyboardData {
+        self
+    }
 }
 
 impl<D, U> Dispatch<wl_keyboard::WlKeyboard, U, D> for SeatState
@@ -560,6 +578,13 @@ where
             wl_keyboard::Event::Leave { serial, surface } => {
                 // We can send this event without any other checks in the protocol will guarantee a leave is
                 // sent before entering a new surface.
+                #[cfg(feature = "calloop")]
+                {
+                    if let Some(repeat_sender) = &udata.repeat_sender {
+                        let _ = repeat_sender.send(RepeatMessage::StopRepeat);
+                    }
+                }
+
                 data.leave(conn, qh, keyboard, &surface, serial);
             }
 
@@ -598,10 +623,44 @@ where
 
                         match state {
                             wl_keyboard::KeyState::Released => {
+                                #[cfg(feature = "calloop")]
+                                {
+                                    if let Some(repeat_sender) = &udata.repeat_sender {
+                                        let mut current_repeat =
+                                            udata.current_repeat.lock().unwrap();
+                                        if Some(event.raw_code)
+                                            == current_repeat.as_ref().map(|r| r.raw_code)
+                                        {
+                                            current_repeat.take();
+                                            let _ = repeat_sender.send(RepeatMessage::StopRepeat);
+                                        }
+                                    }
+                                }
                                 data.release_key(conn, qh, keyboard, serial, event);
                             }
 
                             wl_keyboard::KeyState::Pressed => {
+                                #[cfg(feature = "calloop")]
+                                {
+                                    if let Some(repeat_sender) = &udata.repeat_sender {
+                                        let state_guard = udata.xkb_state.lock().unwrap();
+                                        let key_repeats = state_guard
+                                            .as_ref()
+                                            .map(|guard| {
+                                                guard.get_keymap().key_repeats(event.raw_code + 8)
+                                            })
+                                            .unwrap_or_default();
+                                        if key_repeats {
+                                            udata
+                                                .current_repeat
+                                                .lock()
+                                                .unwrap()
+                                                .replace(event.clone());
+                                            let _ = repeat_sender
+                                                .send(RepeatMessage::StartRepeat(event.clone()));
+                                        }
+                                    }
+                                }
                                 data.press_key(conn, qh, keyboard, serial, event);
                             }
 
@@ -626,7 +685,46 @@ where
 
                 let mask = match guard.as_mut() {
                     Some(state) => {
-                        state.update_mask(mods_depressed, mods_latched, mods_locked, 0, 0, group)
+                        let mask = state.update_mask(
+                            mods_depressed,
+                            mods_latched,
+                            mods_locked,
+                            0,
+                            0,
+                            group,
+                        );
+
+                        // update current repeating key
+                        let mut current_event = udata.current_repeat.lock().unwrap();
+                        if let Some(mut event) = current_event.take() {
+                            if let Some(repeat_sender) = &udata.repeat_sender {
+                                // apply new modifiers to get new utf8
+                                let utf8 = {
+                                    let mut compose = udata.xkb_compose.lock().unwrap();
+
+                                    match compose.as_mut() {
+                                        Some(compose) => match compose.feed(event.keysym) {
+                                            xkb::FeedResult::Ignored => None,
+                                            xkb::FeedResult::Accepted => match compose.status() {
+                                                xkb::Status::Composed => compose.utf8(),
+                                                xkb::Status::Nothing => {
+                                                    Some(state.key_get_utf8(event.raw_code + 8))
+                                                }
+                                                _ => None,
+                                            },
+                                        },
+
+                                        // No compose
+                                        None => Some(state.key_get_utf8(event.raw_code + 8)),
+                                    }
+                                };
+                                event.utf8 = utf8;
+
+                                current_event.replace(event.clone());
+                                let _ = repeat_sender.send(RepeatMessage::StartRepeat(event));
+                            }
+                        }
+                        mask
                     }
                     None => return,
                 };
@@ -650,6 +748,13 @@ where
                     RepeatInfo::Disable
                 };
 
+                #[cfg(feature = "calloop")]
+                {
+                    if let Some(repeat_sender) = &udata.repeat_sender {
+                        let _ = repeat_sender.send(RepeatMessage::RepeatInfo(info));
+                    }
+                }
+
                 data.update_repeat_info(conn, qh, keyboard, info);
             }