euporie 2.3.2__py3-none-any.whl → 2.4.1__py3-none-any.whl

euporie/core/widgets/page.py

@@ -2,14 +2,13 @@
 
 from __future__ import annotations
 
-import asyncio
-import contextvars
 import logging
 import weakref
 from typing import TYPE_CHECKING, cast
 
 from prompt_toolkit.application.current import get_app
 from prompt_toolkit.data_structures import Point
+from prompt_toolkit.eventloop.utils import run_in_executor_with_context
 from prompt_toolkit.filters import is_searching
 from prompt_toolkit.layout.containers import (
     Container,
@@ -20,6 +19,7 @@ from prompt_toolkit.layout.containers import (
 )
 from prompt_toolkit.layout.controls import UIContent
 from prompt_toolkit.layout.dimension import Dimension, to_dimension
+from prompt_toolkit.layout.layout import walk
 from prompt_toolkit.layout.mouse_handlers import MouseHandlers
 from prompt_toolkit.layout.screen import Char, Screen, WritePosition
 from prompt_toolkit.mouse_events import MouseEvent, MouseEventType, MouseModifier
@@ -27,7 +27,7 @@ from prompt_toolkit.mouse_events import MouseEvent, MouseEventType, MouseModifie
 from euporie.core.data_structures import DiInt
 
 if TYPE_CHECKING:
-    from typing import Callable, Sequence
+    from typing import Callable, Iterable, Sequence
 
     from prompt_toolkit.key_binding.key_bindings import (
         KeyBindingsBase,
@@ -35,6 +35,7 @@ if TYPE_CHECKING:
     )
     from prompt_toolkit.layout.containers import AnyContainer
     from prompt_toolkit.layout.dimension import AnyDimension
+    from prompt_toolkit.utils import Event
 
     MouseHandler = Callable[[MouseEvent], object]
 
@@ -84,10 +85,24 @@ class ChildRenderInfo:
         self.screen = Screen(default_char=Char(char=" "))
         self.mouse_handlers = MouseHandlers()
 
+        self.render_counter = -1
+        self._invalid = True
+        self._invalidate_events: list[Event[object]] = []
+        self._layout_hash = 0
         self.height = 0
         self.width = 0
 
-        self.refresh = True
+    def invalidate(self) -> None:
+        """Flag the child's rendering as out-of-date."""
+        self._invalid = True
+
+    def _invalidate_handler(self, sender: object) -> None:
+        self.invalidate()
+
+    @property
+    def layout_hash(self) -> int:
+        """Return a hash of the child's current layout."""
+        return sum(hash(container) for container in walk(self.container))
 
     def render(
         self,
@@ -103,9 +118,24 @@ class ChildRenderInfo:
             style: The parent style to apply when rendering
 
         """
-        if self.refresh:
-            self.refresh = False
+        # Check if refresh is needed
+        refresh = False
+        new_layout_hash = self.layout_hash
+        if self.render_counter != (new_render_counter := get_app().render_counter):
+            if (
+                self._invalid
+                or self.width != available_width
+                or self._layout_hash != (new_layout_hash := self.layout_hash)
+            ):
+                self.render_counter = new_render_counter
+                refresh = True
+
+        # Refresh if needed
+        if refresh:
+            self._invalid = False
+            self._layout_hash = new_layout_hash
             # log.debug("Re-rendering cell %s", self.child.index)
+            self.width = available_width
             self.height = self.container.preferred_height(
                 available_width, available_height
             ).preferred
@@ -128,6 +158,20 @@ class ChildRenderInfo:
             )
             self.screen.draw_all_floats()
 
+            # Collect invalidation events
+            def gather_events() -> Iterable[Event[object]]:
+                for container in walk(self.container):
+                    if isinstance(container, Window):
+                        for event in container.content.get_invalidate_events():
+                            event += self._invalidate_handler
+                            yield event
+
+            # Remove all the original event handlers
+            for event in self._invalidate_events:
+                event -= self._invalidate_handler
+            # Update the list of handlers
+            self._invalidate_events = list(gather_events())
+
     def blit(
         self,
         screen: Screen,
@@ -238,7 +282,7 @@ class ChildRenderInfo:
 
                     # Refresh the child if there was a response
                     if response is None:
-                        self.refresh = True
+                        self.invalidate()
                         return response
 
                     # This would work if windows returned NotImplemented when scrolled
@@ -260,7 +304,7 @@ class ChildRenderInfo:
                         else:
                             self.parent.select(index, extend=False)
                         response = None
-                        self.refresh = True
+                        self.invalidate()
 
                         # Attempt to focus the container
                         layout.focus(self.child)
@@ -316,6 +360,8 @@ class ChildRenderInfo:
 class ScrollingContainer(Container):
     """A scrollable container which renders only the currently visible children."""
 
+    render_info: WindowRenderInfo | None
+
     def __init__(
         self,
         children: Callable[[], Sequence[AnyContainer]] | Sequence[AnyContainer],
@@ -361,41 +407,27 @@ class ScrollingContainer(Container):
 
     def pre_render_children(self, width: int, height: int) -> None:
         """Render all unrendered children in a background thread."""
-        # Copy the current context so ``get_app()`` works in the thread
-        ctx = contextvars.copy_context()
+        # Prevent multiple calls
+        self.pre_rendered = 0.00001
 
         def render_in_thread() -> None:
-            """Create a new event loop in the thread."""
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
-            async def render_run_in_loop() -> None:
-                """Render all children sequentially."""
-                n_children = len(self.children)
-                for i in range(n_children):
-                    if i < len(self.children):
-                        self.get_child_render_info(i).render(width, height)
-                        self.pre_rendered = i / n_children
-                    get_app().invalidate()
-                self.pre_rendered = 1.0
+            """Render children in  thread."""
+            n_children = len(self.children)
+            for i in range(n_children):
+                if i < len(self.children):
+                    self.get_child_render_info(i).render(width, height)
+                    self.pre_rendered = i / n_children
                 get_app().invalidate()
+            self.pre_rendered = 1.0
+            get_app().invalidate()
 
-            loop.run_until_complete(render_run_in_loop())
-
-        async def trigger_render() -> None:
-            """Use an executor thread from the current event loop."""
-            await asyncio.get_event_loop().run_in_executor(
-                None, ctx.run, render_in_thread
-            )
-
-        get_app().create_background_task(trigger_render())
+        run_in_executor_with_context(render_in_thread)
 
     def reset(self) -> None:
         """Reet the state of this container and all the children."""
-        meta_data = list(self.child_render_infos.values())
-        for meta in meta_data:
+        for meta in self.child_render_infos.values():
             meta.container.reset()
-            meta.refresh = True
+            meta.invalidate()
 
     def preferred_width(self, max_available_width: int) -> Dimension:
         """Do not provide a preferred width - grow to fill the available space."""
@@ -446,15 +478,15 @@ class ScrollingContainer(Container):
             render_info: ChildRenderInfo | None
             for render_info in self._selected_child_render_infos:
                 if render_info:
-                    render_info.refresh = True
+                    render_info.invalidate()
             # If a child currently has focus, request to refresh it
-            for child in self.children:
-                if (
-                    render_info := self.child_render_infos.get(hash(child))
-                ) is not None:
-                    if app.layout.has_focus(render_info.child):
-                        render_info.refresh = True
-                        break
+            # for child in self.children:
+            #     if (
+            #         render_info := self.child_render_infos.get(hash(child))
+            #     ) is not None:
+            #         if app.layout.has_focus(render_info.child):
+            #             render_info.invalidate()
+            #             break
             # Get the first selected child and focus it
             child = self.children[new_slice.start]
             if not app.layout.has_focus(child):
@@ -565,7 +597,11 @@ class ScrollingContainer(Container):
         """
         # self.refresh_children = True
         if n > 0:
-            if min(self.visible_indicies) == 0 and self.index_positions[0] is not None:
+            if (
+                min(self.visible_indicies) == 0
+                and self.index_positions
+                and self.index_positions[0] is not None
+            ):
                 n = min(n, 0 - self.index_positions[0] - self.scrolling)
                 if self.index_positions[0] + self.scrolling + n > 0:
                     return NotImplemented
@@ -636,10 +672,6 @@ class ScrollingContainer(Container):
         available_width = write_position.width
         available_height = write_position.height
 
-        # Trigger pre-rendering of children
-        if not self.pre_rendered:
-            self.pre_render_children(available_width, available_height)
-
         # Update screen height
         screen.height = max(screen.height, ypos + write_position.height)
 
@@ -651,23 +683,19 @@ class ScrollingContainer(Container):
         self._selected_child_render_infos = []
         for index in selected_indices:
             render_info = self.get_child_render_info(index)
-            # Do not bother to re-render children if we are scrolling
+            # Do not bother to re-render selected children if we are scrolling
             if not self.scrolling:
-                render_info.refresh = True
+                render_info.invalidate()
             self._selected_child_render_infos.append(render_info)
             self.index_positions[index] = None
 
-        # Refresh all children if the width has changed
-        if self.last_write_position.width != write_position.width:
-            for child_render_info in self.child_render_infos.values():
-                child_render_info.refresh = True
-
         # Refresh visible children if searching
         if is_searching():
             for index in self.visible_indicies:
-                self.get_child_render_info(index).refresh = True
+                self.get_child_render_info(index).invalidate()
 
         # Scroll to make the cursor visible
+        layout = get_app().layout
         if self.scroll_to_cursor:
             selected_child_render_info = self._selected_child_render_infos[0]
             selected_child_render_info.render(
@@ -675,7 +703,7 @@ class ScrollingContainer(Container):
                 available_height=available_height,
                 style=f"{parent_style} {self.style}",
             )
-            current_window = get_app().layout.current_window
+            current_window = layout.current_window
             cursor_position = selected_child_render_info.screen.cursor_positions.get(
                 current_window
             )
@@ -805,13 +833,22 @@ class ScrollingContainer(Container):
 
         # Update which children will appear in the layout
         self.visible_indicies = visible_indicies
+
+        # Update parent relations in layout
+        def _walk(e: Container) -> None:
+            for c in e.get_children():
+                layout._child_to_parent[c] = e
+                _walk(c)
+
+        _walk(self)
+
         # Record where the contain was last drawn so we can determine if cell outputs
         # are partially obscured
         self.last_write_position = write_position
 
         # Calculate scrollbar info
         sizes = self.known_sizes
-        avg_size = sum(sizes.values()) / len(sizes)
+        avg_size = sum(sizes.values()) / len(sizes) if sizes else 0
         n_children = len(self.children)
         for i in range(n_children):
             if i not in sizes:
@@ -836,6 +873,10 @@ class ScrollingContainer(Container):
         # Signal that we are no longer scrolling
         self.scrolling = 0
 
+        # Trigger pre-rendering of children
+        if not self.pre_rendered:
+            self.pre_render_children(available_width, available_height)
+
     @property
     def vertical_scroll(self) -> int:
         """The best guess at the absolute vertical scroll position."""

euporie/core/widgets/pager.py

@@ -15,7 +15,7 @@ from prompt_toolkit.layout.containers import (
 from prompt_toolkit.widgets import Box
 
 from euporie.core.commands import add_cmd
-from euporie.core.convert.base import BASE64_FORMATS, MIME_FORMATS, find_route
+from euporie.core.convert.core import BASE64_FORMATS, MIME_FORMATS, find_route
 from euporie.core.current import get_app
 from euporie.core.filters import pager_has_focus
 from euporie.core.key_binding.registry import (

euporie/core/widgets/palette.py

@@ -17,10 +17,11 @@ from prompt_toolkit.mouse_events import MouseEvent, MouseEventType
 from euporie.core.commands import Command, add_cmd, commands
 from euporie.core.current import get_app
 from euporie.core.key_binding.registry import register_bindings
-from euporie.core.margins import ScrollbarMargin
+from euporie.core.margins import MarginContainer, ScrollbarMargin
 from euporie.core.widgets.decor import FocusedStyle
 from euporie.core.widgets.dialog import Dialog
 from euporie.core.widgets.forms import Text
+from euporie.core.widgets.status_bar import StatusContainer
 
 if TYPE_CHECKING:
     from prompt_toolkit.buffer import Buffer
@@ -29,7 +30,8 @@ if TYPE_CHECKING:
     from prompt_toolkit.key_binding.key_processor import KeyPressEvent
     from prompt_toolkit.layout.controls import GetLinePrefixCallable
 
-    from euporie.core.app import BaseApp, StatusBarFields
+    from euporie.core.app import BaseApp
+    from euporie.core.widgets.status_bar import StatusBarFields
 
 log = logging.getLogger(__name__)
 
@@ -192,39 +194,34 @@ class CommandPalette(Dialog):
             placeholder="  Type to search…",
         )
         self.text_area.buffer.on_text_changed += self.text_changed
-        scroll_bar_margin = ScrollbarMargin(display_arrows=False)
-
-        self.body = HSplit(
-            [
-                VSplit(
-                    [FocusedStyle(self.text_area)],
-                    padding=1,
-                ),
-                Window(
-                    CommandMenuControl(self),
-                    scroll_offsets=ScrollOffsets(bottom=1),
-                    right_margins=[scroll_bar_margin],
-                ),
-            ],
+
+        self.body = StatusContainer(
+            body=HSplit(
+                [
+                    VSplit(
+                        [FocusedStyle(self.text_area)],
+                        padding=1,
+                    ),
+                    VSplit(
+                        [
+                            window := Window(
+                                CommandMenuControl(self),
+                                scroll_offsets=ScrollOffsets(bottom=1),
+                            ),
+                            MarginContainer(ScrollbarMargin(), target=window),
+                        ]
+                    ),
+                ],
+            ),
+            status=self.__pt_status__,
         )
         self.buttons = {}
 
-        get_app().container_statuses[self.container] = self.statusbar_fields
-
     def load(self) -> None:
         """Reset the dialog ready for display."""
         self.text_area.buffer.text = ""
         self.to_focus = self.text_area
 
-    def statusbar_fields(
-        self,
-    ) -> StatusBarFields:
-        """Return a list of statusbar field values shown then this tab is active."""
-        if self.matches:
-            return ([self.matches[self.index].command.description], [])
-        else:
-            return ([], [])
-
     def select(self, n: int, event: KeyPressEvent | None = None) -> None:
         """Change the index of the selected command.
 
@@ -267,6 +264,12 @@ class CommandPalette(Dialog):
         else:
             return False
 
+    def __pt_status__(self) -> StatusBarFields | None:
+        """Return a list of statusbar field values shown then this tab is active."""
+        if self.matches:
+            return ([self.matches[self.index].command.description], [])
+        return None
+
     # ################################### Commands ####################################
 
     @staticmethod

euporie/core/widgets/search_bar.py

@@ -9,6 +9,7 @@ from prompt_toolkit.filters.app import is_searching
 from prompt_toolkit.key_binding.vi_state import InputMode
 from prompt_toolkit.layout.controls import BufferControl, SearchBufferControl
 from prompt_toolkit.search import SearchDirection
+from prompt_toolkit.selection import SelectionState
 from prompt_toolkit.widgets import SearchToolbar as PtkSearchToolbar
 
 from euporie.core.commands import add_cmd
@@ -57,6 +58,20 @@ class SearchBar(PtkSearchToolbar):
             "euporie.core.widgets.search_bar.SearchBar"
         )
 
+    register_bindings(
+        {
+            "euporie.core.app.BaseApp": {
+                "find": ["c-f", "f3", "f7"],
+                "find-next": "c-g",
+                "find-previous": "c-p",
+            },
+            "euporie.core.widgets.search_bar.SearchBar": {
+                "accept-search": "enter",
+                "stop-search": "escape",
+            },
+        }
+    )
+
 
 def start_global_search(
     buffer_control: BufferControl | None = None,
@@ -94,6 +109,7 @@ def start_global_search(
             control.search_state.direction = direction
             # Add it to our list
             searchable_controls.append(control)
+
     # Stop the search if we did not find any searchable controls
     if not searchable_controls:
         return
@@ -113,10 +129,7 @@ def start_global_search(
     app.vi_state.input_mode = InputMode.INSERT
 
 
-@add_cmd(
-    menu_title="Find",
-    # filter=control_is_searchable,
-)
+@add_cmd(menu_title="Find")
 def find() -> None:
     """Enter search mode."""
     start_global_search(direction=SearchDirection.FORWARD)
@@ -142,10 +155,13 @@ def find_prev_next(direction: SearchDirection) -> None:
         search_state = control.search_state
         search_state.direction = direction
         # Apply search to buffer
-        control.buffer.apply_search(
-            search_state, include_current_position=False, count=1
+        buffer = control.buffer
+        buffer.apply_search(search_state, include_current_position=False, count=1)
+        # Set selection
+        buffer.selection_state = SelectionState(
+            buffer.cursor_position + len(search_state.text)
         )
-    # break
+        buffer.selection_state.enter_shift_mode()
 
 
 @add_cmd()
@@ -170,8 +186,8 @@ def stop_search() -> None:
     if buffer_control is None:
         return
     search_buffer_control = buffer_control.search_buffer_control
-    # Focus the original buffer again.
-    layout.focus(buffer_control)
+    # Focus the previous control
+    layout.focus(layout.previous_control)
     # Close the search toolbar
     if search_buffer_control is not None:
         del layout.search_links[search_buffer_control]
@@ -202,23 +218,20 @@ def accept_search() -> None:
             if search_buffer_control.buffer.text:
                 search_state.text = search_buffer_control.buffer.text
             # Apply search.
-            control.buffer.apply_search(search_state, include_current_position=True)
+            control.buffer.apply_search(
+                search_state, include_current_position=True, count=1
+            )
+
+    # Set selection on target control
+    buffer_control = layout.search_target_buffer_control
+    if buffer_control and control.is_focusable():
+        buffer = buffer_control.buffer
+        buffer.selection_state = SelectionState(
+            buffer.cursor_position + len(search_state.text)
+        )
+        buffer.selection_state.enter_shift_mode()
+
     # Add query to history of search line.
     search_buffer_control.buffer.append_to_history()
     # Stop the search
     stop_search()
-
-
-register_bindings(
-    {
-        "euporie.core.app.BaseApp": {
-            "find": ["c-f", "f3", "f7"],
-            "find-next": "c-g",
-            "find-previous": "c-p",
-        },
-        "euporie.core.widgets.search_bar.SearchBar": {
-            "accept-search": "enter",
-            "stop-search": "escape",
-        },
-    }
-)

euporie/core/widgets/status_bar.py

@@ -2,15 +2,23 @@
 
 from __future__ import annotations
 
+import logging
 from typing import TYPE_CHECKING
+from weakref import WeakKeyDictionary
 
+from prompt_toolkit.cache import FastDictCache
 from prompt_toolkit.filters.utils import to_filter
+from prompt_toolkit.formatted_text import to_formatted_text
+from prompt_toolkit.layout import containers
 from prompt_toolkit.layout.containers import (
     ConditionalContainer,
     VSplit,
     Window,
     WindowAlign,
 )
+from prompt_toolkit.layout.containers import (
+    to_container as ptk_to_container,
+)
 from prompt_toolkit.layout.controls import FormattedTextControl
 
 from euporie.core.config import add_setting
@@ -18,28 +26,76 @@ from euporie.core.current import get_app
 from euporie.core.filters import is_searching
 
 if TYPE_CHECKING:
+    from typing import Callable, Sequence
+
     from prompt_toolkit.filters.base import FilterOrBool
-    from prompt_toolkit.layout.containers import AnyContainer
+    from prompt_toolkit.formatted_text import StyleAndTextTuples
+    from prompt_toolkit.formatted_text.base import AnyFormattedText
+    from prompt_toolkit.layout.containers import AnyContainer, Container
+
+    StatusBarFields = tuple[Sequence[AnyFormattedText], Sequence[AnyFormattedText]]
+
+log = logging.getLogger(__name__)
+
+
+_CONTAINER_STATUSES: WeakKeyDictionary[
+    Container, Callable[[], StatusBarFields | None]
+] = WeakKeyDictionary()
+
+
+def to_container(container: AnyContainer) -> Container:
+    """Monkey-patch `to_container` to collect container status functions."""
+    result = ptk_to_container(container)
+    if hasattr(container, "__pt_status__"):
+        _CONTAINER_STATUSES[result] = container.__pt_status__
+    return result
+
+
+containers.to_container = to_container
+
+
+class StatusContainer:
+    """A container which allows attaching a status function."""
+
+    def __init__(
+        self, body: AnyContainer, status: Callable[[], StatusBarFields | None]
+    ) -> None:
+        """Initiate a new instance with a body and status function."""
+        self.body = body
+        self.status = status
+
+    def __pt_status__(self) -> StatusBarFields | None:
+        """Return the status fields."""
+        return self.status()
+
+    def __pt_container__(self) -> AnyContainer:
+        """Return the body container."""
+        return self.body
 
 
 class StatusBar:
     """A status bar which shows the status of the current tab."""
 
-    def __init__(self, extra_filter: FilterOrBool = True) -> None:
+    def __init__(
+        self, extra_filter: FilterOrBool = True, default: StatusBarFields | None = None
+    ) -> None:
         """Create a new status bar instance."""
-        self.app = get_app()
+        self.default: StatusBarFields = default or ([], [])
+        self._status_cache: FastDictCache[
+            tuple[int], list[StyleAndTextTuples]
+        ] = FastDictCache(self._status, size=1)
         self.container = ConditionalContainer(
             content=VSplit(
                 [
                     Window(
                         FormattedTextControl(
-                            lambda: self.app.format_status(part="left")
+                            lambda: self._status_cache[get_app().render_counter,][0]
                         ),
                         style="class:status",
                     ),
                     Window(
                         FormattedTextControl(
-                            lambda: self.app.format_status(part="right")
+                            lambda: self._status_cache[get_app().render_counter,][1]
                         ),
                         style="class:status.right",
                         align=WindowAlign.RIGHT,
@@ -52,6 +108,48 @@ class StatusBar:
             & to_filter(extra_filter),
         )
 
+    def _status(self, render_counter: int = 0) -> list[StyleAndTextTuples]:
+        """Load and format the current status bar entries."""
+        layout = get_app().layout
+        current: Container = layout.current_window
+
+        entries = self.default
+        while True:
+            if callable(
+                func := (
+                    _CONTAINER_STATUSES.get(current)
+                    or getattr(current, "__pt_status__", None)
+                )
+            ):
+                result = func()
+                if result is not None:
+                    entries = result
+                    break
+            elif current in layout._child_to_parent:
+                current = layout._child_to_parent[current]
+                continue
+            break
+
+        output: list[StyleAndTextTuples] = []
+        # Show the tab's status fields
+        for entry in entries:
+            output.append([])
+            for field in entry:
+                if field:
+                    if isinstance(field, tuple):
+                        ft = [field]
+                    else:
+                        ft = to_formatted_text(field, style="class:status.field")
+                    output[-1] += [
+                        ("class:status.field", " "),
+                        *ft,
+                        ("class:status.field", " "),
+                        ("class:status", " "),
+                    ]
+            if output[-1]:
+                output[-1].pop()
+        return output
+
     def __pt_container__(self) -> AnyContainer:
         """Return the widget's container."""
         return self.container