feat: zoom view lock

Author: Atan-D-RP4

niri-config/src/binds.rs

@@ -368,10 +368,6 @@ pub enum Action {
     #[knuffel(skip)]
     UnsetWindowUrgent(u64),
     #[knuffel(skip)]
-    ToggleZoom {
-        output: Option<String>,
-    },
-    #[knuffel(skip)]
     LoadConfigFile,
     #[knuffel(skip)]
     MruAdvance {
@@ -393,6 +389,14 @@ pub enum Action {
     MruSetScope(MruScope),
     #[knuffel(skip)]
     MruCycleScope,
+    #[knuffel(skip)]
+    ToggleZoom {
+        output: Option<String>,
+    },
+    #[knuffel(skip)]
+    ToggleZoomFreeze {
+        output: Option<String>,
+    },
 }
 
 impl From<niri_ipc::Action> for Action {
@@ -704,6 +708,7 @@ impl From<niri_ipc::Action> for Action {
             niri_ipc::Action::SetWindowUrgent { id } => Self::SetWindowUrgent(id),
             niri_ipc::Action::UnsetWindowUrgent { id } => Self::UnsetWindowUrgent(id),
             niri_ipc::Action::ToggleZoom { output } => Self::ToggleZoom { output },
+            niri_ipc::Action::ToggleZoomFreeze { output } => Self::ToggleZoomFreeze { output },
             niri_ipc::Action::LoadConfigFile {} => Self::LoadConfigFile,
         }
     }

niri-config/src/output.rs

@@ -8,7 +8,7 @@ use knuffel::Decode;
 use niri_ipc::{ConfiguredMode, HSyncPolarity, Transform, VSyncPolarity};
 
 use crate::gestures::HotCorners;
-use crate::utils::MergeWith;
+use crate::utils::{Flag, MergeWith};
 use crate::{Color, FloatOrInt, LayoutPart};
 
 #[derive(Debug, Default, Clone, PartialEq)]
@@ -56,6 +56,8 @@ pub struct Zoom {
     pub movement: Option<niri_ipc::ZoomMovement>,
     #[knuffel(child, unwrap(argument))]
     pub threshold: Option<f64>,
+    #[knuffel(child)]
+    pub frozen: Option<Flag>,
 }
 
 impl MergeWith<Zoom> for Zoom {
@@ -69,6 +71,9 @@ impl MergeWith<Zoom> for Zoom {
         if part.threshold.is_some() {
             self.threshold = part.threshold;
         }
+        if part.frozen.is_some() {
+            self.frozen = part.frozen;
+        }
     }
 }
 

niri-ipc/src/lib.rs

@@ -941,6 +941,14 @@ pub enum Action {
         #[cfg_attr(feature = "clap", arg())]
         output: Option<String>,
     },
+    /// Toggle zoom freeze for a monitor.
+    ///
+    /// If no output is specified, uses the focused output.
+    ToggleZoomFreeze {
+        /// Output to toggle zoom freeze for. If not specified, uses the focused output.
+        #[cfg_attr(feature = "clap", arg())]
+        output: Option<String>,
+    },
     /// Reload the config file.
     ///
     /// Can be useful for scripts changing the config file, to avoid waiting the small duration for
@@ -1073,6 +1081,12 @@ pub enum ZoomAction {
         #[cfg_attr(feature = "clap", arg())]
         threshold: f64,
     },
+    /// Set zoom frozen state.
+    Frozen {
+        /// Whether to freeze the zoom center.
+        #[cfg_attr(feature = "clap", arg(action = clap::ArgAction::Set, value_parser = clap::builder::BoolishValueParser::new(), value_name = "true|false"))]
+        frozen: bool,
+    },
 }
 
 /// Output actions that niri can perform.
@@ -1310,6 +1324,8 @@ pub struct Output {
     ///
     /// Default is 0.15.
     pub zoom_threshold: f64,
+    /// Whether the zoom center is frozen.
+    pub zoom_frozen: bool,
 }
 
 /// Output mode.

src/backend/headless.rs

@@ -112,6 +112,7 @@ impl Headless {
                 zoom_factor: 1.0,
                 zoom_movement: niri_ipc::ZoomMovement::default(),
                 zoom_threshold: 0.15,
+                zoom_frozen: false,
             },
         );
 
@@ -170,6 +171,7 @@ impl Headless {
                 ipc_output.zoom_factor = mon.zoom_factor;
                 ipc_output.zoom_movement = mon.zoom_movement;
                 ipc_output.zoom_threshold = mon.zoom_threshold;
+                ipc_output.zoom_frozen = mon.zoom_frozen;
             }
         }
     }

src/backend/tty.rs

@@ -2153,15 +2153,19 @@ impl Tty {
                 let logical = output.map(logical_output);
 
                 // Get zoom state from the monitor if available.
-                let (zoom_factor, zoom_movement, zoom_threshold) = output
+                let (zoom_factor, zoom_movement, zoom_threshold, zoom_frozen) = output
                     .and_then(|o| niri.layout.monitor_for_output(o))
-                    .map_or((1.0, niri_ipc::ZoomMovement::default(), 0.15), |mon| {
-                        (
-                            mon.zoom_factor,
-                            mon.zoom_movement,
-                            mon.zoom_threshold,
-                        )
-                    });
+                    .map_or(
+                        (1.0, niri_ipc::ZoomMovement::default(), 0.15, false),
+                        |mon| {
+                            (
+                                mon.zoom_factor,
+                                mon.zoom_movement,
+                                mon.zoom_threshold,
+                                mon.zoom_frozen,
+                            )
+                        },
+                    );
 
                 let id = device.known_crtcs.get(&crtc).map(|info| info.id);
                 let id = id.unwrap_or_else(|| {
@@ -2184,6 +2188,7 @@ impl Tty {
                     zoom_factor,
                     zoom_movement,
                     zoom_threshold,
+                    zoom_frozen,
                 };
 
                 ipc_outputs.insert(id, ipc_output);

src/backend/winit.rs

@@ -92,6 +92,7 @@ impl Winit {
                 zoom_factor: 1.0,
                 zoom_movement: niri_ipc::ZoomMovement::default(),
                 zoom_threshold: 0.15,
+                zoom_frozen: false,
             },
         )])));
 
@@ -281,6 +282,7 @@ impl Winit {
                 output.zoom_factor = mon.zoom_factor;
                 output.zoom_movement = mon.zoom_movement;
                 output.zoom_threshold = mon.zoom_threshold;
+                output.zoom_frozen = mon.zoom_frozen;
             }
         }
     }

src/input/mod.rs

@@ -2393,6 +2393,18 @@ impl State {
                     self.niri.queue_redraw_all();
                 }
             }
+            Action::ToggleZoomFreeze { output } => {
+                let target_output = match output {
+                    Some(name) => self.niri.output_by_name_match(&name).cloned(),
+                    None => self.niri.layout.active_output().cloned(),
+                };
+                if let Some(output) = target_output {
+                    if let Some(monitor) = self.niri.layout.monitor_for_output_mut(&output) {
+                        monitor.zoom_frozen = !monitor.zoom_frozen;
+                    }
+                    self.niri.queue_redraw_all();
+                }
+            }
         }
     }
 
@@ -2645,7 +2657,23 @@ impl State {
         // When cursor exits visible zoomed area, pan by cursor delta scaled by zoom
         for monitor in self.niri.layout.monitors_mut() {
             let zoom = monitor.zoom_factor;
+
+            // Skip if zoom center is frozen
+            if monitor.zoom_frozen {
+                continue;
+            }
+
             if zoom <= 1.0 || monitor.zoom_movement != ZoomMovement::EdgePushed {
+                // No zoom or not in EdgePushed mode
+                // Just update zoom center to current cursor position
+                monitor.zoom_center = new_pos
+                    - self
+                        .niri
+                        .global_space
+                        .output_geometry(monitor.output())
+                        .unwrap()
+                        .loc
+                        .to_f64();
                 continue;
             }
 

src/ipc/client.rs

@@ -571,6 +571,7 @@ fn print_output(output: Output) -> anyhow::Result<()> {
         zoom_factor,
         zoom_movement,
         zoom_threshold,
+        zoom_frozen,
         ..
     } = output;
 
@@ -655,14 +656,15 @@ fn print_output(output: Output) -> anyhow::Result<()> {
         println!("  Transform: {transform}");
     }
 
-    print!("  Zoom: {zoom_factor}x");
+    println!("  Zoom:");
+    println!("    Factor: {:.2}", zoom_factor);
     let m = match zoom_movement {
         niri_ipc::ZoomMovement::Cursor => "cursor-centered",
         niri_ipc::ZoomMovement::EdgePushed => "edge-pushed",
     };
-    print!(", {m}");
-    print!(", threshold: {:.2}", zoom_threshold);
-    println!();
+    println!("    Movement: {m}");
+    println!("    Threshold: {:.2} px", zoom_threshold);
+    println!("    Frozen: {}", if zoom_frozen { "true" } else { "false" });
 
     println!("  Available modes:");
     for (idx, mode) in modes.into_iter().enumerate() {

src/layout/monitor.rs

@@ -98,6 +98,8 @@ pub struct Monitor<W: LayoutElement> {
     pub zoom_movement: ZoomMovement,
     /// Cursor zoom threshold for edge-pushed behavior (fraction of output size, default 0.15).
     pub zoom_threshold: f64,
+    /// Whether the cursor_zoom center is currently frozen (not updated with cursor movements).
+    pub zoom_frozen: bool,
 }
 
 #[derive(Debug)]
@@ -361,6 +363,7 @@ impl<W: LayoutElement> Monitor<W> {
             zoom_center: Point::from((0., 0.)),
             zoom_movement: ZoomMovement::default(),
             zoom_threshold: 0.15,
+            zoom_frozen: false,
         }
     }
 
@@ -1401,6 +1404,9 @@ impl<W: LayoutElement> Monitor<W> {
             if let Some(threshold) = zoom.threshold {
                 self.zoom_threshold = threshold.clamp(0.0, 1.0);
             }
+            if let Some(frozen) = zoom.frozen {
+                self.zoom_frozen = frozen.0;
+            }
         }
     }