fix: exclude scroll area padding from pane sizing

crates/layout/src/resizable.rs

@@ -6,7 +6,6 @@ use gpui::{
     InteractiveElement as _, IntoElement, ParentElement as _, Pixels, RenderOnce, SharedString,
     StyleRefinement, Styled, Window, canvas, div, px,
 };
-use gpui_native_theme::{ActiveTheme as _, Size};
 use gpui_native_utils::StyledExt as _;
 
 use crate::resize_handle::ResizeHandle;
@@ -58,37 +57,30 @@ impl ResizableState {
     }
 
     /// The equal split of the measured extent.
-    fn equal_split(&self, pane_count: usize, thickness: Pixels) -> Pixels {
+    fn equal_split(&self, pane_count: usize) -> Pixels {
         match self.measured {
-            Some(extent) => (extent - thickness * (pane_count as f32 - 1.0)) / pane_count as f32,
+            Some(extent) => extent / pane_count as f32,
             None => px(DEFAULT_PANE_SIZE),
         }
     }
 
     /// The size pane `ix` renders at: its stored size, or the equal split.
-    fn pane_size(&self, ix: usize, pane_count: usize, thickness: Pixels) -> Pixels {
+    fn pane_size(&self, ix: usize, pane_count: usize) -> Pixels {
         self.sizes
             .get(ix)
             .copied()
-            .unwrap_or_else(|| self.equal_split(pane_count, thickness))
+            .unwrap_or_else(|| self.equal_split(pane_count))
     }
 
     /// Applies a drag at divider `ix` (between pane ix and ix+1).
-    fn resize(
-        &mut self,
-        ix: usize,
-        delta: Pixels,
-        mins: &[Pixels],
-        thickness: Pixels,
-        cx: &mut Context<Self>,
-    ) {
+    fn resize(&mut self, ix: usize, delta: Pixels, mins: &[Pixels], cx: &mut Context<Self>) {
         let Some(&floor) = mins.get(ix) else {
             return;
         };
 
         let pane_count = mins.len();
 
-        let mut size = self.pane_size(ix, pane_count, thickness) + delta;
+        let mut size = self.pane_size(ix, pane_count) + delta;
         size = size.max(floor);
 
         if let Some(extent) = self.measured {
@@ -97,7 +89,7 @@ impl ResizableState {
                 .enumerate()
                 .filter(|(j, _)| *j != ix)
                 .fold(px(0.), |sum, (_, min)| sum + *min);
-            let ceiling = extent - thickness * (pane_count as f32 - 1.0) - floors;
+            let ceiling = extent - floors;
             size = size.min(ceiling);
         }
 
@@ -110,14 +102,8 @@ impl ResizableState {
     }
 
     /// Restores pane `ix` to the equal split, as a double-click does.
-    fn reset_pane(
-        &mut self,
-        ix: usize,
-        pane_count: usize,
-        thickness: Pixels,
-        cx: &mut Context<Self>,
-    ) {
-        let split = self.equal_split(pane_count, thickness);
+    fn reset_pane(&mut self, ix: usize, pane_count: usize, cx: &mut Context<Self>) {
+        let split = self.equal_split(pane_count);
         while self.sizes.len() <= ix {
             self.sizes.push(px(DEFAULT_PANE_SIZE));
         }
@@ -223,7 +209,6 @@ impl Styled for Resizable {
 
 impl RenderOnce for Resizable {
     fn render(self, _window: &mut Window, cx: &mut App) -> impl IntoElement {
-        let thickness = cx.theme().sizes.resolve(Size::default()).dense_padding_x;
         let axis = self.axis;
         let state = self.state.clone();
 
@@ -232,7 +217,7 @@ impl RenderOnce for Resizable {
         let debug_selector = self.debug_selector;
 
         let sizes: Vec<Pixels> = (0..pane_count)
-            .map(|ix| state.read(cx).pane_size(ix, pane_count, thickness))
+            .map(|ix| state.read(cx).pane_size(ix, pane_count))
             .collect();
 
         let mut group = div()
@@ -274,18 +259,14 @@ impl RenderOnce for Resizable {
                             let state = state.clone();
                             let mins = mins.clone();
                             move |delta, _, cx| {
-                                state.update(cx, |state, cx| {
-                                    state.resize(ix, delta, &mins, thickness, cx)
-                                });
+                                state.update(cx, |state, cx| state.resize(ix, delta, &mins, cx));
                             }
                         })
                         .on_reset({
                             let state = state.clone();
                             let mins = mins.clone();
                             move |_, cx| {
-                                state.update(cx, |state, cx| {
-                                    state.reset_pane(ix, mins.len(), thickness, cx)
-                                });
+                                state.update(cx, |state, cx| state.reset_pane(ix, mins.len(), cx));
                             }
                         });