optimizations for Content and Style

Author: willmcgugan

src/textual/_compositor.py

@@ -695,9 +695,9 @@ def add_widget(
                             widget.container_size.height
                             - widget.scrollbar_size_horizontal
                         )
-                        widget.set_reactive(Widget.scroll_y, new_scroll_y)
-                        widget.set_reactive(Widget.scroll_target_y, new_scroll_y)
-                        widget.vertical_scrollbar._reactive_position = new_scroll_y
+                        widget.scroll_y = new_scroll_y
+                        widget.scroll_target_y = new_scroll_y
+                        widget.vertical_scrollbar.position = new_scroll_y
 
                 if visible:
                     # Add any scrollbars

src/textual/content.py

@@ -106,6 +106,27 @@ def extend(self, cells: int) -> "Span":
             return Span(start, end + cells, style)
         return self
 
+    def shift(self, distance: int) -> "Span":
+        """Shift a span a given distance.
+
+        Note that the start offset is clamped to 0.
+        The end offset is not clamped, as it is assumed this has already been checked by the caller.
+
+        Args:
+            distance: Number of characters to move.
+
+        Returns:
+            New Span.
+        """
+        if distance < 0:
+            start, end, style = self
+            return Span(
+                offset if (offset := start + distance) > 0 else 0, end + distance, style
+            )
+        else:
+            start, end, style = self
+            return Span(start + distance, end + distance, style)
+
 
 @rich.repr.auto
 @total_ordering
@@ -126,6 +147,7 @@ def __init__(
         text: str = "",
         spans: list[Span] | None = None,
         cell_length: int | None = None,
+        strip_control_codes: bool = True,
     ) -> None:
         """
         Initialize a Content object.
@@ -134,8 +156,12 @@ def __init__(
             text: text content.
             spans: Optional list of spans.
             cell_length: Cell length of text if known, otherwise `None`.
+            strip_control_codes: Strip control codes that may break output?
         """
-        self._text: str = _strip_control_codes(text)
+        if strip_control_codes and text:
+            self._text: str = _strip_control_codes(text)
+        else:
+            self._text = text
         self._spans: list[Span] = [] if spans is None else spans
         self._cell_length = cell_length
         self._optimal_width_cache: int | None = None
@@ -147,6 +173,8 @@ def __init__(
         self._split_cache: FIFOCache[tuple[str, bool, bool], list[Content]] | None = (
             None
         )
+        # If there are 1 or 0 spans, it can't be simplified further
+        self._simplified = len(self._spans) <= 1
 
     def __str__(self) -> str:
         return self._text
@@ -321,25 +349,35 @@ def styled(
         text: str,
         style: Style | str = "",
         cell_length: int | None = None,
+        strip_control_codes: bool = True,
     ) -> Content:
         """Create a Content instance from text and an optional style.
 
         Args:
             text: String content.
             style: Desired style.
             cell_length: Cell length of text if known, otherwise `None`.
+            strip_control_codes: Strip control codes that may break output.
 
         Returns:
             New Content instance.
         """
         if not text:
             return Content("")
-        new_content = cls(text, [Span(0, len(text), style)] if style else None)
+        new_content = cls(
+            text,
+            [Span(0, len(text), style)] if style else None,
+            cell_length,
+            strip_control_codes=strip_control_codes,
+        )
         return new_content
 
     @classmethod
     def assemble(
-        cls, *parts: str | Content | tuple[str, str | Style], end: str = ""
+        cls,
+        *parts: str | Content | tuple[str, str | Style],
+        end: str = "",
+        strip_control_codes: bool = True,
     ) -> Content:
         """Construct new content from string, content, or tuples of (TEXT, STYLE).
 
@@ -359,6 +397,7 @@ def assemble(
             *parts: Parts to join to gether. A *part* may be a simple string, another Content
             instance, or tuple containing text and a style.
             end: Optional end to the Content.
+            strip_control_codes: Strip control codes that may break output.
         """
         text: list[str] = []
         spans: list[Span] = []
@@ -390,7 +429,7 @@ def assemble(
                 position += len(part.plain)
         if end:
             text_append(end)
-        return cls("".join(text), spans)
+        return cls("".join(text), spans, strip_control_codes=strip_control_codes)
 
     def simplify(self) -> Content:
         """Simplify spans by joining contiguous spans together.
@@ -405,7 +444,7 @@ def simplify(self) -> Content:
         Returns:
             Self.
         """
-        if not (spans := self._spans):
+        if not (spans := self._spans) or self._simplified:
             return self
         last_span = Span(-1, -1, "")
         new_spans: list[Span] = []
@@ -419,6 +458,7 @@ def simplify(self) -> Content:
                 last_span = span
         if changed:
             self._spans[:] = new_spans
+        self._simplified = True
         return self
 
     def add_spans(self, spans: Sequence[Span]) -> Content:
@@ -431,7 +471,12 @@ def add_spans(self, spans: Sequence[Span]) -> Content:
             A Content instance.
         """
         if spans:
-            return Content(self.plain, [*self._spans, *spans], self._cell_length)
+            return Content(
+                self.plain,
+                [*self._spans, *spans],
+                self._cell_length,
+                strip_control_codes=False,
+            )
         return self
 
     def __eq__(self, other: object) -> bool:
@@ -706,7 +751,7 @@ def plain(self) -> str:
     def without_spans(self) -> Content:
         """The content with no spans"""
         if self._spans:
-            return Content(self.plain, [], self._cell_length)
+            return Content(self.plain, [], self._cell_length, strip_control_codes=False)
         return self
 
     @property
@@ -726,6 +771,7 @@ def get_text_at(offset: int) -> "Content":
                     for start, end, style in self._spans
                     if end > offset >= start
                 ],
+                strip_control_codes=False,
             )
             return content
 
@@ -734,16 +780,32 @@ def get_text_at(offset: int) -> "Content":
         else:
             start, stop, step = slice.indices(len(self.plain))
             if step == 1:
-                lines = self.divide([start, stop])
-                return lines[1]
+                if start == 0:
+                    if stop >= len(self.plain):
+                        return self
+                    text = self.plain[:stop]
+                    return Content(
+                        text,
+                        self._trim_spans(text, self._spans),
+                        strip_control_codes=False,
+                    )
+                else:
+                    text = self.plain[start:stop]
+                    spans = [
+                        span.shift(-start) for span in self._spans if span.end > start
+                    ]
+                    return Content(
+                        text, self._trim_spans(text, spans), strip_control_codes=False
+                    )
+
             else:
                 # This would be a bit of work to implement efficiently
                 # For now, its not required
                 raise TypeError("slices with step!=1 are not supported")
 
     def __add__(self, other: Content | str) -> Content:
         if isinstance(other, str):
-            return Content(self._text + other, self._spans)
+            return Content(self._text + other, self._spans, strip_control_codes=False)
         if isinstance(other, Content):
             offset = len(self.plain)
             content = Content(
@@ -801,6 +863,7 @@ def append(self, content: Content | str) -> Content:
                     if self._cell_length is None
                     else self._cell_length + cell_len(content)
                 ),
+                strip_control_codes=False,
             )
         return Content("").join([self, content])
 
@@ -836,12 +899,20 @@ def iter_content() -> Iterable[Content]:
             """Iterate the lines, optionally inserting the separator."""
             if self.plain:
                 for last, line in loop_last(lines):
-                    yield line if isinstance(line, Content) else Content(line)
+                    yield (
+                        line
+                        if isinstance(line, Content)
+                        else Content(line, strip_control_codes=False)
+                    )
                     if not last:
                         yield self
             else:
                 for line in lines:
-                    yield line if isinstance(line, Content) else Content(line)
+                    yield (
+                        line
+                        if isinstance(line, Content)
+                        else Content(line, strip_control_codes=False)
+                    )
 
         extend_text = text.extend
         extend_spans = spans.extend
@@ -935,13 +1006,16 @@ def truncate(
         if pad and length < max_width:
             spaces = max_width - length
             text = f"{self.plain}{' ' * spaces}"
+            return Content(text, spans, max_width, strip_control_codes=False)
         elif length > max_width:
             if ellipsis and max_width:
                 text = set_cell_size(self.plain, max_width - 1) + "…"
             else:
                 text = set_cell_size(self.plain, max_width)
             spans = self._trim_spans(text, self._spans)
-        return Content(text, spans)
+            return Content(text, spans, max_width, strip_control_codes=False)
+        else:
+            return self
 
     def pad_left(self, count: int, character: str = " ") -> Content:
         """Pad the left with a given character.
@@ -962,6 +1036,7 @@ def pad_left(self, count: int, character: str = " ") -> Content:
                 text,
                 spans,
                 None if self._cell_length is None else self._cell_length + count,
+                strip_control_codes=False,
             )
             return content
 
@@ -987,6 +1062,7 @@ def extend_right(self, count: int, character: str = " ") -> Content:
                     for span in self._spans
                 ],
                 None if self._cell_length is None else self._cell_length + count,
+                strip_control_codes=False,
             )
         return self
 
@@ -1003,6 +1079,7 @@ def pad_right(self, count: int, character: str = " ") -> Content:
                 f"{self.plain}{character * count}",
                 self._spans,
                 None if self._cell_length is None else self._cell_length + count,
+                strip_control_codes=False,
             )
         return self
 
@@ -1029,6 +1106,7 @@ def pad(self, left: int, right: int, character: str = " ") -> Content:
                 text,
                 spans,
                 None if self._cell_length is None else self._cell_length + left + right,
+                strip_control_codes=False,
             )
             return content
 
@@ -1114,6 +1192,8 @@ def stylize(
         return Content(
             self.plain,
             self._spans + [Span(start, length if length < end else end, style)],
+            self._cell_length,
+            strip_control_codes=False,
         )
 
     def stylize_before(
@@ -1146,6 +1226,8 @@ def stylize_before(
         return Content(
             self.plain,
             [Span(start, length if length < end else end, style), *self._spans],
+            self._cell_length,
+            strip_control_codes=False,
         )
 
     def render(

src/textual/style.py

@@ -239,6 +239,10 @@ def markup_tag(self) -> str:
     @lru_cache(maxsize=1024 * 4)
     def __add__(self, other: object | None) -> Style:
         if isinstance(other, Style):
+            if self._is_null:
+                return other
+            if other._is_null:
+                return self
             (
                 background,
                 foreground,

src/textual/widget.py

@@ -1896,7 +1896,7 @@ def watch_hover_style(
     ) -> None:
         # TODO: This will cause the widget to refresh, even when there are no links
         # Can we avoid this?
-        if self.auto_links:
+        if self.auto_links and not self.app.mouse_captured:
             self.highlight_link_id = hover_style.link_id
 
     def watch_scroll_x(self, old_value: float, new_value: float) -> None:
@@ -4270,6 +4270,7 @@ def refresh(
         Returns:
             The `Widget` instance.
         """
+
         if layout and not self._layout_required:
             self._layout_required = True
             self._layout_updates += 1