From 0d3bb0411ef2eff5f8dcc31aa1f728936227463a Mon Sep 17 00:00:00 2001
From: Vijay Prakash <vijayprakashpj@gmail.com>
Date: Sun, 8 Mar 2026 23:55:30 +0100
Subject: [PATCH 1/6] feat(scrollbar): Added scrollbar component style with
 defaults

- Encapsulate track, thumb and arrow styles into a struct.
- Implemented builder methods, default styles based on existing implementation
---
 tui-scrollbar/src/scrollbar/mod.rs | 40 ++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/tui-scrollbar/src/scrollbar/mod.rs b/tui-scrollbar/src/scrollbar/mod.rs
index d9473e06..f237df7f 100644
--- a/tui-scrollbar/src/scrollbar/mod.rs
+++ b/tui-scrollbar/src/scrollbar/mod.rs
@@ -126,6 +126,46 @@ struct ArrowLayout {
     end: Option<(u16, u16)>,
 }
 
+/// Style of the scrollbar.
+///
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ScrollBarStyle {
+    pub track_style: Style,
+    pub thumb_style: Style,
+    pub arrow_style: Option<Style>,
+}
+
+impl ScrollBarStyle {
+    pub const fn new() -> Self {
+        ScrollBarStyle {
+            track_style: Style::new().bg(Color::DarkGray),
+            thumb_style: Style::new().fg(Color::White).bg(Color::DarkGray),
+            arrow_style: Some(Style::new().fg(Color::White).bg(Color::DarkGray)),
+        }
+    }
+
+    pub fn track_style(mut self, style: Style) -> Self {
+        self.track_style = style;
+        self
+    }
+
+    pub fn thumb_style(mut self, style: Style) -> Self {
+        self.thumb_style = style;
+        self
+    }
+
+    pub fn arrow_style(mut self, style: Style) -> Self {
+        self.arrow_style = Some(style);
+        self
+    }
+}
+
+impl Default for ScrollBarStyle {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 /// A proportional scrollbar widget with fractional thumb rendering.
 ///
 /// # Method map

From 01470450e4c8f12a65a16bcc723d93439f1a4ddf Mon Sep 17 00:00:00 2001
From: Vijay Prakash <vijayprakashpj@gmail.com>
Date: Mon, 9 Mar 2026 00:31:06 +0100
Subject: [PATCH 2/6] feat(scrollbar): Add `style` field and a `style` method
 to `ScrollBar` for unified style configuration.

---
 tui-scrollbar/src/scrollbar/mod.rs | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/tui-scrollbar/src/scrollbar/mod.rs b/tui-scrollbar/src/scrollbar/mod.rs
index f237df7f..412ed8b4 100644
--- a/tui-scrollbar/src/scrollbar/mod.rs
+++ b/tui-scrollbar/src/scrollbar/mod.rs
@@ -341,6 +341,7 @@ pub struct ScrollBar {
     track_style: Style,
     thumb_style: Style,
     arrow_style: Option<Style>,
+    style: ScrollBarStyle,
     glyph_set: GlyphSet,
     arrows: ScrollBarArrows,
     track_click_behavior: TrackClickBehavior,
@@ -373,6 +374,7 @@ impl ScrollBar {
             track_style: Style::new().bg(Color::DarkGray),
             thumb_style: Style::new().fg(Color::White).bg(Color::DarkGray),
             arrow_style: Some(Style::new().fg(Color::White).bg(Color::DarkGray)),
+            style: ScrollBarStyle::default(),
             glyph_set: GlyphSet::default(),
             arrows: ScrollBarArrows::default(),
             track_click_behavior: TrackClickBehavior::Page,
@@ -555,6 +557,14 @@ impl ScrollBar {
         self
     }
 
+    /// Sets the style of the scrollbar components.
+    ///
+    /// Defaults to [`ScrollBarStyle::default()`].
+    pub const fn style(mut self, style: ScrollBarStyle) -> Self {
+        self.style = style;
+        self
+    }
+
     /// Selects the glyph set used to render the track and thumb.
     ///
     /// [`GlyphSet::symbols_for_legacy_computing`] uses [Symbols for Legacy Computing] for 1/8th
@@ -707,6 +717,12 @@ mod tests {
             .track_style(track_style)
             .thumb_style(thumb_style)
             .arrow_style(arrow_style)
+            .style(
+                ScrollBarStyle::new()
+                    .track_style(track_style)
+                    .thumb_style(thumb_style)
+                    .arrow_style(arrow_style),
+            )
             .glyph_set(glyphs.clone())
             .arrows(ScrollBarArrows::End)
             .track_click_behavior(TrackClickBehavior::JumpToClick)
@@ -719,6 +735,9 @@ mod tests {
         assert_eq!(scrollbar.track_style, track_style);
         assert_eq!(scrollbar.thumb_style, thumb_style);
         assert_eq!(scrollbar.arrow_style, Some(arrow_style));
+        assert_eq!(scrollbar.style.track_style, track_style);
+        assert_eq!(scrollbar.style.thumb_style, thumb_style);
+        assert_eq!(scrollbar.style.arrow_style, Some(arrow_style));
         assert_eq!(scrollbar.glyph_set, glyphs);
         assert_eq!(scrollbar.arrows, ScrollBarArrows::End);
         assert_eq!(

From bcf66c30adb2cad3a2dd6bd6fcdced7ca393c9b0 Mon Sep 17 00:00:00 2001
From: Vijay Prakash <vijayprakashpj@gmail.com>
Date: Mon, 9 Mar 2026 00:37:53 +0100
Subject: [PATCH 3/6] docs(scrollbar): enhance `ScrollBarStyle` documentation
 with field descriptions, method comments, and a usage example.

---
 tui-scrollbar/src/lib.rs           |  1 +
 tui-scrollbar/src/scrollbar/mod.rs | 35 ++++++++++++++----------------
 2 files changed, 17 insertions(+), 19 deletions(-)

diff --git a/tui-scrollbar/src/lib.rs b/tui-scrollbar/src/lib.rs
index 0da87f36..11aa102d 100644
--- a/tui-scrollbar/src/lib.rs
+++ b/tui-scrollbar/src/lib.rs
@@ -225,6 +225,7 @@
 //! - [`ScrollMetrics`]: pure math for thumb sizing and hit testing.
 //! - [`GlyphSet`]: glyph selection for track and thumb rendering.
 //! - [`ScrollBarArrows`]: arrow endcap configuration.
+//! - [`ScrollBarStyle`]: style configuration for the scrollbar.
 //!
 //! ## Enums and events
 //!
diff --git a/tui-scrollbar/src/scrollbar/mod.rs b/tui-scrollbar/src/scrollbar/mod.rs
index 412ed8b4..4440087d 100644
--- a/tui-scrollbar/src/scrollbar/mod.rs
+++ b/tui-scrollbar/src/scrollbar/mod.rs
@@ -130,12 +130,16 @@ struct ArrowLayout {
 ///
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ScrollBarStyle {
+    /// Style applied to track glyphs.
     pub track_style: Style,
+    /// Style applied to thumb glyphs.
     pub thumb_style: Style,
+    /// Style applied to arrow glyphs.
     pub arrow_style: Option<Style>,
 }
 
 impl ScrollBarStyle {
+    /// Creates a new scrollbar style with default colors.
     pub const fn new() -> Self {
         ScrollBarStyle {
             track_style: Style::new().bg(Color::DarkGray),
@@ -144,16 +148,19 @@ impl ScrollBarStyle {
         }
     }
 
+    /// Sets the style applied to track glyphs.
     pub fn track_style(mut self, style: Style) -> Self {
         self.track_style = style;
         self
     }
 
+    /// Sets the style applied to thumb glyphs.
     pub fn thumb_style(mut self, style: Style) -> Self {
         self.thumb_style = style;
         self
     }
 
+    /// Sets the style applied to arrow glyphs.
     pub fn arrow_style(mut self, style: Style) -> Self {
         self.arrow_style = Some(style);
         self
@@ -218,29 +225,19 @@ impl Default for ScrollBarStyle {
 /// Track glyphs use `track_style`. Thumb glyphs use `thumb_style`. Arrow endcaps use
 /// `arrow_style`, which defaults to white on dark gray.
 ///
-/// Scrollbar glyphs are terminal characters. For visible track glyphs, thumb blocks, and arrow
-/// symbols, `Style::fg` colors the glyph itself and `Style::bg` colors the cell behind it. The
-/// default [`GlyphSet::minimal`] track renders spaces, so only the track background is visible in
-/// empty track cells. Visible track glyph sets, such as [`GlyphSet::box_drawing`] and
-/// [`GlyphSet::unicode`], can use foreground color for the track line. Thumb glyphs are block
-/// characters, so `Style::fg` is usually the useful knob for thumb color; `Style::bg` still colors
-/// the rest of the cell. With partial thumb glyphs, especially on a visible line track such as
-/// [`GlyphSet::box_drawing`], that background can show at the ends of the thumb. Match the thumb
-/// background to the track background unless that contrast is intentional.
+/// You can either chain style methods directly on the `ScrollBar` or pass a custom
+/// [`ScrollBarStyle`] constructed using [`ScrollBarStyle::new()`].
 ///
 /// ```rust
 /// use ratatui_core::style::{Color, Style};
-/// use tui_scrollbar::{ScrollBar, ScrollBarArrows, ScrollLengths};
+/// use tui_scrollbar::{ScrollBar, ScrollBarOrientation, ScrollLengths, ScrollBarStyle};
 ///
-/// let lengths = ScrollLengths {
-///     content_len: 120,
-///     viewport_len: 30,
-/// };
-/// let scrollbar = ScrollBar::vertical(lengths)
-///     .arrows(ScrollBarArrows::Both)
-///     .track_style(Style::new().bg(Color::Black))
-///     .thumb_style(Style::new().fg(Color::Rgb(255, 158, 100)))
-///     .arrow_style(Style::new().fg(Color::Yellow).bg(Color::Black));
+/// const CUSTOM_STYLE: ScrollBarStyle = ScrollBarStyle::new()
+///     .track_style(Style::new().bg(Color::Blue))
+///     .thumb_style(Style::new().bg(Color::Red));
+///
+/// let lengths = ScrollLengths { content_len: 120, viewport_len: 40 };
+/// let scrollbar = ScrollBar::vertical(lengths).style(CUSTOM_STYLE);
 /// ```
 ///
 /// # State

From 2a566e8c98aedff7cf086b682a829831c981d0ca Mon Sep 17 00:00:00 2001
From: Vijay Prakash <vijayprakashpj@gmail.com>
Date: Mon, 9 Mar 2026 00:38:32 +0100
Subject: [PATCH 4/6] feat(scrollbar): Make `track_style`, `thumb_style`, and
 `arrow_style` methods `const` functions.

---
 tui-scrollbar/src/scrollbar/mod.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tui-scrollbar/src/scrollbar/mod.rs b/tui-scrollbar/src/scrollbar/mod.rs
index 4440087d..2de2dad0 100644
--- a/tui-scrollbar/src/scrollbar/mod.rs
+++ b/tui-scrollbar/src/scrollbar/mod.rs
@@ -149,19 +149,19 @@ impl ScrollBarStyle {
     }
 
     /// Sets the style applied to track glyphs.
-    pub fn track_style(mut self, style: Style) -> Self {
+    pub const fn track_style(mut self, style: Style) -> Self {
         self.track_style = style;
         self
     }
 
     /// Sets the style applied to thumb glyphs.
-    pub fn thumb_style(mut self, style: Style) -> Self {
+    pub const fn thumb_style(mut self, style: Style) -> Self {
         self.thumb_style = style;
         self
     }
 
     /// Sets the style applied to arrow glyphs.
-    pub fn arrow_style(mut self, style: Style) -> Self {
+    pub const fn arrow_style(mut self, style: Style) -> Self {
         self.arrow_style = Some(style);
         self
     }

From 3986bec18cfa289a580755c3499f15b21dd4941b Mon Sep 17 00:00:00 2001
From: Vijay Prakash <vijayprakashpj@gmail.com>
Date: Thu, 14 May 2026 00:52:46 +0200
Subject: [PATCH 5/6] feat(scrollbar): Update assertions

---
 tui-scrollbar/src/scrollbar/mod.rs    | 15 +----
 tui-scrollbar/src/scrollbar/render.rs | 85 ++++++++++++++++++---------
 2 files changed, 59 insertions(+), 41 deletions(-)

diff --git a/tui-scrollbar/src/scrollbar/mod.rs b/tui-scrollbar/src/scrollbar/mod.rs
index 2de2dad0..f28e18cc 100644
--- a/tui-scrollbar/src/scrollbar/mod.rs
+++ b/tui-scrollbar/src/scrollbar/mod.rs
@@ -335,9 +335,6 @@ pub struct ScrollBar {
     content_len: usize,
     viewport_len: usize,
     offset: usize,
-    track_style: Style,
-    thumb_style: Style,
-    arrow_style: Option<Style>,
     style: ScrollBarStyle,
     glyph_set: GlyphSet,
     arrows: ScrollBarArrows,
@@ -368,9 +365,6 @@ impl ScrollBar {
             content_len: lengths.content_len,
             viewport_len: lengths.viewport_len,
             offset: 0,
-            track_style: Style::new().bg(Color::DarkGray),
-            thumb_style: Style::new().fg(Color::White).bg(Color::DarkGray),
-            arrow_style: Some(Style::new().fg(Color::White).bg(Color::DarkGray)),
             style: ScrollBarStyle::default(),
             glyph_set: GlyphSet::default(),
             arrows: ScrollBarArrows::default(),
@@ -505,7 +499,7 @@ impl ScrollBar {
     /// let scrollbar = ScrollBar::vertical(lengths).track_style(Style::new().bg(Color::Black));
     /// ```
     pub const fn track_style(mut self, style: Style) -> Self {
-        self.track_style = style;
+        self.style = self.style.track_style(style);
         self
     }
 
@@ -528,7 +522,7 @@ impl ScrollBar {
     ///     ScrollBar::vertical(lengths).thumb_style(Style::new().fg(Color::Rgb(255, 158, 100)));
     /// ```
     pub const fn thumb_style(mut self, style: Style) -> Self {
-        self.thumb_style = style;
+        self.style = self.style.thumb_style(style);
         self
     }
 
@@ -550,7 +544,7 @@ impl ScrollBar {
     ///     .arrow_style(Style::new().fg(Color::Yellow).bg(Color::Black));
     /// ```
     pub const fn arrow_style(mut self, style: Style) -> Self {
-        self.arrow_style = Some(style);
+        self.style = self.style.arrow_style(style);
         self
     }
 
@@ -729,9 +723,6 @@ mod tests {
         assert_eq!(scrollbar.content_len, 20);
         assert_eq!(scrollbar.viewport_len, 5);
         assert_eq!(scrollbar.offset, 3);
-        assert_eq!(scrollbar.track_style, track_style);
-        assert_eq!(scrollbar.thumb_style, thumb_style);
-        assert_eq!(scrollbar.arrow_style, Some(arrow_style));
         assert_eq!(scrollbar.style.track_style, track_style);
         assert_eq!(scrollbar.style.thumb_style, thumb_style);
         assert_eq!(scrollbar.style.arrow_style, Some(arrow_style));
diff --git a/tui-scrollbar/src/scrollbar/render.rs b/tui-scrollbar/src/scrollbar/render.rs
index aa5c91d5..a3ac5549 100644
--- a/tui-scrollbar/src/scrollbar/render.rs
+++ b/tui-scrollbar/src/scrollbar/render.rs
@@ -43,7 +43,7 @@ impl ScrollBar {
 
     /// Renders arrow endcaps into the buffer before the thumb/track.
     fn render_arrows(&self, layout: &ArrowLayout, buf: &mut Buffer) {
-        let arrow_style = self.arrow_style.unwrap_or(self.track_style);
+        let arrow_style = self.style.arrow_style.unwrap_or(self.style.track_style);
         if let Some((x, y)) = layout.start {
             let glyph = match self.orientation {
                 ScrollBarOrientation::Vertical => self.glyph_set.arrow_vertical_start,
@@ -105,8 +105,11 @@ impl ScrollBar {
     /// Chooses the vertical glyph + style for a track cell fill.
     fn glyph_for_vertical(&self, fill: CellFill) -> (char, Style) {
         match fill {
-            CellFill::Empty => (self.glyph_set.track_vertical, self.track_style),
-            CellFill::Full => (self.glyph_set.thumb_vertical_lower[7], self.thumb_style),
+            CellFill::Empty => (self.glyph_set.track_vertical, self.style.track_style),
+            CellFill::Full => (
+                self.glyph_set.thumb_vertical_lower[7],
+                self.style.thumb_style,
+            ),
             CellFill::Partial { start, len } => {
                 let index = len.saturating_sub(1) as usize;
                 let glyph = if start == 0 {
@@ -114,7 +117,7 @@ impl ScrollBar {
                 } else {
                     self.glyph_set.thumb_vertical_lower[index]
                 };
-                (glyph, self.thumb_style)
+                (glyph, self.style.thumb_style)
             }
         }
     }
@@ -122,8 +125,11 @@ impl ScrollBar {
     /// Chooses the horizontal glyph + style for a track cell fill.
     fn glyph_for_horizontal(&self, fill: CellFill) -> (char, Style) {
         match fill {
-            CellFill::Empty => (self.glyph_set.track_horizontal, self.track_style),
-            CellFill::Full => (self.glyph_set.thumb_horizontal_left[7], self.thumb_style),
+            CellFill::Empty => (self.glyph_set.track_horizontal, self.style.track_style),
+            CellFill::Full => (
+                self.glyph_set.thumb_horizontal_left[7],
+                self.style.thumb_style,
+            ),
             CellFill::Partial { start, len } => {
                 let index = len.saturating_sub(1) as usize;
                 let glyph = if start == 0 {
@@ -131,7 +137,7 @@ impl ScrollBar {
                 } else {
                     self.glyph_set.thumb_horizontal_right[index]
                 };
-                (glyph, self.thumb_style)
+                (glyph, self.style.thumb_style)
             }
         }
     }
@@ -144,7 +150,7 @@ mod tests {
     use ratatui_core::style::{Color, Style};
 
     use super::*;
-    use crate::{GlyphSet, ScrollBarArrows, ScrollLengths};
+    use crate::{GlyphSet, ScrollBarArrows, ScrollBarStyle, ScrollLengths};
 
     fn assert_horizontal_thumb_walk(
         glyph_set: GlyphSet,
@@ -160,15 +166,16 @@ mod tests {
             let scrollbar = ScrollBar::horizontal(lengths)
                 .arrows(ScrollBarArrows::None)
                 .glyph_set(glyph_set.clone())
+                .style(ScrollBarStyle::new())
                 .offset(offset);
             let mut buf = Buffer::empty(Rect::new(0, 0, 8, 1));
             (&scrollbar).render(buf.area, &mut buf);
 
             let mut expected = Buffer::with_lines(vec![expected_line]);
-            expected.set_style(expected.area, scrollbar.track_style);
+            expected.set_style(expected.area, scrollbar.style.track_style);
             for (x, symbol) in expected_line.chars().enumerate() {
                 if symbol != track_char {
-                    expected[(x as u16, 0)].set_style(scrollbar.thumb_style);
+                    expected[(x as u16, 0)].set_style(scrollbar.style.thumb_style);
                 }
             }
             assert_eq!(buf, expected);
@@ -186,9 +193,9 @@ mod tests {
         let mut buf = Buffer::empty(Rect::new(0, 0, 1, 4));
         (&scrollbar).render(buf.area, &mut buf);
         let mut expected = Buffer::with_lines(vec!["▅", "▀", " ", " "]);
-        expected.set_style(expected.area, scrollbar.track_style);
-        expected[(0, 0)].set_style(scrollbar.thumb_style);
-        expected[(0, 1)].set_style(scrollbar.thumb_style);
+        expected.set_style(expected.area, scrollbar.style.track_style);
+        expected[(0, 0)].set_style(scrollbar.style.thumb_style);
+        expected[(0, 1)].set_style(scrollbar.style.thumb_style);
         assert_eq!(buf, expected);
     }
 
@@ -203,9 +210,9 @@ mod tests {
         let mut buf = Buffer::empty(Rect::new(0, 0, 4, 1));
         (&scrollbar).render(buf.area, &mut buf);
         let mut expected = Buffer::with_lines(vec!["🮉▌  "]);
-        expected.set_style(expected.area, scrollbar.track_style);
-        expected[(0, 0)].set_style(scrollbar.thumb_style);
-        expected[(1, 0)].set_style(scrollbar.thumb_style);
+        expected.set_style(expected.area, scrollbar.style.track_style);
+        expected[(0, 0)].set_style(scrollbar.style.thumb_style);
+        expected[(1, 0)].set_style(scrollbar.style.thumb_style);
         assert_eq!(buf, expected);
     }
 
@@ -252,9 +259,9 @@ mod tests {
         let mut buf = Buffer::empty(Rect::new(0, 0, 4, 1));
         (&scrollbar).render(buf.area, &mut buf);
         let mut expected = Buffer::with_lines(vec!["🮉▌──"]);
-        expected.set_style(expected.area, scrollbar.track_style);
-        expected[(0, 0)].set_style(scrollbar.thumb_style);
-        expected[(1, 0)].set_style(scrollbar.thumb_style);
+        expected.set_style(expected.area, scrollbar.style.track_style);
+        expected[(0, 0)].set_style(scrollbar.style.thumb_style);
+        expected[(1, 0)].set_style(scrollbar.style.thumb_style);
         assert_eq!(buf, expected);
     }
 
@@ -270,9 +277,9 @@ mod tests {
         let mut buf = Buffer::empty(Rect::new(0, 0, 4, 1));
         (&scrollbar).render(buf.area, &mut buf);
         let mut expected = Buffer::with_lines(vec!["▐▌──"]);
-        expected.set_style(expected.area, scrollbar.track_style);
-        expected[(0, 0)].set_style(scrollbar.thumb_style);
-        expected[(1, 0)].set_style(scrollbar.thumb_style);
+        expected.set_style(expected.area, scrollbar.style.track_style);
+        expected[(0, 0)].set_style(scrollbar.style.thumb_style);
+        expected[(1, 0)].set_style(scrollbar.style.thumb_style);
         assert_eq!(buf, expected);
     }
 
@@ -343,7 +350,7 @@ mod tests {
         let mut buf = Buffer::empty(Rect::new(0, 0, 1, 3));
         (&scrollbar).render(buf.area, &mut buf);
         let mut expected = Buffer::with_lines(vec!["█", "█", "█"]);
-        expected.set_style(expected.area, scrollbar.thumb_style);
+        expected.set_style(expected.area, scrollbar.style.thumb_style);
         assert_eq!(buf, expected);
     }
 
@@ -357,9 +364,19 @@ mod tests {
         let mut buf = Buffer::empty(Rect::new(0, 0, 1, 3));
         (&scrollbar).render(buf.area, &mut buf);
         let mut expected = Buffer::with_lines(vec!["▲", "█", "▼"]);
-        expected[(0, 0)].set_style(scrollbar.arrow_style.unwrap_or(scrollbar.track_style));
-        expected[(0, 1)].set_style(scrollbar.thumb_style);
-        expected[(0, 2)].set_style(scrollbar.arrow_style.unwrap_or(scrollbar.track_style));
+        expected[(0, 0)].set_style(
+            scrollbar
+                .style
+                .arrow_style
+                .unwrap_or(scrollbar.style.track_style),
+        );
+        expected[(0, 1)].set_style(scrollbar.style.thumb_style);
+        expected[(0, 2)].set_style(
+            scrollbar
+                .style
+                .arrow_style
+                .unwrap_or(scrollbar.style.track_style),
+        );
         assert_eq!(buf, expected);
     }
 
@@ -373,9 +390,19 @@ mod tests {
         let mut buf = Buffer::empty(Rect::new(0, 0, 3, 1));
         (&scrollbar).render(buf.area, &mut buf);
         let mut expected = Buffer::with_lines(vec!["◀█▶"]);
-        expected[(0, 0)].set_style(scrollbar.arrow_style.unwrap_or(scrollbar.track_style));
-        expected[(1, 0)].set_style(scrollbar.thumb_style);
-        expected[(2, 0)].set_style(scrollbar.arrow_style.unwrap_or(scrollbar.track_style));
+        expected[(0, 0)].set_style(
+            scrollbar
+                .style
+                .arrow_style
+                .unwrap_or(scrollbar.style.track_style),
+        );
+        expected[(1, 0)].set_style(scrollbar.style.thumb_style);
+        expected[(2, 0)].set_style(
+            scrollbar
+                .style
+                .arrow_style
+                .unwrap_or(scrollbar.style.track_style),
+        );
         assert_eq!(buf, expected);
     }
 }

From e25ac27b81a80411b01b62f53108078b3b263bfc Mon Sep 17 00:00:00 2001
From: Vijay Prakash <vijayprakashpj@gmail.com>
Date: Wed, 22 Jul 2026 22:40:19 +0200
Subject: [PATCH 6/6] feat(scrollbar): Render scrollbad widget using the new
 ScrollbarStyle styles - WIP

---
 tui-scrollbar/src/lib.rs              |  6 +-
 tui-scrollbar/src/scrollbar/mod.rs    | 97 +++++++++++++++++++++++++--
 tui-scrollbar/src/scrollbar/render.rs | 42 ++++++------
 3 files changed, 118 insertions(+), 27 deletions(-)

diff --git a/tui-scrollbar/src/lib.rs b/tui-scrollbar/src/lib.rs
index 11aa102d..2c51e507 100644
--- a/tui-scrollbar/src/lib.rs
+++ b/tui-scrollbar/src/lib.rs
@@ -313,5 +313,7 @@ pub use crate::input::{
     ScrollEvent, ScrollWheel,
 };
 pub use crate::lengths::ScrollLengths;
-pub use crate::metrics::{CellFill, HitTest, SUBCELL, ScrollMetrics};
-pub use crate::scrollbar::{ScrollBar, ScrollBarArrows, ScrollBarOrientation, TrackClickBehavior};
+pub use crate::metrics::{CellFill, HitTest, ScrollMetrics, SUBCELL};
+pub use crate::scrollbar::{
+    ScrollBar, ScrollBarArrows, ScrollBarOrientation, ScrollBarStyle, TrackClickBehavior,
+};
diff --git a/tui-scrollbar/src/scrollbar/mod.rs b/tui-scrollbar/src/scrollbar/mod.rs
index f28e18cc..c18017a6 100644
--- a/tui-scrollbar/src/scrollbar/mod.rs
+++ b/tui-scrollbar/src/scrollbar/mod.rs
@@ -126,8 +126,19 @@ struct ArrowLayout {
     end: Option<(u16, u16)>,
 }
 
-/// Style of the scrollbar.
+/// Style of the scrollbar (track, thumb, and optional arrow endcaps).
 ///
+/// # Reading and updating
+///
+/// The `track_style`, `thumb_style`, and `arrow_style` fields are public, so you can read or
+/// assign them directly (including in struct update expressions).
+///
+/// Methods [`Self::track_style`], [`Self::thumb_style`], and [`Self::arrow_style`] that take a
+/// [`Style`] and return `Self` are **builders** for chained construction.
+///
+/// Use [`Self::get_track_style`], [`Self::get_thumb_style`], and [`Self::get_arrow_style`] to read
+/// by method call, and [`Self::set_track_style`], [`Self::set_thumb_style`], [`Self::set_arrow_style`],
+/// and [`Self::clear_arrow_style`] to update a `ScrollBarStyle` in place without consuming it.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ScrollBarStyle {
     /// Style applied to track glyphs.
@@ -149,22 +160,66 @@ impl ScrollBarStyle {
     }
 
     /// Sets the style applied to track glyphs.
+    ///
+    /// For reading or in-place updates, see [`Self::get_track_style`] and [`Self::set_track_style`].
     pub const fn track_style(mut self, style: Style) -> Self {
         self.track_style = style;
         self
     }
 
     /// Sets the style applied to thumb glyphs.
+    ///
+    /// For reading or in-place updates, see [`Self::get_thumb_style`] and [`Self::set_thumb_style`].
     pub const fn thumb_style(mut self, style: Style) -> Self {
         self.thumb_style = style;
         self
     }
 
     /// Sets the style applied to arrow glyphs.
+    ///
+    /// For reading, clearing, or in-place updates, see [`Self::get_arrow_style`],
+    /// [`Self::set_arrow_style`], and [`Self::clear_arrow_style`].
     pub const fn arrow_style(mut self, style: Style) -> Self {
         self.arrow_style = Some(style);
         self
     }
+
+    /// Returns the style applied to track glyphs.
+    pub const fn get_track_style(&self) -> Style {
+        self.track_style
+    }
+
+    /// Returns the style applied to thumb glyphs.
+    pub const fn get_thumb_style(&self) -> Style {
+        self.thumb_style
+    }
+
+    /// Returns the style applied to arrow glyphs, if set.
+    pub const fn get_arrow_style(&self) -> Option<Style> {
+        self.arrow_style
+    }
+
+    /// Sets the style applied to track glyphs in place.
+    pub const fn set_track_style(&mut self, style: Style) {
+        self.track_style = style;
+    }
+
+    /// Sets the style applied to thumb glyphs in place.
+    pub const fn set_thumb_style(&mut self, style: Style) {
+        self.thumb_style = style;
+    }
+
+    /// Sets the style applied to arrow glyphs in place.
+    ///
+    /// Pass [`None`] so arrow cells use the track style at render time (see [`crate::ScrollBar`]).
+    pub const fn set_arrow_style(&mut self, style: Option<Style>) {
+        self.arrow_style = style;
+    }
+
+    /// Clears the dedicated arrow style so arrows use the track style when rendered.
+    pub const fn clear_arrow_style(&mut self) {
+        self.arrow_style = None;
+    }
 }
 
 impl Default for ScrollBarStyle {
@@ -189,6 +244,7 @@ impl Default for ScrollBarStyle {
 /// - [`Self::content_len`]
 /// - [`Self::viewport_len`]
 /// - [`Self::offset`]
+/// - [`Self::styles`]
 ///
 /// ## Appearance
 ///
@@ -228,6 +284,10 @@ impl Default for ScrollBarStyle {
 /// You can either chain style methods directly on the `ScrollBar` or pass a custom
 /// [`ScrollBarStyle`] constructed using [`ScrollBarStyle::new()`].
 ///
+/// The methods [`ScrollBar::track_style`], [`ScrollBar::thumb_style`], and
+/// [`ScrollBar::arrow_style`] are **builders**: they take a [`Style`] and return a new scrollbar.
+/// To read the active styles from an existing scrollbar, use [`ScrollBar::styles`].
+///
 /// ```rust
 /// use ratatui_core::style::{Color, Style};
 /// use tui_scrollbar::{ScrollBar, ScrollBarOrientation, ScrollLengths, ScrollBarStyle};
@@ -551,11 +611,22 @@ impl ScrollBar {
     /// Sets the style of the scrollbar components.
     ///
     /// Defaults to [`ScrollBarStyle::default()`].
+    ///
+    /// For the configured style, see [`Self::styles`].
     pub const fn style(mut self, style: ScrollBarStyle) -> Self {
         self.style = style;
         self
     }
 
+    /// Returns the scrollbar’s configured [`ScrollBarStyle`] (track, thumb, and arrow styles).
+    ///
+    /// This is the supported way to **read** styles from a [`ScrollBar`]. Builder methods named
+    /// [`Self::track_style`], [`Self::thumb_style`], and [`Self::arrow_style`] take a [`Style`]
+    /// argument and return an updated scrollbar; they are not getters.
+    pub const fn styles(&self) -> &ScrollBarStyle {
+        &self.style
+    }
+
     /// Selects the glyph set used to render the track and thumb.
     ///
     /// [`GlyphSet::symbols_for_legacy_computing`] uses [Symbols for Legacy Computing] for 1/8th
@@ -723,9 +794,9 @@ mod tests {
         assert_eq!(scrollbar.content_len, 20);
         assert_eq!(scrollbar.viewport_len, 5);
         assert_eq!(scrollbar.offset, 3);
-        assert_eq!(scrollbar.style.track_style, track_style);
-        assert_eq!(scrollbar.style.thumb_style, thumb_style);
-        assert_eq!(scrollbar.style.arrow_style, Some(arrow_style));
+        assert_eq!(scrollbar.styles().track_style, track_style);
+        assert_eq!(scrollbar.styles().thumb_style, thumb_style);
+        assert_eq!(scrollbar.styles().arrow_style, Some(arrow_style));
         assert_eq!(scrollbar.glyph_set, glyphs);
         assert_eq!(scrollbar.arrows, ScrollBarArrows::End);
         assert_eq!(
@@ -735,6 +806,24 @@ mod tests {
         assert_eq!(scrollbar.scroll_step, 1);
     }
 
+    #[test]
+    fn scroll_bar_style_getters_and_setters() {
+        let mut style = ScrollBarStyle::new()
+            .track_style(Style::new().fg(Color::Yellow))
+            .thumb_style(Style::new().bg(Color::Cyan));
+        style.set_arrow_style(Some(Style::new().fg(Color::Magenta)));
+
+        assert_eq!(style.get_track_style(), style.track_style);
+        assert_eq!(style.get_thumb_style(), style.thumb_style);
+        assert_eq!(style.get_arrow_style(), style.arrow_style);
+
+        style.clear_arrow_style();
+        assert_eq!(style.get_arrow_style(), None);
+
+        style.set_track_style(Style::new().fg(Color::Red));
+        assert_eq!(style.get_track_style(), Style::new().fg(Color::Red));
+    }
+
     #[test]
     fn constructors_set_orientation() {
         let lengths = ScrollLengths {
diff --git a/tui-scrollbar/src/scrollbar/render.rs b/tui-scrollbar/src/scrollbar/render.rs
index a3ac5549..958bb3d4 100644
--- a/tui-scrollbar/src/scrollbar/render.rs
+++ b/tui-scrollbar/src/scrollbar/render.rs
@@ -172,10 +172,10 @@ mod tests {
             (&scrollbar).render(buf.area, &mut buf);
 
             let mut expected = Buffer::with_lines(vec![expected_line]);
-            expected.set_style(expected.area, scrollbar.style.track_style);
+            expected.set_style(expected.area, scrollbar.styles().track_style);
             for (x, symbol) in expected_line.chars().enumerate() {
                 if symbol != track_char {
-                    expected[(x as u16, 0)].set_style(scrollbar.style.thumb_style);
+                    expected[(x as u16, 0)].set_style(scrollbar.styles().thumb_style);
                 }
             }
             assert_eq!(buf, expected);
@@ -193,9 +193,9 @@ mod tests {
         let mut buf = Buffer::empty(Rect::new(0, 0, 1, 4));
         (&scrollbar).render(buf.area, &mut buf);
         let mut expected = Buffer::with_lines(vec!["▅", "▀", " ", " "]);
-        expected.set_style(expected.area, scrollbar.style.track_style);
-        expected[(0, 0)].set_style(scrollbar.style.thumb_style);
-        expected[(0, 1)].set_style(scrollbar.style.thumb_style);
+        expected.set_style(expected.area, scrollbar.styles().track_style);
+        expected[(0, 0)].set_style(scrollbar.styles().thumb_style);
+        expected[(0, 1)].set_style(scrollbar.styles().thumb_style);
         assert_eq!(buf, expected);
     }
 
@@ -210,9 +210,9 @@ mod tests {
         let mut buf = Buffer::empty(Rect::new(0, 0, 4, 1));
         (&scrollbar).render(buf.area, &mut buf);
         let mut expected = Buffer::with_lines(vec!["🮉▌  "]);
-        expected.set_style(expected.area, scrollbar.style.track_style);
-        expected[(0, 0)].set_style(scrollbar.style.thumb_style);
-        expected[(1, 0)].set_style(scrollbar.style.thumb_style);
+        expected.set_style(expected.area, scrollbar.styles().track_style);
+        expected[(0, 0)].set_style(scrollbar.styles().thumb_style);
+        expected[(1, 0)].set_style(scrollbar.styles().thumb_style);
         assert_eq!(buf, expected);
     }
 
@@ -259,9 +259,9 @@ mod tests {
         let mut buf = Buffer::empty(Rect::new(0, 0, 4, 1));
         (&scrollbar).render(buf.area, &mut buf);
         let mut expected = Buffer::with_lines(vec!["🮉▌──"]);
-        expected.set_style(expected.area, scrollbar.style.track_style);
-        expected[(0, 0)].set_style(scrollbar.style.thumb_style);
-        expected[(1, 0)].set_style(scrollbar.style.thumb_style);
+        expected.set_style(expected.area, scrollbar.styles().track_style);
+        expected[(0, 0)].set_style(scrollbar.styles().thumb_style);
+        expected[(1, 0)].set_style(scrollbar.styles().thumb_style);
         assert_eq!(buf, expected);
     }
 
@@ -277,9 +277,9 @@ mod tests {
         let mut buf = Buffer::empty(Rect::new(0, 0, 4, 1));
         (&scrollbar).render(buf.area, &mut buf);
         let mut expected = Buffer::with_lines(vec!["▐▌──"]);
-        expected.set_style(expected.area, scrollbar.style.track_style);
-        expected[(0, 0)].set_style(scrollbar.style.thumb_style);
-        expected[(1, 0)].set_style(scrollbar.style.thumb_style);
+        expected.set_style(expected.area, scrollbar.styles().track_style);
+        expected[(0, 0)].set_style(scrollbar.styles().thumb_style);
+        expected[(1, 0)].set_style(scrollbar.styles().thumb_style);
         assert_eq!(buf, expected);
     }
 
@@ -350,7 +350,7 @@ mod tests {
         let mut buf = Buffer::empty(Rect::new(0, 0, 1, 3));
         (&scrollbar).render(buf.area, &mut buf);
         let mut expected = Buffer::with_lines(vec!["█", "█", "█"]);
-        expected.set_style(expected.area, scrollbar.style.thumb_style);
+        expected.set_style(expected.area, scrollbar.styles().thumb_style);
         assert_eq!(buf, expected);
     }
 
@@ -368,14 +368,14 @@ mod tests {
             scrollbar
                 .style
                 .arrow_style
-                .unwrap_or(scrollbar.style.track_style),
+                .unwrap_or(scrollbar.styles().track_style),
         );
-        expected[(0, 1)].set_style(scrollbar.style.thumb_style);
+        expected[(0, 1)].set_style(scrollbar.styles().thumb_style);
         expected[(0, 2)].set_style(
             scrollbar
                 .style
                 .arrow_style
-                .unwrap_or(scrollbar.style.track_style),
+                .unwrap_or(scrollbar.styles().track_style),
         );
         assert_eq!(buf, expected);
     }
@@ -394,14 +394,14 @@ mod tests {
             scrollbar
                 .style
                 .arrow_style
-                .unwrap_or(scrollbar.style.track_style),
+                .unwrap_or(scrollbar.styles().track_style),
         );
-        expected[(1, 0)].set_style(scrollbar.style.thumb_style);
+        expected[(1, 0)].set_style(scrollbar.styles().thumb_style);
         expected[(2, 0)].set_style(
             scrollbar
                 .style
                 .arrow_style
-                .unwrap_or(scrollbar.style.track_style),
+                .unwrap_or(scrollbar.styles().track_style),
         );
         assert_eq!(buf, expected);
     }