Feature: Add Window Padding Support (neovide#1632)

Co-authored-by: MultisampledNight <contact@multisamplednight.com>

src/renderer/mod.rs

@@ -26,7 +26,9 @@ use crate::{
 use cursor_renderer::CursorRenderer;
 pub use fonts::caching_shaper::CachingShaper;
 pub use grid_renderer::GridRenderer;
-pub use rendered_window::{LineFragment, RenderedWindow, WindowDrawCommand, WindowDrawDetails};
+pub use rendered_window::{
+    LineFragment, RenderedWindow, WindowDrawCommand, WindowDrawDetails, WindowPadding,
+};
 
 #[derive(SettingGroup, Clone)]
 pub struct RendererSettings {
@@ -82,11 +84,14 @@ pub struct Renderer {
     profiler: profiler::Profiler,
     os_scale_factor: f64,
     user_scale_factor: f64,
+    pub window_padding: WindowPadding,
 }
 
 impl Renderer {
     pub fn new(os_scale_factor: f64) -> Self {
-        let user_scale_factor = SETTINGS.get::<WindowSettings>().scale_factor.into();
+        let window_settings = SETTINGS.get::<WindowSettings>();
+
+        let user_scale_factor = window_settings.scale_factor.into();
         let scale_factor = user_scale_factor * os_scale_factor;
         let cursor_renderer = CursorRenderer::new();
         let grid_renderer = GridRenderer::new(scale_factor);
@@ -98,6 +103,13 @@ impl Renderer {
         let batched_draw_command_receiver = EVENT_AGGREGATOR.register_event::<Vec<DrawCommand>>();
         let profiler = profiler::Profiler::new(12.0);
 
+        let window_padding = WindowPadding {
+            top: window_settings.padding_top,
+            left: window_settings.padding_left,
+            right: window_settings.padding_right,
+            bottom: window_settings.padding_bottom,
+        };
+
         Renderer {
             rendered_windows,
             cursor_renderer,
@@ -108,6 +120,7 @@ impl Renderer {
             profiler,
             os_scale_factor,
             user_scale_factor,
+            window_padding,
         }
     }
 
@@ -185,6 +198,10 @@ impl Renderer {
         self.window_regions = windows
             .into_iter()
             .map(|window| {
+                if window.padding != self.window_padding {
+                    window.padding = self.window_padding;
+                }
+
                 window.draw(
                     root_canvas,
                     &settings,
@@ -243,6 +260,7 @@ impl Renderer {
                                 grid_id,
                                 (grid_left as f32, grid_top as f32).into(),
                                 (width, height).into(),
+                                self.window_padding,
                             );
                             vacant_entry.insert(new_window);
                         } else {

src/renderer/rendered_window.rs

@@ -50,6 +50,14 @@ pub enum WindowDrawCommand {
     },
 }
 
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct WindowPadding {
+    pub top: u32,
+    pub left: u32,
+    pub right: u32,
+    pub bottom: u32,
+}
+
 fn build_window_surface(parent_canvas: &mut Canvas, pixel_size: (i32, i32)) -> Surface {
     let mut context = parent_canvas.recording_context().unwrap();
     let budgeted = Budgeted::Yes;
@@ -147,6 +155,8 @@ pub struct RenderedWindow {
     pub current_scroll: f32,
     scroll_destination: f32,
     scroll_t: f32,
+
+    pub padding: WindowPadding,
 }
 
 #[derive(Clone, Debug)]
@@ -163,6 +173,7 @@ impl RenderedWindow {
         id: u64,
         grid_position: Point,
         grid_size: Dimensions,
+        padding: WindowPadding,
     ) -> RenderedWindow {
         let current_surface = LocatedSurface::new(parent_canvas, grid_renderer, grid_size, 0);
 
@@ -185,6 +196,7 @@ impl RenderedWindow {
             current_scroll: 0.0,
             scroll_destination: 0.0,
             scroll_t: 2.0, // 2.0 is out of the 0.0 to 1.0 range and stops animation.
+            padding,
         }
     }
 
@@ -355,9 +367,18 @@ impl RenderedWindow {
                 grid_size,
                 floating_order,
             } => {
+                let Dimensions {
+                    width: font_width,
+                    height: font_height,
+                } = grid_renderer.font_dimensions;
+
+                let top_offset = self.padding.top as f32 / font_height as f32;
+                let left_offset = self.padding.left as f32 / font_width as f32;
+
                 let grid_left = grid_left.max(0.0);
                 let grid_top = grid_top.max(0.0);
-                let new_destination: Point = (grid_left as f32, grid_top as f32).into();
+                let new_destination: Point =
+                    (grid_left as f32 + left_offset, grid_top as f32 + top_offset).into();
                 let new_grid_size: Dimensions = grid_size.into();
 
                 if self.grid_destination != new_destination {

src/window/mod.rs

@@ -42,6 +42,7 @@ use crate::{
     frame::Frame,
     redraw_scheduler::REDRAW_SCHEDULER,
     renderer::Renderer,
+    renderer::WindowPadding,
     running_tracker::*,
     settings::{
         load_last_window_settings, save_window_geometry, PersistentWindowSettings, SETTINGS,
@@ -69,6 +70,7 @@ pub struct GlutinWindowWrapper {
     mouse_manager: MouseManager,
     title: String,
     fullscreen: bool,
+    font_changed_last_frame: bool,
     saved_inner_size: PhysicalSize<u32>,
     saved_grid_size: Option<Dimensions>,
     size_at_startup: PhysicalSize<u32>,
@@ -193,10 +195,32 @@ impl GlutinWindowWrapper {
 
     pub fn draw_frame(&mut self, dt: f32) {
         let window = self.windowed_context.window();
-        let mut font_changed = false;
+        let new_size = window.inner_size();
+
+        let window_settings = SETTINGS.get::<WindowSettings>();
+        let window_padding = WindowPadding {
+            top: window_settings.padding_top,
+            left: window_settings.padding_left,
+            right: window_settings.padding_right,
+            bottom: window_settings.padding_bottom,
+        };
+
+        let padding_changed = window_padding != self.renderer.window_padding;
+        if padding_changed {
+            self.renderer.window_padding = window_padding;
+        }
+
+        if self.saved_inner_size != new_size || self.font_changed_last_frame || padding_changed {
+            self.font_changed_last_frame = false;
+            self.saved_inner_size = new_size;
+
+            self.handle_new_grid_size(new_size);
+            self.skia_renderer.resize(&self.windowed_context);
+        }
 
         if REDRAW_SCHEDULER.should_draw() || SETTINGS.get::<WindowSettings>().no_idle {
-            font_changed = self.renderer.draw_frame(self.skia_renderer.canvas(), dt);
+            self.font_changed_last_frame =
+                self.renderer.draw_frame(self.skia_renderer.canvas(), dt);
             self.skia_renderer.gr_context.flush(None);
             self.windowed_context.swap_buffers().unwrap();
         }
@@ -206,8 +230,6 @@ impl GlutinWindowWrapper {
             return;
         }
 
-        let new_size = window.inner_size();
-
         let settings = SETTINGS.get::<CmdLineSettings>();
         // Resize at startup happens when window is maximized or when using tiling WM
         // which already resized window.
@@ -220,6 +242,7 @@ impl GlutinWindowWrapper {
         log::trace!("Inner size: {:?}", new_size);
 
         if self.saved_grid_size.is_none() && !resized_at_startup {
+            let window = self.windowed_context.window();
             window.set_inner_size(
                 self.renderer
                     .grid_renderer
@@ -228,21 +251,24 @@ impl GlutinWindowWrapper {
             self.saved_grid_size = Some(settings.geometry);
             // Font change at startup is ignored, so grid size (and startup screen) could be preserved.
             // But only when not resized yet. With maximized or resized window we should redraw grid.
-            font_changed = false;
-        }
-
-        if self.saved_inner_size != new_size || font_changed {
-            self.saved_inner_size = new_size;
-            self.handle_new_grid_size(new_size);
-            self.skia_renderer.resize(&self.windowed_context);
+            self.font_changed_last_frame = false;
         }
     }
 
     fn handle_new_grid_size(&mut self, new_size: PhysicalSize<u32>) {
+        let window_padding = self.renderer.window_padding;
+        let window_padding_width = window_padding.left + window_padding.right;
+        let window_padding_height = window_padding.top + window_padding.bottom;
+
+        let content_size = PhysicalSize {
+            width: new_size.width - window_padding_width,
+            height: new_size.height - window_padding_height,
+        };
+
         let grid_size = self
             .renderer
             .grid_renderer
-            .convert_physical_to_grid(new_size);
+            .convert_physical_to_grid(content_size);
 
         // Have a minimum size
         if grid_size.width < MIN_WINDOW_WIDTH || grid_size.height < MIN_WINDOW_HEIGHT {
@@ -424,6 +450,7 @@ pub fn create_window() {
         mouse_manager: MouseManager::new(),
         title: String::from("Neovide"),
         fullscreen: false,
+        font_changed_last_frame: false,
         size_at_startup: initial_size,
         maximized_at_startup: maximized,
         saved_inner_size,

src/window/settings.rs

@@ -16,6 +16,10 @@ pub struct WindowSettings {
     pub touch_drag_timeout: f32,
     pub background_color: String,
     pub confirm_quit: bool,
+    pub padding_top: u32,
+    pub padding_left: u32,
+    pub padding_right: u32,
+    pub padding_bottom: u32,
 }
 
 impl Default for WindowSettings {
@@ -35,6 +39,10 @@ impl Default for WindowSettings {
             touch_drag_timeout: 0.17,
             background_color: "".to_string(),
             confirm_quit: true,
+            padding_top: 0,
+            padding_left: 0,
+            padding_right: 0,
+            padding_bottom: 0,
         }
     }
 }