merge set-size and set-position

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: Ktrompfl

jay-config/src/_private/client.rs

@@ -607,18 +607,28 @@ impl ConfigClient {
         (width, height)
     }
 
-    pub fn set_window_size(&self, window: Window, width: i32, height: i32) {
-        self.send(&ClientMessage::SetWindowSize {
+    #[expect(clippy::too_many_arguments)]
+    pub fn set_window_position(
+        &self,
+        window: Window,
+        x1: Option<i32>,
+        y1: Option<i32>,
+        x2: Option<i32>,
+        y2: Option<i32>,
+        width: Option<i32>,
+        height: Option<i32>,
+    ) {
+        self.send(&ClientMessage::SetWindowPosition {
             window,
+            x1,
+            y1,
+            x2,
+            y2,
             width,
             height,
         });
     }
 
-    pub fn set_window_position(&self, window: Window, x: i32, y: i32) {
-        self.send(&ClientMessage::SetWindowPosition { window, x, y });
-    }
-
     pub fn get_workspace_position(&self, workspace: Workspace) -> (i32, i32) {
         let res = self.send_with_response(&ClientMessage::GetWorkspacePosition { workspace });
         get_response!(res, (0, 0), GetWorkspacePosition { x, y });

jay-config/src/_private/ipc.rs

@@ -984,15 +984,14 @@ pub enum ClientMessage<'a> {
     GetWindowSize {
         window: Window,
     },
-    SetWindowSize {
-        window: Window,
-        width: i32,
-        height: i32,
-    },
     SetWindowPosition {
         window: Window,
-        x: i32,
-        y: i32,
+        x1: Option<i32>,
+        y1: Option<i32>,
+        x2: Option<i32>,
+        y2: Option<i32>,
+        width: Option<i32>,
+        height: Option<i32>,
     },
     GetWorkspacePosition {
         workspace: Workspace,

jay-config/src/input.rs

@@ -713,16 +713,19 @@ impl Seat {
         self.window().resize(dx1, dy1, dx2, dy2);
     }
 
-    /// Resizes the focused window to an absolute size.
-    pub fn set_size(self, width: i32, height: i32) {
-        self.window().set_size(width, height);
-    }
-
-    /// Sets the position of the focused window to an absolute value.
+    /// Sets the position and/or size of the focused window.
     ///
-    /// This only has an effect if the window is floating.
-    pub fn set_position(self, x: i32, y: i32) {
-        self.window().set_position(x, y);
+    /// See [`Window::set_position`](crate::window::Window::set_position) for details.
+    pub fn set_position(
+        self,
+        x1: Option<i32>,
+        y1: Option<i32>,
+        x2: Option<i32>,
+        y2: Option<i32>,
+        width: Option<i32>,
+        height: Option<i32>,
+    ) {
+        self.window().set_position(x1, y1, x2, y2, width, height);
     }
 
     /// Sets whether the cursor should automatically move to the center of a window

jay-config/src/window.rs

@@ -252,19 +252,31 @@ impl Window {
         get!((0, 0)).get_window_size(self)
     }
 
-    /// Resizes the window to an absolute size.
-    ///
-    /// This has the same effect as [`resize`](Self::resize) but takes the target size
-    /// instead of a delta.
-    pub fn set_size(self, width: i32, height: i32) {
-        get!().set_window_size(self, width, height);
-    }
-
-    /// Sets the position of the window in the global compositor space.
+    /// Sets the position and/or size of the window.
     ///
     /// This only has an effect if the window is floating.
-    pub fn set_position(self, x: i32, y: i32) {
-        get!().set_window_position(self, x, y);
+    ///
+    /// Every argument that is `None` is left unconstrained by this call. Every argument that
+    /// is `Some(_)` is constrained to that value.
+    ///
+    /// Since `x2 = x1 + width` (and analogously for the y axis), not every combination of
+    /// constraints is satisfiable. If `x1`, `x2`, and `width` are all constrained but not
+    /// self-consistent (and analogously for `y1`, `y2`, `height`), this call has no effect.
+    ///
+    /// If fewer than two of `x1`, `x2`, `width` are constrained (and analogously for `y1`,
+    /// `y2`, `height`), the missing values default to preserving the window's current size,
+    /// e.g. setting only `width` keeps `x1` fixed and moves `x2`, while setting only `x1` keeps
+    /// the width fixed and moves `x2` along with it.
+    pub fn set_position(
+        self,
+        x1: Option<i32>,
+        y1: Option<i32>,
+        x2: Option<i32>,
+        y2: Option<i32>,
+        width: Option<i32>,
+        height: Option<i32>,
+    ) {
+        get!().set_window_position(self, x1, y1, x2, y2, width, height);
     }
 }
 

src/config/handler.rs

@@ -3046,21 +3046,24 @@ impl ConfigProxyHandler {
         Ok(())
     }
 
-    fn handle_set_window_size(
+    fn handle_set_window_position(
         &self,
         window: Window,
-        width: i32,
-        height: i32,
+        x1: Option<i32>,
+        y1: Option<i32>,
+        x2: Option<i32>,
+        y2: Option<i32>,
+        width: Option<i32>,
+        height: Option<i32>,
     ) -> Result<(), CphError> {
-        if width <= 0 || height <= 0 {
-            return Err(CphError::InvalidWindowSize(width, height));
+        let tl = self.get_window(window)?;
+        let pos = tl.node_absolute_position(LiveTL);
+        let (x1, x2) = resolve_geometry_axis(x1, x2, width, pos.x1(), pos.x2())?;
+        let (y1, y2) = resolve_geometry_axis(y1, y2, height, pos.y1(), pos.y2())?;
+        if x2 - x1 <= 0 || y2 - y1 <= 0 {
+            return Err(CphError::InvalidWindowSize(x2 - x1, y2 - y1));
         }
-        self.get_window(window)?.tl_set_size(width, height);
-        Ok(())
-    }
-
-    fn handle_set_window_position(&self, window: Window, x: i32, y: i32) -> Result<(), CphError> {
-        self.get_window(window)?.tl_set_position(x, y);
+        tl.tl_set_geometry(x1, y1, x2, y2);
         Ok(())
     }
 
@@ -3995,15 +3998,16 @@ impl ConfigProxyHandler {
             ClientMessage::GetWindowSize { window } => {
                 self.handle_get_window_size(window).wrn("get_window_size")?
             }
-            ClientMessage::SetWindowSize {
+            ClientMessage::SetWindowPosition {
                 window,
+                x1,
+                y1,
+                x2,
+                y2,
                 width,
                 height,
             } => self
-                .handle_set_window_size(window, width, height)
-                .wrn("set_window_size")?,
-            ClientMessage::SetWindowPosition { window, x, y } => self
-                .handle_set_window_position(window, x, y)
+                .handle_set_window_position(window, x1, y1, x2, y2, width, height)
                 .wrn("set_window_position")?,
             ClientMessage::GetWorkspacePosition { workspace } => self
                 .handle_get_workspace_position(workspace)
@@ -4175,6 +4179,42 @@ impl ConfigProxyHandler {
     }
 }
 
+/// Resolves the constraints on a single axis (x1/x2/width or y1/y2/height) of
+/// [`ConfigProxyHandler::handle_set_window_position`] into a concrete `(c1, c2)` pair.
+///
+/// `c1`, `c2` and `size` are constrained to their contained value if they are `Some(_)` and
+/// are otherwise unconstrained.
+///
+/// If two of the three are constrained, the third is derived from them. If only one is
+/// constrained, the window keeps its current size (if `c1` or `c2` is constrained) or its
+/// current position (if only `size` is constrained). If none are constrained, the axis is
+/// left unchanged. If all three are constrained but not self-consistent, an error is returned.
+fn resolve_geometry_axis(
+    c1: Option<i32>,
+    c2: Option<i32>,
+    size: Option<i32>,
+    cur_c1: i32,
+    cur_c2: i32,
+) -> Result<(i32, i32), CphError> {
+    let cur_size = cur_c2.saturating_sub(cur_c1);
+    let res = match (c1, c2, size) {
+        (Some(c1), Some(c2), Some(size)) => {
+            if c2.saturating_sub(c1) != size {
+                return Err(CphError::InconsistentWindowGeometry);
+            }
+            (c1, c2)
+        }
+        (Some(c1), Some(c2), None) => (c1, c2),
+        (Some(c1), None, Some(size)) => (c1, c1.saturating_add(size)),
+        (None, Some(c2), Some(size)) => (c2.saturating_sub(size), c2),
+        (Some(c1), None, None) => (c1, c1.saturating_add(cur_size)),
+        (None, Some(c2), None) => (c2.saturating_sub(cur_size), c2),
+        (None, None, Some(size)) => (cur_c1, cur_c1.saturating_add(size)),
+        (None, None, None) => (cur_c1, cur_c2),
+    };
+    Ok(res)
+}
+
 #[derive(Debug, Error)]
 enum CphError {
     #[error("Tried to set an unknown accel profile: {}", (.0).0)]
@@ -4207,6 +4247,8 @@ enum CphError {
     InvalidConnectorPosition(i32, i32),
     #[error("{0}x{1} is not a valid window size")]
     InvalidWindowSize(i32, i32),
+    #[error("The given x1/x2/width or y1/y2/height constraints are not self-consistent")]
+    InconsistentWindowGeometry,
     #[error("Keymap {0:?} does not exist")]
     KeymapDoesNotExist(Keymap),
     #[error("Seat {0:?} does not exist")]

src/tree/toplevel.rs

@@ -79,8 +79,7 @@ pub trait ToplevelNode: ToplevelNodeBase {
     fn tl_mark_ancestor_fullscreen(&self, fullscreen: bool);
     fn tl_mark_fullscreen(&self, connector: Option<&Rc<ConnectorData>>);
     fn tl_resize(&self, dx1: i32, dy1: i32, dx2: i32, dy2: i32);
-    fn tl_set_size(&self, width: i32, height: i32);
-    fn tl_set_position(&self, x: i32, y: i32);
+    fn tl_set_geometry(&self, x1: i32, y1: i32, x2: i32, y2: i32);
 }
 
 impl<T: ToplevelNodeBase> ToplevelNode for T {
@@ -307,21 +306,11 @@ impl<T: ToplevelNodeBase> ToplevelNode for T {
         parent.cnode_resize_child(self, x1, y1, x2, y2);
     }
 
-    fn tl_set_size(&self, width: i32, height: i32) {
+    fn tl_set_geometry(&self, x1: i32, y1: i32, x2: i32, y2: i32) {
         let Some(parent) = self.tl_data().parent.get() else {
             return;
         };
-        let pos = self.node_absolute_position(LiveTL);
-        let x2 = pos.x1().saturating_add(width);
-        let y2 = pos.y1().saturating_add(height);
-        parent.cnode_resize_child(self, None, None, Some(x2), Some(y2));
-    }
-
-    fn tl_set_position(&self, x: i32, y: i32) {
-        let Some(parent) = self.tl_data().parent.get() else {
-            return;
-        };
-        parent.cnode_set_child_position(self, x, y);
+        parent.cnode_resize_child(self, Some(x1), Some(y1), Some(x2), Some(y2));
     }
 }
 

toml-config/src/config.rs

@@ -211,17 +211,17 @@ pub enum Action {
         dx2: i32,
         dy2: i32,
     },
-    SetSize {
-        width: i32,
-        height: i32,
-    },
-    SetPosition {
-        x: i32,
-        y: i32,
-    },
     HideOverlay {
         ws: Rc<WorkspaceSlot>,
     },
+    SetPosition {
+        x1: Option<i32>,
+        y1: Option<i32>,
+        x2: Option<i32>,
+        y2: Option<i32>,
+        width: Option<i32>,
+        height: Option<i32>,
+    },
 }
 
 #[derive(Debug)]

toml-config/src/config/parsers/action.rs

@@ -111,6 +111,29 @@ pub enum ShowWorkspaceError {
     FallbackOutputModeParser(FallbackOutputModeParserError),
 }
 
+/// Extracts a field that should either be an integer or the string `"keep"`.
+///
+/// `"keep"` is represented as `None`, an integer `n` is represented as `Some(n)`.
+fn coordinate(
+    name: &'static str,
+) -> impl for<'v, 'w> FnOnce(
+    &mut Extractor<'v, 'w>,
+) -> Result<Spanned<Option<i32>>, Spanned<ExtractorError>> {
+    move |extractor: &mut Extractor| {
+        val(name)(extractor).and_then(|v| match v.value {
+            Value::String(s) if s.as_str() == "keep" => Ok(None.spanned(v.span)),
+            Value::Integer(i) => match i32::try_from(*i) {
+                Ok(n) => Ok(Some(n).spanned(v.span)),
+                Err(_) => Err(ExtractorError::I32.spanned(v.span)),
+            },
+            _ => Err(
+                ExtractorError::Expected("an integer or \"keep\"", v.value.name())
+                    .spanned(v.span),
+            ),
+        })
+    }
+}
+
 pub struct ActionParser<'a, 'b>(pub &'a Context<'b>);
 
 impl ActionParser<'_, '_> {
@@ -601,19 +624,22 @@ impl ActionParser<'_, '_> {
         })
     }
 
-    fn parse_set_size(&mut self, ext: &mut Extractor<'_, '_>) -> ParseResult<Self> {
-        let (width, height) = ext.extract((s32("width"), s32("height")))?;
-        Ok(Action::SetSize {
-            width: width.value,
-            height: height.value,
-        })
-    }
-
     fn parse_set_position(&mut self, ext: &mut Extractor<'_, '_>) -> ParseResult<Self> {
-        let (x, y) = ext.extract((s32("x"), s32("y")))?;
+        let (x1, y1, x2, y2, width, height) = ext.extract((
+            opt(coordinate("x1")),
+            opt(coordinate("y1")),
+            opt(coordinate("x2")),
+            opt(coordinate("y2")),
+            opt(coordinate("width")),
+            opt(coordinate("height")),
+        ))?;
         Ok(Action::SetPosition {
-            x: x.value,
-            y: y.value,
+            x1: x1.despan().flatten(),
+            y1: y1.despan().flatten(),
+            x2: x2.despan().flatten(),
+            y2: y2.despan().flatten(),
+            width: width.despan().flatten(),
+            height: height.despan().flatten(),
         })
     }
 
@@ -690,7 +716,6 @@ impl Parser for ActionParser<'_, '_> {
             "create-virtual-output" => self.parse_create_virtual_output(&mut ext),
             "remove-virtual-output" => self.parse_remove_virtual_output(&mut ext),
             "resize" => self.parse_resize(&mut ext),
-            "set-size" => self.parse_set_size(&mut ext),
             "set-position" => self.parse_set_position(&mut ext),
             "hide-overlay" => self.parse_hide_overlay(&mut ext),
             "show-overlay" => self.parse_show_overlay(&mut ext),

toml-config/src/lib.rs

@@ -518,12 +518,14 @@ impl Action {
             Action::Resize { dx1, dy1, dx2, dy2 } => {
                 window_or_seat!(s, s.resize(dx1, dy1, dx2, dy2))
             }
-            Action::SetSize { width, height } => {
-                window_or_seat!(s, s.set_size(width, height))
-            }
-            Action::SetPosition { x, y } => {
-                window_or_seat!(s, s.set_position(x, y))
-            }
+            Action::SetPosition {
+                x1,
+                y1,
+                x2,
+                y2,
+                width,
+                height,
+            } => window_or_seat!(s, s.set_position(x1, y1, x2, y2, width, height)),
             Action::HideOverlay { ws } => {
                 let workspace = ws.ws.get();
                 b.new(move || workspace.hide())