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

euporie/core/{widgets/graphics.py → graphics.py}

@@ -25,17 +25,13 @@ from euporie.core.convert.datum import Datum
 from euporie.core.convert.registry import find_route
 from euporie.core.current import get_app
 from euporie.core.data_structures import DiInt
-from euporie.core.filters import (
-    has_dialog,
-    has_menus,
-    in_tmux,
-)
+from euporie.core.filters import has_dialog, has_menus, in_mplex
 from euporie.core.ft.utils import _ZERO_WIDTH_FRAGMENTS
-from euporie.core.terminal import tmuxify
-from euporie.core.widgets.page import BoundedWritePosition
+from euporie.core.layout.scroll import BoundedWritePosition
+from euporie.core.terminal import passthrough
 
 if TYPE_CHECKING:
-    from typing import Any, Callable
+    from typing import Any, Callable, ClassVar
 
     from prompt_toolkit.filters import FilterOrBool
     from prompt_toolkit.formatted_text import StyleAndTextTuples
@@ -82,6 +78,11 @@ class GraphicControl(UIControl, metaclass=ABCMeta):
         self.rendered_lines = self.get_rendered_lines(width, max_available_height)
         return len(self.rendered_lines)
 
+    @abstractmethod
+    def convert_data(self, wp: WritePosition) -> str:
+        """Convert datum to required format."""
+        return ""
+
     @abstractmethod
     def get_rendered_lines(
         self, width: int, height: int, wrap_lines: bool = False
@@ -146,81 +147,91 @@ class GraphicControl(UIControl, metaclass=ABCMeta):
 class SixelGraphicControl(GraphicControl):
     """A graphic control which displays images as sixels."""
 
+    def convert_data(self, wp: WritePosition) -> str:
+        """Convert datum to required format."""
+        bbox = wp.bbox if isinstance(wp, BoundedWritePosition) else DiInt(0, 0, 0, 0)
+        full_width = wp.width + bbox.left + bbox.right
+        full_height = wp.height + bbox.top + bbox.bottom
+        cmd = str(
+            self.datum.convert(
+                to="sixel",
+                cols=full_width,
+                rows=full_height,
+            )
+        )
+        if any(self.bbox):
+            from sixelcrop import sixelcrop
+
+            cell_size_x, cell_size_y = self.app.term_info.cell_size_px
+
+            cmd = sixelcrop(
+                data=cmd,
+                # Horizontal pixel offset of the displayed image region
+                x=bbox.left * cell_size_x,
+                # Vertical pixel offset of the displayed image region
+                y=bbox.top * cell_size_y,
+                # Pixel width of the displayed image region
+                w=wp.width * cell_size_x,
+                # Pixel height of the displayed image region
+                h=wp.height * cell_size_y,
+            )
+
+        return cmd
+
     def get_rendered_lines(
         self, width: int, height: int, wrap_lines: bool = False
     ) -> list[StyleAndTextTuples]:
         """Get rendered lines from the cache, or generate them."""
-        cell_size_x, cell_size_y = self.app.term_info.cell_size_px
 
         def render_lines() -> list[StyleAndTextTuples]:
             """Render the lines to display in the control."""
-            full_width = width + self.bbox.left + self.bbox.right
-            full_height = height + self.bbox.top + self.bbox.bottom
-            cmd = str(
-                self.datum.convert(
-                    to="sixel",
-                    cols=full_width,
-                    rows=full_height,
+            ft: list[StyleAndTextTuples] = []
+            if height:
+                cmd = self.convert_data(
+                    BoundedWritePosition(0, 0, width, height, self.bbox)
                 )
-            )
-            if any(self.bbox):
-                from sixelcrop import sixelcrop
-
-                cmd = sixelcrop(
-                    data=cmd,
-                    # Horizontal pixel offset of the displayed image region
-                    x=self.bbox.left * cell_size_x,
-                    # Vertical pixel offset of the displayed image region
-                    y=self.bbox.top * cell_size_y,
-                    # Pixel width of the displayed image region
-                    w=width * cell_size_x,
-                    # Pixel height of the displayed image region
-                    h=height * cell_size_y,
-                )
-
-            if self.app.config.tmux_graphics:
-                cmd = tmuxify(cmd)
-
-            return list(
-                split_lines(
-                    to_formatted_text(
-                        [
-                            # Move cursor down and across by image height and width
-                            ("", "\n".join((height) * [" " * (width)])),
-                            # Save position, then move back
-                            ("[ZeroWidthEscape]", "\x1b[s"),
-                            # Move cursor up if there is more than one line to display
-                            *(
-                                [("[ZeroWidthEscape]", f"\x1b[{height-1}A")]
-                                if height > 1
-                                else []
-                            ),
-                            ("[ZeroWidthEscape]", f"\x1b[{width}D"),
-                            # Place the image without moving cursor
-                            ("[ZeroWidthEscape]", cmd),
-                            # Restore the last known cursor position (at the bottom)
-                            ("[ZeroWidthEscape]", "\x1b[u"),
-                        ]
+                ft.extend(
+                    split_lines(
+                        to_formatted_text(
+                            [
+                                # Move cursor down and across by image height and width
+                                ("", "\n".join((height) * [" " * (width)])),
+                                # Save position, then move back
+                                ("[ZeroWidthEscape]", "\x1b[s"),
+                                # Move cursor up if there is more than one line to display
+                                *(
+                                    [("[ZeroWidthEscape]", f"\x1b[{height-1}A")]
+                                    if height > 1
+                                    else []
+                                ),
+                                ("[ZeroWidthEscape]", f"\x1b[{width}D"),
+                                # Place the image without moving cursor
+                                ("[ZeroWidthEscape]", passthrough(cmd)),
+                                # Restore the last known cursor position (at the bottom)
+                                ("[ZeroWidthEscape]", "\x1b[u"),
+                            ]
+                        )
                     )
                 )
-            )
+            return ft
 
-        key = (width, self.bbox, (cell_size_x, cell_size_y))
+        key = (width, self.bbox, self.app.term_info.cell_size_px)
         return self._format_cache.get(key, render_lines)
 
 
 class ItermGraphicControl(GraphicControl):
     """A graphic control which displays images using iTerm's graphics protocol."""
 
-    def convert_data(self, rows: int, cols: int) -> str:
+    def convert_data(self, wp: WritePosition) -> str:
         """Convert the graphic's data to base64 data."""
         datum = self.datum
 
-        full_width = cols + self.bbox.left + self.bbox.right
-        full_height = rows + self.bbox.top + self.bbox.bottom
+        bbox = wp.bbox if isinstance(wp, BoundedWritePosition) else DiInt(0, 0, 0, 0)
+        full_width = wp.width + bbox.left + bbox.right
+        full_height = wp.height + bbox.top + bbox.bottom
 
         # Crop image if necessary
-        if any(self.bbox):
+        if any(bbox):
             import io
 
             image = datum.convert(
@@ -232,14 +243,12 @@ class ItermGraphicControl(GraphicControl):
                 cell_size_x, cell_size_y = self.app.term_info.cell_size_px
                 # Downscale image to fit target region for precise cropping
                 image.thumbnail((full_width * cell_size_x, full_height * cell_size_y))
-                image = image.crop(
-                    (
-                        self.bbox.left * cell_size_x,  # left
-                        self.bbox.top * cell_size_y,  # top
-                        (self.bbox.left + cols) * cell_size_x,  # right
-                        (self.bbox.top + rows) * cell_size_y,  # bottom
-                    )
-                )
+                left = self.bbox.left * cell_size_x
+                top = self.bbox.top * cell_size_y
+                right = (self.bbox.left + wp.width) * cell_size_x
+                bottom = (self.bbox.top + wp.height) * cell_size_y
+                upper, lower = sorted((top, bottom))
+                image = image.crop((left, upper, right, lower))
                 with io.BytesIO() as output:
                     image.save(output, format="PNG")
                     datum = Datum(data=output.getvalue(), format="png")
@@ -261,42 +270,46 @@ class ItermGraphicControl(GraphicControl):
 
         def render_lines() -> list[StyleAndTextTuples]:
             """Render the lines to display in the control."""
-            b64data = self.convert_data(cols=width, rows=height)
-            cmd = f"\x1b]1337;File=inline=1;width={width}:{b64data}\a"
-            return list(
-                split_lines(
-                    to_formatted_text(
-                        [
-                            # Move cursor down and across by image height and width
-                            ("", "\n".join((height) * [" " * (width)])),
-                            # Save position, then move back
-                            ("[ZeroWidthEscape]", "\x1b[s"),
-                            # Move cursor up if there is more than one line to display
-                            *(
-                                [("[ZeroWidthEscape]", f"\x1b[{height-1}A")]
-                                if height > 1
-                                else []
-                            ),
-                            ("[ZeroWidthEscape]", f"\x1b[{width}D"),
-                            # Place the image without moving cursor
-                            ("[ZeroWidthEscape]", tmuxify(cmd)),
-                            # Restore the last known cursor position (at the bottom)
-                            ("[ZeroWidthEscape]", "\x1b[u"),
-                        ]
+            ft: list[StyleAndTextTuples] = []
+            if height:
+                b64data = self.convert_data(
+                    BoundedWritePosition(0, 0, width, height, self.bbox)
+                )
+                cmd = f"\x1b]1337;File=inline=1;width={width}:{b64data}\a"
+                ft.extend(
+                    split_lines(
+                        to_formatted_text(
+                            [
+                                # Move cursor down and across by image height and width
+                                ("", "\n".join((height) * [" " * (width)])),
+                                # Save position, then move back
+                                ("[ZeroWidthEscape]", "\x1b[s"),
+                                # Move cursor up if there is more than one line to display
+                                *(
+                                    [("[ZeroWidthEscape]", f"\x1b[{height-1}A")]
+                                    if height > 1
+                                    else []
+                                ),
+                                ("[ZeroWidthEscape]", f"\x1b[{width}D"),
+                                # Place the image without moving cursor
+                                ("[ZeroWidthEscape]", passthrough(cmd)),
+                                # Restore the last known cursor position (at the bottom)
+                                ("[ZeroWidthEscape]", "\x1b[u"),
+                            ]
+                        )
                     )
                 )
-            )
+            return ft
 
         key = (width, self.bbox, self.app.term_info.cell_size_px)
         return self._format_cache.get(key, render_lines)
 
 
-_kitty_image_count = 1
-
-
 class KittyGraphicControl(GraphicControl):
     """A graphic control which displays images using Kitty's graphics protocol."""
 
+    _kitty_image_count: ClassVar[int] = 1
+
     def __init__(
         self,
         datum: Datum,
@@ -307,14 +320,48 @@ class KittyGraphicControl(GraphicControl):
         super().__init__(datum=datum, scale=scale, bbox=bbox)
         self.kitty_image_id = 0
         self.loaded = False
+        self._datum_pad_cache: FastDictCache[
+            tuple[Datum, int, int], Datum
+        ] = FastDictCache(get_value=self._pad_datum, size=1)
+
+    def _pad_datum(self, datum: Datum, cell_size_x: int, cell_size_y: int) -> Datum:
+        from PIL import ImageOps
+
+        px, py = datum.pixel_size()
 
-    def convert_data(self, rows: int, cols: int) -> str:
+        if px and py:
+            target_width = int((px + cell_size_x - 1) // cell_size_x * cell_size_x)
+            target_height = int((py + cell_size_y - 1) // cell_size_y * cell_size_y)
+
+            image = ImageOps.pad(
+                datum.convert("pil").convert("RGBA"),
+                (target_width, target_height),
+                centering=(0, 0),
+            )
+            datum = Datum(
+                image,
+                format="pil",
+                fg=datum.fg,
+                bg=datum.bg,
+                px=target_width,
+                py=target_height,
+                path=datum.path,
+                align=datum.align,
+            )
+        return datum
+
+    def convert_data(self, wp: WritePosition) -> str:
         """Convert the graphic's data to base64 data for kitty graphics protocol."""
+        bbox = wp.bbox if isinstance(wp, BoundedWritePosition) else DiInt(0, 0, 0, 0)
+        full_width = wp.width + bbox.left + bbox.right
+        full_height = wp.height + bbox.top + bbox.bottom
+
+        datum = self._datum_pad_cache[(self.datum, *self.app.term_info.cell_size_px)]
         return str(
-            self.datum.convert(
+            datum.convert(
                 to="base64-png",
-                cols=cols,
-                rows=rows,
+                cols=full_width,
+                rows=full_height,
             )
         ).replace("\n", "")
 
@@ -331,11 +378,13 @@ class KittyGraphicControl(GraphicControl):
 
     def load(self, rows: int, cols: int) -> None:
         """Send the graphic to the terminal without displaying it."""
-        global _kitty_image_count
+        # global _kitty_image_count
 
-        data = self.convert_data(rows=rows, cols=cols)
-        self.kitty_image_id = _kitty_image_count
-        _kitty_image_count += 1
+        data = self.convert_data(
+            BoundedWritePosition(0, 0, width=cols, height=rows, bbox=self.bbox)
+        )
+        self.kitty_image_id = self._kitty_image_count
+        KittyGraphicControl._kitty_image_count += 1
 
         while data:
             chunk, data = data[:4096], data[4096:]
@@ -351,7 +400,7 @@ class KittyGraphicControl(GraphicControl):
                 C=1,  # Do not move the cursor
                 m=1 if data else 0,  # Data will be chunked
             )
-            self.app.output.write_raw(tmuxify(cmd))
+            self.app.output.write_raw(passthrough(cmd))
         self.app.output.flush()
         self.loaded = True
 
@@ -359,7 +408,7 @@ class KittyGraphicControl(GraphicControl):
         """Hide the graphic from show without deleting it."""
         if self.kitty_image_id > 0:
             self.app.output.write_raw(
-                tmuxify(
+                passthrough(
                     self._kitty_cmd(
                         a="d",
                         d="i",
@@ -374,7 +423,7 @@ class KittyGraphicControl(GraphicControl):
         """Delete the graphic from the terminal."""
         if self.kitty_image_id > 0:
             self.app.output.write_raw(
-                tmuxify(
+                passthrough(
                     self._kitty_cmd(
                         a="D",
                         d="I",
@@ -395,59 +444,64 @@ class KittyGraphicControl(GraphicControl):
         if not self.loaded:
             self.load(cols=width, rows=height)
 
-        px, py = self.datum.pixel_size()
-        if not px or not py:
-            log.warning("Cannot determine image size")
-            px, py = px or 100, py or 100
+        cell_size_px = self.app.term_info.cell_size_px
+        datum = self._datum_pad_cache[(self.datum, *cell_size_px)]
+        px, py = datum.pixel_size()
+
+        px = px or 100
+        py = py or 100
 
         def render_lines() -> list[StyleAndTextTuples]:
             """Render the lines to display in the control."""
-            full_width = width + self.bbox.left + self.bbox.right
-            full_height = height + self.bbox.top + self.bbox.bottom
-            cmd = self._kitty_cmd(
-                a="p",  # Display a previously transmitted image
-                i=self.kitty_image_id,
-                p=1,  # Placement ID
-                m=0,  # No batches remaining
-                q=2,  # No backchat
-                c=width,
-                r=height,
-                C=1,  # 1 = Do move the cursor
-                # Horizontal pixel offset of the displayed image region
-                x=int(px * self.bbox.left / full_width),
-                # Vertical pixel offset of the displayed image region
-                y=int(py * self.bbox.top / full_height),
-                # Pixel width of the displayed image region
-                w=int(px * width / full_width),
-                # Pixel height of the displayed image region
-                h=int(py * height / full_height),
-                # z=-(2**30) - 1,
-            )
-            return list(
-                split_lines(
-                    to_formatted_text(
-                        [
-                            # Move cursor down and acoss by image height and width
-                            ("", "\n".join((height) * [" " * (width)])),
-                            # Save position, then move back
-                            ("[ZeroWidthEscape]", "\x1b[s"),
-                            # Move cursor up if there is more than one line to display
-                            *(
-                                [("[ZeroWidthEscape]", f"\x1b[{height-1}A")]
-                                if height > 1
-                                else []
-                            ),
-                            ("[ZeroWidthEscape]", f"\x1b[{width}D"),
-                            # Place the image without moving cursor
-                            ("[ZeroWidthEscape]", tmuxify(cmd)),
-                            # Restore the last known cursor position (at the bottom)
-                            ("[ZeroWidthEscape]", "\x1b[u"),
-                        ]
+            ft: list[StyleAndTextTuples] = []
+            if height:
+                full_width = width + self.bbox.left + self.bbox.right
+                full_height = height + self.bbox.top + self.bbox.bottom
+                cmd = self._kitty_cmd(
+                    a="p",  # Display a previously transmitted image
+                    i=self.kitty_image_id,
+                    p=1,  # Placement ID
+                    m=0,  # No batches remaining
+                    q=2,  # No backchat
+                    c=width,
+                    r=height,
+                    C=1,  # 1 = Do move the cursor
+                    # Horizontal pixel offset of the displayed image region
+                    x=int(px * self.bbox.left / full_width),
+                    # Vertical pixel offset of the displayed image region
+                    y=int(py * self.bbox.top / full_height),
+                    # Pixel width of the displayed image region
+                    w=int(px * width / full_width),
+                    # Pixel height of the displayed image region
+                    h=int(py * height / full_height),
+                    # z=-(2**30) - 1,
+                )
+                ft.extend(
+                    split_lines(
+                        to_formatted_text(
+                            [
+                                # Move cursor down and acoss by image height and width
+                                ("", "\n".join((height) * [" " * (width)])),
+                                # Save position, then move back
+                                ("[ZeroWidthEscape]", "\x1b[s"),
+                                # Move cursor up if there is more than one line to display
+                                *(
+                                    [("[ZeroWidthEscape]", f"\x1b[{height-1}A")]
+                                    if height > 1
+                                    else []
+                                ),
+                                ("[ZeroWidthEscape]", f"\x1b[{width}D"),
+                                # Place the image without moving cursor
+                                ("[ZeroWidthEscape]", passthrough(cmd)),
+                                # Restore the last known cursor position (at the bottom)
+                                ("[ZeroWidthEscape]", "\x1b[u"),
+                            ]
+                        )
                     )
                 )
-            )
+            return ft
 
-        key = (width, height, self.bbox, self.app.term_info.cell_size_px)
+        key = (width, height, self.bbox, cell_size_px)
         return self._format_cache.get(key, render_lines)
 
     def reset(self) -> None:
@@ -467,68 +521,6 @@ class NotVisible(Exception):
     """Exception to signal that a graphic is not currently visible."""
 
 
-def get_position_func_overlay(
-    target_window: Window,
-) -> Callable[[Screen], BoundedWritePosition]:
-    """Generate function to positioning floats over existing windows."""
-
-    def get_position(screen: Screen) -> BoundedWritePosition:
-        target_wp = screen.visible_windows_to_write_positions.get(target_window)
-        if target_wp is None:
-            raise NotVisible
-
-        render_info = target_window.render_info
-        if render_info is None:
-            raise NotVisible
-
-        xpos = target_wp.xpos
-        ypos = target_wp.ypos
-
-        content_height = render_info.ui_content.line_count
-        content_width = target_wp.width  # TODO - get the actual content width
-
-        # Calculate the cropping box in case the window is scrolled
-        bbox = DiInt(
-            top=render_info.vertical_scroll,
-            right=max(
-                0,
-                content_height
-                - target_wp.width
-                - getattr(render_info, "horizontal_scroll", 0),
-            ),
-            bottom=max(
-                0,
-                content_height - target_wp.height - render_info.vertical_scroll,
-            ),
-            left=getattr(render_info, "horizontal_scroll", 0),
-        )
-
-        # If the target is within a scrolling container, we might need to adjust
-        # the position of the cropped region so the float covers only the visible
-        # part of the target window
-        if isinstance(target_wp, BoundedWritePosition):
-            bbox = bbox._replace(
-                top=bbox.top + target_wp.bbox.top,
-                right=bbox.right + target_wp.bbox.right,
-                bottom=bbox.bottom + target_wp.bbox.bottom,
-                left=bbox.left + target_wp.bbox.left,
-            )
-            xpos += bbox.left
-            ypos += bbox.top
-            content_height -= bbox.top + bbox.bottom
-            content_width -= bbox.left + bbox.right
-
-        return BoundedWritePosition(
-            xpos=xpos,
-            ypos=ypos,
-            width=max(0, content_width),
-            height=max(0, content_height),
-            bbox=bbox,
-        )
-
-    return get_position
-
-
 class GraphicWindow(Window):
     """A window responsible for displaying terminal graphics content.
 
@@ -564,6 +556,7 @@ class GraphicWindow(Window):
         self.content = content
         self.get_position = get_position
         self.filter = ~has_completions & ~has_dialog & ~has_menus & to_filter(filter)
+        self._pre_rendered = False
 
     def write_to_screen(
         self,
@@ -575,6 +568,10 @@ class GraphicWindow(Window):
         z_index: int | None,
     ) -> None:
         """Draw the graphic window's contents to the screen if required."""
+        # Pre-convert datum for this write position so result is cached
+        if not self._pre_rendered:
+            self.content.convert_data(write_position)
+            self._pre_rendered = True
         filter_value = self.filter()
         if filter_value:
             try:
@@ -591,6 +588,8 @@ class GraphicWindow(Window):
                     and new_write_position.width
                     and new_write_position.height
                 ):
+                    # Do not pass the bbox on to the window when writing
+                    new_write_position.bbox = DiInt(0, 0, 0, 0)
                     super().write_to_screen(
                         screen,
                         MouseHandlers(),  # Do not let the float add mouse events
@@ -603,7 +602,7 @@ class GraphicWindow(Window):
                     return
 
         # Otherwise hide the content (required for kitty graphics)
-        if not filter_value or not get_app().leave_graphics():
+        if not get_app().leave_graphics():
             self.content.hide()
 
     def _fill_bg(
@@ -635,7 +634,7 @@ def select_graphic_control(format_: str) -> type[GraphicControl] | None:
     term_info = app.term_info
     preferred_graphics_protocol = app.config.graphics
     useable_graphics_controls: list[type[GraphicControl]] = []
-    _in_tmux = in_tmux()
+    _in_mplex = in_mplex()
 
     if preferred_graphics_protocol != "none":
         if term_info.iterm_graphics_status.value and find_route(format_, "base64-png"):
@@ -643,15 +642,15 @@ def select_graphic_control(format_: str) -> type[GraphicControl] | None:
         if (
             preferred_graphics_protocol == "iterm"
             and ItermGraphicControl in useable_graphics_controls
-            # Iterm does not work in tmux without pass-through
-            and (not _in_tmux or (_in_tmux and app.config.tmux_graphics))
+            # Iterm does not work in mplex without pass-through
+            and (not _in_mplex or (_in_mplex and app.config.mplex_graphics))
         ):
             SelectedGraphicControl = ItermGraphicControl
         elif (
             term_info.kitty_graphics_status.value
             and find_route(format_, "base64-png")
-            # Kitty does not work in tmux without pass-through
-            and (not _in_tmux or (_in_tmux and app.config.tmux_graphics))
+            # Kitty does not work in mplex without pass-through
+            and (not _in_mplex or (_in_mplex and app.config.mplex_graphics))
         ):
             useable_graphics_controls.append(KittyGraphicControl)
         if (
@@ -800,7 +799,7 @@ class GraphicProcessor:
 
         GraphicControl = select_graphic_control(format_=datum.format)
         if GraphicControl is None:
-            log.debug("Terminal graphics not supported or format not graphical")
+            # log.debug("Terminal graphics not supported or format not graphical")
             return None
 
         bg_color = datum.bg
@@ -809,15 +808,14 @@ class GraphicProcessor:
                 content=(graphic_control := GraphicControl(datum)),
                 get_position=self._get_position(key, rows, cols),
                 style=f"bg:{bg_color}" if bg_color else "",
-            ),
+                align=datum.align,
+            )
         )
         # Register graphic with application
-        app = self.app
-        if graphic_float:
-            app.graphics.add(graphic_float)
+        (app_graphics := self.app.graphics).add(graphic_float)
         # Hide the graphic from app if the float is deleted
         weak_float_ref = weakref.ref(graphic_float)
-        graphic_window.filter &= Condition(lambda: weak_float_ref() in app.graphics)
+        graphic_window.filter &= Condition(lambda: weak_float_ref() in app_graphics)
         # Hide the graphic from terminal if the float is deleted
         weakref.finalize(graphic_float, graphic_control.close)
 

euporie/core/io.py

@@ -84,6 +84,14 @@ class Vt100_Output(PtkVt100_Output):
         super().disable_mouse_support()
         self.write_raw("\x1b[?1016l")
 
+    def enable_private_sixel_colors(self) -> None:
+        """Enable private color registers for sixel graphics."""
+        self.write_raw("\x1b[1070h")
+
+    def disable_private_sixel_colors(self) -> None:
+        """Disable private color registers for sixel graphics."""
+        self.write_raw("\x1b[1070l")
+
     def enable_extended_keys(self) -> None:
         """Request extended keys."""
         # xterm