euporie 2.8.1__py3-none-any.whl → 2.8.5__py3-none-any.whl

euporie/core/layout/cache.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import logging
-from functools import lru_cache
+from functools import cache
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.data_structures import Point
@@ -17,7 +17,7 @@ from prompt_toolkit.layout.layout import walk
 from prompt_toolkit.layout.mouse_handlers import MouseHandlers
 from prompt_toolkit.mouse_events import MouseEvent
 
-from euporie.core.current import get_app
+from euporie.core.app.current import get_app
 from euporie.core.data_structures import DiInt
 from euporie.core.layout.screen import BoundedWritePosition, Screen
 
@@ -256,7 +256,10 @@ class CachedContainer(Container):
             cols: The columns to copy
             rows: The rows to copy
                                                                                                                                                                                        .
-        """  # Copy write positions
+        """
+        # Copy write positions
+        new_wps = {}
+
         for win, wp in self.screen.visible_windows_to_write_positions.items():
             new_wp = BoundedWritePosition(
                 xpos=wp.xpos + left,
@@ -270,10 +273,9 @@ class CachedContainer(Container):
                     left=max(0, wp.width - (cols.stop - wp.xpos)),
                 ),
             )
-            screen.visible_windows_to_write_positions[win] = new_wp
-            screen.height = max(screen.height, self.screen.height)
+            new_wps[win] = new_wp
 
-            # # Modify render info
+            # Modify render info
             info = win.render_info
             if info is not None:
                 visible_line_to_row_col = {
@@ -308,7 +310,10 @@ class CachedContainer(Container):
                         win.render_info, "horizontal_scroll", horizontal_scroll
                     )
 
-        @lru_cache
+        screen.visible_windows_to_write_positions.update(new_wps)
+        screen.height = max(screen.height, self.screen.height)
+
+        @cache
         def _wrap_mouse_handler(handler: Callable) -> MouseHandler:
             def _wrapped(mouse_event: MouseEvent) -> NotImplementedOrNone:
                 # Modify mouse events to reflect position of content
@@ -334,14 +339,17 @@ class CachedContainer(Container):
         output_db = screen.data_buffer
         output_zwes = screen.zero_width_escapes
         output_mhs = mouse_handlers.mouse_handlers
-        for y in range(max(0, rows.start), rows.stop):
+
+        rows_range = range(max(0, rows.start), rows.stop)
+        cols_range = range(max(0, cols.start), cols.stop)
+        for y in rows_range:
             input_db_row = input_db[y]
             input_zwes_row = input_zwes[y]
             input_mhs_row = input_mhs[y]
             output_dbs_row = output_db[top + y]
             output_zwes_row = output_zwes[top + y]
             output_mhs_row = output_mhs[top + y]
-            for x in range(max(0, cols.start), cols.stop):
+            for x in cols_range:
                 # Data
                 output_dbs_row[left + x] = input_db_row[x]
                 # Escape sequences
@@ -353,24 +361,26 @@ class CachedContainer(Container):
         layout = get_app().layout
         if self.screen.show_cursor:
             for window, point in self.screen.cursor_positions.items():
-                if layout.current_control == window.content:
-                    assert window.render_info is not None
-                    if (
-                        (
-                            window.render_info.ui_content.show_cursor
-                            and not window.always_hide_cursor()
-                        )
-                        and point.x in range(cols.start, cols.stop)
-                        and point.y in range(rows.start, rows.stop)
-                    ):
-                        screen.cursor_positions[window] = Point(
-                            x=left + point.x, y=top + point.y
-                        )
-                        screen.show_cursor = True
+                if (
+                    layout.current_control == window.content
+                    and window.render_info is not None
+                    and window.render_info.ui_content.show_cursor
+                    and not window.always_hide_cursor()
+                    and cols.start <= point.x < cols.stop
+                    and rows.start <= point.y < rows.stop
+                ):
+                    screen.cursor_positions[window] = Point(
+                        x=left + point.x, y=top + point.y
+                    )
+                    screen.show_cursor = True
 
         # Copy menu positions
-        for window, point in self.screen.menu_positions.items():
-            screen.menu_positions[window] = Point(x=left + point.x, y=top + point.y)
+        screen.menu_positions.update(
+            {
+                window: Point(x=left + point.x, y=top + point.y)
+                for window, point in self.screen.menu_positions.items()
+            }
+        )
 
     def get_children(self) -> list[Container]:
         """Return a list of all child containers."""

euporie/core/layout/containers.py

@@ -7,31 +7,47 @@ from functools import lru_cache, partial
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.application.current import get_app
+from prompt_toolkit.cache import FastDictCache
 from prompt_toolkit.data_structures import Point
-from prompt_toolkit.layout import containers
-from prompt_toolkit.layout.containers import WindowAlign, WindowRenderInfo
+from prompt_toolkit.layout import containers as ptk_containers
+from prompt_toolkit.layout.containers import (
+    Container,
+    HorizontalAlign,
+    VerticalAlign,
+    WindowAlign,
+    WindowRenderInfo,
+)
+from prompt_toolkit.layout.controls import DummyControl as PtkDummyControl
 from prompt_toolkit.layout.controls import (
     FormattedTextControl,
     UIContent,
     fragment_list_width,
     to_formatted_text,
 )
-from prompt_toolkit.layout.dimension import sum_layout_dimensions
+from prompt_toolkit.layout.dimension import Dimension
 from prompt_toolkit.layout.screen import _CHAR_CACHE
 from prompt_toolkit.layout.utils import explode_text_fragments
-from prompt_toolkit.mouse_events import MouseEvent
-from prompt_toolkit.utils import get_cwidth, take_using_weights, to_str
+from prompt_toolkit.mouse_events import MouseEvent, MouseEventType
+from prompt_toolkit.utils import get_cwidth, to_str
 
 from euporie.core.data_structures import DiInt
+from euporie.core.layout.controls import DummyControl
 from euporie.core.layout.screen import BoundedWritePosition
 
 if TYPE_CHECKING:
-    from typing import Callable
+    from collections.abc import Sequence
+    from typing import Any, Callable
 
     from prompt_toolkit.formatted_text import AnyFormattedText, StyleAndTextTuples
-    from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
-    from prompt_toolkit.layout.containers import Float
-    from prompt_toolkit.layout.dimension import Dimension
+    from prompt_toolkit.key_binding.key_bindings import (
+        KeyBindingsBase,
+        NotImplementedOrNone,
+    )
+    from prompt_toolkit.layout.containers import (
+        AnyContainer,
+        AnyDimension,
+        Float,
+    )
     from prompt_toolkit.layout.margins import Margin
     from prompt_toolkit.layout.mouse_handlers import MouseHandlers
     from prompt_toolkit.layout.screen import Screen, WritePosition
@@ -40,9 +56,87 @@ if TYPE_CHECKING:
 log = logging.getLogger(__name__)
 
 
-class HSplit(containers.HSplit):
+@lru_cache(maxsize=None)
+class DummyContainer(Container):
+    """Base class for user interface layout."""
+
+    def __init__(self, width: int = 0, height: int = 0) -> None:
+        """Define width and height if any."""
+        self.width = width
+        self.height = height
+
+    def reset(self) -> None:
+        """Reset the state of this container (does nothing)."""
+
+    def preferred_width(self, max_available_width: int) -> Dimension:
+        """Return a zero-width dimension."""
+        return Dimension.exact(self.width)
+
+    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
+        """Return a zero-height dimension."""
+        return Dimension.exact(self.height)
+
+    def write_to_screen(
+        self,
+        screen: Screen,
+        mouse_handlers: MouseHandlers,
+        write_position: WritePosition,
+        parent_style: str,
+        erase_bg: bool,
+        z_index: int | None,
+    ) -> None:
+        """Write the actual content to the screen. Does nothing."""
+
+    def get_children(self) -> list[Container]:
+        """Return an empty list of child :class:`.Container` objects."""
+        return []
+
+
+class HSplit(ptk_containers.HSplit):
     """Several layouts, one stacked above/under the other."""
 
+    _pad_window: Window
+
+    def __init__(
+        self,
+        children: Sequence[AnyContainer],
+        window_too_small: Container | None = None,
+        align: VerticalAlign = VerticalAlign.JUSTIFY,
+        padding: AnyDimension = 0,
+        padding_char: str | None = None,
+        padding_style: str = "",
+        width: AnyDimension = None,
+        height: AnyDimension = None,
+        z_index: int | None = None,
+        modal: bool = False,
+        key_bindings: KeyBindingsBase | None = None,
+        style: str | Callable[[], str] = "",
+    ) -> None:
+        """Initialize the HSplit with a cache."""
+        if window_too_small is None:
+            window_too_small = DummyContainer()
+        super().__init__(
+            children=children,
+            window_too_small=window_too_small,
+            align=align,
+            padding=padding,
+            padding_char=padding_char,
+            padding_style=padding_style,
+            width=width,
+            height=height,
+            z_index=z_index,
+            modal=modal,
+            key_bindings=key_bindings,
+            style=style,
+        )
+        _split_cache_getter = super()._divide_heights
+        self._split_cache: FastDictCache[
+            tuple[int, WritePosition], list[int] | None
+        ] = FastDictCache(lambda rc, wp: _split_cache_getter(wp), size=100)
+
+    def _divide_heights(self, write_position: WritePosition) -> list[int] | None:
+        return self._split_cache[get_app().render_counter, write_position]
+
     def write_to_screen(
         self,
         screen: Screen,
@@ -132,68 +226,87 @@ class HSplit(containers.HSplit):
                     z_index,
                 )
 
-    def _divide_heights(self, write_position: WritePosition) -> list[int] | None:
-        """Return the heights for all rows, or None when there is not enough space."""
-        if not self.children:
-            return []
-
-        # Calculate heights.
-        width = write_position.width
-        height = write_position.height
-
-        return _get_divided_heights(
-            width,
-            height,
-            tuple(c.preferred_height(width, height) for c in self._all_children),
-        )
-
-
-@lru_cache(maxsize=2048)
-def _get_divided_heights(
-    width: int, height: int, dimensions: tuple[Dimension, ...]
-) -> list[int] | None:
-    # Sum dimensions
-    sum_dimensions = sum_layout_dimensions(list(dimensions))
-
-    # If there is not enough space for both.
-    # Don't do anything.
-    if sum_dimensions.min > height:
-        return None
-
-    # Find optimal sizes. (Start with minimal size, increase until we cover
-    # the whole height.)
-    sizes = [d.min for d in dimensions]
-
-    child_generator = take_using_weights(
-        items=list(range(len(dimensions))), weights=[d.weight for d in dimensions]
-    )
-
-    i = next(child_generator)
-
-    # Increase until we meet at least the 'preferred' size.
-    preferred_stop = min(height, sum_dimensions.preferred)
-    preferred_dimensions = [d.preferred for d in dimensions]
+    @property
+    def pad_window(self) -> Window:
+        """Create a single instance of the padding window."""
+        try:
+            return self._pad_window
+        except AttributeError:
+            self._pad_window = Window(
+                height=self.padding,
+                char=self.padding_char,
+                style=self.padding_style,
+            )
+            return self._pad_window
+
+    @property
+    def _all_children(self) -> list[Container]:
+        """List of child objects, including padding."""
+
+        def get() -> list[Container]:
+            result: list[Container] = []
+            # Padding Top.
+            if self.align in (VerticalAlign.CENTER, VerticalAlign.BOTTOM):
+                result.append(Window(width=Dimension(preferred=0)))
+            # The children with padding.
+            for child in self.children:
+                result.append(child)
+                result.append(self.pad_window)
+            if result:
+                result.pop()
+            # Padding right.
+            if self.align in (VerticalAlign.CENTER, VerticalAlign.TOP):
+                result.append(Window(width=Dimension(preferred=0)))
+            return result
 
-    while sum(sizes) < preferred_stop:
-        if sizes[i] < preferred_dimensions[i]:
-            sizes[i] += 1
-        i = next(child_generator)
+        return self._children_cache.get(tuple(self.children), get)
 
-    # Increase until we use all the available space. (or until "max")
-    if not get_app().is_done:
-        max_stop = min(height, sum_dimensions.max)
-        max_dimensions = [d.max for d in dimensions]
 
-        while sum(sizes) < max_stop:
-            if sizes[i] < max_dimensions[i]:
-                sizes[i] += 1
-            i = next(child_generator)
+class VSplit(ptk_containers.VSplit):
+    """Several layouts, one stacked left/right of the other."""
 
-    return sizes
+    _pad_window: Window
 
+    def __init__(
+        self,
+        children: Sequence[AnyContainer],
+        window_too_small: Container | None = None,
+        align: HorizontalAlign = HorizontalAlign.JUSTIFY,
+        padding: AnyDimension = 0,
+        padding_char: str | None = None,
+        padding_style: str = "",
+        width: AnyDimension = None,
+        height: AnyDimension = None,
+        z_index: int | None = None,
+        modal: bool = False,
+        key_bindings: KeyBindingsBase | None = None,
+        style: str | Callable[[], str] = "",
+    ) -> None:
+        """Initialize the VSplit with a cache."""
+        if window_too_small is None:
+            window_too_small = DummyContainer()
+        super().__init__(
+            children=children,
+            window_too_small=window_too_small,
+            align=align,
+            padding=padding,
+            padding_char=padding_char,
+            padding_style=padding_style,
+            width=width,
+            height=height,
+            z_index=z_index,
+            modal=modal,
+            key_bindings=key_bindings,
+            style=style,
+        )
+        _split_cache_getter = super()._divide_widths
+        self._split_cache: FastDictCache[tuple[int, int], list[int] | None] = (
+            FastDictCache(lambda rc, w: _split_cache_getter(w), size=100)
+        )
 
-class VSplit(containers.VSplit):
-    """Several layouts, one stacked left/right of the other."""
+    def _divide_widths(self, width: int) -> list[int] | None:
+        """Calculate and cache widths for all columns."""
+        return self._split_cache[get_app().render_counter, width]
 
     def write_to_screen(
         self,
@@ -294,10 +407,53 @@ class VSplit(containers.VSplit):
                 z_index,
             )
 
+    @property
+    def pad_window(self) -> Window:
+        """Create a single instance of the padding window."""
+        try:
+            return self._pad_window
+        except AttributeError:
+            self._pad_window = Window(
+                width=self.padding,
+                char=self.padding_char,
+                style=self.padding_style,
+            )
+            return self._pad_window
+
+    @property
+    def _all_children(self) -> list[Container]:
+        """List of child objects, including padding."""
+
+        def get() -> list[Container]:
+            result: list[Container] = []
+
+            # Padding left.
+            if self.align in (HorizontalAlign.CENTER, HorizontalAlign.RIGHT):
+                result.append(Window(width=Dimension(preferred=0)))
+            # The children with padding.
+            for child in self.children:
+                result.append(child)
+                result.append(self.pad_window)
+            if result:
+                result.pop()
+            # Padding right.
+            if self.align in (HorizontalAlign.CENTER, HorizontalAlign.LEFT):
+                result.append(Window(width=Dimension(preferred=0)))
+
+            return result
+
+        return self._children_cache.get(tuple(self.children), get)
+
 
-class Window(containers.Window):
+class Window(ptk_containers.Window):
     """Container that holds a control."""
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Initialize `Windows`, updating the default control for empty windows."""
+        super().__init__(*args, **kwargs)
+        if isinstance(self.content, PtkDummyControl):
+            self.content = DummyControl()
+
     def write_to_screen(
         self,
         screen: Screen,
@@ -308,17 +464,20 @@ class Window(containers.Window):
         z_index: int | None,
     ) -> None:
         """Write window to screen."""
-        assert isinstance(write_position, BoundedWritePosition)
         # If dont_extend_width/height was given, then reduce width/height in
         # WritePosition, if the parent wanted us to paint in a bigger area.
         # (This happens if this window is bundled with another window in a
         # HSplit/VSplit, but with different size requirements.)
+        if isinstance(write_position, BoundedWritePosition):
+            bbox = write_position.bbox
+        else:
+            bbox = DiInt(0, 0, 0, 0)
         write_position = BoundedWritePosition(
             xpos=write_position.xpos,
             ypos=write_position.ypos,
             width=write_position.width,
             height=write_position.height,
-            bbox=write_position.bbox,
+            bbox=bbox,
         )
 
         if self.dont_extend_width():
@@ -856,8 +1015,55 @@ class Window(containers.Window):
         else:
             new_screen.fill_area(write_position, "class:last-line", after=True)
 
+    def _mouse_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
+        """Mouse handler. Called when the UI control doesn't handle this particular event.
+
+        Return `NotImplemented` if nothing was done as a consequence of this
+        key binding (no UI invalidate required in that case).
+        """
+        if mouse_event.event_type == MouseEventType.SCROLL_DOWN:
+            return self._scroll_down()
+        elif mouse_event.event_type == MouseEventType.SCROLL_UP:
+            return self._scroll_up()
+
+        return NotImplemented
+
+    def _scroll_down(self) -> NotImplementedOrNone:  # type: ignore [override]
+        """Scroll window down."""
+        info = self.render_info
+
+        if info is None:
+            return NotImplemented
+
+        if self.vertical_scroll < info.content_height - info.window_height:
+            if info.cursor_position.y <= info.configured_scroll_offsets.top:
+                self.content.move_cursor_down()
+            self.vertical_scroll += 1
+            return None
+
+        return NotImplemented
+
+    def _scroll_up(self) -> NotImplementedOrNone:  # type: ignore [override]
+        """Scroll window up."""
+        info = self.render_info
+
+        if info is None:
+            return NotImplemented
+
+        if info.vertical_scroll > 0:
+            # TODO: not entirely correct yet in case of line wrapping and long lines.
+            if (
+                info.cursor_position.y
+                >= info.window_height - 1 - info.configured_scroll_offsets.bottom
+            ):
+                self.content.move_cursor_up()
+            self.vertical_scroll -= 1
+            return None
+
+        return NotImplemented
+
 
-class FloatContainer(containers.FloatContainer):
+class FloatContainer(ptk_containers.FloatContainer):
     """A `FloatContainer` which uses :py`BoundedWritePosition`s."""
 
     def _draw_float(
@@ -1005,7 +1211,7 @@ class FloatContainer(containers.FloatContainer):
                 )
 
 
-containers.HSplit = HSplit  # type: ignore[misc]
-containers.VSplit = VSplit  # type: ignore[misc]
-containers.Window = Window  # type: ignore[misc]
-containers.FloatContainer = FloatContainer  # type: ignore[misc]
+ptk_containers.HSplit = HSplit  # type: ignore[misc]
+ptk_containers.VSplit = VSplit  # type: ignore[misc]
+ptk_containers.Window = Window  # type: ignore[misc]
+ptk_containers.FloatContainer = FloatContainer  # type: ignore[misc]

euporie/core/layout/decor.py

@@ -15,8 +15,8 @@ from prompt_toolkit.layout.dimension import Dimension
 from prompt_toolkit.layout.screen import Char, Screen, WritePosition
 from prompt_toolkit.mouse_events import MouseEventType
 
+from euporie.core.app.current import get_app
 from euporie.core.border import ThinLine
-from euporie.core.current import get_app
 from euporie.core.style import ColorPaletteColor
 
 if TYPE_CHECKING:
@@ -280,9 +280,9 @@ class FocusedStyle(Container):
 
                 return wrapped_mouse_handler
 
-            mouse_handler_wrappers: FastDictCache[
-                tuple[Callable], MouseHandler
-            ] = FastDictCache(get_value=_wrap_mouse_handler)
+            mouse_handler_wrappers: FastDictCache[tuple[Callable], MouseHandler] = (
+                FastDictCache(get_value=_wrap_mouse_handler)
+            )
             for y in range(y_min, y_max):
                 row = mouse_handlers.mouse_handlers[y]
                 for x in range(x_min, x_max):
@@ -341,7 +341,7 @@ class DropShadow(Container):
     ) -> None:
         """Draw the wrapped container with the additional style."""
         attr_cache = self.renderer._attrs_for_style
-        if attr_cache is not None:
+        if attr_cache is not None and self.amount:
             ypos = write_position.ypos
             xpos = write_position.xpos
             amount = self.amount

euporie/core/layout/mouse.py

@@ -13,7 +13,7 @@ from prompt_toolkit.layout.containers import (
 )
 from prompt_toolkit.mouse_events import MouseEventType
 
-from euporie.core.current import get_app
+from euporie.core.app.current import get_app
 
 if TYPE_CHECKING:
     from typing import Callable

euporie/core/layout/print.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING
 
+from prompt_toolkit.application.current import get_app
 from prompt_toolkit.layout.containers import (
     Container,
     Window,
@@ -15,7 +16,8 @@ from prompt_toolkit.layout.dimension import Dimension, to_dimension
 from euporie.core.layout.screen import BoundedWritePosition
 
 if TYPE_CHECKING:
-    from typing import Callable, Sequence
+    from collections.abc import Sequence
+    from typing import Callable
 
     from prompt_toolkit.key_binding.key_bindings import (
         KeyBindingsBase,
@@ -42,8 +44,9 @@ class PrintingContainer(Container):
     ) -> None:
         """Initiate the container."""
         self.width = width
-        self.rendered = False
         self._children = children
+        self._render_count = -1
+        self._cached_children: Sequence[AnyContainer] | None = None
         self.key_bindings = key_bindings
 
     def get_key_bindings(self) -> KeyBindingsBase | None:
@@ -53,7 +56,17 @@ class PrintingContainer(Container):
     @property
     def children(self) -> Sequence[AnyContainer]:
         """Return the container's children."""
-        children = self._children() if callable(self._children) else self._children
+        # Only load the children from a callable once per render cycle
+        if callable(self._children):
+            if (
+                self._cached_children is None
+                or self._render_count != get_app().render_counter
+            ):
+                self._cached_children = self._children()
+                self._render_count = get_app().render_counter
+            children = self._cached_children
+        else:
+            children = self._children
         return children or [Window()]
 
     def get_children(self) -> list[Container]: