scroll view

Author: willmcgugan

src/textual/app.py

@@ -324,21 +324,21 @@ async def on_startup(self, event: events.Startup) -> None:
             footer.add_key("b", "Toggle sidebar")
             footer.add_key("q", "Quit")
 
-            # readme_path = os.path.join(
-            #     os.path.dirname(os.path.abspath(__file__)), "richreadme.md"
-            # )
+            readme_path = os.path.join(
+                os.path.dirname(os.path.abspath(__file__)), "richreadme.md"
+            )
             # scroll_view = LayoutView()
             # scroll_bar = ScrollBar()
-            # with open(readme_path, "rt") as fh:
-            #     readme = Markdown(fh.read(), hyperlinks=True, code_theme="fruity")
+            with open(readme_path, "rt") as fh:
+                readme = Markdown(fh.read(), hyperlinks=True, code_theme="fruity")
             # scroll_view.layout.split_column(
             #     Layout(readme, ratio=1), Layout(scroll_bar, ratio=2, size=2)
             # )
             layout = Layout()
             layout.split_column(Layout(name="l1"), Layout(name="l2"))
             # sub_view = LayoutView(name="Sub view", layout=layout)
 
-            sub_view = ScrollView()
+            sub_view = ScrollView(readme)
 
             # await sub_view.mount_all(l1=Placeholder(), l2=Placeholder())
 

src/textual/events.py

@@ -24,8 +24,14 @@ def __init_subclass__(cls, bubble: bool = False) -> None:
         super().__init_subclass__(bubble=bubble)
 
 
-class NoneEvent(Event):
-    pass
+class Null(Event):
+    def can_batch(self, event: Event) -> bool:
+        return isinstance(event, Null)
+
+
+class Repaint(Event):
+    def can_batch(self, event: Event) -> bool:
+        return isinstance(event, Repaint)
 
 
 class ShutdownRequest(Event):

src/textual/message_pump.py

@@ -161,7 +161,8 @@ async def process_messages(self) -> None:
 
     async def dispatch_message(self, message: Message) -> bool | None:
         if isinstance(message, events.Event):
-            await self.on_event(message)
+            if not isinstance(message, events.Null):
+                await self.on_event(message)
         else:
             return await self.on_message(message)
         return False

src/textual/page.py

@@ -1,28 +1,32 @@
 from __future__ import annotations
 
 from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
+from rich.padding import Padding, PaddingDimensions
 from rich.segment import Segment
 from rich.style import StyleType
 
-from .geometry import Point
+from .geometry import Dimensions, Point
 from .widget import Widget
 
 
-class Page:
+class PageRender:
     def __init__(
         self,
         renderable: RenderableType,
         width: int | None = None,
         height: int | None = None,
         style: StyleType = "",
+        padding: PaddingDimensions = 1,
     ) -> None:
         self.renderable = renderable
         self.width = width
         self.height = height
         self.style = style
+        self.padding = padding
         self.offset = Point(0, 0)
         self._render_width: int | None = None
         self._render_height: int | None = None
+        self.size = Dimensions(0, 0)
         self._lines: list[list[Segment]] = []
 
     def move_to(self, x: int = 0, y: int = 0) -> None:
@@ -38,11 +42,15 @@ def update(self, renderable: RenderableType) -> None:
         self.refresh()
 
     def render(self, console: Console, options: ConsoleOptions) -> None:
-        width = self._render_width = self.width or options.max_width or console.width
-        height = self._render_height = self.height or options.height or None
-        options = options.update_width(width)
+        width = self.width or options.max_width or console.width
+        height = self.height or options.height or None
+        options = options.update_dimensions(width, None)
         style = console.get_style(self.style)
-        self._lines = console.render_lines(self.renderable, options, style=style)
+        renderable = self.renderable
+        if self.padding:
+            renderable = Padding(renderable, self.padding)
+        self._lines[:] = console.render_lines(renderable, options, style=style)
+        self.size = Dimensions(width, len(self._lines))
 
     def __rich_console__(
         self, console: Console, options: ConsoleOptions
@@ -60,5 +68,22 @@ def __rich_console__(
             blank_line = [Segment(" " * width, style), Segment.line()]
             window_lines.extend(blank_line for _ in range(missing_lines))
 
+        new_line = Segment.line()
         for line in window_lines:
-            yield from line
+            yield from line
+            yield new_line
+
+
+class Page(Widget):
+    def __init__(
+        self, renderable: RenderableType, name: str = None, style: StyleType = ""
+    ):
+        self._page = PageRender(renderable, style=style)
+        super().__init__(name=name)
+
+    @property
+    def virtual_size(self) -> Dimensions:
+        return self._page.size
+
+    def render(self) -> RenderableType:
+        return self._page

src/textual/scrollbar.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from math import ceil
-import logging
 
+import logging
 
+from rich.repr import rich_repr, RichReprResult
 from rich.color import Color
 from rich.style import Style
 from rich.console import Console, ConsoleOptions, RenderResult, RenderableType
@@ -12,10 +12,10 @@
 
 log = logging.getLogger("rich")
 
-from .widget import Widget
+from .widget import Reactive, Widget
 
 
-class ScrollBar:
+class ScrollBarRender:
     def __init__(
         self,
         virtual_size: int = 100,
@@ -65,34 +65,39 @@ def render_bar(
         _Segment = Segment
         _Style = Style
         blank = " " * width_thickness
-        segments = [_Segment(blank, _Style(bgcolor=back))] * int(size)
-
-        step_size = virtual_size / size
-
-        start = int(position / step_size * 8)
-        end = start + max(8, int(window_size / step_size * 8))
-
-        start_index, start_bar = divmod(start, 8)
-        end_index, end_bar = divmod(end, 8)
 
-        segments[start_index:end_index] = [_Segment(blank, _Style(bgcolor=bar))] * (
-            end_index - start_index
-        )
-
-        if start_index < len(segments):
-            segments[start_index] = _Segment(
-                bars[7 - start_bar] * width_thickness,
-                _Style(bgcolor=back, color=bar)
-                if vertical
-                else _Style(bgcolor=bar, color=back),
-            )
-        if end_index < len(segments):
-            segments[end_index] = _Segment(
-                bars[7 - end_bar] * width_thickness,
-                _Style(bgcolor=bar, color=back)
-                if vertical
-                else _Style(bgcolor=back, color=bar),
-            )
+        background_meta = {"background": True}
+        foreground_meta = {"background": False}
+
+        back_segment = Segment(blank, _Style(bgcolor=back, meta=background_meta))
+        segments = [back_segment] * int(size)
+        if window_size and size and virtual_size:
+            step_size = virtual_size / size
+
+            start = int(position / step_size * 8)
+            end = start + max(8, int(window_size / step_size * 8))
+
+            start_index, start_bar = divmod(start, 8)
+            end_index, end_bar = divmod(end, 8)
+
+            segments[start_index:end_index] = [
+                _Segment(blank, _Style(bgcolor=bar, meta=foreground_meta))
+            ] * (end_index - start_index)
+
+            if start_index < len(segments):
+                segments[start_index] = _Segment(
+                    bars[7 - start_bar] * width_thickness,
+                    _Style(bgcolor=back, color=bar, meta=foreground_meta)
+                    if vertical
+                    else _Style(bgcolor=bar, color=back, meta=foreground_meta),
+                )
+            if end_index < len(segments):
+                segments[end_index] = _Segment(
+                    bars[7 - end_bar] * width_thickness,
+                    _Style(bgcolor=bar, color=back, meta=foreground_meta)
+                    if vertical
+                    else _Style(bgcolor=back, color=bar, meta=foreground_meta),
+                )
         if vertical:
             return Segments(segments, new_lines=True)
         else:
@@ -127,11 +132,37 @@ def __rich_console__(
         yield bar
 
 
+@rich_repr
+class ScrollBar(Widget):
+    def __init__(self, vertical: bool = True, name: str | None = None) -> None:
+        self.vertical = vertical
+        super().__init__(name=name)
+
+    virtual_size: Reactive[int] = Reactive(100)
+    window_size: Reactive[int] = Reactive(20)
+    position: Reactive[int] = Reactive(0)
+
+    def __rich_repr__(self) -> RichReprResult:
+        yield "virtual_size", self.virtual_size
+        yield "window_size", self.window_size
+        yield "position", self.position
+
+    __rich_repr__.angular = True
+
+    def render(self) -> RenderableType:
+        return ScrollBarRender(
+            virtual_size=self.virtual_size,
+            window_size=self.window_size,
+            position=self.position,
+            vertical=self.vertical,
+        )
+
+
 if __name__ == "__main__":
     from rich.console import Console
     from rich.segment import Segments
 
     console = Console()
-    bar = ScrollBar()
+    bar = ScrollBarRender()
 
-    console.print(ScrollBar(position=15.3, thickness=5, vertical=False))
+    console.print(ScrollBarRender(position=15.3, thickness=5, vertical=False))

src/textual/state.py

@@ -10,7 +10,7 @@ def __init__(self, default: ValueType) -> None:
         self._default = default
 
     def __set_name__(self, owner: object, name: str) -> None:
-        self.internal_name = f"_{name}"
+        self.internal_name = f"__{name}"
         setattr(owner, self.internal_name, self._default)
 
     def __get__(self, obj: object, obj_type: Type[object]) -> ValueType:

src/textual/view.py

@@ -16,7 +16,7 @@
 from .geometry import Dimensions, Region
 from .message import Message
 from .message_pump import MessagePump
-from .widget import Widget, WidgetBase, UpdateMessage
+from .widget import StaticWidget, Widget, WidgetBase, UpdateMessage
 from .widgets.header import Header
 
 if TYPE_CHECKING:
@@ -45,7 +45,9 @@ def __rich_console__(
         yield
 
     @abstractmethod
-    async def mount(self, widget: Widget, *, slot: str = "main") -> None:
+    async def mount(
+        self, widget: WidgetBase | RenderableType, *, slot: str = "main"
+    ) -> None:
         ...
 
     async def mount_all(self, **widgets: Widget) -> None:
@@ -154,7 +156,12 @@ async def on_message(self, message: Message) -> None:
     # async def on_create(self, event: events.Created) -> None:
     #     await self.mount(Header(self.title))
 
-    async def mount(self, widget: Widget, *, slot: str = "main") -> None:
+    async def mount(
+        self, widget: WidgetBase | RenderableType, *, slot: str = "main"
+    ) -> None:
+        if not isinstance(widget, WidgetBase):
+            log.debug("MOUNTED %r", widget)
+            widget = StaticWidget(widget)
         self.layout[slot].update(widget)
         await self.app.add(widget)
         widget.set_parent(self)
@@ -222,7 +229,7 @@ async def forward_event(self, event: events.Event) -> None:
                 await widget.forward_event(event.offset(-region.x, -region.y))
 
         elif isinstance(event, (events.MouseScrollDown, events.MouseScrollUp)):
-            widget, _region = self.get_widget_at(event.x, event.y)
+            widget, _region = self.get_widget_at(event.x, event.y, deep=True)
             scroll_widget = widget or self.focused
             if scroll_widget is not None:
                 await scroll_widget.forward_event(event)

src/textual/widget.py

@@ -13,7 +13,7 @@
 
 from rich.align import Align
 
-from rich.console import Console, ConsoleOptions, RenderableType
+from rich.console import Console, RenderableType
 from rich.pretty import Pretty
 from rich.panel import Panel
 import rich.repr
@@ -73,7 +73,8 @@ def __init__(
         self.validator = validator
 
     def __set_name__(self, owner: "Widget", name: str) -> None:
-        self.internal_name = f"_{name}"
+        self.name = name
+        self.internal_name = f"__{name}"
         setattr(owner, self.internal_name, self._default)
 
     def __get__(self, obj: "Widget", obj_type: type[object]) -> ReactiveType:
@@ -82,20 +83,32 @@ def __get__(self, obj: "Widget", obj_type: type[object]) -> ReactiveType:
     def __set__(self, obj: "Widget", value: ReactiveType) -> 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()
+
+            current_value = getattr(obj, self.internal_name, None)
+            validate_function = getattr(obj, f"validate_{self.name}", None)
+            if callable(validate_function):
+                value = validate_function(value)
+
+            if current_value != value:
+                setattr(obj, self.internal_name, value)
+
+                update_function = getattr(obj, f"update_{self.name}", None)
+                if callable(update_function):
+                    update_function(current_value, value)
+
+                obj.post_message_no_wait(events.Repaint(obj))
 
 
 @rich.repr.auto
 class WidgetBase(MessagePump):
-    _count: ClassVar[int] = 0
+    _counts: ClassVar[dict[str, int]] = {}
     can_focus: bool = False
 
     def __init__(self, name: str | None = None) -> None:
-        self.name = name or f"{self.__class__.__name__}#{self._count}"
-        Widget._count += 1
+        Widget._counts.setdefault(self.__class__.__name__, 1)
+        _count = self._counts[self.__class__.__name__]
+        self.name = name or f"{self.__class__.__name__}#{_count}"
+
         self.size = Dimensions(0, 0)
         self.size_changed = False
         self._repaint_required = False
@@ -201,6 +214,9 @@ async def on_idle(self, event: events.Idle) -> None:
             log.debug("REPAINTING")
             await self.repaint()
 
+    async def on_repaint(self, event: events.Repaint) -> None:
+        self.require_repaint()
+
 
 class Widget(WidgetBase):
     def __init__(self, name: str | None = None) -> None:
@@ -259,10 +275,9 @@ async def on_mouse_move(self, event: events.MouseMove) -> None:
         log.debug("%r", self.get_style_at(event.x, event.y))
 
     async def on_mouse_up(self, event: events.MouseUp) -> None:
-        log.debug("CLICKED %r", event)
         style = self.get_style_at(event.x, event.y)
-        log.debug(style.meta)
         if "@click" in style.meta:
+            log.debug(style._link_id)
             await self.app.action(style.meta["@click"])