Merge pull request #340 from Ph4ntomas/324-window_handle-swap

window: Add method to swap two windows

Author: Ottatop

api/lua/pinnacle/grpc/defs.lua

@@ -1210,6 +1210,12 @@ local pinnacle_window_v1_DecorationMode = {
 ---@class pinnacle.window.v1.ResizeGrabRequest
 ---@field button integer?
 
+---@class pinnacle.window.v1.SwapRequest
+---@field window_id integer?
+---@field target_id integer?
+
+---@class pinnacle.window.v1.SwapResponse
+
 ---@class pinnacle.window.v1.WindowRuleRequest
 ---@field finished pinnacle.window.v1.WindowRuleRequest.Finished?
 
@@ -1427,6 +1433,8 @@ pinnacle.window.v1.MoveToOutputRequest = {}
 pinnacle.window.v1.RaiseRequest = {}
 pinnacle.window.v1.MoveGrabRequest = {}
 pinnacle.window.v1.ResizeGrabRequest = {}
+pinnacle.window.v1.SwapRequest = {}
+pinnacle.window.v1.SwapResponse = {}
 pinnacle.window.v1.WindowRuleRequest = {}
 pinnacle.window.v1.WindowRuleRequest.Finished = {}
 pinnacle.window.v1.WindowRuleResponse = {}
@@ -3256,6 +3264,23 @@ pinnacle.window.v1.WindowService.ResizeGrab.response = ".google.protobuf.Empty"
 function Client:pinnacle_window_v1_WindowService_ResizeGrab(data)
     return self:unary_request(pinnacle.window.v1.WindowService.ResizeGrab, data)
 end
+pinnacle.window.v1.WindowService.Swap = {}
+pinnacle.window.v1.WindowService.Swap.service = "pinnacle.window.v1.WindowService"
+pinnacle.window.v1.WindowService.Swap.method = "Swap"
+pinnacle.window.v1.WindowService.Swap.request = ".pinnacle.window.v1.SwapRequest"
+pinnacle.window.v1.WindowService.Swap.response = ".pinnacle.window.v1.SwapResponse"
+
+---Performs a unary request.
+---
+---@nodiscard
+---
+---@param data pinnacle.window.v1.SwapRequest
+---
+---@return pinnacle.window.v1.SwapResponse | nil response
+---@return string | nil error An error string, if any
+function Client:pinnacle_window_v1_WindowService_Swap(data)
+    return self:unary_request(pinnacle.window.v1.WindowService.Swap, data)
+end
 pinnacle.window.v1.WindowService.WindowRule = {}
 pinnacle.window.v1.WindowService.WindowRule.service = "pinnacle.window.v1.WindowService"
 pinnacle.window.v1.WindowService.WindowRule.method = "WindowRule"

api/lua/pinnacle/window.lua

@@ -743,6 +743,23 @@ function WindowHandle:in_direction(direction)
     return response and window_handle.new_from_table(response.window_ids or {}) or {}
 end
 
+---Swap position with another window.
+---
+---@param target pinnacle.window.WindowHandle
+function WindowHandle:swap(target)
+    if target == nil or target.id == nil then
+        log.error("Invalid window handle")
+        return
+    end
+
+    local _, err =
+        client:pinnacle_window_v1_WindowService_Swap({ window_id = self.id, target_id = target.id })
+
+    if err then
+        log.error(err)
+    end
+end
+
 ---Creates a new `WindowHandle` from an id.
 ---@param window_id integer
 ---@return pinnacle.window.WindowHandle

api/protobuf/pinnacle/window/v1/window.proto

@@ -165,6 +165,12 @@ message ResizeGrabRequest {
   uint32 button = 1;
 }
 
+message SwapRequest {
+  uint32 window_id = 1;
+  uint32 target_id = 2;
+}
+message SwapResponse {}
+
 message WindowRuleRequest {
   message Finished {
     uint32 request_id = 1;
@@ -213,6 +219,7 @@ service WindowService {
   rpc Raise(RaiseRequest) returns (google.protobuf.Empty);
   rpc MoveGrab(MoveGrabRequest) returns (google.protobuf.Empty);
   rpc ResizeGrab(ResizeGrabRequest) returns (google.protobuf.Empty);
+  rpc Swap(SwapRequest) returns (SwapResponse);
 
   rpc WindowRule(stream WindowRuleRequest) returns (stream WindowRuleResponse);
 }

api/rust/src/window.rs

@@ -23,7 +23,7 @@ use pinnacle_api_defs::pinnacle::{
             MoveGrabRequest, MoveToOutputRequest, MoveToTagRequest, RaiseRequest,
             ResizeGrabRequest, ResizeTileRequest, SetDecorationModeRequest, SetFloatingRequest,
             SetFocusedRequest, SetFullscreenRequest, SetGeometryRequest, SetMaximizedRequest,
-            SetTagRequest, SetTagsRequest,
+            SetTagRequest, SetTagsRequest, SwapRequest,
         },
     },
 };
@@ -817,6 +817,21 @@ impl WindowHandle {
         response.window_ids.into_iter().map(WindowHandle::from_id)
     }
 
+    /// Swap position with another window.
+    pub fn swap(&self, target: &WindowHandle) {
+        self.swap_async(target).block_on_tokio()
+    }
+
+    /// Async impl for [`Self::swap`].
+    pub async fn swap_async(&self, target: &WindowHandle) {
+        let request = SwapRequest {
+            window_id: self.id,
+            target_id: target.id,
+        };
+
+        Client::window().swap(request).await.unwrap();
+    }
+
     /// Gets this window's raw compositor id.
     pub fn id(&self) -> u32 {
         self.id

src/api/window.rs

@@ -366,3 +366,72 @@ pub fn resize_grab(state: &mut State, button: u32) {
         state.schedule_render(&output);
     }
 }
+
+pub fn swap(state: &mut State, window: WindowElement, target: WindowElement) {
+    if state.pinnacle.layout_state.pending_swap {
+        return;
+    }
+
+    if window == target {
+        return;
+    }
+
+    let output = window.output(&state.pinnacle);
+    let target_output = target.output(&state.pinnacle);
+
+    let Some((output, target_output)) = output.zip(target_output) else {
+        tracing::warn!("Can't swap windows without output");
+        return;
+    };
+
+    tracing::debug!("Swapping window positions");
+    state.pinnacle.layout_state.pending_swap = true;
+
+    state.pinnacle.swap_window_positions(&window, &target);
+    if output != target_output {
+        tracing::debug!("Swapping window outputs");
+        window.set_tags_to_output(&target_output);
+        target.set_tags_to_output(&output);
+    }
+
+    // Swap floating attribute. In case of cross-output swap, this prevent window jumping back.
+    let window_floating_x = window.with_state(|state| state.floating_x);
+    let window_floating_y = window.with_state(|state| state.floating_y);
+    let window_floating_size = window.with_state(|state| state.floating_size);
+
+    let target_floating_x = target.with_state(|state| state.floating_x);
+    let target_floating_y = target.with_state(|state| state.floating_y);
+    let target_floating_size = target.with_state(|state| state.floating_size);
+
+    target.with_state_mut(|state| {
+        state.floating_x = window_floating_x;
+        state.floating_y = window_floating_y;
+        state.floating_size = window_floating_size
+    });
+
+    window.with_state_mut(|state| {
+        state.floating_x = target_floating_x;
+        state.floating_y = target_floating_y;
+        state.floating_size = target_floating_size
+    });
+
+    if window.with_state(|state| !state.layout_mode.is_tiled())
+        || target.with_state(|state| !state.layout_mode.is_tiled())
+    {
+        tracing::debug!("Swapping non tiled window");
+        let window_layout_mode = window.with_state(|state| state.layout_mode);
+        let target_layout_mode = target.with_state(|state| state.layout_mode);
+
+        state.update_window_layout_mode_and_layout(&window, |layout| {
+            layout.apply_mode(target_layout_mode)
+        });
+        state.update_window_layout_mode_and_layout(&target, |layout| {
+            layout.apply_mode(window_layout_mode)
+        });
+    } else {
+        state.pinnacle.request_layout(&output);
+        if output != target_output {
+            state.pinnacle.request_layout(&target_output);
+        }
+    }
+}

src/api/window/v1.rs

@@ -17,7 +17,7 @@ use pinnacle_api_defs::pinnacle::{
             MoveToTagRequest, RaiseRequest, ResizeGrabRequest, ResizeTileRequest,
             SetDecorationModeRequest, SetFloatingRequest, SetFocusedRequest, SetFullscreenRequest,
             SetGeometryRequest, SetMaximizedRequest, SetTagRequest, SetTagsRequest,
-            SetTagsResponse, WindowRuleRequest, WindowRuleResponse,
+            SetTagsResponse, SwapRequest, SwapResponse, WindowRuleRequest, WindowRuleResponse,
         },
     },
 };
@@ -727,6 +727,25 @@ impl v1::window_service_server::WindowService for super::WindowService {
         .await
     }
 
+    async fn swap(&self, request: Request<SwapRequest>) -> TonicResult<SwapResponse> {
+        let inner = request.into_inner();
+        let window_id = WindowId(inner.window_id);
+        let target_id = WindowId(inner.target_id);
+
+        run_unary(&self.sender, move |state| {
+            let window = window_id.window(&state.pinnacle);
+            let target = target_id.window(&state.pinnacle);
+
+            // Both window & target must be mapped
+            if let Some((window, target)) = window.zip(target) {
+                crate::api::window::swap(state, window, target);
+            };
+
+            Ok(SwapResponse {})
+        })
+        .await
+    }
+
     async fn window_rule(
         &self,
         request: Request<Streaming<WindowRuleRequest>>,

src/handlers/window.rs

@@ -66,7 +66,11 @@ impl State {
                     .pending_transactions
                     .add_for_output(
                         output,
-                        transaction_builder.into_pending(Vec::new(), false, false),
+                        transaction_builder.into_pending(
+                            Vec::new(),
+                            self.pinnacle.layout_state.pending_swap,
+                            false,
+                        ),
                     );
             } else {
                 // No changes were needed, we can map immediately here

src/window/window_state.rs

@@ -350,6 +350,23 @@ impl LayoutMode {
             }
         }
     }
+
+    /// Apply attributes from another LayoutMode.
+    ///
+    /// If other was Maximized or Fullscreen due to a client request, elevated_mode is use instead,
+    /// since the new value doesn't come from a client request.
+    pub fn apply_mode(&mut self, other: LayoutMode) {
+        self.elevated_mode = None;
+        self.client_requested_mode = None;
+
+        match other.current() {
+            LayoutModeKind::Tiled | LayoutModeKind::Floating | LayoutModeKind::Spilled => {
+                self.base_mode = other.base_mode;
+            }
+            LayoutModeKind::Maximized => self.set_maximized(true),
+            LayoutModeKind::Fullscreen => self.set_fullscreen(true),
+        }
+    }
 }
 
 /// State of a [`WindowElement`]