new scrollars

Author: willmcgugan

src/textual/_line_cache.py

@@ -9,6 +9,9 @@
 from rich.segment import Segment
 
 
+log = logging.getLogger("rich")
+
+
 class LineCache:
     def __init__(self, lines: list[list[Segment]]) -> None:
         self.lines = lines
@@ -33,13 +36,12 @@ def dirty(self) -> bool:
     def __rich_console__(
         self, console: Console, options: ConsoleOptions
     ) -> RenderResult:
-        new_line = Segment.line()
+
         for line in self.lines:
             yield from line
 
     def render(self, x: int, y: int) -> Iterable[Segment]:
         move_to = Control.move_to
-        new_line = Segment.line()
         for offset_y, (line, dirty) in enumerate(zip(self.lines, self._dirty), y):
             if dirty:
                 yield move_to(x, offset_y).segment

src/textual/scrollbar.py

@@ -2,8 +2,10 @@
 
 from math import ceil
 import logging
-from typing import Iterable
 
+
+from rich.color import Color
+from rich.style import Style
 from rich.console import Console, ConsoleOptions, RenderResult, RenderableType
 from rich.segment import Segment
 from rich.style import Style
@@ -17,7 +19,7 @@ def __init__(
         lines: list[list[Segment]],
         height: int,
         virtual_height: int,
-        position: int,
+        position: float,
         overlay: bool = False,
     ) -> None:
         self.lines = lines
@@ -31,6 +33,7 @@ def __rich_console__(
     ) -> RenderResult:
         bar = render_bar(
             size=self.height,
+            window_size=len(self.lines),
             virtual_size=self.virtual_height,
             position=self.position,
         )
@@ -46,56 +49,48 @@ def render_bar(
     virtual_size: float = 50,
     window_size: float = 20,
     position: float = 0,
-    bar_style: Style | None = None,
-    back_style: Style | None = None,
+    back_color: str = "#555555",
+    bar_color: str = "bright_magenta",
     ascii_only: bool = False,
     vertical: bool = True,
 ) -> list[Segment]:
-    if vertical:
-        if ascii_only:
-            solid = "|"
-            half_start = "|"
-            half_end = "|"
-        else:
-            solid = "┃"
-            half_start = "╻"
-            half_end = "╹"
-    else:
-        if ascii_only:
-            solid = "-"
-            half_start = "-"
-            half_end = "-"
-        else:
-            solid = "━"
-            half_start = "╺"
-            half_end = "╸"
-
-    _bar_style = bar_style or Style.parse("bright_magenta")
-    _back_style = back_style or Style.parse("#555555")
-
-    _Segment = Segment
 
-    start_bar_segment = _Segment(half_start, _bar_style)
-    end_bar_segment = _Segment(half_end, _bar_style)
-    bar_segment = _Segment(solid, _bar_style)
+    if ascii_only:
+        bars = ["|", "|", "|", "|", "|", "|", "|", "|", "|"]
+    else:
+        bars = [" ", "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"]
 
-    start_back_segment = _Segment(half_end, _bar_style)
-    end_back_segment = _Segment(half_end, _back_style)
-    back_segment = _Segment(solid, _back_style)
+    back = Color.parse(back_color)
+    bar = Color.parse(bar_color)
 
-    segments = [back_segment] * size
+    _Segment = Segment
+    _Style = Style
+    segments = [_Segment(" ", _Style(bgcolor=back))] * int(size)
 
     step_size = virtual_size / size
 
-    start = position / step_size
-    # end = (position + window_size) / step_size
-    end = start + window_size / step_size
+    start = int(position / step_size * 8)
+    end = start + int(window_size / step_size * 8)
+
+    start_index, start_bar = divmod(start, 8)
+    end_index, end_bar = divmod(end, 8)
 
-    start_index = int(start)
-    end_index = start_index + ceil(window_size / step_size)
-    bar_height = end_index - start_index
+    if start_index == end_index:
+        if start_index < len(segments):
+            segments[start_index] = _Segment(" ", _Style(bgcolor=bar))
+    else:
+        segments[start_index:end_index] = [_Segment(" ", _Style(bgcolor=bar))] * (
+            end_index - start_index
+        )
 
-    segments[start_index:end_index] = [bar_segment] * bar_height
+        if start_index < len(segments):
+            segments[start_index] = _Segment(
+                bars[7 - start_bar], _Style(bgcolor=back, color=bar)
+            )
+        if end_index < len(segments):
+            segments[end_index] = _Segment(
+                bars[7 - end_bar], _Style(color=back, bgcolor=bar)
+            )
 
     return segments
 
@@ -107,12 +102,12 @@ def render_bar(
     console = Console()
 
     bar = render_bar(
-        size=20,
+        size=10,
         virtual_size=100,
-        window_size=50,
-        position=0,
-        vertical=False,
+        window_size=20,
+        position=80,
+        vertical=True,
         ascii_only=False,
     )
 
-    console.print(Segments(bar, new_lines=False))
+    console.print(Segments(bar, new_lines=True))

src/textual/view.py

@@ -117,14 +117,8 @@ async def on_message(self, message: Message) -> None:
                 for layout, (region, render) in self.layout.map.items():
                     if layout.renderable is widget:
                         assert isinstance(widget, Widget)
-                        start = time()
                         update = widget.render_update(region.x, region.y)
                         segments = Segments(update)
-                        log.debug(
-                            "RENDER UPDATE %r rendered in %.1fms",
-                            widget,
-                            (time() - start) * 1000.0,
-                        )
                         self.console.print(segments, end="")
 
     async def on_create(self, event: events.Created) -> None:

src/textual/widget.py

@@ -2,6 +2,7 @@
 
 from logging import getLogger
 from typing import (
+    Callable,
     ClassVar,
     Generic,
     Iterable,
@@ -43,8 +44,11 @@ def can_batch(self, message: Message) -> bool:
 
 
 class Reactive(Generic[T]):
-    def __init__(self, default: T) -> None:
+    def __init__(
+        self, default: T, validator: Callable[[object, T], T] | None = None
+    ) -> None:
         self._default = default
+        self.validator = validator
 
     def __set_name__(self, owner: "Widget", name: str) -> None:
         self.internal_name = f"_{name}"
@@ -56,6 +60,8 @@ def __get__(self, obj: "Widget", obj_type: type[object]) -> T:
     def __set__(self, obj: "Widget", value: T) -> None:
         if getattr(obj, self.internal_name) != value:
             log.debug("%s -> %s", self.internal_name, value)
+            if self.validator:
+                value = self.validator(obj, value)
             setattr(obj, self.internal_name, value)
             obj.require_repaint()
 
@@ -129,7 +135,7 @@ async def forward_input_event(self, event: events.Event) -> None:
         await self.post_message(event)
 
     async def refresh(self) -> None:
-        self._line_cache = None
+        # self._line_cache = None
         await self.repaint()
 
     async def repaint(self) -> None:

src/textual/widgets/window.py

@@ -10,6 +10,7 @@
     from typing_extensions import Literal
 
 from rich.console import Console, ConsoleOptions, RenderableType
+from rich.padding import Padding
 from rich.segment import Segment
 
 from .. import events
@@ -28,22 +29,27 @@ def __init__(
     ) -> None:
         self.renderable = renderable
         self.y_scroll = y_scroll
-        self._virtual_size: Dimensions | None = None
+        self._virtual_size: Dimensions = Dimensions(0, 0)
         self._renderable_updated = True
         self._lines: list[list[Segment]] = []
         super().__init__()
 
-    position: Reactive[int] = Reactive(60)
+    def _validate_position(self, position: float) -> float:
+        _position = position
+        validated_pos = min(
+            max(0, position), self._virtual_size.height - self.size.height
+        )
+        log.debug("virtual_size=%r size=%r", self._virtual_size, self.size)
+        log.debug("%r %r", _position, validated_pos)
+        return validated_pos
+
+    position: Reactive[float] = Reactive(60, validator=_validate_position)
     show_vertical_bar: Reactive[bool] = Reactive(True)
 
     @property
     def virtual_size(self) -> Dimensions:
         return self._virtual_size or self.size
 
-    def require_repaint(self) -> None:
-        del self._lines[:]
-        return super().require_repaint()
-
     def get_lines(
         self, console: Console, options: ConsoleOptions
     ) -> list[list[Segment]]:
@@ -52,28 +58,29 @@ def get_lines(
             if self.show_vertical_bar and self.y_scroll != "overlay":
                 width -= 1
             self._lines = console.render_lines(
-                self.renderable, options.update_width(width)
+                Padding(self.renderable, 1), options.update_width(width)
             )
+            self._virtual_size = Dimensions(0, len(self._lines))
         return self._lines
 
     def update(self, renderable: RenderableType) -> None:
         self.renderable = renderable
         del self._lines[:]
 
     def render(self, console: Console, options: ConsoleOptions) -> RenderableType:
-        height = options.height or console.height
+        height = self.size.height
         lines = self.get_lines(console, options)
-
+        position = int(self.position)
+        log.debug("%r, %r, %r", height, self._virtual_size, self.position)
         return VerticalBar(
-            lines[self.position : self.position + height],
+            lines[position : position + height],
             height,
-            len(lines),
+            self._virtual_size.height,
             self.position,
             overlay=self.y_scroll == "overlay",
         )
 
     async def on_key(self, event: events.Key) -> None:
-        log.debug("window.on_key; %s", event)
         if event.key == "down":
             self.position += 1
         elif event.key == "up":
@@ -84,3 +91,8 @@ async def on_mouse_scroll_up(self, event: events.MouseScrollUp) -> None:
 
     async def on_mouse_scroll_down(self, event: events.MouseScrollUp) -> None:
         self.position -= 1
+
+    async def on_resize(self, event: events.Resize) -> None:
+        del self._lines[:]
+        self.position = self.position
+        self.require_repaint()