Add windows' fullscreen states to ipc

niri-ipc/src/lib.rs

@@ -1291,6 +1291,12 @@ pub struct Window {
     ///
     /// There can be either one focused window or zero (e.g. when a layer-shell surface has focus).
     pub is_focused: bool,
+    /// The fullscreen state of this window.
+    ///
+    /// - `0`: not fullscreen (tiled or floating)
+    /// - `1`: maximized
+    /// - `2`: fullscreen
+    pub fullscreen_state: u8,
     /// Whether this window is currently floating.
     ///
     /// If the window isn't floating then it is in the tiling layout.
@@ -1532,6 +1538,16 @@ pub enum Event {
         /// Id of the newly focused window, or `None` if no window is now focused.
         id: Option<u64>,
     },
+    /// A window's fullscreen state was changed changed.
+    WindowFullscreenStateChanged {
+        /// Id of the window.
+        id: u64,
+        /// Fullscreen state for the window
+        /// - `0`: not fullscreen (tiled or floating)
+        /// - `1`: maximized
+        /// - `2`: fullscreen
+        fullscreen_state: u8,
+    },
     /// Window focus timestamp changed.
     ///
     /// This event is separate from [`Event::WindowFocusChanged`] because the focus timestamp only

niri-ipc/src/state.rs

@@ -219,6 +219,17 @@ impl EventStreamStatePart for WindowsState {
                     win.layout = update;
                 }
             }
+            Event::WindowFullscreenStateChanged {
+                id,
+                fullscreen_state,
+            } => {
+                for win in self.windows.values_mut() {
+                    if win.id == id {
+                        win.fullscreen_state = fullscreen_state;
+                        break;
+                    }
+                }
+            }
             event => return Some(event),
         }
         None

src/ipc/client.rs

@@ -458,6 +458,12 @@ pub fn handle_msg(mut msg: Msg, json: bool) -> anyhow::Result<()> {
                     Event::WindowFocusChanged { id } => {
                         println!("Window focus changed: {id:?}");
                     }
+                    Event::WindowFullscreenStateChanged {
+                        id,
+                        fullscreen_state,
+                    } => {
+                        println!("Window {id}: fullscreen state changed to {fullscreen_state}");
+                    }
                     Event::WindowFocusTimestampChanged {
                         id,
                         focus_timestamp,
@@ -659,6 +665,8 @@ fn print_window(window: &Window) {
         if window.is_floating { "yes" } else { "no" }
     );
 
+    println!("  Fullscreen state: {}", window.fullscreen_state);
+
     if let Some(pid) = window.pid {
         println!("  PID: {pid}");
     } else {

src/ipc/server.rs

@@ -32,7 +32,7 @@ use smithay::wayland::shell::wlr_layer::{KeyboardInteractivity, Layer};
 
 use crate::backend::IpcOutputMap;
 use crate::input::pick_window_grab::PickWindowGrab;
-use crate::layout::workspace::WorkspaceId;
+use crate::layout::{workspace::WorkspaceId, LayoutElement};
 use crate::niri::State;
 use crate::utils::{version, with_toplevel_role};
 use crate::window::Mapped;
@@ -504,6 +504,9 @@ fn make_ipc_window(
     workspace_id: Option<WorkspaceId>,
     layout: WindowLayout,
 ) -> niri_ipc::Window {
+    // Quick hack to fix the consistent halting if we tried to access the sizing mode
+    // inside the constructor
+    let fullscreen_state = mapped.sizing_mode().into();
     with_toplevel_role(mapped.toplevel(), |role| niri_ipc::Window {
         id: mapped.id().get(),
         title: role.title.clone(),
@@ -512,6 +515,7 @@ fn make_ipc_window(
         workspace_id: workspace_id.map(|id| id.get()),
         is_focused: mapped.is_focused(),
         is_floating: mapped.is_floating(),
+        fullscreen_state,
         is_urgent: mapped.is_urgent(),
         layout,
         focus_timestamp: mapped.get_focus_timestamp().map(Timestamp::from),
@@ -726,6 +730,13 @@ impl State {
                 events.push(Event::WindowFocusChanged { id: Some(id) });
             }
 
+            if mapped.sizing_mode() != ipc_win.fullscreen_state.into() {
+                events.push(Event::WindowFullscreenStateChanged {
+                    id,
+                    fullscreen_state: mapped.sizing_mode().into(),
+                });
+            }
+
             let focus_timestamp = mapped.get_focus_timestamp().map(Timestamp::from);
             if focus_timestamp != ipc_win.focus_timestamp {
                 events.push(Event::WindowFocusTimestampChanged {

src/layout/mod.rs

@@ -526,6 +526,27 @@ impl SizingMode {
     }
 }
 
+impl From<u8> for SizingMode {
+    fn from(value: u8) -> Self {
+        match value {
+            0 => Self::Normal,
+            1 => Self::Maximized,
+            2 => Self::Fullscreen,
+            _ => Self::Normal,
+        }
+    }
+}
+
+impl From<SizingMode> for u8 {
+    fn from(value: SizingMode) -> Self {
+        match value {
+            SizingMode::Normal => 0,
+            SizingMode::Maximized => 1,
+            SizingMode::Fullscreen => 2,
+        }
+    }
+}
+
 impl<W: LayoutElement> InteractiveMoveState<W> {
     fn moving(&self) -> Option<&InteractiveMoveData<W>> {
         match self {