layout and animation

Author: willmcgugan

src/textual/_animator.py

@@ -3,18 +3,32 @@
 import logging
 
 import asyncio
+import sys
 from time import time
 from tracemalloc import start
-from typing import Callable
+from typing import Callable, TypeVar
 
 from dataclasses import dataclass
 
 from ._timer import Timer
 from ._types import MessageTarget
 
+if sys.version_info >= (3, 8):
+    from typing import Protocol
+else:
+    from typing_extensions import Protocol
+
 
 EasingFunction = Callable[[float], float]
 
+T = TypeVar("T")
+
+
+class Animatable(Protocol):
+    def blend(self: T, destination: T, factor: float) -> T:
+        ...
+
+
 # https://easings.net/
 EASING = {
     "none": lambda x: 1.0,
@@ -25,6 +39,8 @@
     "out_cubic": lambda x: 1 - pow(1 - x, 3),
 }
 
+DEFAULT_EASING = "in_out_cubic"
+
 
 log = logging.getLogger("rich")
 
@@ -35,30 +51,43 @@ class Animation:
     attribute: str
     start_time: float
     duration: float
-    start_value: float
-    end_value: float
+    start_value: float | Animatable
+    end_value: float | Animatable
     easing_function: EasingFunction
 
     def __call__(self, time: float) -> bool:
+        def blend_float(start: float, end: float, factor: float) -> float:
+            return start + (end - start) * factor
+
+        AnimatableT = TypeVar("AnimatableT", bound=Animatable)
+
+        def blend(start: AnimatableT, end: AnimatableT, factor: float) -> AnimatableT:
+            return start.blend(end, factor)
+
+        blend_function = (
+            blend_float if isinstance(self.start_value, (int, float)) else blend
+        )
 
         if self.duration == 0:
             value = self.end_value
         else:
-            progress = min(1.0, (time - self.start_time) / self.duration)
+            factor = min(1.0, (time - self.start_time) / self.duration)
+            eased_factor = self.easing_function(factor)
+            # value = blend_function(self.start_value, self.end_value, eased_factor)
+
             if self.end_value > self.start_value:
-                eased_progress = self.easing_function(progress)
+                eased_factor = self.easing_function(factor)
                 value = (
                     self.start_value
-                    + (self.end_value - self.start_value) * eased_progress
+                    + (self.end_value - self.start_value) * eased_factor
                 )
             else:
-                eased_progress = 1 - self.easing_function(progress)
+                eased_factor = 1 - self.easing_function(factor)
                 value = (
-                    self.end_value
-                    + (self.start_value - self.end_value) * eased_progress
+                    self.end_value + (self.start_value - self.end_value) * eased_factor
                 )
-
         setattr(self.obj, self.attribute, value)
+        log.debug("ANIMATE %r %r -> %r", self.obj, self.attribute, value)
         return value == self.end_value
 
 
@@ -74,7 +103,7 @@ def __call__(
         *,
         duration: float | None = None,
         speed: float | None = None,
-        easing: EasingFunction | str = "in_out_cubic",
+        easing: EasingFunction | str = DEFAULT_EASING,
     ) -> None:
         easing_function = EASING[easing] if isinstance(easing, str) else easing
         self._animator.animate(
@@ -88,7 +117,7 @@ def __call__(
 
 
 class Animator:
-    def __init__(self, target: MessageTarget, frames_per_second: int = 30) -> None:
+    def __init__(self, target: MessageTarget, frames_per_second: int = 60) -> None:
         self._animations: dict[tuple[object, str], Animation] = {}
         self._timer = Timer(target, 1 / frames_per_second, target, callback=self)
 
@@ -109,7 +138,7 @@ def animate(
         *,
         duration: float | None = None,
         speed: float | None = None,
-        easing: EasingFunction = EASING["in_out_cubic"],
+        easing: EasingFunction | str = DEFAULT_EASING,
     ) -> None:
 
         start_time = time()
@@ -123,15 +152,15 @@ def animate(
             animation_duration = duration
         else:
             animation_duration = abs(value - start_value) / (speed or 50)
-
+        easing_function = EASING[easing] if isinstance(easing, str) else easing
         animation = Animation(
             obj,
             attribute=attribute,
             start_time=start_time,
             duration=animation_duration,
             start_value=start_value,
             end_value=value,
-            easing_function=easing,
+            easing_function=easing_function,
         )
         self._animations[animation_key] = animation
         self._timer.resume()

src/textual/_timer.py

@@ -30,6 +30,7 @@ def __init__(
         name: str | None = None,
         callback: TimerCallback | None = None,
         repeat: int = None,
+        skip: bool = True,
     ) -> None:
         self._target_repr = repr(event_target)
         self._target = weakref.ref(event_target)
@@ -39,6 +40,7 @@ def __init__(
         self._timer_count += 1
         self._callback = callback
         self._repeat = repeat
+        self._skip = skip
         self._stop_event = Event()
         self._active = Event()
         self._active.set()
@@ -75,7 +77,11 @@ async def run(self) -> None:
         try:
             while _repeat is None or count <= _repeat:
                 next_timer = start + (count * _interval)
+                if self._skip and next_timer < monotonic():
+                    count += 1
+                    continue
                 try:
+
                     if await wait_for(_wait(), max(0, next_timer - monotonic())):
                         break
                 except TimeoutError:

src/textual/app.py

@@ -18,6 +18,7 @@
 from . import events
 from . import actions
 from ._animator import Animator
+from .geometry import Point
 from ._context import active_app
 from .keys import Binding
 from .driver import Driver
@@ -87,8 +88,9 @@ def __init__(
 
         self._bindings: dict[str, Binding] = {}
         self._docks: list[Dock] = []
-        self._action_targets = {"app": self, "view": self.view}
+        self._action_targets = {"app", "view"}
         self._animator = Animator(self)
+        self.animate = self._animator.bind(self)
 
     def __rich_repr__(self) -> rich.repr.RichReprResult:
         yield "title", self.title
@@ -240,8 +242,10 @@ def refresh(self) -> None:
         if not self._closed:
             console = self.console
             try:
+                console.file.write("\x1bP=1s\x1b\\")
                 with console:
                     console.print(Screen(Control.home(), self.view, Control.home()))
+                console.file.write("\x1bP=2s\x1b\\")
             except Exception:
                 log.exception("refresh failed")
 
@@ -279,9 +283,9 @@ async def action(
         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:
+            if destination not in self._action_targets:
                 raise ActionError("Action namespace {destination} is not known")
+            action_target = getattr(self, destination)
         else:
             action_target = default_namespace or self
             action_name = action
@@ -371,21 +375,35 @@ class MyApp(App):
         async def on_load(self, event: events.Load) -> None:
             await self.bind("q,ctrl+c", "quit")
             await self.bind("x", "bang")
-            await self.bind("b", "view.toggle('left')")
+            await self.bind("b", "toggle_sidebar")
+            self.side = False
+
+        async def action_toggle_sidebar(self) -> None:
+            self.side = not self.side
+            self.animator.animate(
+                self.bar,
+                "layout_offset_x",
+                20 if self.side else 0,
+                speed=30,
+                easing="in_out_cubic",
+            )
 
         async def on_startup(self, event: events.Startup) -> None:
 
             view = await self.push_view(DockView())
 
             header = Header(self.title)
+            footer = Footer()
+            self.bar = Placeholder(name="left")
+            footer.add_key("b", "Toggle sidebar")
+            footer.add_key("q", "Quit")
 
             await view.dock(header, edge="top")
-
-            await view.dock(Placeholder(), edge="left", size=40)
+            await view.dock(footer, edge="bottom")
+            await view.dock(self.bar, edge="left", size=30, z=1)
 
             sub_view = DockView()
             await sub_view.dock(Placeholder(), Placeholder(), edge="top")
-
             await view.dock(sub_view, edge="left")
 
             # self.refresh()

src/textual/geometry.py

@@ -37,18 +37,18 @@ def is_origin(self) -> bool:
         return self == (0, 0)
 
     def __add__(self, other: object) -> Point:
-        if isinstance(other, Point):
+        if isinstance(other, tuple):
             _x, _y = self
             x, y = other
             return Point(_x + x, _y + y)
-        raise NotImplemented
+        return NotImplemented
 
     def __sub__(self, other: object) -> Point:
-        if isinstance(other, Point):
+        if isinstance(other, tuple):
             _x, _y = self
             x, y = other
             return Point(_x - x, _y - y)
-        raise NotImplemented
+        return NotImplemented
 
     def blend(self, destination: Point, factor: float) -> Point:
         """Blend (interpolate) to a new point.

src/textual/layout.py

@@ -67,7 +67,6 @@ def __init__(self) -> None:
         self._cuts: list[list[int]] | None = None
 
     def reset(self) -> None:
-        self._layout_map = {}
         self.renders.clear()
         self._cuts = None
 
@@ -80,15 +79,15 @@ def map(self) -> dict[Widget, MapRegion]:
         return self._layout_map
 
     def __iter__(self) -> Iterable[tuple[Widget, Region]]:
-        layers = sorted(self._layout_map.items(), key=lambda item: item[1].order)
+        layers = sorted(
+            self._layout_map.items(), key=lambda item: item[1].order, reverse=True
+        )
         for widget, (region, _) in layers:
             yield widget, region
 
     def get_widget_at(self, x: int, y: int) -> tuple[Widget, Region]:
         """Get the widget under the given point or None."""
-        for widget, (region, _order) in sorted(
-            self._layout_map.items(), key=lambda item: item[1].order
-        ):
+        for widget, region in self:
             if region.contains(x, y):
                 return widget, region
         raise NoWidget
@@ -175,7 +174,7 @@ def render(widget: Widget, width: int, height: int) -> Lines:
                 new_region = region.clip(width, height)
                 delta_x = new_region.x - region.x
                 delta_y = new_region.y - region.y
-                region = new_region
+                # region = new_region
                 lines = lines[delta_y : delta_y + region.height]
                 lines = [
                     list(Segment.divide(line, [delta_x, delta_x + region.width]))[1]

src/textual/layouts/dock.py

@@ -11,6 +11,7 @@
 from ..widget import WidgetID
 from ..geometry import Region, Point
 from ..layout import Layout, MapRegion
+from .._types import Lines
 
 if sys.version_info >= (3, 8):
     from typing import Literal
@@ -55,21 +56,20 @@ def reflow(self, width: int, height: int, offset: Point = Point(0, 0)) -> None:
         self.width = width
         self.height = height
         map: dict[Widget, MapRegion] = {}
-        region = Region(0, 0, width, height)
 
-        layers: dict[int, Region] = defaultdict(lambda: Region(0, 0, width, height))
-
-        log.debug("%r", self.docks)
+        layers: dict[int, Region] = defaultdict(
+            lambda: Region(0, 0, self.width, self.height)
+        )
 
         def add_widget(widget: Widget, region: Region, order: tuple[int, int]):
             region = region + offset
             if hasattr(widget, "layout"):
                 widget.layout.reflow(
-                    region.width, region.height, region.origin + offset
+                    region.width, region.height, offset=region.origin + offset
                 )
                 map.update(widget.layout.map)
             else:
-                map[widget] = MapRegion(region, order)
+                map[widget] = MapRegion(region + widget.layout_offset, order)
 
         for index, dock in enumerate(self.docks):
             dock_options = [
@@ -94,6 +94,8 @@ def add_widget(widget: Widget, region: Region, order: tuple[int, int]):
                 remaining = region.height
                 total = 0
                 for widget, size in zip(dock.widgets, sizes):
+                    if not widget.visible:
+                        continue
                     size = min(remaining, size)
                     if not size:
                         break
@@ -112,6 +114,8 @@ def add_widget(widget: Widget, region: Region, order: tuple[int, int]):
                 remaining = region.height
                 total = 0
                 for widget, size in zip(dock.widgets, sizes):
+                    if not widget.visible:
+                        continue
                     size = min(remaining, size)
                     if not size:
                         break
@@ -130,6 +134,8 @@ def add_widget(widget: Widget, region: Region, order: tuple[int, int]):
                 remaining = region.width
                 total = 0
                 for widget, size in zip(dock.widgets, sizes):
+                    if not widget.visible:
+                        continue
                     size = min(remaining, size)
                     if not size:
                         break
@@ -148,6 +154,8 @@ def add_widget(widget: Widget, region: Region, order: tuple[int, int]):
                 remaining = region.width
                 total = 0
                 for widget, size in zip(dock.widgets, sizes):
+                    if not widget.visible:
+                        continue
                     size = min(remaining, size)
                     if not size:
                         break
@@ -162,6 +170,13 @@ def add_widget(widget: Widget, region: Region, order: tuple[int, int]):
 
             layers[dock.z] = region
 
+        new_renders: dict[Widget, tuple[Region, Lines]] = {}
+        for widget, (region, order) in map.items():
+            if widget in self.renders and self.renders[widget][0].size == region.size:
+                new_renders[widget] = (region, self.renders[widget][1])
+
+        self.renders = new_renders
+        log.debug("DOCK")
         self._layout_map = map