Unfocus window on X11 side when keyboard focus is lost

Closes #69 (nice)

src/server/event.rs

@@ -525,6 +525,24 @@ impl HandleEvent for Keyboard {
                     self.server.enter(serial, &data.server, keys);
                 }
             }
+            client::wl_keyboard::Event::Leave { serial, surface } => {
+                if !surface.is_alive() {
+                    return;
+                }
+                let key: ObjectKey = surface.data().copied().unwrap();
+                if let Some(data) = state
+                    .objects
+                    .get(key)
+                    .map(|o| <_ as AsRef<SurfaceData>>::as_ref(o))
+                {
+                    if state.to_focus == Some(data.window.unwrap()) {
+                        state.to_focus.take();
+                    } else {
+                        state.unfocus = true;
+                    }
+                    self.server.leave(serial, &data.server);
+                }
+            }
             _ => simple_event_shunt! {
                 self.server, event: client::wl_keyboard::Event => [
                     Keymap {
@@ -532,18 +550,6 @@ impl HandleEvent for Keyboard {
                         |fd| fd.as_fd(),
                         size
                     },
-                    Leave {
-                        serial,
-                        |surface| {
-                            if !surface.is_alive() {
-                                return;
-                            }
-                            let Some(surface_data) = state.get_server_surface_from_client(surface) else {
-                                return;
-                            };
-                            surface_data
-                        }
-                    },
                     Key {
                         serial,
                         time,

src/server/mod.rs

@@ -479,6 +479,7 @@ pub struct ServerState<C: XConnection> {
     qh: ClientQueueHandle,
     client: Option<Client>,
     to_focus: Option<x::Window>,
+    unfocus: bool,
     last_focused_toplevel: Option<x::Window>,
     last_hovered: Option<x::Window>,
     connection: Option<C>,
@@ -527,6 +528,7 @@ impl<C: XConnection> ServerState<C> {
             qh,
             dh,
             to_focus: None,
+            unfocus: false,
             last_focused_toplevel: None,
             last_hovered: None,
             connection: None,
@@ -832,7 +834,12 @@ impl<C: XConnection> ServerState<C> {
                 debug!("focusing window {win:?}");
                 conn.focus_window(win, data);
                 self.last_focused_toplevel = Some(win);
+            } else if self.unfocus {
+                let data = C::ExtraData::create(self);
+                let conn = self.connection.as_mut().unwrap();
+                conn.focus_window(x::WINDOW_NONE, data);
             }
+            self.unfocus = false;
         }
 
         self.handle_clipboard_events();

src/xstate/mod.rs

@@ -294,13 +294,6 @@ impl XState {
                 xcb::Event::X(x::Event::UnmapNotify(e)) => {
                     trace!("unmap event: {:?}", e.event());
                     server_state.unmap_window(e.window());
-                    unwrap_or_skip_bad_window_cont!(self.connection.send_and_check_request(
-                        &x::ChangeWindowAttributes {
-                            window: e.window(),
-                            value_list: &[x::Cw::EventMask(x::EventMask::empty())],
-                        }
-                    ));
-
                     let active_win = self
                         .connection
                         .wait_for_reply(self.get_property_cookie(
@@ -313,16 +306,19 @@ impl XState {
 
                     let active_win: &[x::Window] = active_win.value();
                     if active_win[0] == e.window() {
-                        self.connection
-                            .send_and_check_request(&x::ChangeProperty {
-                                mode: x::PropMode::Replace,
-                                window: self.root,
-                                property: self.atoms.active_win,
-                                r#type: x::ATOM_WINDOW,
-                                data: &[x::Window::none()],
-                            })
-                            .unwrap();
+                        <_ as super::XConnection>::focus_window(
+                            &mut self.connection,
+                            x::Window::none(),
+                            self.atoms.clone(),
+                        );
                     }
+
+                    unwrap_or_skip_bad_window_cont!(self.connection.send_and_check_request(
+                        &x::ChangeWindowAttributes {
+                            window: e.window(),
+                            value_list: &[x::Cw::EventMask(x::EventMask::empty())],
+                        }
+                    ));
                 }
                 xcb::Event::X(x::Event::DestroyNotify(e)) => {
                     debug!("destroying window {:?}", e.window());