smooth scrolling

Author: willmcgugan

examples/simple.py

@@ -4,7 +4,7 @@
 from textual.app import App
 from textual.widgets.header import Header
 from textual.widgets.placeholder import Placeholder
-from textual.widgets.window import Window
+from textual.widgets.scroll_view import ScrollView
 
 with open("richreadme.md", "rt") as fh:
     readme = Markdown(fh.read(), hyperlinks=True, code_theme="fruity")
@@ -16,7 +16,7 @@ class MyApp(App):
 
     async def on_startup(self, event: events.Startup) -> None:
         await self.view.mount_all(
-            header=Header(self.title), left=Placeholder(), body=Window(readme)
+            header=Header(self.title), left=Placeholder(), body=ScrollView(readme)
         )
 
 

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "textual"
-version = "0.1.1"
+version = "0.1.2"
 description = "Text User Interface using Rich"
 authors = ["Will McGugan <[email protected]>"]
 license = "MIT"

src/textual/_animator.py

@@ -4,22 +4,26 @@
 
 import asyncio
 from time import time
+from tracemalloc import start
 from typing import Callable
 
 from dataclasses import dataclass
 
 from ._timer import Timer
 from ._types import MessageTarget
-from .message_pump import MessagePump
-
-EasingFunction = Callable[[float], float]
 
 
-LinearEasing = lambda value: value
-
+EasingFunction = Callable[[float], float]
 
-def InOutCubitEasing(x: float) -> float:
-    return 4 * x * x * x if x < 0.5 else 1 - pow(-2 * x + 2, 3) / 2
+# https://easings.net/
+EASING = {
+    "none": lambda x: 1.0,
+    "round": lambda x: 0.0 if x < 0.5 else 1.0,
+    "linear": lambda x: x,
+    "in_cubic": lambda x: x * x * x,
+    "in_out_cubic": lambda x: 4 * x * x * x if x < 0.5 else 1 - pow(-2 * x + 2, 3) / 2,
+    "out_cubic": lambda x: 1 - pow(1 - x, 3),
+}
 
 
 log = logging.getLogger("rich")
@@ -35,11 +39,26 @@ class Animation:
     end_value: float
     easing_function: EasingFunction
 
-    def __call__(self, obj: object, time: float) -> bool:
-        progress = min(1.0, (time - self.start_time) / self.duration)
-        eased_progress = self.easing_function(progress)
-        value = self.start_value + (self.end_value - self.start_value) * eased_progress
-        setattr(obj, self.attribute, value)
+    def __call__(self, time: float) -> bool:
+
+        if self.duration == 0:
+            value = self.end_value
+        else:
+            progress = min(1.0, (time - self.start_time) / self.duration)
+            if self.end_value > self.start_value:
+                eased_progress = self.easing_function(progress)
+                value = (
+                    self.start_value
+                    + (self.end_value - self.start_value) * eased_progress
+                )
+            else:
+                eased_progress = 1 - self.easing_function(progress)
+                value = (
+                    self.end_value
+                    + (self.start_value - self.end_value) * eased_progress
+                )
+
+        setattr(self.obj, self.attribute, value)
         return value == self.end_value
 
 
@@ -53,22 +72,25 @@ def __call__(
         attribute: str,
         value: float,
         *,
-        duration: float = 1,
-        easing: EasingFunction = InOutCubitEasing,
+        duration: float | None = None,
+        speed: float | None = None,
+        easing: EasingFunction | str = "in_out_cubic",
     ) -> None:
+        easing_function = EASING[easing] if isinstance(easing, str) else easing
         self._animator.animate(
             self._obj,
             attribute=attribute,
             value=value,
             duration=duration,
-            easing=easing,
+            speed=speed,
+            easing=easing_function,
         )
 
 
 class Animator:
-    def __init__(self, target: MessageTarget) -> None:
+    def __init__(self, target: MessageTarget, frames_per_second: int = 30) -> None:
         self._animations: dict[tuple[object, str], Animation] = {}
-        self._timer: Timer = Timer(target, 1 / 30, target, callback=self)
+        self._timer = Timer(target, 1 / frames_per_second, target, callback=self)
 
     async def start(self) -> None:
         asyncio.get_event_loop().create_task(self._timer.run())
@@ -85,22 +107,33 @@ def animate(
         attribute: str,
         value: float,
         *,
-        duration: float = 1,
-        easing: EasingFunction = InOutCubitEasing,
+        duration: float | None = None,
+        speed: float | None = None,
+        easing: EasingFunction = EASING["in_out_cubic"],
     ) -> None:
-        start_value = getattr(obj, attribute)
+
         start_time = time()
 
+        animation_key = (obj, attribute)
+        if animation_key in self._animations:
+            self._animations[animation_key](start_time)
+
+        start_value = getattr(obj, attribute)
+        if duration is not None:
+            animation_duration = duration
+        else:
+            animation_duration = abs(value - start_value) / (speed or 50)
+
         animation = Animation(
             obj,
             attribute=attribute,
             start_time=start_time,
-            duration=duration,
+            duration=animation_duration,
             start_value=start_value,
             end_value=value,
             easing_function=easing,
         )
-        self._animations[(obj, attribute)] = animation
+        self._animations[animation_key] = animation
         self._timer.resume()
 
     async def __call__(self) -> None:
@@ -111,6 +144,5 @@ async def __call__(self) -> None:
             animation_keys = list(self._animations.keys())
             for animation_key in animation_keys:
                 animation = self._animations[animation_key]
-                obj, _attribute = animation_key
-                if animation(obj, animation_time):
+                if animation(animation_time):
                     del self._animations[animation_key]

src/textual/_timer.py

@@ -41,6 +41,7 @@ def __init__(
         self._repeat = repeat
         self._stop_event = Event()
         self._active = Event()
+        self._active.set()
 
     def __rich_repr__(self) -> RichReprResult:
         yield self._interval

src/textual/app.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from argparse import Action
 
 import asyncio
 
@@ -13,6 +14,7 @@
 from rich.screen import Screen
 from rich import get_console
 from rich.console import Console, RenderableType
+from rich.traceback import Traceback
 
 from . import events
 from . import actions
@@ -45,6 +47,10 @@
 #     uvloop.install()
 
 
+class ActionError(Exception):
+    pass
+
+
 class ShutdownError(Exception):
     pass
 
@@ -163,18 +169,10 @@ async def set_mouse_over(self, widget: WidgetBase | None) -> None:
                     self.mouse_over = widget
 
     async def process_messages(self) -> None:
-        try:
-            await self._process_messages()
-        except Exception:
-            self.console.print_exception(show_locals=True)
-
-    async def _process_messages(self) -> None:
         log.debug("driver=%r", self.driver_class)
-        loop = asyncio.get_event_loop()
-
-        loop.add_signal_handler(signal.SIGINT, self.on_keyboard_interupt)
+        # loop = asyncio.get_event_loop()
+        # loop.add_signal_handler(signal.SIGINT, self.on_keyboard_interupt)
         driver = self._driver = self.driver_class(self.console, self)
-
         active_app.set(self)
         self.view.set_parent(self)
         await self.add(self.view)
@@ -184,14 +182,21 @@ async def _process_messages(self) -> None:
         try:
             driver.start_application_mode()
         except Exception:
+            self.console.print_exception()
             log.exception("error starting application mode")
-            raise
-        await self.animator.start()
-        await super().process_messages()
-        await self.animator.stop()
+        else:
+            traceback: Traceback | None = None
+            await self.animator.start()
+            try:
+                await super().process_messages()
+            except Exception:
+                traceback = Traceback(show_locals=True)
 
-        await self.view.close_messages()
-        driver.stop_application_mode()
+            await self.animator.stop()
+            await self.view.close_messages()
+            driver.stop_application_mode()
+            if traceback is not None:
+                self.console.print(traceback)
 
     async def add(self, child: MessagePump) -> None:
         self.children.add(child)
@@ -229,32 +234,35 @@ async def on_event(self, event: events.Event) -> None:
         else:
             await super().on_event(event)
 
-    async def action(self, action: str) -> None:
+    async def action(
+        self, action: str, default_namespace: object | None = None
+    ) -> None:
         """Perform an action.
 
         Args:
             action (str): Action encoded in a string.
         """
-
+        default_target = default_namespace or self
         target, params = actions.parse(action)
         if "." in target:
             destination, action_name = target.split(".", 1)
+            action_target = self._action_targets.get(destination, None)
+            if action_target is None:
+                raise ActionError("Action namespace {destination} is not known")
         else:
-            destination = "app"
+            action_target = default_namespace or self
             action_name = action
 
-        log.debug("ACTION %r %r", destination, action_name)
-        await self.dispatch_action(destination, action_name, params)
+        log.debug("ACTION %r %r", action_target, action_name)
+        await self.dispatch_action(action_target, action_name, params)
 
     async def dispatch_action(
-        self, destination: str, action_name: str, params: Any
+        self, namespace: object, action_name: str, params: Any
     ) -> None:
-        action_target = self._action_targets.get(destination, None)
-        if action_target is not None:
-            method_name = f"action_{action_name}"
-            method = getattr(action_target, method_name, None)
-            if method is not None:
-                await method(*params)
+        method_name = f"action_{action_name}"
+        method = getattr(namespace, method_name, None)
+        if method is not None:
+            await method(*params)
 
     async def on_shutdown_request(self, event: events.ShutdownRequest) -> None:
         log.debug("shutdown request")

src/textual/events.py

@@ -62,6 +62,17 @@ class Idle(Event):
     """Sent when there are no more items in the message queue."""
 
 
+class Action(Event):
+    __slots__ = ["action"]
+
+    def __init__(self, sender: MessageTarget, action: str) -> None:
+        super().__init__(sender)
+        self.action = action
+
+    def __rich_repr__(self) -> RichReprResult:
+        yield "action", self.action
+
+
 class Resize(Event):
     __slots__ = ["width", "height"]
     width: int
@@ -168,7 +179,7 @@ class MouseUp(MouseEvent):
     pass
 
 
-class MouseScrollDown(InputEvent):
+class MouseScrollDown(InputEvent, bubble=True):
     __slots__ = ["x", "y"]
 
     def __init__(self, sender: MessageTarget, x: int, y: int) -> None:
@@ -177,7 +188,7 @@ def __init__(self, sender: MessageTarget, x: int, y: int) -> None:
         self.y = y
 
 
-class MouseScrollUp(MouseScrollDown):
+class MouseScrollUp(MouseScrollDown, bubble=True):
     pass
 
 

src/textual/geometry.py

@@ -1,6 +1,23 @@
 from __future__ import annotations
 
-from typing import Any, NamedTuple
+from typing import Any, NamedTuple, TypeVar
+
+
+T = TypeVar("T", int, float)
+
+
+def clamp(value: T, minimum: T, maximum: T) -> T:
+    """Clamps a value between two other values.
+
+    Args:
+        value (T): A value
+        minimum (T): Minimum value
+        maximum (T): maximum value
+
+    Returns:
+        T: New value that is not less than the minimum or greater than the maximum.
+    """
+    return min(max(value, minimum), maximum)
 
 
 class Point(NamedTuple):

src/textual/message_pump.py

@@ -135,7 +135,7 @@ async def process_messages(self) -> None:
                 log.exception("error in get_message()")
                 raise error from None
 
-            log.debug("%r -> %r", message, self)
+            # log.debug("%r -> %r", message, self)
             # Combine any pending messages that may supersede this one
             while not (self._closed or self._closing):
                 pending = self.peek_message()
@@ -174,7 +174,8 @@ async def on_event(self, event: events.Event) -> None:
             await dispatch_function(event)
         if event.bubble and self._parent and not event._stop_propagaton:
             if event.sender == self._parent:
-                log.debug("bubbled event abandoned; %r", event)
+                pass
+                # log.debug("bubbled event abandoned; %r", event)
             elif not self._parent._closed and not self._parent._closing:
                 await self._parent.post_message(event)
 
@@ -204,7 +205,6 @@ async def post_message_from_child(self, message: Message) -> bool:
 
     async def emit(self, message: Message) -> bool:
         if self._parent:
-            log.debug("EMIT %r -> %r %r", self, self._parent, message)
             await self._parent.post_message_from_child(message)
             return True
         else: