add footer

Author: willmcgugan

poetry.lock

@@ -1,16 +1,17 @@
 [tool.poetry]
 name = "textual"
-version = "0.1.0"
+version = "0.1.1"
 description = "Text User Interface using Rich"
 authors = ["Will McGugan <[email protected]>"]
 license = "MIT"
 
 [tool.poetry.dependencies]
 python = "^3.7"
-rich = "^10.3.0"
+rich = "^10.4.0"
+typing-extensions = { version = "^3.10.0", python = "<3.8" }
 
 [tool.poetry.dev-dependencies]
-rich = {git = "[email protected]:willmcgugan/rich", rev = "pretty-classes"}
+# rich = {git = "[email protected]:willmcgugan/rich", rev = "pretty-classes"}
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

pyproject.toml

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+
 import logging
 
 from typing import Iterable
@@ -8,6 +9,7 @@
 from rich.control import Control
 from rich.segment import Segment
 
+from ._loop import loop_last
 
 log = logging.getLogger("rich")
 
@@ -26,7 +28,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)
         return cls(lines)
 
     @property
@@ -37,14 +39,21 @@ def __rich_console__(
         self, console: Console, options: ConsoleOptions
     ) -> RenderResult:
 
+        new_line = Segment.line()
         for line in self.lines:
             yield from line
+            yield new_line
 
-    def render(self, x: int, y: int) -> Iterable[Segment]:
+    def render(self, x: int, y: int, width: int, height: int) -> Iterable[Segment]:
         move_to = Control.move_to
-        for offset_y, (line, dirty) in enumerate(zip(self.lines, self._dirty), y):
+        lines = self.lines[:height]
+        new_line = Segment.line()
+        for last, (offset_y, (line, dirty)) in loop_last(
+            enumerate(zip(lines, self._dirty), y)
+        ):
             if dirty:
                 yield move_to(x, offset_y).segment
-                yield from line
-
+                yield from Segment.adjust_line_length(line, width)
+                if not last:
+                    yield new_line
         self._dirty[:] = [False] * len(self.lines)

src/textual/_line_cache.py

@@ -167,9 +167,11 @@ class TestParser(Parser[str]):
         def parse(
             self, on_token: Callable[[str], None]
         ) -> Generator[Awaitable, str, None]:
-            # on_token((yield self.read_until("a")))
-            while data := (yield self.read1()):
-                print("buffer", repr((yield self.peek_buffer())))
+            data = yield self.read1()
+            while True:
+                data = yield self.read1()
+                if not data:
+                    break
                 on_token(data)
 
     test_parser = TestParser()

src/textual/_parser.py

@@ -1,4 +1,11 @@
-from typing import Awaitable, Callable, Optional, Protocol, TYPE_CHECKING
+import sys
+from typing import Awaitable, Callable, Optional, TYPE_CHECKING
+
+if sys.version_info >= (3, 8):
+    from typing import Protocol
+else:
+    from typing_extensions import Protocol
+
 
 if TYPE_CHECKING:
     from .events import Event

src/textual/_types.py

@@ -34,12 +34,12 @@
 
 LayoutDefinition = "dict[str, Any]"
 
-try:
-    import uvloop
-except ImportError:
-    pass
-else:
-    uvloop.install()
+# try:
+#     import uvloop
+# except ImportError:
+#     pass
+# else:
+#     uvloop.install()
 
 
 class ShutdownError(Exception):
@@ -106,6 +106,7 @@ async def _process_messages(self) -> None:
         await self.add(self.view)
 
         await self.post_message(events.Startup(sender=self))
+
         try:
             driver.start_application_mode()
         except Exception:
@@ -115,23 +116,26 @@ async def _process_messages(self) -> None:
             await super().process_messages()
         finally:
             try:
-                driver.stop_application_mode()
-            finally:
-                loop.remove_signal_handler(signal.SIGINT)
+                if self.children:
 
-        if self.children:
+                    async def close_all() -> None:
+                        for child in self.children:
+                            await child.close_messages()
+                        await asyncio.gather(*(child.task for child in self.children))
 
-            async def close_all() -> None:
-                for child in self.children:
-                    await child.close_messages()
-                await asyncio.gather(*(child.task for child in self.children))
+                    try:
+                        await asyncio.wait_for(close_all(), timeout=5)
+                    except asyncio.TimeoutError as error:
+                        raise ShutdownError(
+                            "Timeout closing messages pump(s)"
+                        ) from None
 
-            try:
-                await asyncio.wait_for(close_all(), timeout=5)
-            except asyncio.TimeoutError as error:
-                raise ShutdownError("Timeout closing messages pump(s)") from None
-
-            self.children.clear()
+                self.children.clear()
+            finally:
+                try:
+                    driver.stop_application_mode()
+                finally:
+                    loop.remove_signal_handler(signal.SIGINT)
 
     async def add(self, child: MessagePump) -> None:
         self.children.add(child)
@@ -222,31 +226,42 @@ async def action_bang(self) -> None:
     from logging import FileHandler
 
     from .widgets.header import Header
+    from .widgets.footer import Footer
     from .widgets.window import Window
     from .widgets.placeholder import Placeholder
-    from .scrollbar import ScrollBar
 
     from rich.markdown import Markdown
 
+    import os
+
     logging.basicConfig(
         level="NOTSET",
         format="%(message)s",
         datefmt="[%X]",
         handlers=[FileHandler("richtui.log")],
     )
 
-    with open("richreadme.md", "rt") as fh:
-        readme = Markdown(fh.read(), hyperlinks=True, code_theme="fruity")
-
-    from rich import print
-
     class MyApp(App):
 
         KEYS = {"q": "quit", "x": "bang", "ctrl+c": "quit", "b": "view.toggle('left')"}
 
         async def on_startup(self, event: events.Startup) -> None:
+            footer = Footer()
+            footer.add_key("b", "Toggle sidebar")
+            footer.add_key("q", "Quit")
+
+            readme_path = os.path.join(
+                os.path.dirname(os.path.abspath(__file__)), "richreadme.md"
+            )
+
+            with open(readme_path, "rt") as fh:
+                readme = Markdown(fh.read(), hyperlinks=True, code_theme="fruity")
+
             await self.view.mount_all(
-                header=Header(self.title), left=ScrollBar(), body=Window(readme)
+                header=Header(self.title),
+                left=Placeholder(),
+                body=Window(readme),
+                footer=footer,
             )
 
     MyApp.run()

src/textual/app.py

@@ -94,7 +94,8 @@ def __rich_repr__(self) -> RichReprResult:
     def __rich_console__(
         self, console: Console, options: ConsoleOptions
     ) -> RenderResult:
-        segments = console.render(self.layout, options)
+        width, height = self.size
+        segments = console.render(self.layout, options.update_dimensions(width, height))
         yield from segments
 
     def get_widget_at(self, x: int, y: int) -> Tuple[Widget, LayoutRegion]:
@@ -117,8 +118,8 @@ async def on_message(self, message: Message) -> None:
                         segments = Segments(update)
                         self.console.print(segments, end="")
 
-    async def on_create(self, event: events.Created) -> None:
-        await self.mount(Header(self.title))
+    # async def on_create(self, event: events.Created) -> None:
+    #     await self.mount(Header(self.title))
 
     async def mount(self, widget: Widget, *, slot: str = "main") -> None:
         self.layout[slot].update(widget)
@@ -144,8 +145,8 @@ async def set_focus(self, widget: Optional[Widget]) -> None:
                 self.focused = widget
                 await widget.post_message(events.Focus(self))
 
-    async def on_startup(self, event: events.Startup) -> None:
-        await self.mount(Header(self.title), slot="header")
+    # async def on_startup(self, event: events.Startup) -> None:
+    #     await self.mount(Header(self.title), slot="header")
 
     async def layout_update(self) -> None:
         if not self.size:

richreadme.md renamed to src/textual/richreadme.md

@@ -66,7 +66,6 @@ def __set__(self, obj: "Widget", value: T) -> None:
             obj.require_repaint()
 
 
-@rich_repr
 class Widget(MessagePump):
     _count: ClassVar[int] = 0
     can_focus: bool = False
@@ -108,7 +107,13 @@ 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)
+            try:
+                renderable = self.render(
+                    self.console, self.console.options.update_width(width)
+                )
+            except Exception:
+                log.exception("error in render")
+                raise
             self._line_cache = LineCache.from_renderable(
                 self.console, renderable, width, height
             )
@@ -126,14 +131,16 @@ async def forward_input_event(self, event: events.Event) -> None:
         await self.post_message(event)
 
     async def refresh(self) -> None:
-        # self._line_cache = None
+        self._line_cache = None
         await self.repaint()
 
     async def repaint(self) -> None:
         await self.emit(UpdateMessage(self))
 
     def render_update(self, x: int, y: int) -> Iterable[Segment]:
-        yield from self.line_cache.render(x, y)
+        width, height = self.size
+        log.debug("widget size = %r", self.size)
+        yield from self.line_cache.render(x, y, width, height)
 
     def render(self, console: Console, options: ConsoleOptions) -> RenderableType:
         return Panel(

src/textual/view.py

@@ -0,0 +1,32 @@
+from rich.console import Console, ConsoleOptions, RenderableType
+from rich.repr import rich_repr, RichReprResult
+from rich.text import Text
+
+from .. import events
+from ..widget import Widget
+
+
+class Footer(Widget):
+    def __init__(self) -> None:
+        self.keys: list[tuple[str, str]] = []
+        super().__init__()
+
+    def __rich_repr__(self) -> RichReprResult:
+        yield "footer"
+
+    def add_key(self, key: str, label: str) -> None:
+        self.keys.append((key, label))
+
+    def render(self, console: Console, options: ConsoleOptions) -> RenderableType:
+
+        text = Text(
+            style="white on dark_green",
+            no_wrap=True,
+            overflow="ellipsis",
+            justify="left",
+            end="",
+        )
+        for key, label in self.keys:
+            text.append(f" {key.upper()} ", style="default on default")
+            text.append(f" {label} ")
+        return text