Renderable: fold get_scrollbar_info into get_dimensions

src/frontend/gui/scrollbar.rs

@@ -40,7 +40,10 @@ impl ScrollHit {
     /// Compute the y-coordinate for the top of the scrollbar thumb
     /// and the height of the thumb and return them.
     pub fn thumb(render: &dyn Renderable, size: PtySize, dims: &Dimensions) -> ThumbInfo {
-        let (scroll_top, scroll_size) = render.get_scrollbar_info();
+        let render_dims = render.get_dimensions();
+        let scroll_top = render_dims.viewport_offset;
+        let scroll_size = render_dims.scrollback_rows;
+
         let thumb_size = (size.rows as f32 / scroll_size as f32) * dims.pixel_height as f32;
 
         const MIN_HEIGHT: f32 = 10.;
@@ -73,7 +76,8 @@ impl ScrollHit {
         size: PtySize,
         dims: &Dimensions,
     ) -> VisibleRowIndex {
-        let (_scroll_top, scroll_size) = render.get_scrollbar_info();
+        let render_dims = render.get_dimensions();
+        let scroll_size = render_dims.scrollback_rows;
         let thumb = Self::thumb(render, size, dims);
 
         let rows_from_top =

src/frontend/gui/termwindow.rs

@@ -8,7 +8,7 @@ use crate::frontend::gui::scrollbar::*;
 use crate::frontend::gui::tabbar::{TabBarItem, TabBarState};
 use crate::frontend::{executor, front_end};
 use crate::keyassignment::{KeyAssignment, KeyMap, SpawnTabDomain};
-use crate::mux::renderable::Renderable;
+use crate::mux::renderable::{Renderable, RenderableDimensions};
 use crate::mux::tab::{Tab, TabId};
 use crate::mux::window::WindowId as MuxWindowId;
 use crate::mux::Mux;
@@ -27,7 +27,7 @@ use std::sync::Arc;
 use std::sync::Mutex;
 use std::time::{Duration, Instant};
 use term::color::ColorPalette;
-use term::{CursorPosition, Line, Underline, VisibleRowIndex};
+use term::{CursorPosition, Line, Underline};
 use termwiz::color::RgbColor;
 use termwiz::surface::CursorShape;
 
@@ -120,7 +120,7 @@ pub struct TermWindow {
     scroll_drag_start: Option<isize>,
     config_generation: usize,
     prev_cursor: PrevCursorPos,
-    last_scroll_info: (VisibleRowIndex, usize),
+    last_scroll_info: RenderableDimensions,
 
     /// Gross workaround for managing async keyboard fetching
     /// just for middle mouse button paste function
@@ -298,7 +298,7 @@ impl WindowCallbacks for TermWindow {
                 };
 
                 let mut render = tab.renderer();
-                let (current, num_lines) = render.get_scrollbar_info();
+                let dims = render.get_dimensions();
 
                 match ScrollHit::test(
                     event.coords.y,
@@ -309,15 +309,16 @@ impl WindowCallbacks for TermWindow {
                     ScrollHit::Above => {
                         // Page up
                         render.set_viewport_position(
-                            current
+                            dims.viewport_offset
                                 .saturating_add(self.terminal_size.rows as i64)
-                                .min(num_lines.try_into().unwrap()),
+                                .min(dims.scrollback_rows.try_into().unwrap()),
                         );
                     }
                     ScrollHit::Below => {
                         // Page down
                         render.set_viewport_position(
-                            current.saturating_sub(self.terminal_size.rows as i64),
+                            dims.viewport_offset
+                                .saturating_sub(self.terminal_size.rows as i64),
                         );
                     }
                     ScrollHit::OnThumb(from_top) => {
@@ -659,7 +660,7 @@ impl TermWindow {
                 scroll_drag_start: None,
                 config_generation: config.generation(),
                 prev_cursor: PrevCursorPos::new(),
-                last_scroll_info: (0, 0),
+                last_scroll_info: RenderableDimensions::default(),
                 clipboard_contents: Arc::clone(&clipboard_contents),
             }),
         )?;
@@ -923,12 +924,12 @@ impl TermWindow {
             None => return,
         };
 
-        let info = tab.renderer().get_scrollbar_info();
-        if info == self.last_scroll_info {
+        let render_dims = tab.renderer().get_dimensions();
+        if render_dims == self.last_scroll_info {
             return;
         }
 
-        self.last_scroll_info = info;
+        self.last_scroll_info = render_dims;
 
         if let Some(window) = self.window.as_ref() {
             window.invalidate();

src/mux/renderable.rs

@@ -7,7 +7,7 @@ use term::{
 };
 use termwiz::hyperlink::Hyperlink;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub struct RenderableDimensions {
     /// The viewport width
     pub cols: usize,
@@ -15,6 +15,9 @@ pub struct RenderableDimensions {
     pub viewport_rows: usize,
     /// The total number of lines in the scrollback, including the viewport
     pub scrollback_rows: usize,
+    /// The offset is measured from the top of the physical viewable
+    /// screen with larger numbers going backwards.
+    pub viewport_offset: VisibleRowIndex,
 }
 
 /// Renderable allows passing something that isn't an actual term::Terminal
@@ -49,10 +52,6 @@ pub trait Renderable: Downcast {
     /// Returns render related dimensions
     fn get_dimensions(&self) -> RenderableDimensions;
 
-    /// Returns the potentially scrolled viewport offset, and the
-    /// size of the scrollback.  This information is intended to be
-    /// used to render a scrollbar UI
-    fn get_scrollbar_info(&self) -> (VisibleRowIndex, usize);
     fn set_viewport_position(&mut self, position: VisibleRowIndex);
 }
 impl_downcast!(Renderable);
@@ -99,6 +98,7 @@ impl Renderable for Terminal {
             cols: screen.physical_cols,
             viewport_rows: screen.physical_rows,
             scrollback_rows: screen.lines.len(),
+            viewport_offset: self.get_viewport_offset(),
         }
     }
 
@@ -106,12 +106,6 @@ impl Renderable for Terminal {
         TerminalState::has_dirty_lines(self)
     }
 
-    fn get_scrollbar_info(&self) -> (VisibleRowIndex, usize) {
-        let offset = self.get_viewport_offset();
-        let num_lines = self.screen().lines.len();
-        (offset, num_lines)
-    }
-
     fn set_viewport_position(&mut self, position: VisibleRowIndex) {
         self.set_scroll_viewport(position);
     }

src/server/tab.rs

@@ -496,15 +496,10 @@ impl Renderable for RenderableState {
             viewport_rows,
             cols,
             scrollback_rows: 0,
+            viewport_offset: 0,
         }
     }
 
-    fn get_scrollbar_info(&self) -> (VisibleRowIndex, usize) {
-        // Dummy scrollback information for now, until we
-        // plumb this into the protocol
-        let dims = self.get_dimensions();
-        (0, dims.viewport_rows)
-    }
     fn set_viewport_position(&mut self, _: VisibleRowIndex) {}
 }
 

src/termwiztermtab.rs

@@ -160,13 +160,10 @@ impl Renderable for RenderableState {
             viewport_rows,
             cols,
             scrollback_rows: 0,
+            viewport_offset: 0,
         }
     }
 
-    fn get_scrollbar_info(&self) -> (VisibleRowIndex, usize) {
-        let dims = self.get_dimensions();
-        (0, dims.viewport_rows)
-    }
     fn set_viewport_position(&mut self, _: VisibleRowIndex) {}
 }