Refactor everything, add initial tiling code

1 files changed, 204 insertions, 43 deletions

diff --git a/src/niri.rs b/src/niri.rs
index e5246313..d856b8c6 100644
--- a/src/niri.rs
+++ b/src/niri.rs
@@ -1,9 +1,10 @@
+use std::collections::HashMap;
 use std::os::unix::io::AsRawFd;
 use std::sync::Arc;
 use std::time::Duration;
 
-use smithay::backend::renderer::element::render_elements;
 use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
+use smithay::backend::renderer::element::{render_elements, RenderElement};
 use smithay::backend::renderer::ImportAll;
 use smithay::desktop::space::{space_render_elements, SpaceRenderElements};
 use smithay::desktop::{PopupManager, Space, Window, WindowSurfaceType};
@@ -11,12 +12,14 @@ use smithay::input::keyboard::XkbConfig;
 use smithay::input::{Seat, SeatState};
 use smithay::output::Output;
 use smithay::reexports::calloop::generic::Generic;
-use smithay::reexports::calloop::{Interest, LoopHandle, LoopSignal, Mode, PostAction};
+use smithay::reexports::calloop::{Idle, Interest, LoopHandle, LoopSignal, Mode, PostAction};
 use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel::WmCapabilities;
-use smithay::reexports::wayland_server::backend::{ClientData, ClientId, DisconnectReason};
+use smithay::reexports::wayland_server::backend::{
+    ClientData, ClientId, DisconnectReason, GlobalId,
+};
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::reexports::wayland_server::{Display, DisplayHandle};
-use smithay::utils::{Logical, Point};
+use smithay::utils::{Logical, Point, SERIAL_COUNTER};
 use smithay::wayland::compositor::{CompositorClientState, CompositorState};
 use smithay::wayland::data_device::DataDeviceState;
 use smithay::wayland::output::OutputManagerState;
@@ -25,6 +28,7 @@ use smithay::wayland::shm::ShmState;
 use smithay::wayland::socket::ListeningSocketSource;
 
 use crate::backend::Backend;
+use crate::layout::MonitorSet;
 use crate::LoopData;
 
 pub struct Niri {
@@ -33,7 +37,18 @@ pub struct Niri {
     pub stop_signal: LoopSignal,
     pub display_handle: DisplayHandle,
 
-    pub space: Space<Window>,
+    // Each workspace corresponds to a Space. Each workspace generally has one Output mapped to it,
+    // however it may have none (when there are no outputs connected) or mutiple (when mirroring).
+    pub monitor_set: MonitorSet,
+
+    // This space does not actually contain any windows, but all outputs are mapped into it
+    // according to their global position.
+    pub global_space: Space<Window>,
+
+    // Windows which don't have a buffer attached yet.
+    pub unmapped_windows: HashMap<WlSurface, Window>,
+
+    pub output_state: HashMap<Output, OutputState>,
 
     // Smithay state.
     pub compositor_state: CompositorState,
@@ -45,13 +60,17 @@ pub struct Niri {
     pub popups: PopupManager,
 
     pub seat: Seat<Self>,
-    pub output: Option<Output>,
 
     pub pointer_buffer: SolidColorBuffer,
+}
 
-    // Set to `true` if there's a redraw queued on the event loop. Reset to `false` in redraw()
-    // which means that you cannot queue more than one redraw at once.
-    pub redraw_queued: bool,
+pub struct OutputState {
+    pub global: GlobalId,
+    // Set if there's a redraw queued on the event loop. Reset in redraw() which means that you
+    // cannot queue more than one redraw at once.
+    pub queued_redraw: Option<Idle<'static>>,
+    // Set to `true` when the output was redrawn and is waiting for a VBlank. Upon VBlank a redraw
+    // will always be queued, so you cannot queue a redraw while waiting for a VBlank.
     pub waiting_for_vblank: bool,
 }
 
@@ -90,8 +109,6 @@ impl Niri {
         seat.add_keyboard(xkb, 400, 30).unwrap();
         seat.add_pointer();
 
-        let space = Space::default();
-
         let socket_source = ListeningSocketSource::new_auto().unwrap();
         let socket_name = socket_source.socket_name().to_os_string();
         event_loop
@@ -130,7 +147,10 @@ impl Niri {
             stop_signal,
             display_handle,
 
-            space,
+            monitor_set: MonitorSet::new(),
+            global_space: Space::default(),
+            output_state: HashMap::new(),
+            unmapped_windows: HashMap::new(),
 
             compositor_state,
             xdg_shell_state,
@@ -141,60 +161,188 @@ impl Niri {
             popups: PopupManager::default(),
 
             seat,
-            output: None,
             pointer_buffer,
-            redraw_queued: false,
+        }
+    }
+
+    pub fn add_output(&mut self, output: Output) {
+        let x = self
+            .global_space
+            .outputs()
+            .map(|output| self.global_space.output_geometry(output).unwrap())
+            .map(|geom| geom.loc.x + geom.size.w)
+            .max()
+            .unwrap_or(0);
+
+        self.global_space.map_output(&output, (x, 0));
+        self.monitor_set.add_output(output.clone());
+
+        let state = OutputState {
+            global: output.create_global::<Niri>(&self.display_handle),
+            queued_redraw: None,
             waiting_for_vblank: false,
+        };
+        let rv = self.output_state.insert(output, state);
+        assert!(rv.is_none(), "output was already tracked");
+    }
+
+    pub fn remove_output(&mut self, output: &Output) {
+        let mut state = self.output_state.remove(output).unwrap();
+        self.display_handle.remove_global::<Niri>(state.global);
+
+        if let Some(idle) = state.queued_redraw.take() {
+            idle.cancel();
         }
+
+        self.monitor_set.remove_output(output);
+        self.global_space.unmap_output(output);
+        // FIXME: reposition outputs so they are adjacent.
+    }
+
+    pub fn output_resized(&mut self, output: Output) {
+        // FIXME resize windows etc
+        self.queue_redraw(output);
+    }
+
+    pub fn output_under(&self, pos: Point<f64, Logical>) -> Option<(&Output, Point<f64, Logical>)> {
+        let output = self.global_space.output_under(pos).next()?;
+        let pos_within_output = pos
+            - self
+                .global_space
+                .output_geometry(output)
+                .unwrap()
+                .loc
+                .to_f64();
+
+        Some((output, pos_within_output))
+    }
+
+    pub fn window_under(
+        &mut self,
+        pos: Point<f64, Logical>,
+    ) -> Option<(&mut Space<Window>, Window, Point<i32, Logical>)> {
+        let (output, pos_within_output) = self.output_under(pos)?;
+        let output = output.clone();
+
+        let space = &mut self.monitor_set.workspace_for_output(&output)?.space;
+        let output_pos = space.output_geometry(&output).unwrap().loc.to_f64();
+
+        let pos_within_space = pos_within_output + output_pos;
+        let (window, loc) = space.element_under(pos_within_space)?;
+        let window = window.clone();
+        Some((space, window, loc))
     }
 
     pub fn surface_under(
-        &self,
+        &mut self,
         pos: Point<f64, Logical>,
     ) -> Option<(WlSurface, Point<i32, Logical>)> {
-        self.space
-            .element_under(pos)
+        let (output, pos_within_output) = self.output_under(pos)?;
+        let output = output.clone();
+
+        let space = &self.monitor_set.workspace_for_output(&output)?.space;
+        let output_pos = space.output_geometry(&output).unwrap().loc.to_f64();
+
+        let pos_within_space = pos_within_output + output_pos;
+        space
+            .element_under(pos_within_space)
             .and_then(|(window, location)| {
                 window
-                    .surface_under(pos - location.to_f64(), WindowSurfaceType::ALL)
+                    .surface_under(pos_within_space - location.to_f64(), WindowSurfaceType::ALL)
                     .map(|(s, p)| (s, p + location))
             })
     }
 
+    /// Returns the surface under cursor and its position in the global space.
+    ///
+    /// Pointer needs location in global space, and focused window location compatible with that
+    /// global space. We don't have a global space for all windows, but this function converts the
+    /// window location temporarily to the current global space.
+    pub fn surface_under_and_global_space(
+        &mut self,
+        pos: Point<f64, Logical>,
+    ) -> Option<(WlSurface, Point<i32, Logical>)> {
+        let (output, pos_within_output) = self.output_under(pos)?;
+        let output = output.clone();
+
+        let workspace = &self.monitor_set.workspace_for_output(&output)?;
+        let space = &workspace.space;
+        let output_pos_in_local_space = space.output_geometry(&output).unwrap().loc;
+        let pos_within_space = pos_within_output + output_pos_in_local_space.to_f64();
+
+        let (surface, surface_loc_in_local_space) = space
+            .element_under(pos_within_space)
+            .and_then(|(window, location)| {
+                window
+                    .surface_under(pos_within_space - location.to_f64(), WindowSurfaceType::ALL)
+                    .map(|(s, p)| (s, p + location))
+            })?;
+        let output_pos_in_global_space = self.global_space.output_geometry(&output).unwrap().loc;
+        let surface_loc_in_global_space =
+            surface_loc_in_local_space - output_pos_in_local_space + output_pos_in_global_space;
+
+        Some((surface, surface_loc_in_global_space))
+    }
+
+    pub fn output_under_cursor(&self) -> Option<Output> {
+        let pos = self.seat.get_pointer().unwrap().current_location();
+        self.global_space.output_under(pos).next().cloned()
+    }
+
+    pub fn update_focus(&mut self) {
+        let focus = self
+            .monitor_set
+            .focus()
+            .map(|win| win.toplevel().wl_surface().clone());
+        let keyboard = self.seat.get_keyboard().unwrap();
+        if keyboard.current_focus() != focus {
+            keyboard.set_focus(self, focus, SERIAL_COUNTER.next_serial());
+            // FIXME: can be more granular.
+            self.queue_redraw_all();
+        }
+    }
+
+    /// Schedules an immediate redraw on all outputs if one is not already scheduled.
+    pub fn queue_redraw_all(&mut self) {
+        let outputs: Vec<_> = self.output_state.keys().cloned().collect();
+        for output in outputs {
+            self.queue_redraw(output);
+        }
+    }
+
     /// Schedules an immediate redraw if one is not already scheduled.
-    pub fn queue_redraw(&mut self) {
-        if self.redraw_queued || self.waiting_for_vblank {
+    pub fn queue_redraw(&mut self, output: Output) {
+        let state = self.output_state.get_mut(&output).unwrap();
+
+        if state.queued_redraw.is_some() || state.waiting_for_vblank {
             return;
         }
 
-        self.redraw_queued = true;
-
         // Timer::immediate() adds a millisecond of delay for some reason.
         // This should be fixed in calloop v0.11: https://github.com/Smithay/calloop/issues/142
-        self.event_loop.insert_idle(|data| {
+        let idle = self.event_loop.insert_idle(move |data| {
             let backend: &mut dyn Backend = if let Some(tty) = &mut data.tty {
                 tty
             } else {
                 data.winit.as_mut().unwrap()
             };
-            data.niri.redraw(backend);
+            data.niri.redraw(backend, &output);
         });
+        state.queued_redraw = Some(idle);
     }
 
-    fn redraw(&mut self, backend: &mut dyn Backend) {
+    fn redraw(&mut self, backend: &mut dyn Backend, output: &Output) {
         let _span = tracy_client::span!("redraw");
+        let state = self.output_state.get_mut(output).unwrap();
 
-        assert!(self.redraw_queued);
-        assert!(!self.waiting_for_vblank);
-        self.redraw_queued = false;
+        assert!(state.queued_redraw.take().is_some());
+        assert!(!state.waiting_for_vblank);
 
-        let elements = space_render_elements(
-            backend.renderer(),
-            [&self.space],
-            self.output.as_ref().unwrap(),
-            1.,
-        )
-        .unwrap();
+        let space = &self.monitor_set.workspace_for_output(output).unwrap().space;
+        let elements = space_render_elements(backend.renderer(), [space], output, 1.).unwrap();
+
+        let output_pos = self.global_space.output_geometry(output).unwrap().loc;
+        let pointer_pos = self.seat.get_pointer().unwrap().current_location() - output_pos.to_f64();
 
         let mut elements: Vec<_> = elements
             .into_iter()
@@ -204,20 +352,16 @@ impl Niri {
             0,
             OutputRenderElements::Pointer(SolidColorRenderElement::from_buffer(
                 &self.pointer_buffer,
-                self.seat
-                    .get_pointer()
-                    .unwrap()
-                    .current_location()
-                    .to_physical_precise_round(1.),
+                pointer_pos.to_physical_precise_round(1.),
                 1.,
                 1.,
             )),
         );
 
-        backend.render(self, &elements);
+        backend.render(self, output, &elements);
 
-        let output = self.output.as_ref().unwrap();
-        self.space.elements().for_each(|window| {
+        let space = &self.monitor_set.workspace_for_output(output).unwrap().space;
+        space.elements().for_each(|window| {
             window.send_frame(
                 output,
                 self.start_time.elapsed(),
@@ -234,6 +378,23 @@ render_elements! {
     Pointer = SolidColorRenderElement,
 }
 
+impl<R: ImportAll, E: RenderElement<R>> std::fmt::Debug for OutputRenderElements<R, E> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            OutputRenderElements::Space(_) => {
+                f.debug_tuple("OutputRenderElements::Space").finish()?
+            }
+            OutputRenderElements::Pointer(element) => f
+                .debug_tuple("OutputRenderElements::Pointer")
+                .field(element)
+                .finish()?,
+            _ => (),
+        }
+
+        Ok(())
+    }
+}
+
 #[derive(Default)]
 pub struct ClientState {
     pub compositor_state: CompositorClientState,