stylize method for the Strip class

[0x42656E]

Hello,

I've had several situations where I needed a method to apply a style to the Strip from a to b, in addition to Strip.apply_style.
Such a functionality would be helpful if the underlying segments (where styles may have already been applied to the segments)
need different styles and not only one style as with Strip.apply_style 🙂 .

Here is an example how this method could look like inside the Strip class (no caching implemented)

    def stylize(self, style: Style, start: int = 0, end: Optional[int] = None) -> Strip:
        """Apply a style to the Strip, or a portion of the Strip.
        Args:
            style: Style instance to apply.
            start: Start offset (negative indexing is supported). Defaults to 0.
            end: End offset (negative indexing is supported), or None for end of text. Defaults to None.
        Returns:
            A new Strip.
        """
        length = sum(len(segment.text) for segment in self._segments)
        if start < 0:
            start = abs(start)
            start = length - start if start < length else 0
        if end is None or end > length:
            end = length
        elif end < 0:
            end = length + end
        if not start and end == length:
            return self.apply_style(style)
        if not length or start >= end:
            return Strip(self._segments, self.cell_length)
        length = 0
        text = ""
        segments: list[Segment] = []
        segments_iter = iter(self._segments)
        for segment in segments_iter:
            segment_text = segment.text
            segment_length = len(segment_text)
            length += segment_length
            if length < start:
                segments.append(segment)
                continue
            if not text:
                offset = start - (length - segment_length)
                text += segment_text[offset:]
                tail_text = segment_text[:offset]
                if tail_text:
                    segments.append(Segment(tail_text, segment.style))
            else:
                text += segment_text
            if length >= end:
                offset = end - start
                head_text = text[offset:]
                text = text[:offset]
                segments.append(Segment(text, style))
                if head_text:
                    segments.append(Segment(head_text, segment.style))
                break
        segments.extend(segments_iter)
        return Strip(segments)

[willmcgugan]

Could you describe a situation where you need this?

If needed to apply styles to parts of a render, I'd probably use the Text class. With Text you can apply styles to arbitrary ranges, and efficiently in to segments.

[0x42656E]

Of course I should have added an example (my bad) ...

I am currently building a text editor using the line API.
I use the Syntax class from rich for syntax highlighting.
And render the Syntax class into lines using Console.render_lines and store the lines to a reactive attribute.
In the render_line method I set the cursor (see below).

def render_line(self, y: int) -> Strip:
    scroll_x, scroll_y = self.scroll_offset
    y += scroll_y
    try:
        # get the line by y from the reactive lines attribute
        segments = self.lines[y]
    except IndexError:
        return Strip.blank(0)

    cursor_x, cursor_y = self.cursor_offset
    strip = Strip(segments)
    if y == cursor_y:
       cursor_style = self.get_component_rich_style("textarea--cursor")
       # here I set the cursor and a "stylize" method would be really useful
       strip = strip.stylize(cursor_style, cursor_x, cursor_x + 1)

    strip = strip.crop(scroll_x, scroll_x + self.size.width)
    return strip

Maybe there is another way to solve this?

[0x42656E]

To sum it up, I'm missing some kind of "stylize" method for the line API, which is available for rich in Text class (stylize) or Syntax class (stylize_range).