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

euporie/core/widgets/menu.py

@@ -6,7 +6,8 @@ import logging
 from functools import partial
 from typing import TYPE_CHECKING
 
-from prompt_toolkit.filters import Condition, to_filter
+from prompt_toolkit.data_structures import Point
+from prompt_toolkit.filters import Condition, has_completions, is_done, to_filter
 from prompt_toolkit.formatted_text.base import to_formatted_text
 from prompt_toolkit.formatted_text.utils import (
     fragment_list_to_text,
@@ -18,9 +19,16 @@ from prompt_toolkit.layout.containers import (
     ConditionalContainer,
     Container,
     Float,
+    HSplit,
+    ScrollOffsets,
+    VSplit,
     Window,
 )
-from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.layout.controls import FormattedTextControl, UIContent
+from prompt_toolkit.layout.dimension import Dimension
+from prompt_toolkit.layout.menus import (
+    CompletionsMenuControl as PtkCompletionsMenuControl,
+)
 from prompt_toolkit.layout.utils import explode_text_fragments
 from prompt_toolkit.mouse_events import MouseEvent, MouseEventType
 from prompt_toolkit.utils import get_cwidth
@@ -38,11 +46,13 @@ if TYPE_CHECKING:
         OneStyleAndTextTuple,
         StyleAndTextTuples,
     )
+    from prompt_toolkit.key_binding.key_bindings import NotImplementedOrNone
     from prompt_toolkit.key_binding.key_processor import KeyPressEvent
 
     from euporie.core.app import BaseApp
     from euporie.core.border import GridStyle
     from euporie.core.commands import Command
+    from euporie.core.widgets.status_bar import StatusBarFields
 
 
 log = logging.getLogger(__name__)
@@ -254,203 +264,6 @@ class MenuItem:
 class MenuBar:
     """A container to hold the menubar and main application body."""
 
-    def _get_menu(self, level: int) -> MenuItem:
-        menu = self.menu_items[self.selected_menu[0]]
-
-        for i, index in enumerate(self.selected_menu[1:]):
-            if i < level:
-                try:
-                    menu = menu.children[index]
-                except IndexError:
-                    return MenuItem("debug")
-
-        return menu
-
-    def _get_menu_fragments(self) -> StyleAndTextTuples:
-        focused = get_app().layout.has_focus(self.window)
-
-        # This is called during the rendering. When we discover that this
-        # widget doesn't have the focus anymore. Reset menu state.
-        if not focused:
-            self.selected_menu = [0]
-
-        def mouse_handler(index: int, mouse_event: MouseEvent) -> None:
-            hover = mouse_event.event_type == MouseEventType.MOUSE_MOVE
-            if mouse_event.event_type == MouseEventType.MOUSE_DOWN or hover and focused:
-                # Toggle focus.
-                app = get_app()
-                if not hover:
-                    if app.layout.has_focus(self.window):
-                        if self.selected_menu == [index]:
-                            app.layout.focus_last()
-                    else:
-                        app.layout.focus(self.window)
-                self.selected_menu = [index]
-
-        results: StyleAndTextTuples = []
-        used_keys = set()
-
-        for i, item in enumerate(self.menu_items):
-            # Add shortcut key hints
-            key = to_plain_text(item.formatted_text)[0].lower()
-            ft: StyleAndTextTuples
-            if key not in used_keys:
-                ft = explode_text_fragments(item.formatted_text)
-                ft = [(f"underline {ft[0][0]}", ft[0][1]), *ft[1:]]
-                used_keys |= {key}
-            else:
-                ft = item.formatted_text
-
-            mh = partial(mouse_handler, i)
-            selected = i == self.selected_menu[0] and focused
-            style = "class:selection" if selected else ""
-            first_style = f"{style} [SetMenuPosition]" if selected else style
-
-            results.extend(
-                [
-                    (first_style, " ", mh),
-                    *[(f"{style} {style_}", text, mh) for style_, text, *_ in ft],
-                    (style, " ", mh),
-                ]
-            )
-
-        return results
-
-    def _submenu(self, level: int = 0) -> Window:
-        def get_text_fragments() -> StyleAndTextTuples:
-            result: StyleAndTextTuples = []
-            if level < len(self.selected_menu):
-                menu = self._get_menu(level)
-
-                if menu.children:
-                    result.extend(
-                        [
-                            ("class:menu,border", self.grid.TOP_LEFT),
-                            ("class:menu,border", self.grid.TOP_MID * menu.width),
-                            ("class:menu,border", self.grid.TOP_RIGHT),
-                            ("", "\n"),
-                        ]
-                    )
-
-                    try:
-                        selected_item = self.selected_menu[level + 1]
-                    except IndexError:
-                        selected_item = -1
-
-                    def one_item(
-                        i: int, item: MenuItem
-                    ) -> Iterable[OneStyleAndTextTuple]:
-                        assert isinstance(item, MenuItem)
-                        assert isinstance(menu, MenuItem)
-
-                        def mouse_handler(mouse_event: MouseEvent) -> None:
-                            if item.disabled:
-                                # The arrow keys can't interact with menu items that
-                                # are disabled. The mouse shouldn't be able to either.
-                                return
-                            hover = mouse_event.event_type == MouseEventType.MOUSE_MOVE
-                            if (
-                                mouse_event.event_type == MouseEventType.MOUSE_UP
-                                or hover
-                            ):
-                                app = get_app()
-                                if not hover and item.handler:
-                                    app.layout.focus_last()
-                                    item.handler()
-                                else:
-                                    self.selected_menu = self.selected_menu[
-                                        : level + 1
-                                    ] + [i]
-
-                        if item.separator:
-                            # Show a connected line with no mouse handler
-                            yield (
-                                "class:menu,border",
-                                self.grid.SPLIT_LEFT
-                                + (self.grid.SPLIT_MID * menu.width)
-                                + self.grid.SPLIT_RIGHT,
-                            )
-
-                        else:
-                            # Show the right edge
-                            style = ""
-                            # Set the style if disabled
-                            if item.disabled:
-                                style += "class:menu,disabled"
-                            # Set the style and cursor if selected
-                            if i == selected_item:
-                                style += "class:menu,selection"
-                            yield (f"{style} class:menu,border", self.grid.MID_LEFT)
-                            if i == selected_item:
-                                yield ("[SetCursorPosition]", "")
-                            # Construct the menu item contents
-                            prefix_padding = " " * (
-                                0
-                                if menu.collapse_prefix
-                                else menu.prefix_width
-                                - fragment_list_width(item.prefix)
-                            )
-                            suffix_padding = " " * (
-                                menu.width
-                                - fragment_list_width(item.prefix)
-                                - len(prefix_padding)
-                                - fragment_list_width(item.formatted_text)
-                                - (
-                                    fragment_list_width(item.suffix)
-                                    if menu.collapse_suffix
-                                    else menu.suffix_width
-                                )
-                            )
-                            text_padding = " " * (
-                                menu.width
-                                - fragment_list_width(item.prefix)
-                                - len(prefix_padding)
-                                - fragment_list_width(item.formatted_text)
-                                - fragment_list_width(item.suffix)
-                                - len(suffix_padding)
-                            )
-                            menu_formatted_text: StyleAndTextTuples = to_formatted_text(
-                                [
-                                    *item.prefix,
-                                    ("", prefix_padding),
-                                    *item.formatted_text,
-                                    ("", text_padding),
-                                    ("", suffix_padding),
-                                    *item.suffix,
-                                ],
-                                style=style,
-                            )
-                            # Apply mouse handler to all fragments
-                            menu_formatted_text = [
-                                (fragment[0], fragment[1], mouse_handler)
-                                for fragment in menu_formatted_text
-                            ]
-                            # Show the menu item contents
-                            yield from menu_formatted_text
-                            # Position the sub-menu
-                            if i == selected_item:
-                                yield ("[SetMenuPosition]", "")
-                            # Show the right edge
-                            yield (f"{style} class:menu,border", self.grid.MID_RIGHT)
-
-                        yield ("", "\n")
-
-                    for i, item in enumerate(menu.children):
-                        if not item.hidden():
-                            result.extend(one_item(i, item))
-
-                    result.extend(
-                        [
-                            ("class:menu,border", self.grid.BOTTOM_LEFT),
-                            ("class:menu,border", self.grid.BOTTOM_MID * menu.width),
-                            ("class:menu,border", self.grid.BOTTOM_RIGHT),
-                        ]
-                    )
-
-            return result
-
-        return Window(FormattedTextControl(get_text_fragments), style="class:menu")
-
     def __init__(
         self,
         app: BaseApp,
@@ -495,7 +308,10 @@ class MenuBar:
 
         @kb.add("down", filter=in_main_menu)
         def _down(event: KeyPressEvent) -> None:
-            self.selected_menu.append(0)
+            menu = self._get_menu(len(self.selected_menu) - 2)
+            indices = [i for i, item in enumerate(menu.children) if not item.disabled]
+            if indices:
+                self.selected_menu.append(indices[0])
 
         @kb.add("c-c", filter=in_main_menu)
         @kb.add("c-g", filter=in_main_menu)
@@ -540,7 +356,7 @@ class MenuBar:
             previous_indexes = [
                 i
                 for i, item in enumerate(menu.children)
-                if i < index and not item.disabled
+                if i < index and not item.disabled and not item.hidden()
             ]
 
             if previous_indexes:
@@ -558,7 +374,7 @@ class MenuBar:
             next_indexes = [
                 i
                 for i, item in enumerate(menu.children)
-                if i > index and not item.disabled
+                if i > index and not item.disabled and not item.hidden()
             ]
 
             if next_indexes:
@@ -607,9 +423,7 @@ class MenuBar:
             show_cursor=False,
         )
         self.window: Window = Window(
-            height=1,
-            content=self.control,
-            style="class:menu,bar",
+            height=1, content=self.control, style="class:menu,bar"
         )
 
         submenu = self._submenu(0)
@@ -628,31 +442,242 @@ class MenuBar:
             ),
         )
         self.app.menus["menu-2"] = Float(
-            attach_to_window=submenu,
+            attach_to_window=submenu.get_children()[1],
             xcursor=True,
             ycursor=True,
             allow_cover_cursor=True,
             content=ConditionalContainer(
                 content=Shadow(body=submenu2),
-                filter=has_focus & Condition(lambda: len(self.selected_menu) >= 1),
+                filter=has_focus
+                & Condition(lambda: len(self.selected_menu) > 1)
+                & Condition(lambda: bool(self._get_menu(1).children)),
             ),
         )
         self.app.menus["menu-3"] = Float(
-            attach_to_window=submenu2,
+            attach_to_window=submenu2.get_children()[1],
             xcursor=True,
             ycursor=True,
             allow_cover_cursor=True,
             content=ConditionalContainer(
                 content=Shadow(body=submenu3),
-                filter=has_focus & Condition(lambda: len(self.selected_menu) >= 2),
+                filter=has_focus
+                & Condition(lambda: len(self.selected_menu) > 2)
+                & Condition(lambda: bool(self._get_menu(2).children)),
             ),
         )
 
-        get_app().container_statuses[self.window] = self.statusbar_fields
+    def _get_menu(self, level: int) -> MenuItem:
+        menu = self.menu_items[self.selected_menu[0]]
+        for i, index in enumerate(self.selected_menu[1:]):
+            if i < level:
+                try:
+                    menu = menu.children[index]
+                except IndexError:
+                    return MenuItem("debug")
+        return menu
+
+    def _get_menu_fragments(self) -> StyleAndTextTuples:
+        focused = get_app().layout.has_focus(self.window)
 
-    def statusbar_fields(
-        self,
-    ) -> tuple[list[AnyFormattedText], list[AnyFormattedText]]:
+        # This is called during the rendering. When we discover that this
+        # widget doesn't have the focus anymore. Reset menu state.
+        if not focused:
+            self.selected_menu = [0]
+
+        def mouse_handler(index: int, mouse_event: MouseEvent) -> NotImplementedOrNone:
+            hover = mouse_event.event_type == MouseEventType.MOUSE_MOVE
+            if mouse_event.event_type == MouseEventType.MOUSE_DOWN or hover and focused:
+                # Toggle focus.
+                app = get_app()
+                if not hover:
+                    if app.layout.has_focus(self.window):
+                        if self.selected_menu == [index]:
+                            app.layout.focus_last()
+                    else:
+                        app.layout.focus(self.window)
+                self.selected_menu = [index]
+                return None
+            return NotImplemented
+
+        results: StyleAndTextTuples = []
+        used_keys = set()
+
+        for i, item in enumerate(self.menu_items):
+            # Add shortcut key hints
+            key = to_plain_text(item.formatted_text)[0].lower()
+            ft: StyleAndTextTuples
+            if key not in used_keys:
+                ft = explode_text_fragments(item.formatted_text)
+                ft = [(f"underline {ft[0][0]}", ft[0][1]), *ft[1:]]
+                used_keys |= {key}
+            else:
+                ft = item.formatted_text
+
+            mh = partial(mouse_handler, i)
+            selected = i == self.selected_menu[0] and focused
+            style = "class:selection" if selected else ""
+            first_style = f"{style} [SetMenuPosition]" if selected else style
+
+            results.extend(
+                [
+                    (first_style, " ", mh),
+                    *[(f"{style} {style_}", text, mh) for style_, text, *_ in ft],
+                    (style, " ", mh),
+                ]
+            )
+
+        return results
+
+    def _submenu(self, level: int = 0) -> Container:
+        grid = self.grid
+
+        def get_text_fragments() -> StyleAndTextTuples:
+            result: StyleAndTextTuples = []
+            if level < len(self.selected_menu):
+                menu = self._get_menu(level)
+
+                if menu.children:
+                    try:
+                        selected_item = self.selected_menu[level + 1]
+                    except IndexError:
+                        selected_item = -1
+
+                    def one_item(
+                        i: int, item: MenuItem
+                    ) -> Iterable[OneStyleAndTextTuple]:
+                        assert isinstance(item, MenuItem)
+                        assert isinstance(menu, MenuItem)
+
+                        def mouse_handler(mouse_event: MouseEvent) -> None:
+                            if item.disabled:
+                                # The arrow keys can't interact with menu items that
+                                # are disabled. The mouse shouldn't be able to either.
+                                return
+                            hover = mouse_event.event_type == MouseEventType.MOUSE_MOVE
+                            if (
+                                mouse_event.event_type == MouseEventType.MOUSE_UP
+                                or hover
+                            ):
+                                app = get_app()
+                                if not hover and item.handler:
+                                    app.layout.focus_last()
+                                    item.handler()
+                                else:
+                                    self.selected_menu = self.selected_menu[
+                                        : level + 1
+                                    ] + [i]
+
+                        if item.separator:
+                            # Show a connected line with no mouse handler
+                            yield (
+                                "class:menu,border",
+                                grid.SPLIT_LEFT
+                                + (grid.SPLIT_MID * menu.width)
+                                + grid.SPLIT_RIGHT,
+                            )
+
+                        else:
+                            # Show the right edge
+                            style = ""
+                            # Set the style if disabled
+                            if item.disabled:
+                                style += "class:menu,disabled"
+                            # Set the style and cursor if selected
+                            if i == selected_item:
+                                style += "class:menu,selection"
+                            yield (f"{style} class:menu,border", grid.MID_LEFT)
+                            if i == selected_item:
+                                yield ("[SetCursorPosition]", "")
+                            # Construct the menu item contents
+                            prefix_padding = " " * (
+                                0
+                                if menu.collapse_prefix
+                                else menu.prefix_width
+                                - fragment_list_width(item.prefix)
+                            )
+                            suffix_padding = " " * (
+                                menu.width
+                                - fragment_list_width(item.prefix)
+                                - len(prefix_padding)
+                                - fragment_list_width(item.formatted_text)
+                                - (
+                                    fragment_list_width(item.suffix)
+                                    if menu.collapse_suffix
+                                    else menu.suffix_width
+                                )
+                            )
+                            text_padding = " " * (
+                                menu.width
+                                - fragment_list_width(item.prefix)
+                                - len(prefix_padding)
+                                - fragment_list_width(item.formatted_text)
+                                - fragment_list_width(item.suffix)
+                                - len(suffix_padding)
+                            )
+                            menu_formatted_text: StyleAndTextTuples = to_formatted_text(
+                                [
+                                    *item.prefix,
+                                    ("", prefix_padding),
+                                    *item.formatted_text,
+                                    ("", text_padding),
+                                    ("", suffix_padding),
+                                    *item.suffix,
+                                ],
+                                style=style,
+                            )
+                            # Apply mouse handler to all fragments
+                            menu_formatted_text = [
+                                (fragment[0], fragment[1], mouse_handler)
+                                for fragment in menu_formatted_text
+                            ]
+                            # Show the menu item contents
+                            yield from menu_formatted_text
+                            # Position the sub-menu
+                            if i == selected_item:
+                                yield ("[SetMenuPosition]", "")
+                            # Show the right edge
+                            yield (f"{style} class:menu,border", grid.MID_RIGHT)
+
+                    for i, item in enumerate(menu.children):
+                        if not item.hidden():
+                            result.extend(one_item(i, item))
+                            if i < len(menu.children) - 1:
+                                result.append(("", "\n"))
+
+            return result
+
+        return HSplit(
+            [
+                VSplit(
+                    [
+                        Window(char=grid.TOP_LEFT, width=1, height=1),
+                        Window(char=grid.TOP_MID, height=1),
+                        Window(char=grid.TOP_RIGHT, width=1, height=1),
+                    ],
+                    style="class:border",
+                ),
+                Window(
+                    FormattedTextControl(get_text_fragments),
+                    scroll_offsets=ScrollOffsets(top=1, bottom=1),
+                ),
+                VSplit(
+                    [
+                        Window(char=grid.BOTTOM_LEFT, width=1, height=1),
+                        Window(char=grid.BOTTOM_MID, height=1),
+                        # Window(char="🭑🭆", height=1),
+                        Window(char=grid.BOTTOM_RIGHT, width=1, height=1),
+                    ],
+                    style="class:border",
+                ),
+            ],
+            style="class:menu",
+        )
+
+    def __pt_container__(self) -> Container:
+        """Return the menu bar container's content."""
+        return self.window
+
+    def __pt_status__(self) -> StatusBarFields:
         """Return the description of the currently selected menu item."""
         selected_item = self._get_menu(len(self.selected_menu) - 1)
         if isinstance(selected_item, MenuItem):
@@ -660,6 +685,133 @@ class MenuBar:
         else:
             return (["", ""], [])
 
-    def __pt_container__(self) -> Container:
-        """Return the menu bar container's content."""
-        return self.window
+
+class CompletionsMenuControl(PtkCompletionsMenuControl):
+    """A custom completions menu control."""
+
+    def create_content(self, width: int, height: int) -> UIContent:
+        """Create a UIContent object for this control."""
+        complete_state = get_app().current_buffer.complete_state
+        if complete_state:
+            completions = complete_state.completions
+            index = complete_state.complete_index  # Can be None!
+
+            # Calculate width of completions menu.
+            menu_width = self._get_menu_width(width, complete_state)
+            menu_meta_width = self._get_menu_meta_width(
+                width - menu_width, complete_state
+            )
+            total_width = menu_width + menu_meta_width
+
+            grid = OuterHalfGrid
+
+            def get_line(i: int) -> StyleAndTextTuples:
+                c = completions[i]
+                selected_item = i == index
+                output: StyleAndTextTuples = []
+
+                style = "class:menu"
+                if selected_item:
+                    style += ",selection"
+
+                output.append((f"{style},border", grid.MID_LEFT))
+                if selected_item:
+                    output.append(("[SetCursorPosition]", ""))
+                # Construct the menu item contents
+                padding = " " * (
+                    total_width
+                    - fragment_list_width(c.display)
+                    - fragment_list_width(c.display_meta)
+                    - 2
+                )
+                output.extend(
+                    to_formatted_text(
+                        [
+                            *c.display,
+                            ("", padding),
+                            *to_formatted_text(
+                                c.display_meta, style=f"{style} {c.style}"
+                            ),
+                        ],
+                        style=style,
+                    )
+                )
+                output.append((f"{style},border", grid.MID_RIGHT))
+
+                # Apply mouse handler
+                output = [
+                    (fragment[0], fragment[1], self.mouse_handler)
+                    for fragment in output
+                ]
+
+                return output
+
+            return UIContent(
+                get_line=get_line,
+                cursor_position=Point(x=0, y=index or 0),
+                line_count=len(completions),
+            )
+
+        return UIContent()
+
+    def mouse_handler(self, mouse_event: MouseEvent) -> NotImplementedOrNone:
+        """Handle mouse events: clicking and scrolling."""
+        if mouse_event.event_type == MouseEventType.MOUSE_MOVE:
+            # Set completion
+            complete_state = get_app().current_buffer.complete_state
+            if complete_state:
+                complete_state.complete_index = mouse_event.position.y
+                return None
+
+        return super().mouse_handler(mouse_event)
+
+
+class CompletionsMenu(ConditionalContainer):
+    """A custom completions menu."""
+
+    def __init__(
+        self,
+        max_height: int | None = 16,
+        scroll_offset: int | Callable[[], int] = 1,
+        extra_filter: FilterOrBool = True,
+        z_index: int = 10**8,
+    ) -> None:
+        """Create a completions menu with borders."""
+        extra_filter = to_filter(extra_filter)
+        grid = OuterHalfGrid
+        super().__init__(
+            content=HSplit(
+                [
+                    VSplit(
+                        [
+                            Window(char=grid.TOP_LEFT, width=1, height=1),
+                            Window(char=grid.TOP_MID, height=1),
+                            Window(char=grid.TOP_RIGHT, width=1, height=1),
+                        ],
+                        style="class:border",
+                    ),
+                    Window(
+                        content=CompletionsMenuControl(),
+                        width=Dimension(min=8),
+                        height=Dimension(min=1, max=max_height),
+                        scroll_offsets=ScrollOffsets(
+                            top=scroll_offset, bottom=scroll_offset
+                        ),
+                        dont_extend_width=True,
+                        z_index=z_index,
+                    ),
+                    VSplit(
+                        [
+                            Window(char=grid.BOTTOM_LEFT, width=1, height=1),
+                            Window(char=grid.BOTTOM_MID, height=1),
+                            Window(char=grid.BOTTOM_RIGHT, width=1, height=1),
+                        ],
+                        style="class:border",
+                    ),
+                ],
+                style="class:menu",
+            ),
+            # Show when there are completions but not at the point we are
+            # returning the input.
+            filter=has_completions & ~is_done & extra_filter,
+        )