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

euporie/core/key_binding/bindings/__init__.py

@@ -1,5 +1,11 @@
 """Define collections of generic key-bindings which do not belong to widgets."""
 
-from euporie.core.key_binding.bindings import basic, completion, micro, mouse
+from euporie.core.key_binding.bindings import (
+    basic,
+    completion,
+    micro,
+    mouse,
+    page_navigation,
+)
 
-__all__ = ["basic", "completion", "micro", "mouse"]
+__all__ = ["basic", "completion", "micro", "mouse", "page_navigation"]

euporie/core/key_binding/bindings/basic.py

@@ -32,15 +32,14 @@ log = logging.getLogger(__name__)
 class TextEntry:
     """Basic key-bindings for text entry."""
 
-
-# Register default bindings for micro edit mode
-register_bindings(
-    {
-        "euporie.core.key_binding.bindings.basic.TextEntry": {
-            "type-key": "<any>",
-        },
-    }
-)
+    # Register default bindings for micro edit mode
+    register_bindings(
+        {
+            "euporie.core.key_binding.bindings.basic.TextEntry": {
+                "type-key": "<any>",
+            },
+        }
+    )
 
 
 def load_basic_bindings(config: Config | None = None) -> KeyBindingsBase:
@@ -56,11 +55,7 @@ def load_basic_bindings(config: Config | None = None) -> KeyBindingsBase:
 # Commands
 
 
-@add_cmd(
-    filter=buffer_has_focus,
-    save_before=if_no_repeat,
-    hidden=True,
-)
+@add_cmd(filter=buffer_has_focus, save_before=if_no_repeat, hidden=True)
 def type_key(event: KeyPressEvent) -> None:
     """Enter a key."""
     # Do not insert escape sequences

euporie/core/key_binding/bindings/micro.py

@@ -36,8 +36,6 @@ from prompt_toolkit.key_binding.bindings.scroll import (
     scroll_half_page_up,
     scroll_one_line_down,
     scroll_one_line_up,
-    scroll_page_down,
-    scroll_page_up,
 )
 from prompt_toolkit.keys import Keys
 from prompt_toolkit.selection import SelectionState, SelectionType
@@ -160,8 +158,6 @@ register_bindings(
             "duplicate-selection": "c-d",
             "paste-clipboard": "c-v",
             "select-all": "c-a",
-            "scroll-page-up": "pageup",
-            "scroll-page-down": "pagedown",
             "delete": "delete",
             "toggle-case": "f4",
             "toggle-overwrite-mode": "insert",
@@ -310,14 +306,6 @@ add_cmd(
     title="Scroll up one line",
     filter=buffer_has_focus,
 )(scroll_one_line_up)
-add_cmd(
-    title="Scroll one one page",
-    filter=buffer_has_focus,
-)(scroll_page_down)
-add_cmd(
-    title="Scroll up one page",
-    filter=buffer_has_focus,
-)(scroll_page_up)
 
 
 @add_cmd(

euporie/core/key_binding/bindings/mouse.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, NamedTuple
 
+from prompt_toolkit.cache import FastDictCache
 from prompt_toolkit.data_structures import Point
 from prompt_toolkit.key_binding.bindings.mouse import (
     MOUSE_MOVE,
@@ -59,99 +60,131 @@ class MouseEvent(PtkMouseEvent):
         self.cell_position = cell_position or RelativePosition(0.5, 0.5)
 
 
+def _parse_mouse_data(
+    data: str, sgr_pixels: bool, cell_size_xy: tuple[int, int]
+) -> MouseEvent | None:
+    """Convert key-press data to a mouse event."""
+    rx = ry = 0.5
+
+    # Parse incoming packet.
+    if data[2] == "M":
+        # Typical.
+        mouse_event, x, y = map(ord, data[3:])
+
+        # TODO: Is it possible to add modifiers here?
+        mouse_button, mouse_event_type, mouse_modifiers = typical_mouse_events[
+            mouse_event
+        ]
+
+        # Handle situations where `PosixStdinReader` used surrogateescapes.
+        if x >= 0xDC00:
+            x -= 0xDC00
+        if y >= 0xDC00:
+            y -= 0xDC00
+
+        x -= 32
+        y -= 32
+    else:
+        # Urxvt and Xterm SGR.
+        # When the '<' is not present, we are not using the Xterm SGR mode,
+        # but Urxvt instead.
+        data = data[2:]
+        if data[:1] == "<":
+            sgr = True
+            data = data[1:]
+        else:
+            sgr = False
+
+        # Extract coordinates.
+        mouse_event, x, y = map(int, data[:-1].split(";"))
+        m = data[-1]
+
+        # Parse event type.
+        if sgr:
+            if sgr_pixels:
+                # Calculate cell position
+                cell_x, cell_y = cell_size_xy
+                px, py = x, y
+                fx, fy = px / cell_x + 1, py / cell_y + 1
+                x, y = int(fx), int(fy)
+                rx, ry = fx - x, fy - y
+
+            try:
+                (
+                    mouse_button,
+                    mouse_event_type,
+                    mouse_modifiers,
+                ) = xterm_sgr_mouse_events[mouse_event, m]
+            except KeyError:
+                return None
+
+        else:
+            # Some other terminals, like urxvt, Hyper terminal, ...
+            (
+                mouse_button,
+                mouse_event_type,
+                mouse_modifiers,
+            ) = urxvt_mouse_events.get(
+                mouse_event, (UNKNOWN_BUTTON, MOUSE_MOVE, UNKNOWN_MODIFIER)
+            )
+
+    x -= 1
+    y -= 1
+
+    return MouseEvent(
+        position=Point(x=x, y=y),
+        event_type=mouse_event_type,
+        button=mouse_button,
+        modifiers=mouse_modifiers,
+        cell_position=RelativePosition(rx, ry),
+    )
+
+
+_MOUSE_EVENT_CACHE: FastDictCache[
+    tuple[str, bool, tuple[int, int]], MouseEvent | None
+] = FastDictCache(get_value=_parse_mouse_data)
+
+
 def load_mouse_bindings() -> KeyBindings:
     """Additional key-bindings to deal with SGR-pixel mouse positioning."""
     key_bindings = load_ptk_mouse_bindings()
 
-    @key_bindings.add(Keys.Vt100MouseEvent)
+    @key_bindings.add(Keys.Vt100MouseEvent, eager=True)
     def _(event: KeyPressEvent) -> NotImplementedOrNone:
         """Handle incoming mouse event, include SGR-pixel mode."""
-        # Ensure mypy knows this would only run in a euporie app
-        assert isinstance(event.app, BaseApp)
-
-        rx = ry = 0.5
+        # Ensure mypy knows this would only run in a euporie appo
+        assert isinstance(app := event.app, BaseApp)
 
-        # Parse incoming packet.
-        if event.data[2] == "M":
-            # Typical.
-            mouse_event, x, y = map(ord, event.data[3:])
+        if not event.app.renderer.height_is_known:
+            return NotImplemented
 
-            # TODO: Is it possible to add modifiers here?
-            mouse_button, mouse_event_type, mouse_modifiers = typical_mouse_events[
-                mouse_event
-            ]
+        mouse_event = _MOUSE_EVENT_CACHE[
+            event.data, app.term_info.sgr_pixel_status.value, app.term_info.cell_size_px
+        ]
 
-            # Handle situations where `PosixStdinReader` used surrogateescapes.
-            if x >= 0xDC00:
-                x -= 0xDC00
-            if y >= 0xDC00:
-                y -= 0xDC00
-
-            x -= 32
-            y -= 32
-        else:
-            # Urxvt and Xterm SGR.
-            # When the '<' is not present, we are not using the Xterm SGR mode,
-            # but Urxvt instead.
-            data = event.data[2:]
-            if data[:1] == "<":
-                sgr = True
-                data = data[1:]
-            else:
-                sgr = False
-
-            # Extract coordinates.
-            mouse_event, x, y = map(int, data[:-1].split(";"))
-            m = data[-1]
-
-            # Parse event type.
-            if sgr:
-                if event.app.term_info.sgr_pixel_status.value:
-                    # Calculate cell position
-                    cell_px, cell_py = event.app.term_info.cell_size_px
-                    px, py = x, y
-                    fx, fy = px / cell_px + 1, py / cell_py + 1
-                    x, y = int(fx), int(fy)
-                    rx, ry = fx - x, fy - y
-
-                try:
-                    (
-                        mouse_button,
-                        mouse_event_type,
-                        mouse_modifiers,
-                    ) = xterm_sgr_mouse_events[mouse_event, m]
-                except KeyError:
-                    return NotImplemented
-
-            else:
-                # Some other terminals, like urxvt, Hyper terminal, ...
-                (
-                    mouse_button,
-                    mouse_event_type,
-                    mouse_modifiers,
-                ) = urxvt_mouse_events.get(
-                    mouse_event, (UNKNOWN_BUTTON, MOUSE_MOVE, UNKNOWN_MODIFIER)
-                )
-
-        x -= 1
-        y -= 1
+        if mouse_event is None:
+            return NotImplemented
 
         # Only handle mouse events when we know the window height.
-        if event.app.renderer.height_is_known and mouse_event_type is not None:
+        if mouse_event.event_type is not None:
             # Take region above the layout into account. The reported
             # coordinates are absolute to the visible part of the terminal.
             from prompt_toolkit.renderer import HeightIsUnknownError
 
+            x, y = mouse_event.position
+
             try:
-                y -= event.app.renderer.rows_above_layout
+                rows_above = app.renderer.rows_above_layout
             except HeightIsUnknownError:
                 return NotImplemented
+            else:
+                y -= rows_above
 
             # Save global mouse position
-            event.app.mouse_position = Point(x=x, y=y)
+            app.mouse_position = mouse_event.position
 
             # Apply limits to mouse position if enabled
-            if (mouse_limits := event.app.mouse_limits) is not None:
+            if (mouse_limits := app.mouse_limits) is not None:
                 x = max(
                     mouse_limits.xpos,
                     min(x, mouse_limits.xpos + (mouse_limits.width - 1)),
@@ -161,6 +194,8 @@ def load_mouse_bindings() -> KeyBindings:
                     min(y, mouse_limits.ypos + (mouse_limits.height - 1)),
                 )
 
+            mouse_event.position = Point(x=x, y=y)
+
             # Call the mouse handler from the renderer.
             # Note: This can return `NotImplemented` if no mouse handler was
             #       found for this position, or if no repainting needs to
@@ -168,15 +203,7 @@ def load_mouse_bindings() -> KeyBindings:
             #       movements.
             handler = event.app.renderer.mouse_handlers.mouse_handlers[y][x]
 
-            return handler(
-                MouseEvent(
-                    position=Point(x=x, y=y),
-                    event_type=mouse_event_type,
-                    button=mouse_button,
-                    modifiers=mouse_modifiers,
-                    cell_position=RelativePosition(rx, ry),
-                )
-            )
+            return handler(mouse_event)
 
         return NotImplemented
 

euporie/core/key_binding/bindings/page_navigation.py

@@ -0,0 +1,129 @@
+"""Define page navigation key-bindings for buffers."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.application.current import get_app
+from prompt_toolkit.filters import buffer_has_focus
+from prompt_toolkit.key_binding.bindings.page_navigation import (
+    load_emacs_page_navigation_bindings,
+    load_vi_page_navigation_bindings,
+)
+from prompt_toolkit.key_binding.key_bindings import (
+    ConditionalKeyBindings,
+    merge_key_bindings,
+)
+
+from euporie.core.commands import add_cmd
+from euporie.core.filters import micro_mode
+from euporie.core.key_binding.registry import (
+    load_registered_bindings,
+    register_bindings,
+)
+
+if TYPE_CHECKING:
+    from prompt_toolkit.key_binding import KeyBindingsBase, KeyPressEvent
+
+    from euporie.core.config import Config
+
+log = logging.getLogger(__name__)
+
+
+class PageNavigation:
+    """Key-bindings for page navigation."""
+
+    # Register default bindings for micro edit mode
+    register_bindings(
+        {
+            "euporie.core.key_binding.bindings.page_navigation.PageNavigation": {
+                "scroll-page-up": "pageup",
+                "scroll-page-down": "pagedown",
+            },
+        }
+    )
+
+
+def load_page_navigation_bindings(config: Config | None = None) -> KeyBindingsBase:
+    """Load page navigation key-bindings for text entry."""
+    return ConditionalKeyBindings(
+        merge_key_bindings(
+            [
+                load_emacs_page_navigation_bindings(),
+                load_vi_page_navigation_bindings(),
+                ConditionalKeyBindings(
+                    load_registered_bindings(
+                        "euporie.core.key_binding.bindings.page_navigation.PageNavigation",
+                        config=config,
+                    ),
+                    micro_mode,
+                ),
+            ]
+        ),
+        buffer_has_focus,
+    )
+
+
+# Commands
+
+
+@add_cmd(filter=buffer_has_focus, hidden=True)
+def scroll_page_down(event: KeyPressEvent) -> None:
+    """Scroll page down (prefer the cursor at the top of the page, after scrolling)."""
+    w = event.app.layout.current_window
+    b = event.app.current_buffer
+
+    if w and w.render_info:
+        # Scroll down one page.
+        line_index = b.document.cursor_position_row
+        page = w.render_info.window_height
+
+        if (
+            (screen := get_app().renderer._last_screen)
+            and (wp := screen.visible_windows_to_write_positions.get(w))
+            and (bbox := getattr(wp, "bbox", None))
+        ):
+            page -= bbox.top + bbox.bottom
+
+        line_index = max(line_index + page, w.vertical_scroll + 1)
+        w.vertical_scroll = line_index
+
+        b.cursor_position = b.document.translate_row_col_to_index(line_index, 0)
+        b.cursor_position += b.document.get_start_of_line_position(
+            after_whitespace=True
+        )
+
+
+@add_cmd(filter=buffer_has_focus, hidden=True)
+def scroll_page_up(event: KeyPressEvent) -> None:
+    """Scroll page up (prefer the cursor at the bottom of the page, after scrolling)."""
+    w = event.app.layout.current_window
+    b = event.app.current_buffer
+
+    if w and w.render_info:
+        line_index = b.document.cursor_position_row
+        page = w.render_info.window_height
+
+        if (
+            (screen := get_app().renderer._last_screen)
+            and (wp := screen.visible_windows_to_write_positions.get(w))
+            and (bbox := getattr(wp, "bbox", None))
+        ):
+            page -= bbox.top + bbox.bottom
+
+        # Put cursor at the first visible line. (But make sure that the cursor
+        # moves at least one line up.)
+        line_index = max(
+            0,
+            min(line_index - page, b.document.cursor_position_row - 1),
+        )
+
+        b.cursor_position = b.document.translate_row_col_to_index(line_index, 0)
+        b.cursor_position += b.document.get_start_of_line_position(
+            after_whitespace=True
+        )
+
+        # Set the scroll offset. We can safely set it to zero; the Window will
+        # make sure that it scrolls at least until the cursor becomes visible.
+        w.vertical_scroll = 0

euporie/core/key_binding/key_processor.py

@@ -67,6 +67,7 @@ class KeyProcessor(PtKeyProcessor):
     def process_keys(self) -> None:
         """Process all the keys in the input queue."""
         app = get_app()
+        input_queue = self.input_queue
 
         def not_empty() -> bool:
             # When the application result is set, stop processing keys.  (E.g.
@@ -86,7 +87,14 @@ class KeyProcessor(PtKeyProcessor):
                 self.input_queue.remove(cpr)
                 return cpr
             else:
-                return self.input_queue.popleft()
+                return input_queue.popleft()
+
+        # Throttle repeated mouse events - limit to 10 per flush
+        if len(input_queue) >= 10 and not any(
+            input_queue[i].key != Keys.Vt100MouseEvent for i in range(10)
+        ):
+            for _ in range(len(input_queue) - 10):
+                input_queue.popleft()
 
         is_flush = False
 

euporie/core/layout/__init__.py

@@ -0,0 +1 @@
+"""Contains containers and controls relating to layout."""