Merge pull request #15 from willmcgugan/view-scroll

View scroll

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"
@@ -25,6 +25,7 @@ typing-extensions = { version = "^3.10.0", python = "<3.8" }
 
 [tool.poetry.dev-dependencies]
 # rich = {git = "[email protected]:willmcgugan/rich", rev = "pretty-classes"}
+mypy = "^0.910"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

src/textual/_animator.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import logging
+
+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
+
+
+EasingFunction = Callable[[float], float]
+
+# 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")
+
+
+@dataclass
+class Animation:
+    obj: object
+    attribute: str
+    start_time: float
+    duration: float
+    start_value: float
+    end_value: float
+    easing_function: EasingFunction
+
+    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
+
+
+class BoundAnimator:
+    def __init__(self, animator: Animator, obj: object) -> None:
+        self._animator = animator
+        self._obj = obj
+
+    def __call__(
+        self,
+        attribute: str,
+        value: float,
+        *,
+        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,
+            speed=speed,
+            easing=easing_function,
+        )
+
+
+class Animator:
+    def __init__(self, target: MessageTarget, frames_per_second: int = 30) -> None:
+        self._animations: dict[tuple[object, str], Animation] = {}
+        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())
+
+    async def stop(self) -> None:
+        self._timer.stop()
+
+    def bind(self, obj: object) -> BoundAnimator:
+        return BoundAnimator(self, obj)
+
+    def animate(
+        self,
+        obj: object,
+        attribute: str,
+        value: float,
+        *,
+        duration: float | None = None,
+        speed: float | None = None,
+        easing: EasingFunction = EASING["in_out_cubic"],
+    ) -> None:
+
+        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=animation_duration,
+            start_value=start_value,
+            end_value=value,
+            easing_function=easing,
+        )
+        self._animations[animation_key] = animation
+        self._timer.resume()
+
+    async def __call__(self) -> None:
+        if not self._animations:
+            self._timer.pause()
+        else:
+            animation_time = time()
+            animation_keys = list(self._animations.keys())
+            for animation_key in animation_keys:
+                animation = self._animations[animation_key]
+                if animation(animation_time):
+                    del self._animations[animation_key]

src/textual/_line_cache.py

@@ -5,9 +5,11 @@
 
 from typing import Iterable
 
+from rich.cells import cell_len
 from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
 from rich.control import Control
 from rich.segment import Segment
+from rich.style import Style
 
 from ._loop import loop_last
 
@@ -57,3 +59,15 @@ def render(self, x: int, y: int, width: int, height: int) -> Iterable[Segment]:
                 if not last:
                     yield new_line
         self._dirty[:] = [False] * len(self.lines)
+
+    def get_style_at(self, x: int, y: int) -> Style:
+        try:
+            line = self.lines[y]
+        except IndexError:
+            return Style.null()
+        end = 0
+        for segment in line:
+            end += cell_len(segment.text)
+            if x < end:
+                return segment.style or Style.null()
+        return Style.null()

src/textual/_timer.py

@@ -40,6 +40,8 @@ def __init__(
         self._callback = callback
         self._repeat = repeat
         self._stop_event = Event()
+        self._active = Event()
+        self._active.set()
 
     def __rich_repr__(self) -> RichReprResult:
         yield self._interval
@@ -54,13 +56,21 @@ def target(self) -> MessageTarget:
         return target
 
     def stop(self) -> None:
+        self._active.set()
         self._stop_event.set()
 
+    def pause(self) -> None:
+        self._active.clear()
+
+    def resume(self) -> None:
+        self._active.set()
+
     async def run(self) -> None:
         count = 0
         _repeat = self._repeat
         _interval = self._interval
         _wait = self._stop_event.wait
+        _wait_active = self._active.wait
         start = monotonic()
         try:
             while _repeat is None or count <= _repeat:
@@ -78,5 +88,6 @@ async def run(self) -> None:
                 except EventTargetGone:
                     break
                 count += 1
+                await _wait_active()
         except CancelledError:
             pass

src/textual/_xterm_parser.py

@@ -65,12 +65,12 @@ def parse(self, on_token: TokenCallback) -> Generator[Awaitable, str, None]:
 
         while not self.is_eof:
             character = yield read1()
-            log.debug("character=%r", character)
+            # log.debug("character=%r", character)
             if character == ESC and ((yield self.peek_buffer()) or more_data()):
                 sequence: str = character
                 while True:
                     sequence += yield read1()
-                    log.debug(f"sequence=%r", sequence)
+                    # log.debug(f"sequence=%r", sequence)
                     keys = get_ansi_sequence(sequence, None)
                     if keys is not None:
                         for key in keys: