app animator

Author: willmcgugan

src/textual/animator.py renamed to src/textual/_animator.py

@@ -1,16 +1,20 @@
 from __future__ import annotations
 
 import logging
-from .message_pump import MessagePump
-from ._timer import Timer
+
+import asyncio
 from time import time
 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
 
 
@@ -23,6 +27,7 @@ def InOutCubitEasing(x: float) -> float:
 
 @dataclass
 class Animation:
+    obj: object
     attribute: str
     start_time: float
     duration: float
@@ -39,43 +44,44 @@ def __call__(self, obj: object, time: float) -> bool:
 
 
 class Animator:
-    def __init__(self, obj: MessagePump) -> None:
-        self.obj = obj
-        self._animations: dict[str, Animation] = {}
-        self._timer: Timer | None = None
+    def __init__(self, target: MessageTarget) -> None:
+        self._animations: dict[tuple[object, str], Animation] = {}
+        self._timer: Timer = Timer(target, 1 / 30, target, callback=self)
+
+    async def start(self) -> None:
+        asyncio.get_event_loop().create_task(self._timer.run())
+
+    async def stop(self) -> None:
+        self._timer.stop()
 
     def animate(
         self,
+        obj: object,
         attribute: str,
         value: float,
         duration: float = 1,
         easing: EasingFunction = InOutCubitEasing,
     ) -> None:
-        start_value = getattr(self.obj, attribute)
+        start_value = getattr(obj, attribute)
         start_time = time()
 
         animation = Animation(
+            obj,
             attribute=attribute,
             start_time=start_time,
             duration=duration,
             start_value=start_value,
             end_value=value,
             easing_function=easing,
         )
-        self._animations[attribute] = animation
-        if self._timer is None:
-            self._timer = self.obj.set_interval(0.02, callback=self)
+        self._animations[(obj, attribute)] = animation
 
     async def __call__(self) -> None:
         log.debug("ANIMATION FRAME")
         animation_time = time()
-        if all(
-            animation(self.obj, animation_time)
-            for animation in self._animations.values()
-        ):
-            if self._timer is not None:
-                self._timer.stop()
-                self._timer = None
-
-        for _attribute, animation in self._animations.items():
-            animation(self.obj, animation_time)
+        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):
+                del self._animations[animation_key]

src/textual/_timer.py

@@ -56,6 +56,12 @@ def target(self) -> MessageTarget:
     def stop(self) -> None:
         self._stop_event.set()
 
+    async def pause(self) -> None:
+        pass
+
+    async def resume(self) -> None:
+        pass
+
     async def run(self) -> None:
         count = 0
         _repeat = self._repeat

src/textual/app.py

@@ -16,6 +16,7 @@
 
 from . import events
 from . import actions
+from ._animator import Animator
 from ._context import active_app
 from .driver import Driver
 from ._linux_driver import LinuxDriver
@@ -75,13 +76,18 @@ def __init__(
         self._driver: Driver | None = None
 
         self._action_targets = {"app": self, "view": self.view}
+        self._animator = Animator(self)
 
     def __rich_repr__(self) -> rich.repr.RichReprResult:
         yield "title", self.title
 
     def __rich__(self) -> RenderableType:
         return self.view
 
+    @property
+    def animator(self) -> Animator:
+        return self._animator
+
     @classmethod
     def run(
         cls, console: Console = None, screen: bool = True, driver: Type[Driver] = None
@@ -180,7 +186,9 @@ async def _process_messages(self) -> None:
         except Exception:
             log.exception("error starting application mode")
             raise
+        await self.animator.start()
         await super().process_messages()
+        await self.animator.stop()
 
         await self.view.close_messages()
         driver.stop_application_mode()

src/textual/widget.py

@@ -6,7 +6,6 @@
     ClassVar,
     Generic,
     Iterable,
-    NamedTuple,
     TypeVar,
     TYPE_CHECKING,
 )
@@ -21,7 +20,6 @@
 from rich.style import Style
 
 from . import events
-from .animator import Animator
 from ._context import active_app
 from ._loop import loop_last
 from ._line_cache import LineCache
@@ -116,7 +114,6 @@ def __init__(self, name: str | None = None) -> None:
         self._repaint_required = False
 
         super().__init__()
-        self._animator = Animator(self)
         # self.disable_messages(events.MouseMove)
 
     def __init_subclass__(

src/textual/widgets/scroll_view.py

@@ -38,7 +38,7 @@ def __init__(
     y: Reactive[float] = Reactive(0)
 
     def validate_y(self, value: float) -> int:
-        return max(0, value)
+        return max(0, round(value))
 
     def update_y(self, old_value: float, new_value: float) -> None:
         self._page.y = int(new_value)
@@ -69,6 +69,6 @@ async def on_key(self, event: events.Key) -> None:
         elif event.key == "up":
             self.y -= 1
         elif event.key == "pagedown":
-            self._animator.animate("y", self.y + self.size.height, duration=1)
+            self.app.animator.animate(self, "y", self.y + self.size.height, duration=1)
         elif event.key == "pageup":
-            self._animator.animate("y", self.y - self.size.height, duration=1)
+            self.app.animator.animate(self, "y", self.y - self.size.height, duration=1)