added cursor types

Reviewed-on: https://desktop-host/git/janis/wm/pulls/4

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wm"
-version = "0.2.1"
+version = "0.3.0"
 authors = ["noonebtw <noonebtw@gmail.com>"]
 edition = "2018"
 
@@ -11,16 +11,17 @@ path = "src/main.rs"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-x11 = {version = "2.18.2", features = ["xlib", "xft"] }
+x11 = {version = "2.19", features = ["xlib", "xft"] }
-log = "0.4.13"
+log = "0.4"
-simple_logger = "1.11.0"
+simple_logger = "2.0"
-dirs = "3.0.2"
+dirs = "3.0.0"
-log4rs = "1.0.0"
+log4rs = "1.0"
-indexmap = "1.6.2"
+indexmap = "1.0"
-thiserror = "1.0.30"
+thiserror = "1.0"
-bitflags = "1.3.2"
+bitflags = "1.3"
 derivative = "2.2.0"
 serde = { version = "1.0", features = ["derive"] }
 toml = "0.5"
-num-traits = "0.2.14"
+num-traits = "0.2"
 strum = {version = "0.24.0", features = ["derive"]}
+bytemuck = "1.0"

src/backends/mod.rs

@@ -18,4 +18,11 @@ pub mod structs {
         Dock,
         Desktop,
     }
+
+    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
+    pub enum Cursor {
+        Normal,
+        Resize,
+        Move,
+    }
 }

src/backends/window_event.rs

@@ -1,10 +1,13 @@
 #![allow(dead_code)]
 
-use super::keycodes::{KeyOrButton, MouseButton, VirtualKeyCode};
+use super::{
+    keycodes::{KeyOrButton, MouseButton, VirtualKeyCode},
+    structs::WindowType,
+};
 use crate::util::{Point, Size};
 use bitflags::bitflags;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum WindowEvent<Window> {
     KeyEvent(KeyEvent<Window>),
     ButtonEvent(ButtonEvent<Window>),
@@ -18,6 +21,7 @@ pub enum WindowEvent<Window> {
     ConfigureEvent(ConfigureEvent<Window>),
     FullscreenEvent(FullscreenEvent<Window>), //1 { window: Window, event: 1 },
     WindowNameEvent(WindowNameEvent<Window>),
+    WindowTypeChangedEvent(WindowTypeChangedEvent<Window>),
 }
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
@@ -107,7 +111,7 @@ impl Into<u8> for ModifierKey {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct KeyEvent<Window> {
     pub window: Window,
     pub state: KeyState,
@@ -131,7 +135,7 @@ impl<Window> KeyEvent<Window> {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ButtonEvent<Window> {
     pub window: Window,
     pub state: KeyState,
@@ -158,7 +162,7 @@ impl<Window> ButtonEvent<Window> {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct MotionEvent<Window> {
     pub position: Point<i32>,
     pub window: Window,
@@ -170,22 +174,22 @@ impl<Window> MotionEvent<Window> {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct MapEvent<Window> {
     pub window: Window,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct UnmapEvent<Window> {
     pub window: Window,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct EnterEvent<Window> {
     pub window: Window,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct DestroyEvent<Window> {
     pub window: Window,
 }
@@ -196,7 +200,7 @@ impl<Window> DestroyEvent<Window> {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct CreateEvent<Window> {
     pub window: Window,
     pub position: Point<i32>,
@@ -213,7 +217,7 @@ impl<Window> CreateEvent<Window> {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ConfigureEvent<Window> {
     pub window: Window,
     pub position: Point<i32>,
@@ -230,7 +234,7 @@ impl<Window> ConfigureEvent<Window> {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum FullscreenState {
     On,
     Off,
@@ -246,7 +250,7 @@ impl From<bool> for FullscreenState {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct FullscreenEvent<Window> {
     pub window: Window,
     pub state: FullscreenState,
@@ -258,7 +262,7 @@ impl<Window> FullscreenEvent<Window> {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct WindowNameEvent<Window> {
     pub window: Window,
     pub name: String,
@@ -270,6 +274,21 @@ impl<Window> WindowNameEvent<Window> {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct WindowTypeChangedEvent<Window> {
+    pub window: Window,
+    pub window_type: WindowType,
+}
+
+impl<Window> WindowTypeChangedEvent<Window> {
+    pub fn new(window: Window, window_type: WindowType) -> Self {
+        Self {
+            window,
+            window_type,
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct KeyBind {
     pub key: VirtualKeyCode,

src/backends/xlib/mod.rs

@@ -4,14 +4,15 @@ use std::{convert::TryFrom, ptr::NonNull, rc::Rc};
 
 use thiserror::Error;
 
-use x11::xlib::{self, Atom, Success, XEvent, XKeyEvent};
+use x11::xlib::{self, Atom, Success, Window, XEvent, XKeyEvent, XA_WINDOW};
 
 use crate::backends::{
     keycodes::KeyOrButton, xlib::keysym::mouse_button_to_xbutton,
 };
 
 use self::{
-    connection::XLibConnection,
+    connection::{PropMode, XLibConnection},
+    cursors::Cursors,
     ewmh::{EWMHAtom, EWMHAtoms},
     keysym::{
         keysym_to_virtual_keycode, virtual_keycode_to_keysym,
@@ -27,6 +28,7 @@ use super::{
         ButtonEvent, ConfigureEvent, DestroyEvent, EnterEvent, FullscreenEvent,
         FullscreenState, KeyEvent, KeyOrMouseBind, KeyState, MapEvent,
         ModifierState, MotionEvent, UnmapEvent, WindowEvent, WindowNameEvent,
+        WindowTypeChangedEvent,
     },
     WindowServerBackend,
 };
@@ -35,7 +37,7 @@ use crate::util::{Point, Size};
 pub mod color;
 pub mod keysym;
 
-pub type XLibWindowEvent = WindowEvent<xlib::Window>;
+pub type XLibWindowEvent = WindowEvent<Window>;
 
 #[derive(Clone)]
 pub struct Display(Rc<NonNull<x11::xlib::Display>>);
@@ -122,6 +124,7 @@ pub mod wmh {
         WmTakeFocus,
         WmState,
         WmTransientFor,
+        Utf8String,
     }
 
     #[derive(Debug, Clone)]
@@ -185,6 +188,7 @@ pub mod wmh {
                 ICCCMAtom::WmTakeFocus => "WM_TAKE_FOCUS",
                 ICCCMAtom::WmState => "WM_STATE",
                 ICCCMAtom::WmTransientFor => "WM_TRANSIENT_FOR",
+                ICCCMAtom::Utf8String => "UTF8_STRING",
             }
         }
     }
@@ -472,12 +476,14 @@ pub mod ewmh {
 pub mod connection {
     use std::{
         ffi::CString,
+        mem::size_of,
         os::raw::{c_char, c_long},
     };
 
+    use bytemuck::from_bytes;
     use x11::xlib::{self, Atom, Window};
 
-    use super::Display;
+    use super::{xpointer::XPointer, Display};
 
     pub struct XLibConnection {
         display: Display,
@@ -539,6 +545,61 @@ pub mod connection {
             self.screen
         }
 
+        pub fn get_window_property(
+            &self,
+            window: Window,
+            atom: Atom,
+            atom_type: Atom,
+        ) -> Option<Vec<u8>> {
+            let mut format_returned = 0;
+            let mut items_returned = 0;
+            let mut bytes_after_return = 0;
+            let mut type_returned = 0;
+
+            let (ptr, success) =
+                XPointer::<u8>::build_with_result(|ptr| unsafe {
+                    xlib::XGetWindowProperty(
+                        self.dpy(),
+                        window,
+                        atom,
+                        0,
+                        4096 / 4,
+                        0,
+                        atom_type,
+                        &mut type_returned,
+                        &mut format_returned,
+                        &mut items_returned,
+                        &mut bytes_after_return,
+                        ptr as *mut _ as *mut _,
+                    ) == i32::from(xlib::Success)
+                });
+
+            success.then(|| ptr).flatten().map(|ptr| {
+                unsafe {
+                    std::slice::from_raw_parts(
+                        ptr.as_ptr(),
+                        items_returned as usize * format_returned as usize,
+                    )
+                }
+                .to_vec()
+            })
+        }
+
+        pub fn get_property_long(
+            &self,
+            window: Window,
+            atom: Atom,
+            atom_type: Atom,
+        ) -> Option<Vec<c_long>> {
+            self.get_window_property(window, atom, atom_type)
+                .map(|bytes| {
+                    bytes
+                        .chunks(size_of::<c_long>())
+                        .map(|bytes| *from_bytes::<c_long>(bytes))
+                        .collect::<Vec<_>>()
+                })
+        }
+
         pub fn get_text_property(
             &self,
             window: Window,
@@ -565,8 +626,15 @@ pub mod connection {
             }
         }
 
-        pub fn change_root_property_byte<T: AsRef<[u8]>>(
+        pub fn delete_property(&self, window: Window, atom: Atom) {
+            unsafe {
+                xlib::XDeleteProperty(self.dpy(), window, atom);
+            }
+        }
+
+        pub fn change_property_byte<T: AsRef<[u8]>>(
             &self,
+            window: Window,
             atom: Atom,
             atom_type: Atom,
             mode: PropMode,
@@ -575,7 +643,7 @@ pub mod connection {
             unsafe {
                 xlib::XChangeProperty(
                     self.dpy(),
-                    self.root,
+                    window,
                     atom,
                     atom_type,
                     8,
@@ -586,6 +654,38 @@ pub mod connection {
             }
         }
 
+        pub fn change_root_property_byte<T: AsRef<[u8]>>(
+            &self,
+            atom: Atom,
+            atom_type: Atom,
+            mode: PropMode,
+            data: T,
+        ) {
+            self.change_property_byte(self.root, atom, atom_type, mode, data)
+        }
+
+        pub fn change_property_long<T: AsRef<[c_long]>>(
+            &self,
+            window: Window,
+            atom: Atom,
+            atom_type: Atom,
+            mode: PropMode,
+            data: T,
+        ) {
+            unsafe {
+                xlib::XChangeProperty(
+                    self.dpy(),
+                    window,
+                    atom,
+                    atom_type,
+                    32,
+                    mode.into(),
+                    data.as_ref().as_ptr().cast::<u8>(),
+                    data.as_ref().len() as i32,
+                );
+            }
+        }
+
         pub fn change_root_property_long<T: AsRef<[c_long]>>(
             &self,
             atom: Atom,
@@ -593,18 +693,7 @@ pub mod connection {
             mode: PropMode,
             data: T,
         ) {
-            unsafe {
+            self.change_property_long(self.root, atom, atom_type, mode, data)
-                xlib::XChangeProperty(
-                    self.dpy(),
-                    self.root,
-                    atom,
-                    atom_type,
-                    32,
-                    mode.into(),
-                    data.as_ref().as_ptr().cast::<u8>(),
-                    data.as_ref().len() as i32,
-                );
-            }
         }
     }
 }
@@ -625,14 +714,77 @@ impl Display {
     }
 }
 
+mod cursors {
+    use std::{borrow::Borrow, ops::Index};
+
+    use x11::xlib::{Cursor as XCursor, XCreateFontCursor, XFreeCursor};
+
+    use crate::backends::structs::Cursor;
+
+    use super::connection::XLibConnection;
+
+    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
+    pub struct Cursors {
+        normal: XCursor,
+        resize: XCursor,
+        grab: XCursor,
+    }
+
+    impl Cursors {
+        const LEFT_PTR: u32 = 68;
+        const SIZING: u32 = 120;
+        const FLEUR: u32 = 52;
+
+        pub fn from_connection<C: Borrow<XLibConnection>>(con: C) -> Self {
+            unsafe {
+                Self {
+                    normal: XCreateFontCursor(
+                        con.borrow().dpy(),
+                        Self::LEFT_PTR,
+                    ),
+                    resize: XCreateFontCursor(con.borrow().dpy(), Self::SIZING),
+                    grab: XCreateFontCursor(con.borrow().dpy(), Self::FLEUR),
+                }
+            }
+        }
+
+        pub unsafe fn free<C: Borrow<XLibConnection>>(&self, con: C) {
+            unsafe {
+                XFreeCursor(con.borrow().dpy(), self.normal);
+                XFreeCursor(con.borrow().dpy(), self.resize);
+                XFreeCursor(con.borrow().dpy(), self.grab);
+            }
+        }
+    }
+
+    impl Index<Cursor> for Cursors {
+        type Output = XCursor;
+
+        fn index(&self, index: Cursor) -> &Self::Output {
+            match index {
+                Cursor::Normal => &self.normal,
+                Cursor::Resize => &self.resize,
+                Cursor::Move => &self.grab,
+            }
+        }
+    }
+}
+
 pub struct XLib {
     connection: Rc<XLibConnection>,
-    //atoms: XLibAtoms,
     atoms: ICCCMAtoms,
     ewmh_atoms: EWMHAtoms,
     keybinds: Vec<KeyOrMouseBind>,
     active_border_color: Option<color::XftColor>,
     inactive_border_color: Option<color::XftColor>,
+    wm_window: Window,
+    cursors: Cursors,
+}
+
+impl Drop for XLib {
+    fn drop(&mut self) {
+        unsafe { self.cursors.free(self.connection.clone()) };
+    }
 }
 
 impl XLib {
@@ -648,6 +800,20 @@ impl XLib {
             keybinds: Vec::new(),
             active_border_color: None,
             inactive_border_color: None,
+            cursors: Cursors::from_connection(con.clone()),
+            wm_window: unsafe {
+                xlib::XCreateSimpleWindow(
+                    con.dpy(),
+                    con.root(),
+                    0,
+                    0,
+                    1,
+                    1,
+                    0,
+                    0,
+                    0,
+                )
+            },
         }
     }
 
@@ -680,6 +846,34 @@ impl XLib {
         xlib::XSync(self.dpy(), 0);
 
         self.ewmh_atoms.set_supported_atoms(self.connection.clone());
+        self.connection.delete_property(
+            self.connection.root(),
+            self.ewmh_atoms[EWMHAtom::NetClientList],
+        );
+
+        self.connection.change_property_long(
+            self.wm_window,
+            self.ewmh_atoms[EWMHAtom::NetSupportingWmCheck],
+            XA_WINDOW,
+            PropMode::Replace,
+            &[self.wm_window as i64],
+        );
+
+        self.connection.change_property_long(
+            self.connection.root(),
+            self.ewmh_atoms[EWMHAtom::NetSupportingWmCheck],
+            XA_WINDOW,
+            PropMode::Replace,
+            &[self.wm_window as i64],
+        );
+
+        self.connection.change_property_byte(
+            self.wm_window,
+            self.ewmh_atoms[EWMHAtom::NetWmName],
+            self.atoms[ICCCMAtom::Utf8String],
+            PropMode::Replace,
+            "nirgendwm".as_bytes(),
+        );
     }
 
     //#[deprecated = "use `self.connection.dpy()` instead"]
@@ -803,28 +997,12 @@ impl XLib {
                     atom if atom
                         == self.ewmh_atoms[EWMHAtom::NetWmWindowType] =>
                     {
-                        if self
+                        Some(XLibWindowEvent::WindowTypeChangedEvent(
-                            .get_atom_property(
+                            WindowTypeChangedEvent::new(
                                 ev.window,
-                                self.ewmh_atoms[EWMHAtom::NetWmState],
+                                self.get_window_type(ev.window),
-                            )
-                            .map(|atom| {
-                                *atom
-                                    == self.ewmh_atoms
-                                        [EWMHAtom::NetWmStateFullscreen]
-                            })
-                            .unwrap_or(false)
-                        {
-                            debug!("fullscreen event");
-                            Some(XLibWindowEvent::FullscreenEvent(
-                                FullscreenEvent::new(
-                                    ev.window,
-                                    FullscreenState::On,
                             ),
                         ))
-                        } else {
-                            None
-                        }
                     }
                     _ => None,
                 }
@@ -872,7 +1050,7 @@ impl XLib {
     #[allow(dead_code)]
     fn get_window_attributes(
         &self,
-        window: xlib::Window,
+        window: Window,
     ) -> Option<xlib::XWindowAttributes> {
         let mut wa = unsafe {
             std::mem::MaybeUninit::<xlib::XWindowAttributes>::zeroed()
@@ -890,7 +1068,7 @@ impl XLib {
 
     fn get_atom_property(
         &self,
-        window: xlib::Window,
+        window: Window,
         atom: xlib::Atom,
     ) -> Option<xpointer::XPointer<xlib::Atom>> {
         let mut di = 0;
@@ -919,11 +1097,7 @@ impl XLib {
         success.then(|| atom_out).flatten()
     }
 
-    fn check_for_protocol(
+    fn check_for_protocol(&self, window: Window, proto: xlib::Atom) -> bool {
-        &self,
-        window: xlib::Window,
-        proto: xlib::Atom,
-    ) -> bool {
         let mut protos: *mut xlib::Atom = std::ptr::null_mut();
         let mut num_protos: i32 = 0;
 
@@ -946,7 +1120,7 @@ impl XLib {
         return false;
     }
 
-    fn send_protocol(&self, window: xlib::Window, proto: Atom) -> bool {
+    fn send_protocol(&self, window: Window, proto: Atom) -> bool {
         if self.check_for_protocol(window, proto) {
             let mut data = xlib::ClientMessageData::default();
             data.set_long(0, proto as i64);
@@ -1032,11 +1206,7 @@ impl XLib {
         None
     }
 
-    fn grab_key_or_button(
+    fn grab_key_or_button(&self, binding: &KeyOrMouseBind, window: Window) {
-        &self,
-        binding: &KeyOrMouseBind,
-        window: xlib::Window,
-    ) {
         let modmask = binding.modifiers.as_modmask(self);
 
         let numlock_mask = self
@@ -1090,11 +1260,7 @@ impl XLib {
     }
 
     #[allow(dead_code)]
-    fn ungrab_key_or_button(
+    fn ungrab_key_or_button(&self, binding: &KeyOrMouseBind, window: Window) {
-        &self,
-        binding: &KeyOrMouseBind,
-        window: xlib::Window,
-    ) {
         let modmask = binding.modifiers.as_modmask(self);
 
         let numlock_mask = self
@@ -1135,7 +1301,7 @@ impl XLib {
         }
     }
 
-    fn grab_global_keybinds(&self, window: xlib::Window) {
+    fn grab_global_keybinds(&self, window: Window) {
         for binding in self.keybinds.iter() {
             self.grab_key_or_button(binding, window);
         }
@@ -1197,7 +1363,7 @@ impl ModifierStateExt for ModifierState {
 }
 
 impl WindowServerBackend for XLib {
-    type Window = xlib::Window;
+    type Window = Window;
 
     fn build() -> Self {
         let xlib = Self::new();
@@ -1211,6 +1377,7 @@ impl WindowServerBackend for XLib {
             let ev = self.xevent_to_window_event(ev);
 
             if let Some(ev) = ev {
+                self.handle_event(ev.clone());
                 return ev;
             }
         }
@@ -1236,15 +1403,35 @@ impl WindowServerBackend for XLib {
                 }
 
                 self.grab_global_keybinds(event.window);
-            }
+
-            WindowEvent::ConfigureEvent(event) => {
+                // add window to client list
-                self.configure_window(
+                self.connection.change_root_property_long(
-                    event.window,
+                    self.ewmh_atoms[EWMHAtom::NetClientList],
-                    Some(event.size),
+                    XA_WINDOW,
-                    Some(event.position),
+                    PropMode::Append,
-                    None,
+                    &[event.window as i64],
                 );
             }
+            WindowEvent::DestroyEvent(event) => {
+                self.connection
+                    .get_property_long(
+                        self.connection.root(),
+                        self.ewmh_atoms[EWMHAtom::NetClientList],
+                        XA_WINDOW,
+                    )
+                    .map(|mut clients| {
+                        clients
+                            .retain(|&window| window as Window != event.window);
+
+                        self.connection.change_property_long(
+                            self.connection.root(),
+                            self.ewmh_atoms[EWMHAtom::NetClientList],
+                            XA_WINDOW,
+                            PropMode::Replace,
+                            &clients,
+                        );
+                    });
+            }
             _ => {}
         }
     }
@@ -1612,6 +1799,10 @@ pub mod xpointer {
             let result = cb(&mut ptr);
             (NonNull::new(ptr as *mut T).map(|ptr| Self(ptr)), result)
         }
+
+        pub fn as_ptr(&self) -> *const T {
+            self.0.as_ptr() as *const _
+        }
     }
 
     impl<T> AsRef<T> for XPointer<T> {

src/clients.rs

@@ -606,6 +606,20 @@ impl ClientState {
         }
     }
 
+    pub fn update_window_type<K>(&mut self, key: &K, window_type: WindowType)
+    where
+        K: ClientKey,
+    {
+        if let Some(client) = self.get_mut(key).into_option() {
+            client.window_type = window_type;
+
+            match window_type {
+                WindowType::Normal => self.set_floating(key),
+                _ => self.set_tiled(key),
+            };
+        }
+    }
+
     fn remove_from_virtual_screens<K>(&mut self, key: &K)
     where
         K: ClientKey,

src/state.rs

@@ -6,7 +6,7 @@ use x11::xlib::{self, Window};
 
 use crate::backends::structs::WindowType;
 use crate::backends::window_event::{
-    FullscreenEvent, FullscreenState, WindowNameEvent,
+    FullscreenEvent, FullscreenState, WindowNameEvent, WindowTypeChangedEvent,
 };
 use crate::util::{Point, Size};
 use crate::{
@@ -306,13 +306,6 @@ where
             &self.config.inactive_window_border_color,
         );
 
-        // add all already existing windows to the WM
-        if let Some(windows) = self.backend.all_windows() {
-            windows
-                .into_iter()
-                .for_each(|window| self.new_client(window));
-        }
-
         self
     }
 
@@ -431,8 +424,6 @@ where
                     self.button_event(&event);
                 }
                 WindowEvent::MapRequestEvent(MapEvent { window }) => {
-                    self.backend.handle_event(event);
-
                     if !self.clients.contains(&window) {
                         self.new_client(window);
                     }
@@ -448,9 +439,11 @@ where
                     self.do_move_resize_window(&event);
                 }
                 WindowEvent::ConfigureEvent(ConfigureEvent {
-                    window, ..
+                    window,
-                }) => {
+                    size,
-                    match self.clients.get(&window) {
+                    position,
+                    ..
+                }) => match self.clients.get(&window) {
                     ClientEntry::Tiled(client)
                     | ClientEntry::Floating(client) => {
                         self.backend.configure_window(
@@ -460,16 +453,13 @@ where
                             None,
                         )
                     }
-                        ClientEntry::Vacant => self.backend.handle_event(event),
+                    ClientEntry::Vacant => self.backend.configure_window(
-                    }
+                        window,
-                    // TODO
+                        Some(size),
-                    // match self.clients.get(&event.window).into_option() {
+                        Some(position),
-                    //     Some(client) => self
+                        None,
-                    //         .xlib
+                    ),
-                    //         .configure_client(client, self.clients.get_border()),
+                },
-                    //     None => self.xlib.configure_window(event),
-                    // }
-                }
                 WindowEvent::FullscreenEvent(FullscreenEvent {
                     window,
                     state,
@@ -506,6 +496,14 @@ where
                 WindowEvent::WindowNameEvent(WindowNameEvent { .. }) => {
                     info!("{:#?}", event);
                 }
+                WindowEvent::WindowTypeChangedEvent(
+                    WindowTypeChangedEvent {
+                        window,
+                        window_type,
+                    },
+                ) => {
+                    self.clients.update_window_type(&window, window_type);
+                }
 
                 // i dont think i actually have to handle destroy notify events.
                 // every window should be unmapped regardless