Add subcommand to set globally reserved zones

This expands on the fullscreen reserved zones introduced in 4172a10, by
adding the option to reserve space for non-fullscreen applications. No
application can render to these reserved spaces, however the gesture
handle will expand into this area when set.

To avoid putting too many subcommands on the top level, the command uses
the `catacomb msg deadzone` subcommand instead, which the fullscreen
deadzone subcommand has been moved to too.

Since certain applications, like panels at the top of the screen, are
generally better at dealing with these issues than other apps, a new
`--orientation` flag has been added which allows applying deadzones to
specific device orientations. This means that a panel can work around
the deadzone by itself in portrait mode, while the area can be excluded
entirely while the panel is outside of the deadzone.

Author: chrisduerr

CHANGELOG.md

@@ -11,7 +11,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 - IPC subcommand to retrieve output scale (`catacomb msg scale`)
 - IPC subcommand to set gesture handle height (`catacomb msg gesture-handle`)
-- IPC subcommand to set fullscreen reserved zones (`catacomb msg fullscreen-deadzone`)
+- IPC subcommand to manage exclusive zones (`catacomb msg deadzone`)
 
 ### Changed
 

catacomb_ipc/src/lib.rs

@@ -20,7 +20,7 @@ use std::{env, process};
 #[cfg(feature = "clap")]
 use clap::error::{Error as ClapError, ErrorKind as ClapErrorKind};
 #[cfg(feature = "clap")]
-use clap::{Subcommand, ValueEnum};
+use clap::{Args, Subcommand, ValueEnum};
 use regex::{Error as RegexError, Regex};
 use serde::{Deserialize, Serialize};
 #[cfg(feature = "smithay")]
@@ -199,26 +199,76 @@ pub enum IpcMessage {
         #[cfg_attr(feature = "clap", clap(long, value_name = "HEIGHT"))]
         height: u16,
     },
-    /// Set reserved space in fullscreen mode.
-    FullscreenDeadzone {
-        /// Top edge reserved physical pixels.
-        #[cfg_attr(feature = "clap", clap(long, value_name = "PIXELS", default_value = "0"))]
-        top: u16,
-        /// Right edge reserved physical pixels.
-        #[cfg_attr(feature = "clap", clap(long, value_name = "PIXELS", default_value = "0"))]
-        right: u16,
-        /// Bottom edge reserved physical pixels.
-        #[cfg_attr(feature = "clap", clap(long, value_name = "PIXELS", default_value = "0"))]
-        bottom: u16,
-        /// Left edge reserved physical pixels.
-        #[cfg_attr(feature = "clap", clap(long, value_name = "PIXELS", default_value = "0"))]
-        left: u16,
-    },
+    /// Manage compositor deadzones.
+    #[cfg_attr(feature = "clap", clap(subcommand))]
+    Deadzone(Deadzones),
+}
+
+/// Compositor deadzones.
+#[cfg_attr(feature = "clap", derive(Subcommand))]
+#[derive(Deserialize, Serialize, Debug)]
+pub enum Deadzones {
+    /// Set reserved space for fullscreen windows.
+    Fullscreen(Deadzone),
+    /// Set reserved space for all windows.
+    Global(Deadzone),
+}
+
+/// Compositor reserved area.
+#[cfg_attr(feature = "clap", derive(Args))]
+#[derive(Deserialize, Serialize, PartialEq, Eq, Copy, Clone, Default, Debug)]
+pub struct Deadzone {
+    /// Top edge reserved physical pixels.
+    #[cfg_attr(feature = "clap", clap(long, value_name = "PIXELS", default_value = "0"))]
+    pub top: u16,
+    /// Right edge reserved physical pixels.
+    #[cfg_attr(feature = "clap", clap(long, value_name = "PIXELS", default_value = "0"))]
+    pub right: u16,
+    /// Bottom edge reserved physical pixels.
+    #[cfg_attr(feature = "clap", clap(long, value_name = "PIXELS", default_value = "0"))]
+    pub bottom: u16,
+    /// Left edge reserved physical pixels.
+    #[cfg_attr(feature = "clap", clap(long, value_name = "PIXELS", default_value = "0"))]
+    pub left: u16,
+    /// Limit this deadzone to a specific orientation.
+    #[cfg_attr(feature = "clap", clap(long))]
+    pub orientation: Option<Orientation>,
+}
+
+impl Deadzone {
+    /// Apply scale and output transform to get the logical deadzone size.
+    pub fn transform(&self, orientation: Orientation, scale: f64) -> Self {
+        let mut deadzone = match orientation {
+            Orientation::Portrait => *self,
+            Orientation::InversePortrait => Self { top: self.bottom, bottom: self.top, ..*self },
+            Orientation::Landscape => Self {
+                orientation: self.orientation,
+                top: self.right,
+                right: self.bottom,
+                bottom: self.left,
+                left: self.top,
+            },
+            Orientation::InverseLandscape => Self {
+                orientation: self.orientation,
+                top: self.left,
+                right: self.top,
+                bottom: self.right,
+                left: self.bottom,
+            },
+        };
+
+        deadzone.top = (deadzone.top as f64 / scale).round() as u16;
+        deadzone.right = (deadzone.right as f64 / scale).round() as u16;
+        deadzone.bottom = (deadzone.bottom as f64 / scale).round() as u16;
+        deadzone.left = (deadzone.left as f64 / scale).round() as u16;
+
+        deadzone
+    }
 }
 
 /// Device orientation.
 #[cfg_attr(feature = "clap", derive(ValueEnum))]
-#[derive(Deserialize, Serialize, Default, PartialEq, Eq, Copy, Clone, Debug)]
+#[derive(Deserialize, Serialize, Default, Hash, PartialEq, Eq, Copy, Clone, Debug)]
 #[serde(rename_all = "kebab-case")]
 pub enum Orientation {
     /// Portrait mode.

src/drawing.rs

@@ -479,9 +479,11 @@ impl Graphics {
 
         // Initialize texture or replace it after scale change.
         let scale = canvas.scale();
-        let width = canvas.physical_size().w;
+        let width = canvas.output_size_physical().w;
         let height = canvas.gesture_handle_height() as i32;
-        if handle.as_ref().is_none_or(|handle| handle.buffer_size() != (width, height).into()) {
+        if handle.as_ref().is_none_or(|handle| {
+            handle.buffer_size() != (width, height).into() || handle.scale != scale
+        }) {
             // Initialize a black buffer with the correct size.
             let mut buffer = vec![0; (height * width * 4) as usize];
 
@@ -515,7 +517,9 @@ impl Graphics {
     pub fn cursor(&mut self, renderer: &mut GlesRenderer, canvas: &Canvas) -> RenderTexture {
         let scale = canvas.scale();
         let size = (CURSOR_SIZE * scale).round() as i32;
-        if self.cursor.as_ref().is_none_or(|cursor| cursor.buffer_size() != (size, size).into()) {
+        if self.cursor.as_ref().is_none_or(|cursor| {
+            cursor.buffer_size() != (size, size).into() || cursor.scale != scale
+        }) {
             // Create a texture with a circle inside it.
             let mut buffer = vec![0; (size * size * 4) as usize];
             for x in 0..size {

src/input.rs

@@ -230,7 +230,7 @@ impl TouchState {
         start: Point<f64, Logical>,
         end: Option<Point<f64, Logical>>,
     ) -> impl Iterator<Item = &'a GestureBinding> {
-        let canvas_size = canvas.size().to_f64();
+        let canvas_size = canvas.output_size().to_f64();
         let start_sector = GestureSector::from_point(canvas_size, start);
         let end_sector = end.map(|end| GestureSector::from_point(canvas_size, end));
 
@@ -325,8 +325,9 @@ impl HandleGesture {
 
     /// Check if a touch should start a new gesture.
     fn is_start(canvas: &Canvas, position: Point<f64, Logical>) -> bool {
-        let wm_size = canvas.wm_size().to_f64();
-        Rectangle::new((0., wm_size.h).into(), wm_size).contains(position)
+        let ui_rect = canvas.ui_rect(false).to_f64();
+        let handle_y = ui_rect.loc.y + ui_rect.size.h;
+        Rectangle::new((0., handle_y).into(), (f64::MAX, f64::MAX).into()).contains(position)
     }
 }
 
@@ -1065,6 +1066,11 @@ impl Catacomb {
             Orientation::InverseLandscape => (height - y, x),
         };
 
+        // Clamp position within global deadzones.
+        let ui_rect = canvas.ui_rect(true).to_f64();
+        x = x.clamp(ui_rect.loc.x, ui_rect.loc.x + ui_rect.size.w);
+        y = y.clamp(ui_rect.loc.y, ui_rect.loc.y + ui_rect.size.h);
+
         (x, y).into()
     }
 

src/ipc_server.rs

@@ -6,14 +6,13 @@ use std::io::{BufRead, BufReader, Write};
 use std::os::unix::net::{UnixListener, UnixStream};
 use std::path::PathBuf;
 
-use catacomb_ipc::{AppIdMatcher, CliToggle, IpcMessage, Keysym, WindowScale};
+use catacomb_ipc::{AppIdMatcher, CliToggle, Deadzones, IpcMessage, Keysym, WindowScale};
 use smithay::input::keyboard::XkbConfig;
 use smithay::reexports::calloop::LoopHandle;
 use tracing::{error, warn};
 
 use crate::catacomb::Catacomb;
 use crate::config::{GestureBinding, GestureBindingAction, KeyBinding};
-use crate::output::FullscreenDeadzone;
 use crate::socket::SocketSource;
 
 /// Create an IPC socket.
@@ -175,10 +174,12 @@ fn handle_message(buffer: &mut String, mut stream: UnixStream, catacomb: &mut Ca
             catacomb.draw_cursor = state == CliToggle::On;
         },
         IpcMessage::GestureHandle { height } => catacomb.windows.set_gesture_handle_height(height),
-        IpcMessage::FullscreenDeadzone { top, right, bottom, left } => {
-            let deadzone = FullscreenDeadzone::new(top, right, bottom, left);
+        IpcMessage::Deadzone(Deadzones::Fullscreen(deadzone)) => {
             catacomb.windows.set_fullscreen_deadzone(deadzone);
         },
+        IpcMessage::Deadzone(Deadzones::Global(deadzone)) => {
+            catacomb.windows.set_global_deadzone(deadzone);
+        },
         // Ignore IPC replies.
         IpcMessage::DpmsReply { .. } | IpcMessage::ScaleReply { .. } => (),
     }