Actions and updates

Author: willmcgugan

src/textual/_line_cache.py

@@ -23,7 +23,7 @@ def from_renderable(
         height: int,
     ) -> "LineCache":
         options = console.options.update_dimensions(width, height)
-        lines = console.render_lines(renderable, options, new_lines=True)
+        lines = console.render_lines(renderable, options, new_lines=False)
         return cls(lines)
 
     @property
@@ -40,8 +40,10 @@ def __rich_console__(
 
     def render(self, x: int, y: int) -> Iterable[Segment]:
         move_to = Control.move_to
+        new_line = Segment.line()
         for offset_y, (line, dirty) in enumerate(zip(self.lines, self._dirty), y):
             if dirty:
                 yield move_to(x, offset_y).segment
                 yield from line
+                yield new_line
         self._dirty[:] = [False] * len(self.lines)

src/textual/actions.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import ast
+from typing import Any, Tuple
+import re
+
+
+class ActionError(Exception):
+    pass
+
+
+re_action_params = re.compile(r"([\w\.]+)(\(.*?\))")
+
+
+def parse(action: str) -> tuple[str, tuple[Any, ...]]:
+    params_match = re_action_params.match(action)
+    if params_match is not None:
+        action_name, action_params_str = params_match.groups()
+        try:
+            action_params = ast.literal_eval(action_params_str)
+        except Exception as error:
+            raise ActionError(str(error))
+    else:
+        action_name = action
+        action_params = ()
+
+    return (
+        action_name,
+        action_params if isinstance(action_params, tuple) else (action_params,),
+    )
+
+
+if __name__ == "__main__":
+
+    print(parse("view.toggle('side')"))
+
+    print(parse("view.toggle"))

src/textual/app.py

@@ -13,6 +13,7 @@
 from rich.console import Console
 
 from . import events
+from . import actions
 from ._context import active_app
 from .driver import Driver
 from ._linux_driver import LinuxDriver
@@ -22,7 +23,7 @@
 log = logging.getLogger("rich")
 
 
-LayoutDefinition = dict[str, Any]
+LayoutDefinition = "dict[str, Any]"
 
 try:
     import uvloop
@@ -54,6 +55,8 @@ def __init__(
         self.view = view or LayoutView()
         self.children: set[MessagePump] = set()
 
+        self._action_targets = {"app": self, "view": self.view}
+
     def __rich_repr__(self) -> RichReprResult:
         yield "title", self.title
 
@@ -107,9 +110,7 @@ async def add(self, child: MessagePump) -> None:
     def refresh(self) -> None:
         console = self.console
         with console:
-            console.print(
-                Screen(Control.home(), self.view, Control.home(), application_mode=True)
-            )
+            console.print(Screen(Control.home(), self.view, Control.home()))
 
     async def on_event(self, event: events.Event, priority: int) -> None:
         if isinstance(event, events.Key):
@@ -128,18 +129,38 @@ async def on_idle(self, event: events.Idle) -> None:
         await self.view.post_message(event)
 
     async def action(self, action: str) -> None:
-        if "." in action:
-            destination, action_name, *tokens = action.split(".")
+        """Perform an action.
+
+        Args:
+            action (str): Action encoded in a string.
+        """
+
+        target, params = actions.parse(action)
+        if "." in target:
+            destination, action_name = target.split(".", 1)
         else:
             destination = "app"
             action_name = action
-            tokens = []
 
-        if destination == "app":
+        log.debug("ACTION %r %r", destination, action_name)
+        await self.dispatch_action(destination, action_name, params)
+
+    async def dispatch_action(
+        self, destination: str, action_name: str, params: Any
+    ) -> None:
+        action_target = self._action_targets.get(destination, None)
+        log.debug("ACTION TARGET %r", action_target)
+        if action_target is not None:
             method_name = f"action_{action_name}"
-            method = getattr(self, method_name, None)
+            method = getattr(action_target, method_name, None)
+            log.debug("ACTION METHOD %r", method)
             if method is not None:
-                await method(tokens)
+                try:
+                    await method(*params)
+                except Exception:
+                    log.exception(
+                        f"error in action {destination}.{action_name}{params!r}"
+                    )
 
     async def on_shutdown_request(self, event: events.ShutdownRequest) -> None:
         log.debug("shutdown request")
@@ -163,7 +184,7 @@ async def on_mouse_scroll_up(self, event: events.MouseScrollUp) -> None:
     async def on_mouse_scroll_down(self, event: events.MouseScrollUp) -> None:
         await self.view.post_message(event)
 
-    async def action_quit(self, tokens: list[str]) -> None:
+    async def action_quit(self) -> None:
         await self.close_messages()
 
 
@@ -191,7 +212,7 @@ async def action_quit(self, tokens: list[str]) -> None:
 
     class MyApp(App):
 
-        KEYS = {"q": "quit", "ctrl+c": "quit"}
+        KEYS = {"q": "quit", "ctrl+c": "quit", "b": "view.toggle('left')"}
 
         async def on_startup(self, event: events.Startup) -> None:
             await self.view.mount_all(

src/textual/message_pump.py

@@ -153,7 +153,7 @@ async def process_messages(self) -> None:
                 pending = self.peek_message()
                 if pending is None or not message.can_batch(pending.message):
                     break
-                priority, message = pending
+                priority, message = await self.get_message()
 
             try:
                 await self.dispatch_message(message, priority)

src/textual/view.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
+from time import time
 import logging
 from typing import Optional, Tuple, TYPE_CHECKING
 
@@ -12,6 +13,7 @@
 
 from . import events
 from ._context import active_app
+from .geometry import Dimensions
 from .message import Message
 from .message_pump import MessagePump
 from .widget import Widget, UpdateMessage
@@ -85,6 +87,7 @@ def __init__(
         self.layout = layout
         self.mouse_over: MessagePump | None = None
         self.focused: Widget | None = None
+        self.size = Dimensions(0, 0)
         self._widgets: set[Widget] = set()
         super().__init__()
         self.enable_messages(events.Idle)
@@ -114,10 +117,15 @@ async def on_message(self, message: Message) -> None:
                 for layout, (region, render) in self.layout.map.items():
                     if layout.renderable is widget:
                         assert isinstance(widget, Widget)
+                        start = time()
                         update = widget.render_update(region.x, region.y)
                         segments = Segments(update)
+                        log.debug(
+                            "RENDER UPDATE %r rendered in %.1fms",
+                            widget,
+                            (time() - start) * 1000.0,
+                        )
                         self.console.print(segments, end="")
-                        break
 
     async def on_create(self, event: events.Created) -> None:
         await self.mount(Header(self.title))
@@ -149,15 +157,22 @@ async def set_focus(self, widget: Optional[Widget]) -> None:
     async def on_startup(self, event: events.Startup) -> None:
         await self.mount(Header(self.title), slot="header")
 
-    async def on_resize(self, event: events.Resize) -> None:
-        region_map = self.layout._make_region_map(event.width, event.height)
+    async def layout_update(self) -> None:
+        if not self.size:
+            return
+        width, height = self.size
+        region_map = self.layout._make_region_map(width, height)
         for layout, region in region_map.items():
             if isinstance(layout.renderable, Widget):
                 await layout.renderable.post_message(
                     events.Resize(self, region.width, region.height)
                 )
         self.app.refresh()
 
+    async def on_resize(self, event: events.Resize) -> None:
+        self.size = Dimensions(event.width, event.height)
+        await self.layout_update()
+
     async def _on_mouse_move(self, event: events.MouseMove) -> None:
         try:
             widget, region = self.get_widget_at(event.x, event.y)
@@ -212,3 +227,8 @@ async def forward_input_event(self, event: events.Event) -> None:
         else:
             if self.focused is not None:
                 await self.focused.forward_input_event(event)
+
+    async def action_toggle(self, layout_name: str) -> None:
+        visible = self.layout[layout_name].visible
+        self.layout[layout_name].visible = not visible
+        await self.layout_update()

src/textual/widget.py

@@ -25,6 +25,8 @@
 from .message_pump import MessagePump
 from .geometry import Dimensions
 
+from time import time
+
 if TYPE_CHECKING:
     from .app import App
 
@@ -34,7 +36,10 @@
 
 
 class UpdateMessage(Message):
-    pass
+    default_priority = 10
+
+    def can_batch(self, message: Message) -> bool:
+        return isinstance(message, UpdateMessage) and message.sender == self.sender
 
 
 class Reactive(Generic[T]):
@@ -105,10 +110,12 @@ def line_cache(self) -> LineCache:
 
         if self._line_cache is None:
             width, height = self.size
+            start = time()
             renderable = self.render(self.console, self.console.options)
             self._line_cache = LineCache.from_renderable(
                 self.console, renderable, width, height
             )
+            log.debug("%.1fms %r render elapsed", (time() - start) * 1000, self)
         assert self._line_cache is not None
         return self._line_cache
 
@@ -151,5 +158,5 @@ async def on_event(self, event: events.Event, priority: int) -> None:
         await super().on_event(event, priority)
 
     async def on_idle(self, event: events.Idle) -> None:
-        if self.line_cache.dirty:
+        if self.line_cache is None or self.line_cache.dirty:
             await self.repaint()