urwid 4.0.4__tar.gz → 4.0.5__tar.gz

{urwid-4.0.4/urwid.egg-info → urwid-4.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: urwid
-Version: 4.0.4
+Version: 4.0.5
 Summary: A full-featured console (xterm et al.) user interface library
 Author-email: Ian Ward <ian@excess.org>
 License-Expression: LGPL-2.1-only

{urwid-4.0.4 → urwid-4.0.5}/docs/changelog.rst

@@ -2,6 +2,33 @@
 Changelog
 ---------
 
+Urwid 4.0.5
+===========
+
+2026-07-20
+
+New features 🗹
++++++++++++++++
+* Copy signal handlers before emission by @Sanjays2402 in https://github.com/urwid/urwid/pull/1187
+* Implement `_scrollbar_layout` and left click handling for `Scrollable` by @penguinolog in https://github.com/urwid/urwid/pull/1192
+Bug fixes 🕷
+++++++++++++
+* Fix rle_product for zero-len elements by @penguinolog in https://github.com/urwid/urwid/pull/1191
+Documentation 🕮
+++++++++++++++++
+* typing: fix `Filler` typing annotations by @penguinolog in https://github.com/urwid/urwid/pull/1183
+* typing: extend widget_decoration module typing coverage by @penguinolog in https://github.com/urwid/urwid/pull/1184
+* Typing: annotate and fix attr_map by @penguinolog in https://github.com/urwid/urwid/pull/1186
+Refactoring 🛠
+++++++++++++++
+* Migrate `Edit` widget to use `WidgetWrap` as base class and update methods by @penguinolog in https://github.com/urwid/urwid/pull/1180
+
+New Contributors
+++++++++++++++++
+* @Sanjays2402 made their first contribution in https://github.com/urwid/urwid/pull/1187
+
+**Full Changelog**: https://github.com/urwid/urwid/compare/4.0.4...4.0.5
+
 Urwid 4.0.4
 ===========
 

urwid-4.0.5/ruff-requirements.txt

@@ -0,0 +1 @@
+ruff==0.15.22

{urwid-4.0.4 → urwid-4.0.5}/tests/test_scrollable.py

@@ -142,6 +142,72 @@ class TestScrollBarScrollable(unittest.TestCase):
 
         self.assertEqual(top_position_rendered, widget.render(reduced_size).decoded_text)
 
+    def test_mouse_left_click_scrollbar(self):
+        """Left click on the rendered scrollbar jumps to the clicked position."""
+        content = urwid.Text("\n".join(string.ascii_letters))  # 52 single-char lines
+        reduced_size = (3, 5)
+        widget = urwid.ScrollBar(urwid.Scrollable(content))
+        scrollable = widget.original_widget
+        scrollbar_col = reduced_size[0] - 1  # right side scrollbar
+
+        self.assertEqual(0, scrollable.get_scrollpos())
+
+        # posmax == 52 - 5 == 47, thumb_height == 1, thumb travel == 5 - 1 == 4.
+        # Clicking the bottom row moves past the end and is clamped to posmax.
+        self.assertTrue(widget.mouse_event(reduced_size, "mouse press", 1, scrollbar_col, 4, False))
+        self.assertEqual(47, scrollable.get_scrollpos())
+
+        # Clicking the top row scrolls back to the top.
+        self.assertTrue(widget.mouse_event(reduced_size, "mouse press", 1, scrollbar_col, 0, False))
+        self.assertEqual(0, scrollable.get_scrollpos())
+
+        # Intermediate rows map proportionally: round(row * posmax / travel).
+        self.assertTrue(widget.mouse_event(reduced_size, "mouse press", 1, scrollbar_col, 1, False))
+        self.assertEqual(12, scrollable.get_scrollpos())
+
+        self.assertTrue(widget.mouse_event(reduced_size, "mouse press", 1, scrollbar_col, 3, False))
+        self.assertEqual(35, scrollable.get_scrollpos())
+
+    def test_mouse_left_click_content_ignored(self):
+        """Left click outside of the scrollbar columns does not scroll."""
+        content = urwid.Text("\n".join(string.ascii_letters))
+        reduced_size = (3, 5)
+        widget = urwid.ScrollBar(urwid.Scrollable(content))
+        scrollable = widget.original_widget
+
+        self.assertEqual(0, scrollable.get_scrollpos())
+
+        # Column 0 belongs to the wrapped content, not the scrollbar.
+        self.assertFalse(widget.mouse_event(reduced_size, "mouse press", 1, 0, 4, False))
+        self.assertEqual(0, scrollable.get_scrollpos())
+
+    def test_mouse_left_click_left_side_scrollbar(self):
+        """Left click detection honours a left-aligned scrollbar."""
+        content = urwid.Text("\n".join(string.ascii_letters))
+        reduced_size = (3, 5)
+        widget = urwid.ScrollBar(urwid.Scrollable(content), side="left")
+        scrollable = widget.original_widget
+
+        self.assertEqual(0, scrollable.get_scrollpos())
+
+        # The scrollbar occupies column 0 when aligned to the left.
+        self.assertTrue(widget.mouse_event(reduced_size, "mouse press", 1, 0, 4, False))
+        self.assertEqual(47, scrollable.get_scrollpos())
+
+        # A click on the content columns is ignored.
+        self.assertFalse(widget.mouse_event(reduced_size, "mouse press", 1, 1, 0, False))
+        self.assertEqual(47, scrollable.get_scrollpos())
+
+    def test_mouse_left_click_without_scrollbar(self):
+        """Without a rendered scrollbar a left click is not handled."""
+        content = urwid.Text("a\nb")  # fits into the available height
+        reduced_size = (3, 5)
+        widget = urwid.ScrollBar(urwid.Scrollable(content))
+        scrollable = widget.original_widget
+
+        self.assertFalse(widget.mouse_event(reduced_size, "mouse press", 1, 2, 2, False))
+        self.assertEqual(0, scrollable.get_scrollpos())
+
     def test_alt_symbols(self):
         long_content = urwid.Text(LGPL_HEADER)
         reduced_size = (40, 5)

{urwid-4.0.4 → urwid-4.0.5}/tests/test_signals.py

@@ -25,6 +25,30 @@ class SiglnalsTest(unittest.TestCase):
         edit.set_edit_text("another text")
         handler.assert_not_called()
 
+    def test_handler_mutation_during_emit(self):
+        emitter = self.EmClass()
+        calls = []
+
+        def third():
+            calls.append("third")
+
+        def first():
+            calls.append("first")
+            disconnect_signal(emitter, "test", first)
+            connect_signal(emitter, "test", third)
+
+        def second():
+            calls.append("second")
+
+        connect_signal(emitter, "test", first)
+        connect_signal(emitter, "test", second)
+
+        emit_signal(emitter, "test")
+        self.assertEqual(calls, ["first", "second"])
+
+        emit_signal(emitter, "test")
+        self.assertEqual(calls, ["first", "second", "second", "third"])
+
     @unittest.skipIf(sys.implementation.name == "pypy", "WeakRef works differently on PyPy")
     def test_weak_del(self):
         emitter = SiglnalsTest.EmClass()

{urwid-4.0.4 → urwid-4.0.5}/tests/test_widget.py

@@ -39,6 +39,58 @@ class TextTest(unittest.TestCase):
             got = urwid.Text("û").render((3,))._text
             assert got == expected, f"got: {got!r} expected: {expected!r}"
 
+    def test_empty_markup_segment_middle(self) -> None:
+        """An empty markup segment in the middle must not truncate the rendered row."""
+        widget = urwid.Text([("a", "X" * 10), ("b", ""), ("c", " END")])
+
+        self.assertEqual(("XXXXXXXXXX END", [("a", 10), ("b", 0), ("c", 4)]), widget.get_text())
+
+        canvas = widget.render(())
+        self.assertEqual([b"XXXXXXXXXX END"], canvas.text)
+        self.assertEqual(("XXXXXXXXXX END",), canvas.decoded_text)
+
+    def test_empty_markup_segment_start(self) -> None:
+        """An empty markup segment at the start must keep the whole rendered row."""
+        widget = urwid.Text([("b", ""), ("a", "X" * 10), ("c", " END")])
+
+        self.assertEqual(("XXXXXXXXXX END", [("b", 0), ("a", 10), ("c", 4)]), widget.get_text())
+
+        canvas = widget.render(())
+        self.assertEqual([b"XXXXXXXXXX END"], canvas.text)
+        self.assertEqual(("XXXXXXXXXX END",), canvas.decoded_text)
+
+    def test_empty_markup_segment_end(self) -> None:
+        """An empty markup segment at the end must keep the whole rendered row."""
+        widget = urwid.Text([("a", "X" * 10), ("c", " END"), ("b", "")])
+
+        self.assertEqual(("XXXXXXXXXX END", [("a", 10), ("c", 4), ("b", 0)]), widget.get_text())
+
+        canvas = widget.render(())
+        self.assertEqual([b"XXXXXXXXXX END"], canvas.text)
+        self.assertEqual(("XXXXXXXXXX END",), canvas.decoded_text)
+
+    def test_multiple_empty_markup_segments(self) -> None:
+        """Several consecutive empty markup segments must not drop following content."""
+        widget = urwid.Text([("a", "AB"), ("b", ""), ("c", ""), ("d", "CD")])
+
+        self.assertEqual(("ABCD", [("a", 2), ("b", 0), ("c", 0), ("d", 2)]), widget.get_text())
+
+        canvas = widget.render(())
+        self.assertEqual([b"ABCD"], canvas.text)
+        self.assertEqual(("ABCD",), canvas.decoded_text)
+
+    def test_empty_markup_segment_render_content(self) -> None:
+        """The canvas content rows must expose the display attribute of each segment."""
+        widget = urwid.Text([("a", "X" * 10), ("b", ""), ("c", " END")])
+
+        content = list(widget.render(()).content())
+        attrs = [attr for row in content for attr, _cs, _text in row]
+        rendered = b"".join(text for row in content for _attr, _cs, text in row)
+
+        self.assertEqual(b"XXXXXXXXXX END", rendered)
+        self.assertIn("a", attrs)
+        self.assertIn("c", attrs)
+
 
 class EditTest(unittest.TestCase):
     def setUp(self):

{urwid-4.0.4 → urwid-4.0.5}/urwid/display/_posix_raw_display.py

@@ -333,7 +333,7 @@ class Screen(_raw_display_base.Screen):
             input_ready = selector.select(0)
             while input_ready:
                 chunk = os.read(fd, 1024)
-                if len(chunk) == 0:
+                if not chunk:
                     raise RuntimeError("stdin has been closed")
                 chars.extend(chunk)
                 input_ready = selector.select(0)

{urwid-4.0.4 → urwid-4.0.5}/urwid/display/_raw_display_base.py

@@ -483,7 +483,7 @@ class Screen(BaseScreen, RealTerminal):
         try:
             while codes:
                 run, remaining_codes = escape.process_keyqueue(codes, wait_for_more)
-                codes = list(remaining_codes)
+                codes = remaining_codes.copy()
                 decoded_codes.extend(run)
         except escape.MoreInputRequired:
             # Set a timer to wait for the rest of the input; if it goes off
@@ -587,9 +587,7 @@ class Screen(BaseScreen, RealTerminal):
             run: bytes,
             last: bool,
         ) -> None:
-            nonlocal last_charset_flag  # type: ignore[misc]
-            nonlocal last_attributes  # type: ignore[misc]
-            nonlocal first  # type: ignore[misc]
+            nonlocal last_charset_flag, last_attributes, first  # type: ignore[misc]
 
             if not isinstance(run, bytes):  # canvases render with bytes
                 raise TypeError(run)

{urwid-4.0.4 → urwid-4.0.5}/urwid/signals.py

@@ -293,7 +293,7 @@ class Signals:
         """
         result = False
         handlers = getattr(obj, self._signal_attr, {}).get(name, [])
-        for _key, callback, user_arg, (weak_args, user_args) in handlers:
+        for _key, callback, user_arg, (weak_args, user_args) in handlers.copy():
             result |= self._call_callback(callback, user_arg, weak_args, user_args, args)
         return result
 

{urwid-4.0.4 → urwid-4.0.5}/urwid/split_repr.py

@@ -52,7 +52,7 @@ def split_repr(self: Widget) -> str:
     >>> Bar()
     <Bar words here too attrs='appear too' barttr=42>
     """
-    alist = sorted((str(k), normalize_repr(v)) for k, v in self._repr_attrs().items())
+    alist = sorted((k, normalize_repr(v)) for k, v in self._repr_attrs().items())
 
     words = self._repr_words()
     if not words and not alist:

{urwid-4.0.4 → urwid-4.0.5}/urwid/util.py

@@ -429,17 +429,22 @@ def rle_product(
     a2, r2 = rle2[0]
 
     result: list[tuple[tuple[Hashable, Hashable], int]] = []
-    while r1 and r2:
-        r = min(r1, r2)
-        rle_append_modify(result, ((a1, a2), r))  # type: ignore[arg-type]
-        r1 -= r
-        if r1 == 0 and i1 < len(rle1):
+    while True:
+        # Skip zero-length runs (e.g. produced by empty markup segments): they carry no
+        # columns but must not stop the merge early, otherwise following runs are dropped.
+        while r1 == 0 and i1 < len(rle1):
             a1, r1 = rle1[i1]
             i1 += 1
-        r2 -= r
-        if r2 == 0 and i2 < len(rle2):
+        while r2 == 0 and i2 < len(rle2):
             a2, r2 = rle2[i2]
             i2 += 1
+        if r1 == 0 or r2 == 0:
+            break
+
+        r = min(r1, r2)
+        rle_append_modify(result, ((a1, a2), r))  # type: ignore[arg-type]
+        r1 -= r
+        r2 -= r
     return result
 
 

{urwid-4.0.4 → urwid-4.0.5}/urwid/version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '4.0.4'
-__version_tuple__ = version_tuple = (4, 0, 4)
+__version__ = version = '4.0.5'
+__version_tuple__ = version_tuple = (4, 0, 5)
 
-__commit_id__ = commit_id = 'g171c58bd2'
+__commit_id__ = commit_id = 'gecd583268'

{urwid-4.0.4 → urwid-4.0.5}/urwid/widget/attr_map.py

@@ -90,7 +90,7 @@ class AttrMap(delegate_to_widget_mixin("_original_widget"), WidgetDecoration[Wra
         # FIXME: a dictionary that detects modifications would be better
         return dict(self._attr_map)
 
-    def set_attr_map(self, attr_map: dict[Hashable, Hashable] | None) -> None:
+    def set_attr_map(self, attr_map: dict[Hashable, Hashable]) -> None:
         """
         Set the attribute mapping dictionary {from_attr: to_attr, ...}
 
@@ -152,7 +152,11 @@ class AttrMap(delegate_to_widget_mixin("_original_widget"), WidgetDecoration[Wra
 
     focus_map = property(get_focus_map, set_focus_map)
 
-    def render(self, size, focus: bool = False) -> CompositeCanvas:
+    def render(
+        self,
+        size: tuple[()] | tuple[int] | tuple[int, int],
+        focus: bool = False,
+    ) -> CompositeCanvas:
         """
         Render wrapped widget and apply attribute. Return canvas.
         """

{urwid-4.0.4 → urwid-4.0.5}/urwid/widget/edit.py

@@ -4,7 +4,7 @@ import string
 import typing
 
 from urwid import text_layout
-from urwid.canvas import CompositeCanvas
+from urwid.canvas import CompositeCanvas, apply_text_layout
 from urwid.command_map import Command
 from urwid.split_repr import remove_defaults
 from urwid.str_util import is_wide_char, move_next_char, move_prev_char
@@ -12,6 +12,7 @@ from urwid.util import decompose_tagmarkup
 
 from .constants import Align, Sizing, WrapMode
 from .text import Text, TextError
+from .widget import WidgetWrap
 
 if typing.TYPE_CHECKING:
     from collections.abc import Hashable
@@ -27,7 +28,7 @@ class EditError(TextError):
     pass
 
 
-class Edit(Text):
+class Edit(WidgetWrap[Text]):
     """
     Text editing widget implements cursor movement, text insertion and
     deletion.  A caption may prefix the editing area.  Uses text class
@@ -78,12 +79,10 @@ class Edit(Text):
         mask: str | None = None,
     ) -> None:
         """
-        :param caption: markup for caption preceding edit_text, see
-                        :class:`Text` for description of text markup.
+        :param caption: markup for caption preceding edit_text, see :class:`Text` for description of text markup.
         :type caption: text markup
-        :param edit_text: initial text for editing, type (bytes or unicode)
-                          must match the text in the caption
-        :type edit_text: bytes or unicode
+        :param edit_text: initial text for editing, type (bytes or str) must match the text in the caption
+        :type edit_text: bytes or str
         :param multiline: True: 'enter' inserts newline  False: return it
         :type multiline: bool
         :param align: typically 'left', 'center' or 'right'
@@ -97,7 +96,7 @@ class Edit(Text):
         :param layout: defaults to a shared :class:`StandardTextLayout` instance
         :type layout: text layout instance
         :param mask: hide text entered with this character, None:disable mask
-        :type mask: bytes or unicode
+        :type mask: bytes or str
 
         >>> Edit()
         <Edit selectable flow widget '' edit_pos=0>
@@ -108,33 +107,60 @@ class Edit(Text):
         >>> Edit("", "3.14", align="right")
         <Edit selectable flow widget '3.14' align='right' edit_pos=4>
         """
-
-        super().__init__("", align, wrap, layout)
+        super().__init__(Text("", align, wrap, layout))
         self.multiline = multiline
         self.allow_tab = allow_tab
         self._edit_pos = 0
-        self._caption, self._attrib = decompose_tagmarkup(caption)  # type: ignore[arg-type]  # discourage `bytes` input
+        self._caption, self._attrib = decompose_tagmarkup(caption)  # type: ignore[arg-type]
         self._edit_text = ""
         self.highlight: tuple[int, int] | None = None
+        self._mask: str | None = None
+        self._shift_view_to_cursor = False
+        self.pref_col_maxcol: tuple[int | None, int | None] = (None, None)
         self.set_edit_text(edit_text)
         if edit_pos is None:
             edit_pos = len(edit_text)
         self.set_edit_pos(edit_pos)
         self.set_mask(mask)
-        self._shift_view_to_cursor = False
+
+    def selectable(self) -> bool:
+        """Selectable mark.
+
+        Wrapped Text widget is not selectable while the edit widget has to be selectable.
+        """
+        return True
+
+    def sizing(self) -> frozenset[Sizing]:
+        """Sizing information.
+
+        Edit widget sizing is narrower than Text: we cannot predict the final input length.
+        """
+        return self._sizing
 
     def _repr_words(self) -> list[str]:
-        return (
-            super()._repr_words()[:-1]
-            + [repr(self._edit_text)]
-            + [f"caption={self._caption!r}"] * bool(self._caption)
-            + ["multiline"] * (self.multiline is True)
-        )
+        return [
+            *super()._repr_words(),
+            repr(self._edit_text),
+            *([f"caption={self._caption!r}"] if self._caption else []),
+            *(["multiline"] if self.multiline is True else []),
+        ]
 
     def _repr_attrs(self) -> dict[str, typing.Any]:
-        attrs = {**super()._repr_attrs(), "edit_pos": self._edit_pos}
+        attrs = {
+            **super()._repr_attrs(),
+            "align": self._w.align,
+            "wrap": self._w.wrap,
+            "edit_pos": self._edit_pos,
+        }
         return remove_defaults(attrs, Edit.__init__)
 
+    def _sync_wrapped(self) -> None:
+        """Synchronize the wrapped Text widget with current caption+edit_text state."""
+        text, attrib = self.get_text()
+        self._w._text = text  # pylint: disable=protected-access
+        self._w._attrib = attrib  # pylint: disable=protected-access
+        self._w._invalidate()
+
     def get_text(self) -> tuple[str | bytes, list[tuple[Hashable, int]]]:
         """
         Returns ``(text, display attributes)``. See :meth:`Text.get_text`
@@ -151,27 +177,59 @@ class Edit(Text):
         """
 
         if self._mask is None:
-            return self._caption + self._edit_text, self._attrib
+            return self._caption + self._edit_text, self._attrib  # type: ignore[operator]  # type normalised
 
-        return self._caption + (self._mask * len(self._edit_text)), self._attrib
+        return self._caption + (self._mask * len(self._edit_text)), self._attrib  # type: ignore[operator]
 
-    def set_text(self, markup: _TagMarkup) -> None:
+    @property
+    def text(self) -> str | bytes:
         """
-        Not supported by Edit widget.
+        Read-only property returning the complete bytes/unicode content
+        of this widget (caption plus edit_text, possibly masked).
+        """
+        return self.get_text()[0]
 
-        >>> Edit().set_text("test")
-        Traceback (most recent call last):
-        EditError: set_text() not supported.  Use set_caption() or set_edit_text() instead.
+    @property
+    def attrib(self) -> list[tuple[Hashable, int]]:
+        """
+        Read-only property returning the run-length encoded display
+        attributes of this widget.
         """
-        # FIXME: this smells. reimplement Edit as a WidgetWrap subclass to
-        # clean this up
+        return self.get_text()[1]
 
-        # hack to let Text.__init__() work
-        if not hasattr(self, "_text") and markup == "":  # noqa: PLC1901,RUF100
-            self._text = None
-            return
+    def set_align_mode(self, mode: Literal["left", "center", "right"] | Align) -> None:
+        """
+        Set text alignment mode. See :meth:`Text.set_align_mode` for details.
+        """
+        self._w.set_align_mode(mode)
+        self._invalidate()
 
-        raise EditError("set_text() not supported.  Use set_caption() or set_edit_text() instead.")
+    def set_wrap_mode(self, mode: Literal["space", "any", "clip", "ellipsis"] | WrapMode) -> None:
+        """
+        Set text wrapping mode. See :meth:`Text.set_wrap_mode` for details.
+        """
+        self._w.set_wrap_mode(mode)
+        self._invalidate()
+
+    def set_layout(
+        self,
+        align: Literal["left", "center", "right"] | Align,
+        wrap: Literal["space", "any", "clip", "ellipsis"] | WrapMode,
+        layout: text_layout.TextLayout | None = None,
+    ) -> None:
+        """
+        Set the text layout object, alignment and wrapping modes at the same time.
+        See :meth:`Text.set_layout` for details.
+        """
+        self._w.set_layout(align, wrap, layout)
+        self._invalidate()
+
+    align = property(lambda self: self._w.align, set_align_mode)
+    wrap = property(lambda self: self._w.wrap, set_wrap_mode)
+
+    @property
+    def layout(self) -> text_layout.TextLayout:
+        return self._w.layout
 
     def get_pref_col(self, size: tuple[int]) -> int:
         """
@@ -209,7 +267,7 @@ class Edit(Text):
         if then_maxcol != maxcol:
             return self.get_cursor_coords((maxcol,))[0]
 
-        return pref_col
+        return typing.cast("int", pref_col)
 
     def set_caption(self, caption: str | tuple[Hashable, str] | list[str | tuple[Hashable, str]]) -> None:
         """
@@ -231,11 +289,12 @@ class Edit(Text):
         Traceback (most recent call last):
         AttributeError: can't set attribute
         """
-        self._caption, self._attrib = decompose_tagmarkup(caption)
+        self._caption, self._attrib = decompose_tagmarkup(caption)  # type: ignore[arg-type]
+        self._sync_wrapped()
         self._invalidate()
 
     @property
-    def caption(self) -> str:
+    def caption(self) -> str | bytes:
         """
         Read-only property returning the caption for this widget.
         """
@@ -285,6 +344,7 @@ class Edit(Text):
         """
 
         self._mask = mask
+        self._sync_wrapped()
         self._invalidate()
 
     def set_edit_text(self, text: str) -> None:
@@ -310,6 +370,7 @@ class Edit(Text):
         self._emit("change", text)
         old_text = self._edit_text
         self._edit_text = text
+        self._sync_wrapped()
         self.edit_pos = min(self.edit_pos, len(text))
 
         self._emit("postchange", old_text)
@@ -367,8 +428,8 @@ class Edit(Text):
         if tu == cu:
             return text
         if tu:
-            return text.encode("ascii")  # follow python2's implicit conversion
-        return text.decode("ascii")
+            return text.encode("ascii")  # type: ignore[union-attr]  # follow python2's implicit conversion
+        return text.decode("ascii")  # type: ignore[union-attr]
 
     def insert_text_result(self, text: str) -> tuple[str | bytes, int]:
         """
@@ -401,7 +462,7 @@ class Edit(Text):
 
     def keypress(
         self,
-        size: tuple[int],  # type: ignore[override]
+        size: tuple[int],
         key: str,
     ) -> str | None:
         """
@@ -460,9 +521,6 @@ class Edit(Text):
             if pref_col is None:
                 raise ValueError(pref_col)
 
-            # if pref_col is None:
-            #    pref_col = x
-
             if self._command_map[key] == Command.UP:
                 y -= 1
             else:
@@ -546,7 +604,7 @@ class Edit(Text):
 
     def mouse_event(
         self,
-        size: tuple[int],  # type: ignore[override]
+        size: tuple[int],
         event: str,
         button: int,
         col: int,
@@ -581,9 +639,9 @@ class Edit(Text):
         self.highlight = None
         return True
 
-    def render(  # type: ignore[override]
+    def render(
         self,
-        size: tuple[int],  # type: ignore[override]
+        size: tuple[int],
         focus: bool = False,
     ) -> TextCanvas | CompositeCanvas:
         """
@@ -599,7 +657,11 @@ class Edit(Text):
         """
         self._shift_view_to_cursor = bool(focus)
 
-        canv: TextCanvas | CompositeCanvas = super().render(size, focus)
+        (maxcol,) = size
+        text, attr = self.get_text()
+        trans = self.get_line_translation(maxcol, (text, attr))
+        canv: TextCanvas | CompositeCanvas = apply_text_layout(text, attr, trans, maxcol)
+
         if focus:
             canv = CompositeCanvas(canv)
             canv.cursor = self.get_cursor_coords(size)
@@ -615,7 +677,7 @@ class Edit(Text):
         maxcol: int,
         ta: tuple[str | bytes, list[tuple[Hashable, int]]] | None = None,
     ) -> list[list[tuple[int, int, int | bytes] | tuple[int, int | None]]]:
-        trans = super().get_line_translation(maxcol, ta)
+        trans = self._w.get_line_translation(maxcol, ta)
         if not self._shift_view_to_cursor:
             return trans
 
@@ -685,7 +747,7 @@ class IntEdit(Edit):
 
     def keypress(
         self,
-        size: tuple[int],  # type: ignore[override]
+        size: tuple[int],
         key: str,
     ) -> str | None:
         """