tuile 0.13.0 → 0.15.0

data/lib/tuile/component/layout/box.rb

@@ -26,6 +26,13 @@ module Tuile
       # Nest boxes to vary the gap — a `Vertical.new(spacing: 0)` inside a
       # `Vertical.new(spacing: 1)` groups two rows tightly within a looser stack.
       #
+      # **Hiding a pane is {#remove}, not `Fixed[0]`** (see {Fixed} for why an
+      # empty rect is not hiding). {#add}'s `at:` is what makes it reversible —
+      # keep the index and the constraints on your side:
+      #
+      #   remove(@sidebar)                    # hide: siblings reclaim the space
+      #   add(@sidebar, Expand[1], at: 0)     # show: back where it was
+      #
       # == Implementation details
       #
       # Every child-list mutation re-runs the whole pass, because in a box the
@@ -98,6 +105,7 @@ module Tuile
         #
         #   add(field, Fixed[1], cross: Fixed[30], align: :center)
         #   add([ok, cancel], Fixed[1])
+        #   add(sidebar, Expand[1], at: 0)   # back where it was, after a #remove
         #
         # @param child [Component, Enumerable<Component>]
         # @param main [Fixed, Percent, Expand] extent along the main axis.
@@ -105,24 +113,58 @@ module Tuile
         # @param align [Symbol] one of {ALIGNMENTS} — where a child narrower than
         #   the cross extent sits. {Vertical} / {Horizontal} say which edge
         #   `:start` is.
+        # @param at [Integer, nil] position among the existing children; appends
+        #   when nil. An Enumerable is inserted in order from there. This is what
+        #   makes hiding-by-{#remove} reversible — see the class doc.
         # @raise [ArgumentError] on an unknown constraint or alignment, or an
         #   {Expand} passed as `cross` (see {Expand}).
         # @raise [TypeError] if `child` is not a {Component}.
         # @return [void]
-        def add(child, main = Fixed[1], cross: Percent[100], align: :start)
+        def add(child, main = Fixed[1], cross: Percent[100], align: :start, at: nil)
           if child.is_a? Enumerable
-            child.each { add(_1, main, cross:, align:) }
+            child.each_with_index { |c, i| add(c, main, cross:, align:, at: at && at + i) }
             return
           end
 
           validate_main(main)
           validate_cross(cross)
           validate_align(align)
-          add_child(child)
+          add_child(child, at:)
           @placements[child] = { main:, cross:, align: }
           relayout
         end
 
+        # Re-constrains a child already in the layout and re-runs the pass. A
+        # `nil` argument keeps what that axis already had, so one can move alone:
+        #
+        #   box.constrain(sidebar, Fixed[0])   # collapse it; cross: and align: stand
+        #
+        # `Fixed[0]` *collapses* — see {Fixed} for why that is not the same as
+        # hiding, and the class doc for what is.
+        #
+        # @param child [Component] a child of this layout.
+        # @param main [Fixed, Percent, Expand, nil] extent along the main axis.
+        # @param cross [Fixed, Percent, nil] extent across it.
+        # @param align [Symbol, nil] one of {ALIGNMENTS}.
+        # @raise [ArgumentError] if `child` is not a child of this layout, or on
+        #   an unknown constraint or alignment.
+        # @return [void]
+        def constrain(child, main = nil, cross: nil, align: nil)
+          raise ArgumentError, "#{child} is not a child of #{self}" unless children.any? { _1.equal?(child) }
+
+          validate_main(main) unless main.nil?
+          validate_cross(cross) unless cross.nil?
+          validate_align(align) unless align.nil?
+
+          current = placement(child)
+          updated = { main: main || current[:main], cross: cross || current[:cross],
+                      align: align || current[:align] }
+          return if current == updated
+
+          @placements[child] = updated
+          relayout
+        end
+
         # Removes the child, forgets its constraints, and closes the gap it left
         # by re-running the layout.
         # @param child [Component]
@@ -140,19 +182,34 @@ module Tuile
           relayout
         end
 
+        protected
+
+        # Re-divides the space: a child that went hidden gives its slot *and*
+        # the {#spacing} around it to its siblings, and one that came back takes
+        # them again with the constraints it was added with — which is what
+        # {Component#visible=} buys over `remove` plus `add(…, at:)`.
+        # @param _child [Component]
+        # @return [void]
+        def on_child_visibility_changed(_child) = relayout
+
         private
 
-        # Recomputes and assigns every child's rect. Silent until this layout has
-        # a rect of its own — {#add} runs during construction, long before a
-        # parent assigns one.
+        # Recomputes and assigns every child's rect, giving each an empty one
+        # when this layout's own rect — or {#inner_rect} — is empty.
+        #
+        # Deliberately *no* `return if rect.empty?` guard: that strands the
+        # children at the coordinates they last had, and the next full repaint
+        # paints them there (`D_empty_ancestor`). Construction is silent without
+        # one anyway — {#add} runs before a parent assigns a rect, so the
+        # children are already empty and `invalidate` no-ops while detached.
         # @return [void]
         def relayout
-          return if rect.empty?
-
           inner = inner_rect
-          if inner.empty?
-            children.each { _1.rect = Rect.new(rect.left, rect.top, 0, 0) }
+          collapsed = Rect.new(rect.left, rect.top, 0, 0)
+          if rect.empty? || inner.empty?
+            children.each { _1.rect = collapsed }
           else
+            children.each { _1.rect = collapsed unless _1.visible? }
             place_children(inner)
           end
           invalidate
@@ -168,20 +225,30 @@ module Tuile
         # @param inner [Rect] {#inner_rect}, known non-empty.
         # @return [void]
         def place_children(inner)
-          sizes = main_sizes(inner)
+          kids = shown_children
+          sizes = main_sizes(inner, kids)
           available = cross_extent(inner)
           offset = 0
-          children.each_with_index do |child, i|
+          kids.each_with_index do |child, i|
             cross_offset, cross_size = cross_placement(child, available)
             child.rect = build_rect(inner, offset, sizes[i], cross_offset, cross_size)
             offset += sizes[i] + spacing
           end
         end
 
+        # The children this pass divides space between — a hidden one is out of
+        # the {#spacing} count as well as the arithmetic, so hiding a middle
+        # child closes the row up rather than leaving a double gap. Contrast a
+        # `Fixed[0]` child, still a member of the sequence and still paying for
+        # its gap (`D_visibility`).
+        # @return [Array<Component>]
+        def shown_children = children.select(&:visible?)
+
         # @param inner [Rect] {#inner_rect}.
-        # @return [Array<Integer>] main-axis extent per child, in child order.
-        def main_sizes(inner)
-          count = children.size
+        # @param kids [Array<Component>] {#shown_children}.
+        # @return [Array<Integer>] main-axis extent per shown child, in order.
+        def main_sizes(inner, kids)
+          count = kids.size
           return [] if count.zero?
 
           available = [main_extent(inner) - (spacing * (count - 1)), 0].max
@@ -189,7 +256,7 @@ module Tuile
           expanding = []
           unassigned = available
 
-          children.each_with_index do |child, i|
+          kids.each_with_index do |child, i|
             case (constraint = placement(child)[:main])
             when Expand then expanding << i
             when Fixed then unassigned -= (sizes[i] = constraint.cells.clamp(0, unassigned))
@@ -197,19 +264,20 @@ module Tuile
             end
           end
 
-          distribute_expand(sizes, expanding, unassigned) unless expanding.empty?
+          distribute_expand(sizes, kids, expanding, unassigned) unless expanding.empty?
           sizes
         end
 
         # Splits `slack` between the {Expand} children by weight, writing the
         # results into `sizes`.
         # @param sizes [Array<Integer>] mutated in place.
+        # @param kids [Array<Component>] {#shown_children}, which `indices` index.
         # @param indices [Array<Integer>] child indices carrying an {Expand}.
         # @param slack [Integer] cells left over; a negative value yields zeroes.
         # @return [void]
-        def distribute_expand(sizes, indices, slack)
+        def distribute_expand(sizes, kids, indices, slack)
           slack = 0 if slack.negative?
-          weights = indices.map { placement(children[_1])[:main].weight }
+          weights = indices.map { placement(kids[_1])[:main].weight }
           total = weights.sum
           shares = weights.map { slack * _1 / total }
           # Under one cell is lost per floor, so the remainder can't outrun the

data/lib/tuile/component/layout.rb

@@ -23,7 +23,14 @@ module Tuile
       #   add(prompt, Fixed[4])                    # 4 rows in a Vertical
       #   add(field, Fixed[1], cross: Fixed[30])   # 1 row, 30 columns wide
       #
-      # `Fixed[0]` hides the child — it gets an empty rect and paints nothing.
+      # `Fixed[0]` *collapses* the child: it and its whole subtree get an empty
+      # rect and paint nothing. That is not the same as hiding it — an empty
+      # rect is a paint convention and gates nothing else, so the subtree keeps
+      # its tab stops and still takes keys. **To hide a child, set
+      # {Component#visible=} false**; it then costs no {Box#spacing} gap either,
+      # where a collapsed child still does. The difference is exactly that: a
+      # collapsed child is still a member of the sequence, a hidden one is not
+      # (`D_visibility`).
       #
       # @!attribute [r] cells
       #   @return [Integer] cell count along the axis.
@@ -190,16 +197,6 @@ module Tuile
         invalidate if @children.empty? # nothing left to paint over the gap
       end
 
-      # Dispatches the event to the child under the mouse cursor.
-      # @param event [MouseEvent]
-      # @return [void]
-      def handle_mouse(event)
-        super
-        @children.each do |child|
-          child.handle_mouse(event) if child.rect.contains?(event.point)
-        end
-      end
-
       # @return [void]
       def on_focus
         super
@@ -209,12 +206,15 @@ module Tuile
         # containers like a {Window} or another {Layout}. Fall back to the
         # first focusable direct child for the rare case where the layout has
         # focusable but non-tab-stop children (e.g. an empty {Window}).
+        #
+        # Both halves skip hidden subtrees — this is the cascade that would
+        # otherwise walk straight back into the pane just hidden.
         first_tab_stop = nil
-        on_tree { |c| first_tab_stop ||= c if !c.equal?(self) && c.tab_stop? }
+        on_shown_tree { |c| first_tab_stop ||= c if !c.equal?(self) && c.tab_stop? }
         if first_tab_stop
           screen.focused = first_tab_stop
         else
-          first_focusable = @children.find(&:focusable?)
+          first_focusable = @children.find { _1.visible? && _1.focusable? }
           screen.focused = first_focusable unless first_focusable.nil?
         end
       end

data/lib/tuile/component/list.rb

@@ -564,7 +564,7 @@ module Tuile
       protected
 
       # Drops the rendered-row cache when the wrap width changes. The wrap
-      # width depends on {#rect}`.width` and the scrollbar gutter, both of
+      # width depends on {#rect}`.width` and the scrollbar column, both of
       # which trigger this hook. Also re-evaluates {#auto_scroll}: if items were
       # assigned while the rect was empty (e.g. a {Popup}-wrapped list was
       # populated before the popup was opened), the auto-scroll update
@@ -766,7 +766,7 @@ module Tuile
       end
 
       # @return [Integer] column width available for row content (rect width
-      #   minus the scrollbar gutter, when visible). `0` when {#rect}'s width
+      #   minus the scrollbar column, when visible). `0` when {#rect}'s width
       #   is non-positive.
       def content_width
         return 0 if rect.width <= 0
@@ -809,9 +809,11 @@ module Tuile
         rendered.lines.first
       end
 
-      # Pads `row` to one full row of the viewport (scrollbar gutter
-      # excluded). Rows wider than the content area are ellipsized via
-      # {StyledString#ellipsize} (span styles survive the cut); shorter
+      # Pads `row` to one full row of the viewport (scrollbar column
+      # excluded), including the one-column gutter either side — the trailing
+      # one is what keeps a row off the bar, as {TextView#scrollbar_columns}
+      # reserves separately. Rows wider than the content area are ellipsized
+      # via {StyledString#ellipsize} (span styles survive the cut); shorter
       # ones are padded with default-styled spaces.
       # @param row [StyledString]
       # @return [StyledString] exactly {#content_width} display columns wide
@@ -837,7 +839,10 @@ module Tuile
         base = index < @items.size ? padded_row(index) : blank_row
         is_cursor = (active? || @show_cursor_when_inactive) && index < @items.size && @cursor.position == index
         styled = is_cursor ? base.with_bg(screen.theme.active_bg_color) : base
-        styled += StyledString.plain(scrollbar.scrollbar_char(row_in_viewport)) if scrollbar
+        if scrollbar
+          styled += StyledString.styled(scrollbar.scrollbar_char(row_in_viewport),
+                                        fg: screen.theme.scrollbar_color)
+        end
         styled
       end
     end

data/lib/tuile/component/list_dropdown.rb

@@ -4,7 +4,7 @@ module Tuile
   class Component
     # A borderless, tinted, non-focusable floating selection list — the dropdown
     # a *driver* drops open, drives by forwarding movement keys, and commits a
-    # pick from: a non-modal {Popup} wrapping a {List} that never takes focus, so
+    # pick from: an {Overlay} wrapping a {List} that never takes focus, so
     # focus stays on the driver while the caller refills the rows, moves the
     # highlight, and reads the pick.
     #
@@ -34,7 +34,7 @@ module Tuile
     # different tint (a `Theme.ref(:token)` keeps the flip-tracking).
     #
     # UI-thread-confined, like every component (see {Screen}).
-    class ListDropdown < Popup
+    class ListDropdown < Overlay
       # The dropdown's {List}. Non-focusable on purpose: the driver forwards keys
       # while focus stays on it, and a mouse click selects an item without
       # stealing focus — so a driving text input never loses its caret
@@ -51,6 +51,10 @@ module Tuile
       # caret; {Select} would spend a branch on what a second arrow press already
       # does) — and Enter/ESC, which carry driver-specific tails (see the class
       # docs).
+      #
+      # A driver only ever sees the keys its own children decline, so a
+      # {ComboBox} never gets Ctrl+U — its field claims it to clear the query —
+      # while {Select}, wrapping no editor, gets every one of these.
       # @return [Array<String>]
       MOVE_KEYS = [Keys::UP_ARROW, Keys::DOWN_ARROW, Keys::PAGE_UP, Keys::PAGE_DOWN,
                    Keys::CTRL_U, Keys::CTRL_D].freeze
@@ -64,7 +68,7 @@ module Tuile
         @list = Menu.new
         @list.cursor = List::Cursor.new
         @list.show_cursor_when_inactive = true # highlight the selection though focus stays on the driver
-        super(content: @list, modal: false)
+        super(content: @list)
         self.bg_color = Theme.ref(:input_bg_color)
       end
 
@@ -124,7 +128,16 @@ module Tuile
       # Vertical flips but horizontal slides because covering the driver would
       # hide what is being chosen, while sharing its columns is the point.
       #
-      # @param anchor [Rect] the driver's rect; the dropdown never covers it.
+      # **`anchor` is the region actually occupied, and may be taller than one
+      # row** — "beneath" means the row *after* it, so a multi-row driver (a
+      # {Component::TextArea} carrying an autocomplete menu) is cleared entirely
+      # rather than overdrawn from its second row down. A widget that paints one
+      # row but may be *assigned* more height passes its face, not its rect:
+      # {ComboBox} and {Select} both do, since a {Window} content slot hands them
+      # the full inner height.
+      #
+      # @param anchor [Rect] the region the driver occupies, of any height; the
+      #   dropdown never covers it.
       # @param rows [Integer] how many rows there are to show — the content
       #   count, not the height: more than fits turns the scrollbar on. `0`
       #   collapses the dropdown to an empty rect (drivers close instead).
@@ -136,20 +149,20 @@ module Tuile
       # @return [void]
       def anchor_to(anchor, rows:, width: anchor.width, max_rows: MAX_VISIBLE_ROWS)
         desired = [rows, max_rows].min
-        below = screen.size.height - (anchor.top + 1)
+        beneath = anchor.top + anchor.height
+        below = screen.size.height - beneath
         above = anchor.top
         if desired <= below
-          top = anchor.top + 1
+          top = beneath
           height = desired
         elsif above >= below
           height = [desired, above].min
           top = anchor.top - height
         else
           height = below
-          top = anchor.top + 1
+          top = beneath
         end
         width = [width, screen.size.width].min
-        self.size = Size.new(width, height)
         self.rect = Rect.new([anchor.left, screen.size.width - width].min.clamp(0, nil), top, width, height)
         # After the geometry: the setter rebuilds the list's padded rows against
         # the width it can see, and the gutter takes a column off it.
@@ -182,7 +195,7 @@ module Tuile
       # @param width [Integer] the panel's width in columns, clamped to the
       #   screen. **Required, with no default:** `anchor.width` is the *parent's*
       #   width and would be meaningless here, so the caller measures (see
-      #   `DECISIONS.md` `D-select` on why the width policy stays with the
+      #   `DECISIONS.md` `D_select` on why the width policy stays with the
       #   driver).
       # @param max_rows [Integer] rows shown before the list scrolls.
       # @return [void]
@@ -197,7 +210,6 @@ module Tuile
                end
         left = left.clamp(0, [screen.size.width - width, 0].max)
         top = [anchor.top, screen.size.height - height].min.clamp(0, nil)
-        self.size = Size.new(width, height)
         self.rect = Rect.new(left, top, width, height)
         # After the geometry, as in {#anchor_to}: the setter rebuilds the list's
         # padded rows against the width it can see.

data/lib/tuile/component/log_text_view.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    # A {TextView} purpose-built for log output: auto-scroll is on, the
+    # scrollbar is visible, and lines arrive via {#log} — from any thread.
+    # Point a logger at a {LogTextView::IO} to route its lines here:
+    #
+    #   view = Tuile::Component::LogTextView.new
+    #   logger = Logger.new(Tuile::Component::LogTextView::IO.new(view))
+    #   logger.info("started")   # appears in the view, from any thread
+    #
+    # Any logger that writes formatted lines to an IO works the same way —
+    # for example `TTY::Logger` configured with the `:console` handler and
+    # `output: LogTextView::IO.new(view)`.
+    #
+    # Add it to a layout as-is for a frameless log pane, or use {LogWindow}
+    # for the framed assembly. A {TextView} rather than a {List}: long lines
+    # (stacktraces, wide log records) word-wrap rather than ellipsize — a
+    # truncated log line hides the very detail you opened the log to read.
+    class LogTextView < TextView
+      def initialize
+        super
+        self.auto_scroll = true
+        self.scrollbar_visibility = :visible
+      end
+
+      # Appends the given line to the log. Safe to call from any thread —
+      # the one exception to the UI-thread confinement every component
+      # carries: the append is marshalled through `event_queue.submit`, so
+      # it lands once a loop drains the queue (deferred before the first
+      # loop; silently dropped after the loop has returned).
+      # @param string [String, nil] the line (or multiple lines) to log;
+      #   `nil` is a no-op.
+      # @return [void]
+      def log(string)
+        return if string.nil?
+
+        screen.event_queue.submit { add_line(string) }
+      end
+
+      # IO-shaped adapter that forwards each log line to its sink's `#log`.
+      # Implements both {#write} (stdlib `Logger`) and {#puts} (loggers that
+      # call `output.puts`, e.g. `TTY::Logger`).
+      class IO
+        # @param sink [LogTextView, LogWindow] anything responding to `#log`.
+        def initialize(sink)
+          @sink = sink
+        end
+
+        # @param string [String]
+        # @return [void]
+        def write(string)
+          @sink.log(string.chomp)
+        end
+
+        # @param string [String]
+        # @return [void]
+        def puts(string)
+          @sink.log(string)
+        end
+
+        # Stdlib `Logger` only treats an object as an IO target when it
+        # responds to both {#write} and {#close}; otherwise it tries to
+        # interpret it as a filename. This is a no-op.
+        # @return [void]
+        def close; end
+      end
+    end
+  end
+end

data/lib/tuile/component/log_window.rb

@@ -2,65 +2,30 @@
 
 module Tuile
   class Component
-    # Shows a log. Construct your logger pointed at a {LogWindow::IO} to route
-    # log lines into this window:
+    # A {Window} framing a {LogTextView} — the framed log pane. All the log
+    # behavior lives on the view (see {LogTextView} for the adapter and the
+    # wrap rationale); the window adds the border, caption and delegation:
     #
     #   log_window = Tuile::Component::LogWindow.new
     #   logger = Logger.new(Tuile::Component::LogWindow::IO.new(log_window))
-    #
-    # Any logger that writes formatted lines to an IO works the same way —
-    # for example `TTY::Logger` configured with the `:console` handler and
-    # `output: LogWindow::IO.new(window)`.
     class LogWindow < Window
+      # Alias of {LogTextView::IO}, which accepts the window itself as its sink.
+      # @return [Class]
+      IO = LogTextView::IO
+
       # @param caption [String]
       def initialize(caption = "Log")
         super
-        view = Component::TextView.new
-        # Word-wrap long lines (stacktraces, wide log records) rather than
-        # ellipsizing them as a {List} would — a truncated log line hides the
-        # very detail you opened the log to read.
-        view.auto_scroll = true
-        self.content = view
-        self.scrollbar = true
+        self.content = LogTextView.new
       end
 
-      # Appends given line to the log. Can be called from any thread. Does nothing if nil is passed in.
-      # @param string [String, nil] the line (or multiple lines) to log.
+      # Appends the given line to the log, from any thread — delegates to
+      # {LogTextView#log}.
+      # @param string [String, nil] the line (or multiple lines) to log;
+      #   `nil` is a no-op.
       # @return [void]
       def log(string)
-        return if string.nil?
-
-        screen.event_queue.submit do
-          content.add_line(string)
-        end
-      end
-
-      # IO-shaped adapter that forwards each log line to the owning {LogWindow}.
-      # Implements both {#write} (stdlib `Logger`) and {#puts} (loggers that
-      # call `output.puts`, e.g. `TTY::Logger`).
-      class IO
-        # @param window [LogWindow]
-        def initialize(window)
-          @window = window
-        end
-
-        # @param string [String]
-        # @return [void]
-        def write(string)
-          @window.log(string.chomp)
-        end
-
-        # @param string [String]
-        # @return [void]
-        def puts(string)
-          @window.log(string)
-        end
-
-        # Stdlib `Logger` only treats an object as an IO target when it
-        # responds to both {#write} and {#close}; otherwise it tries to
-        # interpret it as a filename. This is a no-op.
-        # @return [void]
-        def close; end
+        content.log(string)
       end
     end
   end

data/lib/tuile/component/menu_bar/cascade.rb

@@ -19,7 +19,7 @@ module Tuile
       #
       # Widths are measured here, per level — the panel is as wide as the level's
       # widest label — because {ListDropdown} deliberately measures nothing
-      # itself (`DECISIONS.md` `D-select`).
+      # itself (`DECISIONS.md` `D_select`).
       #
       # == Implementation details
       # While open it consumes **everything** except the two keys that mean
@@ -33,7 +33,7 @@ module Tuile
         # The affordance painted on a row that opens a submenu. U+25B8 rather
         # than the obvious `▶`: like {Component::Select}'s `▾` it is East-Asian
         # **Neutral**, so it measures one column even under ambiguous-as-wide and
-        # stays outside `D-ambiguous-width`'s bet, where `▶` and `▼` are
+        # stays outside `D_ambiguous_width`'s bet, where `▶` and `▼` are
         # Ambiguous and would need an ASCII opt-in.
         # @return [String]
         SUBMENU_ARROW = "▸"
@@ -179,7 +179,7 @@ module Tuile
           drop.on_cursor_changed = ->(_index, _child) { truncate(level + 1) }
           # The cascade's own record of what is open is reconciled from the
           # popup's own closure, not maintained alongside it: an outside click
-          # closes panels behind our back ({Popup#close_on_outside_click?}), and
+          # closes panels behind our back ({Overlay#close_on_outside_click?}), and
           # a level left in `@levels` after its panel is gone would have `depth`,
           # `deepest` and `highlighted` all lying. Identity-keyed and idempotent,
           # because the notice also arrives from `truncate` (which has already

data/lib/tuile/component/menu_bar.rb

@@ -43,7 +43,7 @@ module Tuile
     # {Item} handles are minted by {#add_item} and nest via the *same* method, so
     # depth is unlimited. There is no removal, no reordering and no dynamic
     # rebuilding: a menu is built once, at construction. See `DECISIONS.md`
-    # `D-menu-bar`.
+    # `D_menu_bar`.
     #
     # == Sizing
     # Assign a {#rect} (typically one {Layout::Fixed}`[1]` row at the top of a
@@ -244,11 +244,11 @@ module Tuile
       # tail — or on a lower row, when the rect is taller than one — opens
       # nothing. It still *focuses*: {Component#handle_mouse}'s click-to-focus is
       # ungated by geometry.
-      # @return [Rect]
+      # @return [Size]
       def extent
-        return Rect.new(rect.left, rect.top, 0, 1) if rect.empty?
+        return Size.new(0, 1) if rect.empty?
 
-        Rect.new(rect.left, rect.top, [painted_width - @left_column, rect.width].min, 1)
+        Size.new([painted_width - @left_column, rect.width].min, 1)
       end
 
       # @param new_rect [Rect]
@@ -470,7 +470,7 @@ module Tuile
       # @return [Integer, nil] the index of the item painted at `point`; `nil`
       #   for the blank tail or a row the strip doesn't paint.
       def index_at(point)
-        return nil unless extent.contains?(point)
+        return nil unless extent_rect.contains?(point)
 
         column = point.x - rect.left + @left_column
         segments.index { |_item, start, width| column >= start && column < start + width }