tuile 0.7.0 → 0.9.0

data/lib/tuile/buffer.rb

@@ -0,0 +1,481 @@
+# frozen_string_literal: true
+
+module Tuile
+  # An in-memory grid of styled cells mirroring the terminal screen. This is
+  # the back buffer behind flicker-free rendering: components paint into it
+  # (via {#set_line} / {#set_char} / {#fill}) instead of writing escape
+  # sequences straight to the terminal, and {#flush} emits the minimal escape
+  # string needed to bring a terminal — one that already matches the buffer's
+  # state as of the previous flush — up to date. Only cells that actually
+  # changed are emitted, so nothing flickers regardless of terminal/multiplexer
+  # synchronized-output support.
+  #
+  # Coordinates are 0-based `(x, y)` = `(column, row)`, matching
+  # {Component#rect} and `TTY::Cursor.move_to`.
+  #
+  # ## Dirty tracking
+  #
+  # Every mutator compares the incoming grapheme+style against what's already
+  # there and records the cell dirty only when it differs — so both mutation
+  # and {#flush} cost scale with what actually changed, never with the buffer
+  # size. There is deliberately no per-frame whole-buffer clear or copy;
+  # un-touched cells retain the previous frame's value.
+  #
+  # The bookkeeping avoids hashing and full-grid scans: a dirty flag **on each
+  # cell** (O(1) set, no `Set` bucket math, no separate array), a per-row
+  # boolean so {#flush} scans only the rows that changed, and one global flag
+  # so {#dirty?} and the "nothing changed" early-out are O(1). {#flush} clears
+  # every flag it consumes.
+  #
+  # Cells are **mutable and pre-allocated**: the grid builds its {Cell}s once
+  # (at construction and {#resize}) and rewrites them in place, so a normal
+  # paint allocates nothing per cell. That is why {Cell} is a plain mutable
+  # object rather than a frozen value type. The empty state of a cell is a
+  # space in the default style.
+  #
+  # ## Wide characters
+  #
+  # A 2-column glyph (fullwidth CJK, most emoji) occupies its origin cell plus a
+  # **continuation** cell to its right (an empty-grapheme {Cell} the flush emits
+  # nothing for, since the glyph itself advances the cursor two columns).
+  # Overwriting either half of a wide glyph blanks the orphaned half, so the
+  # grid never holds a dangling continuation or a headless one.
+  #
+  # ## Future direction
+  #
+  # Components paint through this drawing surface ({#set_line} / {#set_char})
+  # without knowing whether it is the one global buffer or a private one — that
+  # indirection is deliberate, so per-component back buffers plus a z-order
+  # compositor could drop in without touching component code. It is not worth
+  # doing yet: the diff already drops unchanged cells from the wire, and an
+  # occluded component that didn't change is never repainted at all, so a
+  # compositor would only save residual `repaint` CPU. It pays off in exactly
+  # one regime — high repeat-rate scroll (held arrow / mouse wheel) of a large
+  # component on a large screen, where re-rendering the content each repeat is
+  # the dominant cost.
+  class Buffer
+    # One screen cell: a single grapheme cluster, the {StyledString::Style} it's
+    # drawn in, and a dirty flag. Mutable by design (see {Buffer} "Dirty
+    # tracking") — the grid rewrites cells in place. A continuation cell (right
+    # half of a wide glyph) carries an empty grapheme — see {#continuation?}.
+    class Cell
+      # Read-only: mutate content through {#set} so dirty tracking stays correct.
+      # @return [String] one grapheme cluster, `" "` for blank, or `""` for a
+      #   wide-glyph continuation.
+      attr_reader :grapheme
+
+      # @return [StyledString::Style]
+      attr_reader :style
+
+      # @return [Boolean] true if this cell changed since the last {Buffer#flush}.
+      #   {Buffer} flips it (off as it flushes, on via {Buffer#mark_all_dirty}).
+      attr_accessor :dirty
+
+      # @param grapheme [String]
+      # @param style [StyledString::Style]
+      def initialize(grapheme, style)
+        @grapheme = grapheme
+        @style = style
+        @dirty = false
+      end
+
+      # @return [Boolean] true if this is the right half of a wide glyph, which
+      #   {Buffer#flush} skips (the glyph to the left already moved the cursor
+      #   past it).
+      def continuation? = @grapheme.empty?
+
+      # Sets the cell's content, flipping {#dirty} on when grapheme or style
+      # actually changes (an already-dirty cell stays dirty). Returns the
+      # resulting dirty flag, so callers can aggregate row/buffer dirty state in
+      # one step. The single mutation path behind {Buffer#set_char} / {#fill} /
+      # {#clear}.
+      # @param grapheme [String]
+      # @param style [StyledString::Style]
+      # @return [Boolean] {#dirty} after the write.
+      def set(grapheme, style)
+        return @dirty if @grapheme == grapheme && @style == style
+
+        @grapheme = grapheme
+        @style = style
+        @dirty = true
+      end
+
+      # Content equality (grapheme + style); the dirty flag is bookkeeping and
+      # is deliberately excluded.
+      # @param other [Object]
+      # @return [Boolean]
+      def ==(other)
+        other.is_a?(Cell) && @grapheme == other.grapheme && @style == other.style
+      end
+    end
+
+    # @return [StyledString::Style] the unstyled default.
+    DEFAULT_STYLE = StyledString::Style::DEFAULT
+    private_constant :DEFAULT_STYLE
+
+    # Memo for {.display_width}: a grapheme's display width is fixed, and a TTY
+    # paints from a small, recurring alphabet (ASCII, box-drawing rules, a few
+    # emoji), so the per-grapheme width lookup — the dominant cost of a repaint
+    # (see `benchmark/display_width.rb`) — collapses to a Hash read after the
+    # first sighting. Shared across all buffers and unbounded, but bounded in
+    # practice by the font's glyph set; safe to share because all painting runs
+    # on the single UI thread (see AGENTS.md "Threading rule").
+    # @return [Hash{String => Integer}]
+    WIDTH_CACHE = Hash.new { |h, g| h[g] = Unicode::DisplayWidth.of(g) }
+    private_constant :WIDTH_CACHE
+
+    # Memoized {Unicode::DisplayWidth.of}. Use this for every paint-path width
+    # lookup instead of calling the gem directly.
+    # @param grapheme [String] one grapheme cluster.
+    # @return [Integer] its display width in columns (0 for combining marks).
+    def self.display_width(grapheme) = WIDTH_CACHE[grapheme]
+
+    # @param size [Size] grid dimensions in columns × rows.
+    def initialize(size)
+      allocate_grid(size)
+      # A fresh buffer never matches the terminal yet — the screen holds
+      # whatever was there at startup — so it begins fully dirty and the first
+      # flush paints the whole grid (gaps included). Same reasoning as {#resize}.
+      mark_all_dirty
+    end
+
+    # @return [Size] grid dimensions.
+    def size = Size.new(@width, @height)
+
+    # @return [Integer]
+    attr_reader :width, :height
+
+    # @param x [Integer] column.
+    # @param y [Integer] row.
+    # @return [Cell, nil] the live cell at `(x, y)` (do not mutate — paint via
+    #   {#set_char} / {#set_line} so dirty tracking stays correct), or nil when
+    #   out of bounds.
+    def cell(x, y)
+      return nil unless in_bounds?(x, y)
+
+      @cells[index(x, y)]
+    end
+
+    # @return [Boolean] true if any cell has changed since the last {#flush}.
+    def dirty? = @any_dirty
+
+    # Writes one grapheme cluster at `(x, y)`. A 2-column glyph also writes a
+    # continuation cell at `(x + 1, y)`; a wide glyph that would overflow the
+    # last column is replaced by a blank (terminals can't render a half-clipped
+    # wide glyph). Zero-width input (a lone combining mark) is ignored — it has
+    # no cell of its own. Out-of-bounds writes are dropped.
+    # @param x [Integer] column.
+    # @param y [Integer] row.
+    # @param grapheme [String] one grapheme cluster.
+    # @param style [StyledString::Style]
+    # @return [void]
+    def set_char(x, y, grapheme, style = DEFAULT_STYLE)
+      put_char(x, y, grapheme, Buffer.display_width(grapheme), style)
+    end
+
+    # Writes a {StyledString} starting at `(x, y)`, advancing by each grapheme's
+    # display width and clipping at the right edge. The workhorse that replaces
+    # the old `screen.print(TTY::Cursor.move_to(x, y), styled.to_ansi)` per-row
+    # paint. Newlines in the string are not handled — pass one physical line.
+    # @param x [Integer] starting column.
+    # @param y [Integer] row.
+    # @param styled [StyledString]
+    # @return [void]
+    def set_line(x, y, styled)
+      col = x
+      styled.spans.each do |span|
+        span.text.grapheme_clusters.each do |g|
+          w = Buffer.display_width(g)
+          next if w <= 0 # combining mark with no base in this run: skip
+
+          break if col >= @width # rest of the line is clipped
+
+          # Reuse the width we just computed: put_char skips re-measuring `g`.
+          put_char(col, y, g, w, span.style)
+          col += w
+        end
+      end
+    end
+
+    # Fills the intersection of `rect` and the buffer with blank cells in
+    # `style` — the cell-grid equivalent of clearing a background. Only `bg`
+    # shows; the grapheme is a space.
+    # @param rect [Rect]
+    # @param style [StyledString::Style]
+    # @return [void]
+    def fill(rect, style = DEFAULT_STYLE)
+      top = [rect.top, 0].max
+      bottom = [rect.top + rect.height, @height].min
+      left = [rect.left, 0].max
+      right = [rect.left + rect.width, @width].min
+      y = top
+      while y < bottom
+        x = left
+        while x < right
+          write_cell(x, y, " ", style)
+          x += 1
+        end
+        y += 1
+      end
+    end
+
+    # Blanks the entire buffer in `style`. A flat pass over every cell — no
+    # rect math or nested loops, since it covers the whole grid. Only cells
+    # that actually change are marked dirty (and their rows), so a {#flush}
+    # after clearing an already-blank buffer emits nothing.
+    # @param style [StyledString::Style]
+    # @return [void]
+    def clear(style = DEFAULT_STYLE)
+      @cells.each_with_index do |c, i|
+        next unless c.set(" ", style)
+
+        @dirty_rows[i / @width] = true
+        @any_dirty = true
+      end
+    end
+
+    # Marks every cell dirty, so the next {#flush} re-emits the whole grid.
+    # Used after a resize and whenever the terminal contents become unknown
+    # (e.g. the screen was cleared underneath us).
+    # @return [void]
+    def mark_all_dirty
+      @cells.each { |c| c.dirty = true }
+      @dirty_rows.fill(true)
+      @any_dirty = true
+    end
+
+    # Resizes the grid to `size`, reallocating blank cells and marking the
+    # whole buffer dirty — after a resize the terminal contents are undefined,
+    # so the next flush redraws from scratch.
+    # @param size [Size]
+    # @return [void]
+    def resize(size)
+      allocate_grid(size)
+      mark_all_dirty
+    end
+
+    # Emits the minimal escape sequence that updates a terminal — already
+    # matching this buffer as of the previous flush — to the current contents,
+    # then clears the dirty flags. Returns `""` when nothing changed.
+    #
+    # Scans only dirty rows; within a row, consecutive dirty cells form one run
+    # (one `TTY::Cursor.move_to` followed by their graphemes), with a running
+    # {StyledString::Style#sgr_to} diff so only changed attributes are sent
+    # (continuation cells emit nothing). The sequence always ends in the default
+    # style ({Ansi::RESET} when needed), the invariant the next flush relies on:
+    # the terminal's SGR state is default at flush boundaries.
+    # @return [String] the escape sequence to write to the terminal.
+    def flush
+      return "" unless @any_dirty
+
+      out = +""
+      style = DEFAULT_STYLE
+      y = 0
+      while y < @height
+        if @dirty_rows[y]
+          @dirty_rows[y] = false
+          style = flush_row(out, y, style)
+        end
+        y += 1
+      end
+      out << Ansi::RESET unless style.default?
+      @any_dirty = false
+      out
+    end
+
+    # @param y [Integer] row.
+    # @return [String] the plain text of row `y` (continuation cells contribute
+    #   nothing, so wide glyphs read as their single cluster). Intended for
+    #   tests; see {FakeScreen}.
+    def row_text(y)
+      return "" unless y >= 0 && y < @height
+
+      base = y * @width
+      (0...@width).map { |x| @cells[base + x].grapheme }.join
+    end
+
+    # @param y [Integer] row.
+    # @return [String] row `y` rendered to ANSI across its full width — the
+    #   minimal-SGR encoding of its cells, equivalent to what a component's
+    #   `set_line` of the whole row would have printed. Intended for tests that
+    #   assert on styled output (see {FakeScreen}); empty for an out-of-range row.
+    def row_ansi(y)
+      return "" unless y >= 0 && y < @height
+
+      base = y * @width
+      spans = (0...@width).map do |x|
+        c = @cells[base + x]
+        StyledString::Span.new(text: c.grapheme, style: c.style)
+      end
+      StyledString.new(spans).to_ansi
+    end
+
+    # @param rect [Rect]
+    # @return [Array<String>] the plain text of each row within `rect`'s column
+    #   range, top to bottom. The region equivalent of {#row_text}, for asserting
+    #   what a component painted into its own rect. Intended for tests.
+    def region_text(rect)
+      region_cells(rect).map { |row| row.map(&:grapheme).join }
+    end
+
+    # @param rect [Rect]
+    # @return [Array<String>] each row within `rect` rendered to ANSI, top to
+    #   bottom — byte-identical to what a component's per-row `set_line` over
+    #   that rect emitted. The region equivalent of {#row_ansi}. Intended for
+    #   tests asserting styled output.
+    def region_ansi(rect)
+      region_cells(rect).map do |row|
+        StyledString.new(row.map { |c| StyledString::Span.new(text: c.grapheme, style: c.style) }).to_ansi
+      end
+    end
+
+    private
+
+    # Core of {#set_char} with the grapheme's display width already known.
+    # {#set_line} computes each width once while advancing the column and passes
+    # it straight through, so the paint hot path measures every grapheme exactly
+    # once (and that once is a {.display_width} memo read). See {#set_char} for
+    # the wide-glyph / clipping / out-of-bounds contract.
+    # @param x [Integer] column.
+    # @param y [Integer] row.
+    # @param grapheme [String] one grapheme cluster.
+    # @param w [Integer] `grapheme`'s display width (0, 1, or 2).
+    # @param style [StyledString::Style]
+    # @return [void]
+    def put_char(x, y, grapheme, w, style)
+      return unless in_bounds?(x, y)
+      return if w <= 0
+
+      if w == 2 && !in_bounds?(x + 1, y)
+        blank_left_partner(x, y)
+        return write_cell(x, y, " ", style)
+      end
+
+      # Repair only the glyphs we'd leave half-overwritten on our flanks: a wide
+      # glyph whose right half sits at `x`, or one whose left half sits at the
+      # last cell we write. The cells we fully rewrite need no pre-blanking —
+      # pre-blanking the continuation only to re-empty it would churn it
+      # spuriously dirty, which misplaces the next flush onto the glyph's right
+      # half (see bug/, balloon corruption).
+      blank_left_partner(x, y)
+      blank_right_partner(x + w - 1, y)
+      write_cell(x, y, grapheme, style)
+      write_cell(x + 1, y, "", style) if w == 2
+    end
+
+    # (Re)allocates a blank grid of `size` with clean dirty state. Callers
+    # follow with {#mark_all_dirty} when the terminal doesn't match the new
+    # grid — construction and {#resize} both do.
+    # @param size [Size]
+    # @return [void]
+    def allocate_grid(size)
+      raise TypeError, "expected Size, got #{size.inspect}" unless size.is_a?(Size)
+
+      @width = size.width
+      @height = size.height
+      @cells = Array.new(@width * @height) { Cell.new(" ", DEFAULT_STYLE) }
+      @dirty_rows = Array.new(@height, false)
+      @any_dirty = false
+    end
+
+    # Emits the dirty cells of row `y` into `out`, breaking a run at each clean
+    # cell, and returns the running style at the end of the row.
+    # @param out [String] accumulator.
+    # @param y [Integer]
+    # @param style [StyledString::Style] style the terminal currently holds.
+    # @return [StyledString::Style]
+    def flush_row(out, y, style)
+      base = y * @width
+      run_open = false
+      x = 0
+      while x < @width
+        c = @cells[base + x]
+        if c.dirty
+          c.dirty = false
+          # A continuation cell (right half of a wide glyph) renders nothing of
+          # its own and must never open a run: positioning the cursor onto its
+          # column would land the next glyph on the wide glyph's left half,
+          # corrupting it. When the wide glyph itself is dirty it is emitted from
+          # its origin cell and advances the cursor across this column; when the
+          # glyph is intact this column needs no output at all. (A continuation
+          # can be left spuriously dirty by an in-place wide-glyph repaint, so we
+          # can't assume its origin was emitted in this same run.)
+          unless c.continuation?
+            unless run_open
+              out << TTY::Cursor.move_to(x, y)
+              run_open = true
+            end
+            out << style.sgr_to(c.style) << c.grapheme
+            style = c.style
+          end
+        else
+          run_open = false
+        end
+        x += 1
+      end
+      style
+    end
+
+    # @param rect [Rect]
+    # @return [Array<Array<Cell>>] cells within `rect`, row-major, clamped to
+    #   the grid (out-of-bounds positions yield a blank cell).
+    def region_cells(rect)
+      blank = Cell.new(" ", DEFAULT_STYLE)
+      (rect.top...(rect.top + rect.height)).map do |y|
+        (rect.left...(rect.left + rect.width)).map { |x| cell(x, y) || blank }
+      end
+    end
+
+    # @param x [Integer] column
+    # @param y [Integer] row
+    # @return [Integer] flat-array index for `(x, y)`.
+    def index(x, y) = (y * @width) + x
+
+    # @param x [Integer] column
+    # @param y [Integer] row
+    # @return [Boolean] true when `(x, y)` falls within the grid.
+    def in_bounds?(x, y) = x >= 0 && x < @width && y >= 0 && y < @height
+
+    # Rewrites the cell at `(x, y)` in place, marking it (and its row) dirty
+    # only when grapheme or style actually changes. Caller guarantees `(x, y)`
+    # is in bounds.
+    # @param x [Integer] column
+    # @param y [Integer] row
+    # @param grapheme [String] the new grapheme cluster
+    # @param style [StyledString::Style] the new style
+    # @return [void]
+    def write_cell(x, y, grapheme, style)
+      return unless @cells[index(x, y)].set(grapheme, style)
+
+      @dirty_rows[y] = true
+      @any_dirty = true
+    end
+
+    # If `(x, y)` holds the right half (continuation) of a wide glyph, blanks the
+    # orphaned left half at `x - 1`. Called before a write lands on `x`, so the
+    # wide glyph to the left isn't left headless.
+    # @param x [Integer] column
+    # @param y [Integer] row
+    # @return [void]
+    def blank_left_partner(x, y)
+      return unless in_bounds?(x, y) && @cells[index(x, y)].continuation? && in_bounds?(x - 1, y)
+
+      write_cell(x - 1, y, " ", DEFAULT_STYLE)
+    end
+
+    # If the cell just right of `(x, y)` is a continuation (the right half of a
+    # wide glyph whose origin is `(x, y)`), blanks it. Called before a write
+    # lands on `x`, so overwriting a wide origin doesn't strand its continuation.
+    # A continuation can only ever belong to the wide glyph immediately to its
+    # left, so the empty-grapheme test is exact — and cheaper than re-measuring
+    # the origin's width.
+    # @param x [Integer] column
+    # @param y [Integer] row
+    # @return [void]
+    def blank_right_partner(x, y)
+      return unless in_bounds?(x + 1, y) && @cells[index(x + 1, y)].continuation?
+
+      write_cell(x + 1, y, " ", DEFAULT_STYLE)
+    end
+  end
+end

data/lib/tuile/component/button.rb

@@ -12,7 +12,7 @@ module Tuile
     # {Component#handle_mouse}.
     #
     # Assign a {#rect} (typically by the surrounding {Layout}) wide enough to
-    # show `[ caption ]`; {#content_size} reports that natural width.
+    # show `[ caption ]` — that natural width is `caption.length + 4`.
     class Button < Component
       # @param caption [String] the button's label.
       # @yield optional `on_click` callback; same as assigning {#on_click=}.
@@ -20,7 +20,6 @@ module Tuile
         super()
         @caption = caption.to_s
         @on_click = on_click
-        self.content_size = natural_size
       end
 
       # @return [String] the button's label.
@@ -39,7 +38,6 @@ module Tuile
 
         @caption = new_caption
         invalidate
-        self.content_size = natural_size
       end
 
       def focusable? = true
@@ -49,9 +47,6 @@ module Tuile
       # @param key [String]
       # @return [Boolean]
       def handle_key(key)
-        return false unless active?
-        return true if super
-
         case key
         when Keys::ENTER, " "
           @on_click&.call
@@ -76,15 +71,9 @@ module Tuile
         return if rect.empty?
 
         label = "[ #{@caption} ]"[0, rect.width]
-        styled = active? ? screen.theme.active_bg(label) : label
-        screen.print TTY::Cursor.move_to(rect.left, rect.top), styled
+        styled = active? ? StyledString.styled(label, bg: screen.theme.active_bg_color) : StyledString.plain(label)
+        screen.buffer.set_line(rect.left, rect.top, styled)
       end
-
-      private
-
-      # Natural width is `caption.length + 4` to fit `[ caption ]`; height 1.
-      # @return [Size]
-      def natural_size = Size.new(@caption.length + 4, 1)
     end
   end
 end

data/lib/tuile/component/has_content.rb

@@ -9,12 +9,6 @@ module Tuile
       # @return [Component, nil] the current content component.
       attr_reader :content
 
-      # @param key [String] a key.
-      # @return [Boolean] true if the key was handled, false if not.
-      def handle_key(key)
-        content.nil? || !content.active? ? false : content.handle_key(key)
-      end
-
       # @param event [MouseEvent]
       # @return [void]
       def handle_mouse(event)

data/lib/tuile/component/info_window.rb

@@ -21,9 +21,11 @@ module Tuile
       # Opens the info window as a popup.
       # @param caption [String]
       # @param lines [Array<String>] the content, may contain formatting.
+      # @param size [Size, Fraction] the popup's size, applied top-down; the
+      #   list wraps and scrolls within it. Defaults to {Fraction::HALF}.
       # @return [Popup] the opened popup.
-      def self.open(caption, lines)
-        Popup.open(content: InfoWindow.new(caption, lines))
+      def self.open(caption, lines, size: Fraction::HALF)
+        Popup.open(content: InfoWindow.new(caption, lines), size: size)
       end
     end
   end

data/lib/tuile/component/label.rb

@@ -8,12 +8,17 @@ module Tuile
     # embedded ANSI is honored) or a {StyledString} directly. {#text}
     # always returns the {StyledString}.
     class Label < Component
-      def initialize
-        super
+      # @param text [String, StyledString, nil] initial text, coerced the same
+      #   way {#text=} coerces it (a `String` is parsed via
+      #   {StyledString.parse}; `nil` is an empty label). Equivalent to
+      #   constructing empty and assigning {#text=}.
+      def initialize(text = nil)
+        super()
         @text = StyledString::EMPTY
         @bg = nil
         @clipped_lines = []
         @blank_line = ""
+        self.text = text unless text.nil?
       end
 
       # @return [StyledString] the current text. Defaults to an empty
@@ -38,7 +43,6 @@ module Tuile
         @text = new_text
         update_clipped_lines
         invalidate
-        self.content_size = compute_content_size
       end
 
       # Sets the background color. Coerced via {Color.coerce}, so a Symbol,
@@ -70,7 +74,7 @@ module Tuile
 
         (0...rect.height).each do |row|
           line = @clipped_lines[row] || @blank_line
-          screen.print TTY::Cursor.move_to(rect.left, rect.top + row), line
+          screen.buffer.set_line(rect.left, rect.top + row, line)
         end
       end
 
@@ -84,29 +88,17 @@ module Tuile
 
       private
 
-      # Natural size: longest hard-line's display width × number of hard
-      # lines. Computed on the *unclipped* text — sizing is intrinsic to the
-      # content, not the viewport. Empty text yields {Size::ZERO}.
-      # @return [Size]
-      def compute_content_size
-        return Size::ZERO if @text.empty?
-
-        hard_lines = @text.lines
-        width = hard_lines.map(&:display_width).max || 0
-        Size.new(width, hard_lines.size)
-      end
-
       # Recomputes {@clipped_lines} for the current text and rect width.
-      # Each line is ellipsized to fit, padded with trailing spaces out to
-      # the full width, and pre-rendered to ANSI so {#repaint} is just a
-      # lookup + screen.print per row. {@blank_line} covers rows past the
-      # last text line. When {#bg} is set, every produced line (and the
-      # blank row) has the bg applied uniformly.
+      # Each line is ellipsized to fit and padded with trailing spaces out to
+      # the full width, so {#repaint} is just a lookup + {Buffer#set_line} per
+      # row. {@blank_line} covers rows past the last text line. When {#bg} is
+      # set, every produced line (and the blank row) has the bg applied
+      # uniformly.
       # @return [void]
       def update_clipped_lines
         width = rect.width.clamp(0, nil)
-        @blank_line = apply_bg(StyledString.plain(" " * width)).to_ansi
-        @clipped_lines = @text.lines.map { |line| apply_bg(pad_to(line.ellipsize(width), width)).to_ansi }
+        @blank_line = apply_bg(StyledString.plain(" " * width))
+        @clipped_lines = @text.lines.map { |line| apply_bg(pad_to(line.ellipsize(width), width)) }
       end
 
       # @param line [StyledString]

data/lib/tuile/component/layout.rb

@@ -56,15 +56,6 @@ module Tuile
         on_child_removed(child)
       end
 
-      # @return [Size]
-      def content_size
-        return Size::ZERO if @children.empty?
-
-        right  = @children.map { |c| c.rect.left + c.rect.width  }.max
-        bottom = @children.map { |c| c.rect.top  + c.rect.height }.max
-        Size.new(right - rect.left, bottom - rect.top)
-      end
-
       # Dispatches the event to the child under the mouse cursor.
       # @param event [MouseEvent]
       # @return [void]
@@ -75,18 +66,6 @@ module Tuile
         end
       end
 
-      # Called when a character is pressed on the keyboard.
-      # @param key [String] a key.
-      # @return [Boolean] true if the key was handled, false if not.
-      def handle_key(key)
-        return true if super
-
-        sc = @children.find(&:active?)
-        return false if sc.nil?
-
-        sc.handle_key(key)
-      end
-
       # @return [void]
       def on_focus
         super