b15bbec4fa
Follow up to #31836 After enabling rounding in the Taffy layout engine, we frequently run into cases where the bounds produced by Taffy and ours slightly differ after 5 or more decimal places. This leads to cases where containers become scrollable for less than 0.0000x Pixels. In case this happens for e.g. hover popovers, we render a scrollbar due to the container being technically scrollable, even though the scroll amount here will in practice never be visible. This change fixes this by rounding the `scroll_max` by which we clamp the current scroll position to two decimal places. We don't benefit from the additional floating point precision here at all and it stops such containers from becoming scrollable altogether. Furthermore, we now store the `scroll_max` instead of the `padded_content_size` as the former gives a much better idea on whether the corresponding container is scrollable or not. | `main` | After these changes | | -- | -- | | <img width="610" height="316" alt="main" src="https://github.com/user-attachments/assets/ffcc0322-6d6e-4f79-a916-bd3c57fe4211" /> | <img width="610" height="316" alt="scroll_max_rounded" src="https://github.com/user-attachments/assets/5fe530f5-2e21-4aaa-81f4-e5c53ab73e4f" /> | Release Notes: - Fixed an issue where scrollbars would appear in containers where no scrolling was possible.
91 lines
2.5 KiB
Rust
91 lines
2.5 KiB
Rust
use std::{
|
|
cell::{Cell, RefCell},
|
|
rc::Rc,
|
|
};
|
|
|
|
use gpui::{Bounds, Point, Size, size};
|
|
use terminal::Terminal;
|
|
use ui::{Pixels, ScrollableHandle, px};
|
|
|
|
#[derive(Debug)]
|
|
struct ScrollHandleState {
|
|
line_height: Pixels,
|
|
total_lines: usize,
|
|
viewport_lines: usize,
|
|
display_offset: usize,
|
|
}
|
|
|
|
impl ScrollHandleState {
|
|
fn new(terminal: &Terminal) -> Self {
|
|
Self {
|
|
line_height: terminal.last_content().terminal_bounds.line_height,
|
|
total_lines: terminal.total_lines(),
|
|
viewport_lines: terminal.viewport_lines(),
|
|
display_offset: terminal.last_content().display_offset,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct TerminalScrollHandle {
|
|
state: Rc<RefCell<ScrollHandleState>>,
|
|
pub future_display_offset: Rc<Cell<Option<usize>>>,
|
|
}
|
|
|
|
impl TerminalScrollHandle {
|
|
pub fn new(terminal: &Terminal) -> Self {
|
|
Self {
|
|
state: Rc::new(RefCell::new(ScrollHandleState::new(terminal))),
|
|
future_display_offset: Rc::new(Cell::new(None)),
|
|
}
|
|
}
|
|
|
|
pub fn update(&self, terminal: &Terminal) {
|
|
*self.state.borrow_mut() = ScrollHandleState::new(terminal);
|
|
}
|
|
}
|
|
|
|
impl ScrollableHandle for TerminalScrollHandle {
|
|
fn max_offset(&self) -> Size<Pixels> {
|
|
let state = self.state.borrow();
|
|
size(
|
|
Pixels::ZERO,
|
|
state
|
|
.total_lines
|
|
.checked_sub(state.viewport_lines)
|
|
.unwrap_or(0) as f32
|
|
* state.line_height,
|
|
)
|
|
}
|
|
|
|
fn offset(&self) -> Point<Pixels> {
|
|
let state = self.state.borrow();
|
|
let scroll_offset = state.total_lines - state.viewport_lines - state.display_offset;
|
|
Point::new(
|
|
px(0.),
|
|
-px(scroll_offset as f32 * self.state.borrow().line_height.0),
|
|
)
|
|
}
|
|
|
|
fn set_offset(&self, point: Point<Pixels>) {
|
|
let state = self.state.borrow();
|
|
let offset_delta = (point.y.0 / state.line_height.0).round() as i32;
|
|
|
|
let max_offset = state.total_lines - state.viewport_lines;
|
|
let display_offset = (max_offset as i32 + offset_delta).clamp(0, max_offset as i32);
|
|
|
|
self.future_display_offset
|
|
.set(Some(display_offset as usize));
|
|
}
|
|
|
|
fn viewport(&self) -> Bounds<Pixels> {
|
|
let state = self.state.borrow();
|
|
Bounds::new(
|
|
Point::new(px(0.), px(0.)),
|
|
size(
|
|
px(0.),
|
|
px(state.viewport_lines as f32 * state.line_height.0),
|
|
),
|
|
)
|
|
}
|
|
}
|