euporie 2.6.2__py3-none-any.whl → 2.7.0__py3-none-any.whl

euporie/core/widgets/decor.py

@@ -5,207 +5,34 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING
 
-from prompt_toolkit.cache import FastDictCache
-from prompt_toolkit.filters import has_focus, to_filter
+from prompt_toolkit.filters import to_filter
 from prompt_toolkit.layout.containers import (
     ConditionalContainer,
-    Container,
     DynamicContainer,
     Float,
     FloatContainer,
-    HSplit,
-    VSplit,
-    Window,
-    to_container,
 )
-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.border import ThinLine
 from euporie.core.config import add_setting
 from euporie.core.current import get_app
 from euporie.core.data_structures import DiBool
-from euporie.core.style import ColorPaletteColor
+from euporie.core.layout.containers import HSplit, VSplit, Window
+from euporie.core.layout.decor import DropShadow
 
 if TYPE_CHECKING:
     from typing import Callable
 
-    from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.layout.containers import AnyContainer
-    from prompt_toolkit.layout.mouse_handlers import MouseHandlers
     from prompt_toolkit.mouse_events import MouseEvent
 
     from euporie.core.border import GridStyle
-    from euporie.core.style import ColorPalette
 
     MouseHandler = Callable[[MouseEvent], object]
 
 log = logging.getLogger(__name__)
 
 
-class Line(Container):
-    """Draw a horizontal or vertical line."""
-
-    def __init__(
-        self,
-        char: str | None = None,
-        width: int | None = None,
-        height: int | None = None,
-        collapse: bool = False,
-        style: str = "class:grid-line",
-    ) -> None:
-        """Initialize a grid line.
-
-        Args:
-            char: The character to draw. If unset, the relevant character from
-                :py:class:`euporie.core.box.grid` is used
-            width: The length of the line. If specified, the line will be horizontal
-            height: The height of the line. If specified, the line will be vertical
-            collapse: Whether to hide the line when there is not enough space
-            style: Style to apply to the line
-
-        Raises:
-            ValueError: If both width and height are specified. A line must only have a
-                single dimension.
-
-        """
-        if width and height:
-            raise ValueError("Only one of `width` or `height` must be set")
-        self.width = width
-        self.height = height
-        if char is None:
-            char = ThinLine.grid.VERTICAL if width else ThinLine.grid.HORIZONTAL
-        self.char = Char(char, style)
-        self.collapse = collapse
-
-    def reset(self) -> None:
-        """Reet the state of the line. Does nothing."""
-
-    def preferred_width(self, max_available_width: int) -> Dimension:
-        """Return the preferred width of the line."""
-        return Dimension(min=int(not self.collapse), max=self.width)
-
-    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
-        """Return the preferred height of the line."""
-        return Dimension(min=int(not self.collapse), max=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:
-        """Draw a continuous line in the ``write_position`` area.
-
-        Args:
-            screen: The :class:`~prompt_toolkit.layout.screen.Screen` class to which
-                the output has to be written.
-            mouse_handlers: :class:`prompt_toolkit.layout.mouse_handlers.MouseHandlers`.
-            write_position: A :class:`prompt_toolkit.layout.screen.WritePosition` object
-                defining where this container should be drawn.
-            erase_bg: If true, the background will be erased prior to drawing.
-            parent_style: Style string to pass to the :class:`.Window` object. This will
-                be applied to all content of the windows. :class:`.VSplit` and
-                :class:`prompt_toolkit.layout.containers.HSplit` can use it to pass
-                their style down to the windows that they contain.
-            z_index: Used for propagating z_index from parent to child.
-
-        """
-        ypos = write_position.ypos
-        xpos = write_position.xpos
-
-        for y in range(ypos, ypos + write_position.height):
-            row = screen.data_buffer[y]
-            for x in range(xpos, xpos + write_position.width):
-                row[x] = self.char
-
-    def get_children(self) -> list:
-        """Return an empty list of the container's children."""
-        return []
-
-
-class Pattern(Container):
-    """Fill an area with a repeating background pattern."""
-
-    def __init__(
-        self,
-        char: str | Callable[[], str],
-        pattern: int | Callable[[], int] = 1,
-    ) -> None:
-        """Initialize the :class:`Pattern`."""
-        self.bg = Char(" ", "class:pattern")
-        self.char = char
-        self.pattern = pattern
-
-    def reset(self) -> None:
-        """Reet the pattern. Does nothing."""
-
-    def preferred_width(self, max_available_width: int) -> Dimension:
-        """Return an empty dimension (expand to available width)."""
-        return Dimension()
-
-    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
-        """Return an empty dimension (expand to available height)."""
-        return Dimension()
-
-    def write_to_screen(
-        self,
-        screen: Screen,
-        mouse_handlers: MouseHandlers,
-        write_position: WritePosition,
-        parent_style: str,
-        erase_bg: bool,
-        z_index: int | None,
-    ) -> None:
-        """Fill the whole area of write_position with a pattern.
-
-        Args:
-            screen: The :class:`~prompt_toolkit.layout.screen.Screen` class to which
-                the output has to be written.
-            mouse_handlers: :class:`prompt_toolkit.layout.mouse_handlers.MouseHandlers`.
-            write_position: A :class:`prompt_toolkit.layout.screen.WritePosition` object
-                defining where this container should be drawn.
-            erase_bg: If true, the background will be erased prior to drawing.
-            parent_style: Style string to pass to the :class:`.Window` object. This will
-                be applied to all content of the windows. :class:`.VSplit` and
-                :class:`prompt_toolkit.layout.containers.HSplit` can use it to pass
-                their style down to the windows that they contain.
-            z_index: Used for propagating z_index from parent to child.
-
-        """
-        bg = self.bg
-        pattern = self.pattern() if callable(self.pattern) else self.pattern
-        if callable(self.char):
-            char = Char(self.char(), "class:pattern")
-        else:
-            char = Char(self.char, "class:pattern")
-
-        ypos = write_position.ypos
-        xpos = write_position.xpos
-
-        for y in range(ypos, ypos + write_position.height):
-            row = screen.data_buffer[y]
-            for x in range(xpos, xpos + write_position.width):
-                if (
-                    (pattern == 1)
-                    or (pattern == 2 and (x + y) % 2 == 0)
-                    or (pattern == 3 and (x + 2 * y) % 4 == 0)
-                    or (pattern == 4 and (x + y) % 3 == 0)
-                    or (pattern == 5 and ((x + y % 2 * 3) % 6) % 4 == 0)
-                ):
-                    row[x] = char
-                else:
-                    row[x] = bg
-
-    def get_children(self) -> list:
-        """Return an empty list of the container's children."""
-        return []
-
-
 class Border:
     """Draw a border around any container."""
 
@@ -353,189 +180,6 @@ class Border:
         return self.container
 
 
-class FocusedStyle(Container):
-    """Apply a style to child containers when focused or hovered."""
-
-    def __init__(
-        self,
-        body: AnyContainer,
-        style_focus: str | Callable[[], str] = "class:focused",
-        style_hover: str | Callable[[], str] = "",
-    ) -> None:
-        """Create a new instance of the widget.
-
-        Args:
-            body: The container to act on
-            style_focus: The style to apply when the body has focus
-            style_hover: The style to apply when the body is hovered
-        """
-        self.body = body
-        self.style_focus = style_focus
-        self.style_hover = style_hover
-        self.hover = False
-        self.has_focus = has_focus(self.body)
-
-    def reset(self) -> None:
-        """Reet the wrapped container."""
-        to_container(self.body).reset()
-
-    def preferred_width(self, max_available_width: int) -> Dimension:
-        """Return the wrapped container's preferred width."""
-        return to_container(self.body).preferred_width(max_available_width)
-
-    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
-        """Return the wrapped container's preferred height."""
-        return to_container(self.body).preferred_height(width, max_available_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:
-        """Draw the wrapped container with the additional style."""
-        to_container(self.body).write_to_screen(
-            screen,
-            mouse_handlers,
-            write_position,
-            f"{parent_style} {self.get_style()}",
-            erase_bg,
-            z_index,
-        )
-
-        if self.style_hover:
-            x_min = write_position.xpos
-            x_max = x_min + write_position.width
-            y_min = write_position.ypos
-            y_max = y_min + write_position.height
-
-            # Wrap mouse handlers to add "hover" class on hover
-            def _wrap_mouse_handler(handler: Callable) -> MouseHandler:
-                def wrapped_mouse_handler(
-                    mouse_event: MouseEvent,
-                ) -> NotImplementedOrNone:
-                    result = handler(mouse_event)
-
-                    if mouse_event.event_type == MouseEventType.MOUSE_MOVE:
-                        app = get_app()
-                        if (
-                            mouse_event.position.x,
-                            mouse_event.position.y,
-                        ) == app.mouse_position:
-                            app.mouse_limits = write_position
-                            self.hover = True
-                        else:
-                            app.mouse_limits = None
-                            self.hover = False
-                        result = None
-                    return result
-
-                return wrapped_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):
-                    row[x] = mouse_handler_wrappers[(row[x],)]
-
-    def get_style(self) -> str:
-        """Determine the style to apply depending on the focus status."""
-        style = ""
-        if self.has_focus():
-            style += (
-                self.style_focus() if callable(self.style_focus) else self.style_focus
-            )
-        if self.hover:
-            style += " " + (
-                self.style_hover() if callable(self.style_hover) else self.style_hover
-            )
-        return style
-
-    def get_children(self) -> list[Container]:
-        """Return the list of child :class:`.Container` objects."""
-        return [to_container(self.body)]
-
-
-class DropShadow(Container):
-    """A transparent container which makes the background darker."""
-
-    def __init__(self, amount: float = 0.5) -> None:
-        """Create a new instance."""
-        self.amount = amount
-        self.renderer = get_app().renderer
-
-    @property
-    def cp(self) -> ColorPalette:
-        """Get the current app's current color palette."""
-        return get_app().color_palette
-
-    def reset(self) -> None:
-        """Reet the wrapped container - here, do nothing."""
-
-    def preferred_width(self, max_available_width: int) -> Dimension:
-        """Return the wrapped container's preferred width."""
-        return Dimension(weight=1)
-
-    def preferred_height(self, width: int, max_available_height: int) -> Dimension:
-        """Return the wrapped container's preferred height."""
-        return Dimension(weight=1)
-
-    def write_to_screen(
-        self,
-        screen: Screen,
-        mouse_handlers: MouseHandlers,
-        write_position: WritePosition,
-        parent_style: str,
-        erase_bg: bool,
-        z_index: int | None,
-    ) -> None:
-        """Draw the wrapped container with the additional style."""
-        attr_cache = self.renderer._attrs_for_style
-        if attr_cache is not None:
-            ypos = write_position.ypos
-            xpos = write_position.xpos
-            amount = self.amount
-            for y in range(ypos, ypos + write_position.height):
-                row = screen.data_buffer[y]
-                for x in range(xpos, xpos + write_position.width):
-                    char = row[x]
-                    style = char.style
-                    attrs = attr_cache[style]
-
-                    if not (fg := attrs.color) or fg == "default":
-                        color = self.cp.fg
-                        style += f" fg:{color.darker(amount)}"
-                    else:
-                        try:
-                            color = ColorPaletteColor(fg)
-                        except ValueError:
-                            pass
-                        else:
-                            style += f" fg:{color.darker(amount)}"
-
-                    if not (bg := attrs.bgcolor) or bg == "default":
-                        color = self.cp.bg
-                        style += f" bg:{color.darker(amount)}"
-                    else:
-                        try:
-                            color = ColorPaletteColor(bg)
-                        except ValueError:
-                            pass
-                        else:
-                            style += f" bg:{color.darker(amount)}"
-
-                    row[x] = Char(char=char.char, style=style)
-
-    def get_children(self) -> list[Container]:
-        """Return an empty list of child :class:`.Container` objects."""
-        return []
-
-
 class Shadow:
     """Draw a shadow underneath/behind this container.
 

euporie/core/widgets/dialog.py

@@ -27,15 +27,12 @@ from prompt_toolkit.layout.containers import (
     ConditionalContainer,
     DynamicContainer,
     Float,
-    HSplit,
-    VSplit,
-    Window,
 )
 from prompt_toolkit.layout.controls import FormattedTextControl, UIContent, UIControl
 from prompt_toolkit.layout.dimension import Dimension
 from prompt_toolkit.layout.screen import WritePosition
 from prompt_toolkit.mouse_events import MouseButton, MouseEventType
-from prompt_toolkit.widgets.base import Box, Label
+from prompt_toolkit.widgets.base import Label
 
 from euporie.core.app import get_app
 from euporie.core.border import (
@@ -47,10 +44,13 @@ from euporie.core.commands import add_cmd
 from euporie.core.filters import tab_has_focus
 from euporie.core.ft.utils import FormattedTextAlign, align, lex
 from euporie.core.key_binding.registry import register_bindings
+from euporie.core.layout.containers import HSplit, VSplit, Window
+from euporie.core.layout.decor import FocusedStyle
 from euporie.core.tabs.base import Tab
-from euporie.core.widgets.decor import Border, FocusedStyle, Shadow
+from euporie.core.widgets.decor import Border, Shadow
 from euporie.core.widgets.file_browser import FileBrowser
 from euporie.core.widgets.forms import Button, LabelledWidget, Select, Text
+from euporie.core.widgets.layout import Box
 
 if TYPE_CHECKING:
     from typing import Any, Callable, Hashable

euporie/core/widgets/display.py

@@ -3,14 +3,15 @@
 from __future__ import annotations
 
 import logging
+from functools import partial
 from math import ceil
 from typing import TYPE_CHECKING, cast
 
-from prompt_toolkit.cache import FastDictCache
+from prompt_toolkit.cache import FastDictCache, SimpleCache
 from prompt_toolkit.data_structures import Point, Size
 from prompt_toolkit.filters.utils import to_filter
 from prompt_toolkit.formatted_text.utils import fragment_list_width, split_lines
-from prompt_toolkit.layout.containers import ConditionalContainer, VSplit, Window
+from prompt_toolkit.layout.containers import ConditionalContainer
 from prompt_toolkit.layout.controls import GetLinePrefixCallable, UIContent, UIControl
 from prompt_toolkit.mouse_events import MouseEvent, MouseEventType
 from prompt_toolkit.utils import Event, to_str
@@ -23,15 +24,14 @@ from euporie.core.filters import (
     scrollable,
 )
 from euporie.core.ft.utils import wrap
+from euporie.core.graphics import GraphicProcessor
 from euporie.core.key_binding.registry import (
     load_registered_bindings,
     register_bindings,
 )
+from euporie.core.layout.containers import VSplit, Window
 from euporie.core.margins import MarginContainer, ScrollbarMargin
 from euporie.core.utils import run_in_thread_with_context
-from euporie.core.widgets.graphics import (
-    GraphicProcessor,
-)
 
 if TYPE_CHECKING:
     from typing import Any, Callable, Iterable
@@ -96,10 +96,17 @@ class DisplayControl(UIControl):
             self.on_cursor_position_changed,
         ]
 
+        # Caches
+        self._content_cache: FastDictCache = FastDictCache(self.get_content, size=1000)
         self._line_cache: FastDictCache[
             tuple[Datum, int | None, int | None, bool], list[StyleAndTextTuples]
-        ] = FastDictCache(get_value=self.get_lines, size=100_000)
-        self._content_cache: FastDictCache = FastDictCache(self.get_content, size=1_000)
+        ] = FastDictCache(get_value=self.get_lines, size=1000)
+        self._line_width_cache: SimpleCache[
+            tuple[Datum, int | None, int | None, bool, int], int
+        ] = SimpleCache(maxsize=10_000)
+        self._max_line_width_cache: FastDictCache[
+            tuple[Datum, int | None, int | None, bool], int
+        ] = FastDictCache(get_value=self.get_max_line_width, size=1000)
 
     @property
     def datum(self) -> Any:
@@ -157,6 +164,23 @@ class DisplayControl(UIControl):
             lines.extend([[]] * max(0, height - len(lines)))
         return lines
 
+    def get_max_line_width(
+        self,
+        datum: Datum,
+        width: int | None,
+        height: int | None,
+        wrap_lines: bool = False,
+    ) -> int:
+        """Get the maximum lines width for a given rendering."""
+        lines = self._line_cache[datum, width, height, wrap_lines]
+        return max(
+            self._line_width_cache.get(
+                (datum, width, height, wrap_lines, i),
+                partial(fragment_list_width, line),
+            )
+            for i, line in enumerate(lines)
+        )
+
     def render(self) -> None:
         """Render the HTML DOM in a thread."""
         datum = self.datum
@@ -167,7 +191,6 @@ class DisplayControl(UIControl):
         rows = ceil(cols * aspect) if aspect else self.height
 
         def _render() -> None:
-            # Potentially redirect url
             self.lines = self._line_cache[datum, cols, rows, wrap_lines]
             self.loading = False
             self.resizing = False
@@ -189,11 +212,9 @@ class DisplayControl(UIControl):
         max_cols, aspect = self.datum.cell_size()
         if max_cols:
             return min(max_cols, max_available_width)
-        self.lines = self._line_cache[
+        return self._max_line_width_cache[
             self.datum, max_available_width, None, self.wrap_lines()
         ]
-        return max(fragment_list_width(line) for line in self.lines)
-        return max_available_width
 
     def preferred_height(
         self,
@@ -206,7 +227,6 @@ class DisplayControl(UIControl):
         max_cols, aspect = self.datum.cell_size()
         if aspect:
             return ceil(min(width, max_cols) * aspect)
-
         self.lines = self._line_cache[self.datum, width, None, self.wrap_lines()]
         return len(self.lines)
 

euporie/core/widgets/file_browser.py

@@ -14,9 +14,6 @@ from prompt_toolkit.filters.utils import to_filter
 from prompt_toolkit.key_binding.key_bindings import KeyBindings, KeyBindingsBase
 from prompt_toolkit.layout.containers import (
     ConditionalContainer,
-    HSplit,
-    VSplit,
-    Window,
 )
 from prompt_toolkit.layout.controls import UIContent, UIControl
 from prompt_toolkit.layout.screen import WritePosition
@@ -27,8 +24,10 @@ from upath import UPath
 from euporie.core.app import get_app
 from euporie.core.border import InsetGrid
 from euporie.core.config import add_setting
+from euporie.core.layout.containers import HSplit, VSplit, Window
+from euporie.core.layout.decor import FocusedStyle
 from euporie.core.margins import MarginContainer, ScrollbarMargin
-from euporie.core.widgets.decor import Border, FocusedStyle
+from euporie.core.widgets.decor import Border
 from euporie.core.widgets.forms import Button, Text
 
 if TYPE_CHECKING:

euporie/core/widgets/forms.py

@@ -44,7 +44,7 @@ from prompt_toolkit.layout.utils import explode_text_fragments
 from prompt_toolkit.mouse_events import MouseButton, MouseEvent, MouseEventType
 from prompt_toolkit.utils import Event
 from prompt_toolkit.validation import Validator
-from prompt_toolkit.widgets.base import Box, TextArea
+from prompt_toolkit.widgets.base import TextArea
 
 from euporie.core.border import InsetGrid
 from euporie.core.current import get_app
@@ -52,7 +52,7 @@ from euporie.core.data_structures import DiBool
 from euporie.core.ft.utils import FormattedTextAlign, align
 from euporie.core.margins import MarginContainer, ScrollbarMargin
 from euporie.core.widgets.decor import Border, Shadow
-from euporie.core.widgets.layout import ConditionalSplit
+from euporie.core.widgets.layout import Box, ConditionalSplit
 
 if TYPE_CHECKING:
     from typing import Any, Callable, Sequence
@@ -240,7 +240,12 @@ class Button:
         if mouse_event.button == MouseButton.LEFT:
             if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
                 self.selected = True
-                if (render_info := self.window.render_info) is not None:
+                # Set global mouse capture
+                if (
+                    self.window is not None
+                    and (render_info := self.window.render_info) is not None
+                    and render_info._rowcol_to_yx
+                ):
                     y_min, x_min = min(render_info._rowcol_to_yx.values())
                     y_max, x_max = max(render_info._rowcol_to_yx.values())
                     get_app().mouse_limits = WritePosition(
@@ -632,6 +637,19 @@ class Text:
             key_bindings=self.text_area.control.key_bindings,
             expand=expand,
         )
+        window = self.text_area.window
+        self.text_area.window = Window(
+            height=window.height,
+            width=window.width,
+            dont_extend_height=window.dont_extend_height,
+            dont_extend_width=window.dont_extend_width,
+            content=self.text_area.control,
+            style=window.style,
+            wrap_lines=window.wrap_lines,
+            left_margins=window.left_margins,
+            right_margins=window.right_margins,
+            get_line_prefix=window.get_line_prefix,
+        )
         self.text_area.window.content = self.text_area.control
 
         if on_text_changed:
@@ -1568,18 +1586,21 @@ class ToggleButtons(SelectableWidget):
 
     def load_container(self) -> AnyContainer:
         """Load the widget's container."""
-        if self.vertical():
-            show_borders_values = [
-                DiBool(False, True, False, True) for _ in self.options
-            ]
-            show_borders_values[0] = show_borders_values[0]._replace(top=True)
-            show_borders_values[-1] = show_borders_values[-1]._replace(bottom=True)
+        if self.options:
+            if self.vertical():
+                show_borders_values = [
+                    DiBool(False, True, False, True) for _ in self.options
+                ]
+                show_borders_values[0] = show_borders_values[0]._replace(top=True)
+                show_borders_values[-1] = show_borders_values[-1]._replace(bottom=True)
+            else:
+                show_borders_values = [
+                    DiBool(True, False, True, False) for _ in self.options
+                ]
+                show_borders_values[0] = show_borders_values[0]._replace(left=True)
+                show_borders_values[-1] = show_borders_values[-1]._replace(right=True)
         else:
-            show_borders_values = [
-                DiBool(True, False, True, False) for _ in self.options
-            ]
-            show_borders_values[0] = show_borders_values[0]._replace(left=True)
-            show_borders_values[-1] = show_borders_values[-1]._replace(right=True)
+            show_borders_values = []
         self.buttons = [
             ToggleButton(
                 text=label,
@@ -1825,6 +1846,7 @@ class SliderControl(UIControl):
             if (
                 self.window is not None
                 and (render_info := self.window.render_info) is not None
+                and render_info._rowcol_to_yx
             ):
                 y_min, x_min = min(render_info._rowcol_to_yx.values())
                 y_max, x_max = max(render_info._rowcol_to_yx.values())