tuile 0.16.0 → 0.17.0

data/lib/tuile/component/overlay.rb

@@ -3,17 +3,23 @@
 module Tuile
   class Component
     # A component mounted on the {Screen}'s overlay stack rather than in the
-    # tiled tree: it floats above the content at a rect the caller assigns, and
-    # has an open/close lifecycle instead of a parent that lays it out.
+    # tiled tree: it floats above the content, and has an open/close lifecycle.
+    # It opens with a *placement* — where it wants to be — and the
+    # {ScreenPane}'s layout pass turns that into its rect, again on every
+    # resize:
     #
     #   overlay = Component::Overlay.new(content: Component::Label.new("saved"))
-    #   overlay.rect = Rect.new(10, 4, 20, 1)   # you place it — nothing else does
-    #   overlay.open                            # mounts it on the Screen
+    #   overlay.open(Overlay::At[Rect.new(10, 4, 20, 1)])   # mounts it on the Screen
+    #   overlay.placement = Overlay::At[Rect.new(10, 6, 20, 1)]   # moves it
     #   overlay.close
     #
     # That is the whole of it — floating, plus the lifecycle, {#on_close},
     # outside-click dismissal and {#owner}. {Component::Popup} is the subclass
-    # that adds a declared size, self-centering, focus and key handling.
+    # that adds a declared size, centering, focus and key handling.
+    #
+    # Where it goes is a {Placement}: {At} a fixed rect, {Centered} and
+    # {TopRight} an overlay that declares its size ({#declared_size_in}),
+    # {ListDropdown::Anchored} a dropdown hanging off a field.
     #
     # The wrapped content fills the overlay's whole {#rect}; for a frame and a
     # caption, wrap a {Component::Window} and let it draw its own border.
@@ -30,18 +36,127 @@ module Tuile
     # non-modal overlay is therefore driven from its owner's key handler
     # ({Component::Select} forwarding to its dropdown) instead of claiming focus.
     #
-    # **A derived position needs a {#reposition} override.** The default is a
-    # no-op: the rect is whatever the caller last assigned. An overlay whose
-    # position is computed — from the screen, or from an anchor — must recompute
-    # it there, or it keeps a stale rect after a SIGWINCH and sits off-screen
-    # entirely if the terminal narrowed. Closing on resize is equally legal
-    # ({Component::MenuBar} drops its cascade from `rect=` rather than walking
-    # every level to re-anchor it).
+    # **An overlay whose size changes calls {#reposition}**, which asks the pane
+    # to place it again; the placement itself stays put. That is how a growing
+    # {Component::Notification} or a re-measured {Component::ConfirmWindow}
+    # gets its new rect.
     #
     # UI-thread-confined, like every component (see {Screen}).
     class Overlay < Component
       include Component::HasContent
 
+      # Where an overlay wants to be. Include it to *be* a placement — the pane
+      # asks for a rect on every layout pass, and an app supplies its own by
+      # answering {#rect_for}:
+      #
+      #   Bottom = Data.define do
+      #     include Overlay::Placement
+      #
+      #     def rect_for(overlay, screen_size, _anchor_rect)
+      #       size = overlay.declared_size_in(screen_size)
+      #       Rect.new(0, screen_size.height - size.height, size.width, size.height)
+      #     end
+      #   end
+      #
+      #   overlay.open(Bottom[])
+      #
+      # A placement is a **rule, not a rect**: it is re-read on every resize and
+      # every settle, so re-running it moves nothing that stood still. Built in
+      # are {At}, {Centered}, {TopRight} and {ListDropdown::Anchored}.
+      #
+      # == Anchors
+      #
+      # A placement that hangs off something on screen — a field, a menu row —
+      # says so by answering {#anchor}; the pane resolves it and hands the rect
+      # to {#rect_for}:
+      #
+      #   def anchor = field
+      #
+      # Resolving is deliberately the framework's job: a component becomes a
+      # screen rect through an ancestor-inclusive visibility walk, an
+      # {Component#attached?} test and {Component#absolute_extent_rect} (not
+      # {Component#absolute_rect}) — three invariants, one of them the trap
+      # {Component#walk_shown_tree} exists to prevent. {#anchor} therefore
+      # answers one of three things:
+      #
+      # - a {Component} — resolved while it is reachable, and **losable**: once
+      #   detached or hidden there is no rect to compute, so the pane leaves the
+      #   overlay where it was and warns its owner once rather than placing it
+      #   against nothing. Closing it is the owner's job.
+      # - a {Rect} in screen coordinates — always resolves, never lost. Anchors to an absolute position.
+      # - `nil`, the default — not anchored; {#rect_for} is handed `nil`.
+      #
+      # An anchor also earns a **second settle pass**: the pane lays out before
+      # the content its anchor sits in does, so {Screen#flush_layout} re-reads
+      # every {#anchor} once the queue is empty and runs the pane again if any
+      # now resolves elsewhere.
+      module Placement
+        # What this placement hangs off, re-read on every pass — see the
+        # *Anchors* section above.
+        # @return [Component, Rect, nil] `nil`, the default, is not anchored.
+        def anchor = nil
+
+        # The rect this placement wants for `overlay`, in screen coordinates.
+        # The pane assigns it as-is — clamping it on screen is the placement's
+        # own job.
+        # @param overlay [Overlay] the overlay being placed.
+        # @param screen_size [Size] the whole terminal.
+        # @param anchor_rect [Rect, nil] {#anchor} resolved to screen
+        #   coordinates; `nil` only for an unanchored placement, since a lost
+        #   anchor is not placed at all.
+        # @raise [NotImplementedError] unless the includer overrides it.
+        # @return [Rect]
+        def rect_for(overlay, screen_size, anchor_rect)
+          raise(NotImplementedError, "#{self.class}#rect_for")
+        end
+      end
+
+      # Places the overlay at exactly `rect`, in screen coordinates.
+      #
+      #   overlay.open(Overlay::At[Rect.new(10, 4, 20, 1)])
+      #
+      # @!attribute [r] rect
+      #   @return [Rect]
+      At = Data.define(:rect) do
+        include Placement
+
+        # @param _overlay [Overlay]
+        # @param _screen_size [Size]
+        # @param _anchor_rect [Rect, nil] unused: this placement declares no {#anchor}.
+        # @return [Rect]
+        def rect_for(_overlay, _screen_size, _anchor_rect) = rect
+      end
+
+      # Centers the overlay on the screen at the size it declares
+      # ({Overlay#declared_size_in}) — {Popup}'s default.
+      Centered = Data.define do
+        include Placement
+
+        # @param overlay [Overlay]
+        # @param screen_size [Size]
+        # @param _anchor_rect [Rect, nil] unused: this placement declares no {#anchor}.
+        # @return [Rect]
+        def rect_for(overlay, screen_size, _anchor_rect)
+          size = overlay.declared_size_in(screen_size)
+          Rect.new(0, 0, size.width, size.height).centered(screen_size)
+        end
+      end
+
+      # Puts the overlay in the screen's top-right corner at the size it
+      # declares ({Overlay#declared_size_in}) — {Notification}'s default.
+      TopRight = Data.define do
+        include Placement
+
+        # @param overlay [Overlay]
+        # @param screen_size [Size]
+        # @param _anchor_rect [Rect, nil] unused: this placement declares no {#anchor}.
+        # @return [Rect]
+        def rect_for(overlay, screen_size, _anchor_rect)
+          size = overlay.declared_size_in(screen_size)
+          Rect.new([screen_size.width - size.width, 0].max, 0, size.width, size.height)
+        end
+      end
+
       # @param content [Component, nil] initial content; can be set later via
       #   {#content=}. It fills the overlay's {#rect} and does not determine it.
       # @param close_on_outside_click [Boolean] true (default) to dismiss on a
@@ -50,7 +165,6 @@ module Tuile
         super()
         @close_on_outside_click = close_on_outside_click
         @owner = nil
-        @on_close = nil
         @content = nil
         self.content = content unless content.nil?
       end
@@ -127,46 +241,74 @@ module Tuile
       # @return [Component, nil]
       attr_accessor :owner
 
-      # A callback taking no arguments, fired once this overlay has left the
-      # screen — **however it left**: {#close}, a direct {Screen#remove_popup},
-      # an outside click, or teardown via {Screen#close}. That unconditionality
-      # is the point, so it hangs off {#handle_detached} rather than {#close}; a
-      # driver keeping its own record of open overlays reconciles it here and
-      # cannot drift ({Component::MenuBar::Cascade} is the worked example).
-      #
-      # It fires *after* the overlay is detached, so {#open?} is already false
-      # and the usual {Component#handle_detached} caveats apply: release state, don't
-      # inspect the tree, keep it trivial (it may run while the pane is mid-way
-      # through closing a batch of overlays, and a raise propagates).
-      # @return [Proc, nil]
-      attr_accessor :on_close
-
-      # Reassigns the overlay's rect, escalating to a full scene repaint when an
-      # open overlay shrinks or moves so its new rect no longer covers the cells
-      # it previously painted. An overlay overdraws the scene without clipping
-      # and nothing clears underneath it, so {Screen#repaint}'s overlay-only fast
-      # path would repaint into the new rect and leave the vacated cells showing
-      # stale content. When the new rect fully covers the old one (the overlay
-      # only grew), the fast path is correct and the full repaint is skipped.
-      # @param new_rect [Rect]
+      # What {#on_close} fires.
+      #
+      # @!attribute [r] source
+      #   @return [Overlay] the overlay that left the screen.
+      CloseEvent = Data.define(:source) { include Tuile::Event }
+
+      # @!method on_close
+      #   Fired with a {CloseEvent} once this overlay has left the screen —
+      #   **however it left**: {#close}, a direct {Screen#remove_popup}, an
+      #   outside click, or teardown via {Screen#close}. That unconditionality is
+      #   the point, so it hangs off {#handle_detached} rather than {#close}; a
+      #   driver keeping its own record of open overlays reconciles it here and
+      #   cannot drift ({Component::MenuBar::Cascade} is the worked example).
+      #
+      #   It fires *after* the overlay is detached, so {#open?} is already false
+      #   and the usual {Component#handle_detached} caveats apply: release state,
+      #   don't inspect the tree, keep it trivial (it may run while the pane is
+      #   mid-way through closing a batch of overlays, and a raise propagates).
+      #   @return [Listeners]
+      listener :on_close
+
+      # The box this overlay asks for on a screen of `screen_size` — what
+      # {Centered} and {TopRight} place. A bare overlay declares none.
+      # @param _screen_size [Size]
+      # @raise [Tuile::Error] always, here; {Popup} and {Notification} answer.
+      # @return [Size]
+      def declared_size_in(_screen_size)
+        raise Tuile::Error, "#{self.class} declares no size — place it with Overlay::At[rect]"
+      end
+
+      # The placement a bare {#open} uses. A bare overlay has none, because
+      # nothing about it says where it goes.
+      # @raise [ArgumentError] always, here; {Popup} and {Notification} answer.
+      # @return [Placement]
+      def default_placement
+        raise ArgumentError, "#{self.class} has no default placement — open(Overlay::At[rect])"
+      end
+
+      # Escalates to a full scene repaint when an open overlay shrinks or moves
+      # so its new rect no longer covers the cells it previously painted. An
+      # overlay overdraws the scene without clipping and nothing clears
+      # underneath it, so {Screen#repaint}'s overlay-only fast path would repaint
+      # into the new rect and leave the vacated cells showing stale content.
+      # When the new rect fully covers the old one (the overlay only grew), the
+      # fast path is correct and the full repaint is skipped.
+      # @param old_rect [Rect]
       # @return [void]
-      def rect=(new_rect)
-        old_rect = rect
+      def handle_rect_changed(old_rect)
         super
-        screen.needs_full_repaint if open? && !new_rect.contains_rect?(old_rect)
+        screen.needs_full_repaint if open? && !rect.contains_rect?(old_rect)
       end
 
-      # Mounts this overlay on the {Screen}.
+      # Mounts this overlay on the {Screen} at `placement`; the pane assigns the
+      # rect on the next settle.
       #
-      #   overlay = Component::Overlay.new(content: label).open   # construct and mount
+      #   Component::Popup.new(content: window).open   # its default: centered
+      #   overlay.open(Overlay::At[Rect.new(10, 4, 20, 1)])
       #
       # There is deliberately no class-level `Overlay.open` factory — see
       # `design/decisions.md` `D_popup_open`; returning `self` is what keeps the
       # one-liner above available without one.
+      # @param placement [Placement] where it wants to be.
+      # @raise [ArgumentError] with no placement, for an overlay that has no
+      #   {#default_placement}.
+      # @raise [TypeError] if `placement` does not include {Placement}.
       # @return [self]
-      def open
-        reposition
-        screen.add_popup(self)
+      def open(placement = default_placement)
+        screen.add_popup(self, placement)
         self
       end
 
@@ -181,29 +323,45 @@ module Tuile
         screen.has_popup?(self)
       end
 
-      # Recomputes this overlay's own rect (not its content's layout). A no-op
-      # here — the rect is whatever the caller assigned — and the hook a subclass
-      # with a *derived* position overrides; see the class docs. Called on
-      # {#open} and by the screen's layout pass, so an override tracks SIGWINCH.
+      # Where this overlay wants to be, or `nil` while closed.
+      # @return [Placement, nil] the placement it was opened or moved with.
+      def placement = open? ? screen.pane.placement(self) : nil
+
+      # Moves the open overlay; it takes the new rect on the next settle.
+      # @param placement [Placement] see the class docs.
+      # @raise [Tuile::Error] unless open — a closed overlay takes its
+      #   placement from {#open}.
+      # @raise [TypeError] if `placement` does not include {Placement}.
       # @return [void]
-      def reposition; end
+      def placement=(placement)
+        raise Tuile::Error, "#{self} is not open — pass the placement to #open" unless open?
+
+        screen.pane.constrain(self, placement)
+      end
+
+      # Asks the pane to place this overlay again, because something its
+      # placement reads — its declared size, its row count — changed. A no-op
+      # while closed: {#open} places it anyway.
+      # @return [void]
+      def reposition
+        parent&.invalidate_layout
+      end
 
       # Fires {#on_close}. A subclass overriding this **must** call `super`, or
       # the overlay's driver never hears that it closed.
       # @return [void]
       def handle_detached
         super
-        @on_close&.call
+        on_close.fire(CloseEvent.new(source: self))
       end
 
       protected
 
       # Content fills the overlay's full rect — an Overlay has no border to
       # subtract.
-      # @param content [Component]
       # @return [void]
-      def layout(content)
-        content.rect = rect
+      def relayout
+        content&.rect = local_rect
       end
     end
   end

data/lib/tuile/component/password_field.rb

@@ -51,10 +51,7 @@ module Tuile
       #   one-glyph-per-character contract {TextField#display_text} rests on,
       #   a wide one the column axis.
       def mask_char=(char)
-        raise TypeError, "expected String, got #{char.inspect}" unless char.is_a?(String)
-        raise ArgumentError, "expected one grapheme cluster, got #{char.inspect}" unless single_cluster?(char)
-        raise ArgumentError, "expected a 1-column glyph, got #{char.inspect}" unless Buffer.display_width(char) == 1
-
+        char = StyledString.validate_glyph(char, :mask_char)
         return if @mask_char == char
 
         @mask_char = char
@@ -91,10 +88,6 @@ module Tuile
 
       private
 
-      # @param char [String]
-      # @return [Boolean]
-      def single_cluster?(char) = char.each_grapheme_cluster.take(2).size == 1
-
       # @return [Integer] caret target for CTRL+LEFT: the start, while masked.
       def word_left = revealed? ? super : 0
 

data/lib/tuile/component/picker_window.rb

@@ -56,19 +56,24 @@ module Tuile
         @options = options.map { Option.new(_1[0], StyledString.parse(_1[1])) }
         @block = block
         list = Component::List.new
-        list.renderer = ->(option) { StyledString.plain("#{option.key} ") + option.caption }
+        list.renderer = ->(option, _text_width) { StyledString.plain("#{option.key} ") + option.caption }
         list.items = @options
         list.cursor = Component::List::Cursor.new
-        list.on_item_chosen = ->(_index, option) { select_option(option.key) }
+        list.on_item_chosen { |e| select_option(e.item.key) }
         self.content = list
-        # Optional hook for a containing Popup to dismiss itself after a pick.
-        @on_pick = nil
       end
 
-      # Callback invoked after the user picks an option (after the block
-      # fires). The {Popup} returned by {.open} sets this to its own `close`.
-      # @return [Proc, nil]
-      attr_accessor :on_pick
+      # What {#on_pick} fires.
+      #
+      # @!attribute [r] source
+      #   @return [PickerWindow] the picker whose option was chosen.
+      PickEvent = Data.define(:source) { include Tuile::Event }
+
+      # @!method on_pick
+      #   Fired with a {PickEvent} after the user picks an option, after the
+      #   block fires. The {Popup} returned by {.open} registers its own `close`.
+      #   @return [Listeners]
+      listener :on_pick
 
       # Handles an option-key press. Reached by bubbling: the inner {List}
       # (the focused component) sees the key first and handles cursor/Enter
@@ -96,7 +101,7 @@ module Tuile
       def self.open(caption, options, &block)
         picker = PickerWindow.new(caption, options, &block)
         popup = Popup.new(content: picker)
-        picker.on_pick = -> { popup.close }
+        picker.on_pick { popup.close }
         popup.open
       end
 
@@ -106,7 +111,7 @@ module Tuile
       # @return [void]
       def select_option(key)
         @block.call(key)
-        @on_pick&.call
+        on_pick.fire(PickEvent.new(source: self))
       end
     end
   end

data/lib/tuile/component/popup.rb

@@ -2,7 +2,7 @@
 
 module Tuile
   class Component
-    # A modal dialog: an {Component::Overlay} that centers itself on the screen,
+    # A modal dialog: an {Component::Overlay} centered on the screen, which
     # grabs focus, scopes keys to its own subtree, blocks clicks beneath it, and
     # closes on ESC or `q`.
     #
@@ -34,7 +34,7 @@ module Tuile
     #
     # A left click *outside* the popup closes it too — see
     # {Overlay#close_on_outside_click?} for the exact contract and
-    # {Overlay#on_close=} for the notice a driver hears when it happens.
+    # {Overlay#on_close} for the notice a driver hears when it happens.
     #
     # UI-thread-confined, like every component (see {Screen}).
     class Popup < Overlay
@@ -50,7 +50,6 @@ module Tuile
       def initialize(content: nil, declared_size: Fraction::HALF, close_on_outside_click: true)
         super(content: content, close_on_outside_click: close_on_outside_click)
         @declared_size = declared_size
-        reposition
       end
 
       # The box this popup asks for, *as set* — a {Fraction} comes back
@@ -69,9 +68,9 @@ module Tuile
       #   and focus repair falls back to it when its subtree has no tab stop.
       def focusable? = true
 
-      # Sets the popup's box and repositions it. Accepts a {Fraction} (resolved
-      # against the screen every layout pass, so it tracks resize) or an
-      # absolute {Size} (clamped to the screen). This is **authoritative**, not
+      # Sets the popup's box; an open popup takes it on the next settle.
+      # Accepts a {Fraction} (resolved against the screen every layout pass, so
+      # it tracks resize) or an absolute {Size} (clamped to the screen). This is **authoritative**, not
       # a preference: the screen applies exactly what you ask for (clamped),
       # with no negotiation — a popup has no siblings to compete with.
       # @param new_size [Size, Fraction]
@@ -81,26 +80,16 @@ module Tuile
         reposition
       end
 
-      # Re-resolves {#declared_size} against the current screen and recenters the popup
-      # *itself* (this is not laying out content — the popup's own rect). Called
-      # on {Overlay#open}, on {#declared_size=}, and by the screen's layout pass,
-      # so a {Fraction} tracks SIGWINCH.
-      #
-      # The final rect is computed and assigned in one step rather than sizing at
-      # the origin and then centering: the intermediate origin rect rarely covers
-      # the previous one, which would make {Overlay#rect=}'s shrink/move
-      # detection fire a full repaint on every resize.
-      # @return [void]
-      def reposition
-        size = @declared_size.is_a?(Fraction) ? @declared_size.resolve(screen.size) : @declared_size.clamp(screen.size)
-        self.rect = Rect.new(rect.left, rect.top, size.width, size.height).centered(screen.size)
+      # {#declared_size} resolved against `screen_size`: a {Fraction} scaled, a
+      # {Size} clamped.
+      # @param screen_size [Size]
+      # @return [Size]
+      def declared_size_in(screen_size)
+        @declared_size.is_a?(Fraction) ? @declared_size.resolve(screen_size) : @declared_size.clamp(screen_size)
       end
 
-      # Recenters the popup on the screen, preserving its current width/height.
-      # @return [void]
-      def center
-        self.rect = rect.centered(screen.size)
-      end
+      # @return [Overlay::Centered] a popup opens centered.
+      def default_placement = Centered[]
 
       # `q` and ESC close the popup. The popup sits on the focus chain of
       # whatever it wraps, so the key reaches here by bubbling up from the

data/lib/tuile/component/progress_bar.rb

@@ -12,10 +12,9 @@ module Tuile
     #   add(bar)
     #   add(label)
     #
-    #   def rect=(new_rect)             # the enclosing Layout positions both
-    #     super
-    #     bar.rect   = Rect.new(rect.left, rect.top, rect.width, 1)
-    #     label.rect = Rect.new(rect.left, rect.top + 1, rect.width, 1)
+    #   private def relayout            # the enclosing Layout positions both
+    #     bar.rect   = Rect.new(0, 0, width, 1)
+    #     label.rect = Rect.new(0, 1, width, 1)
     #   end
     #
     #   bar.value  = done
@@ -209,12 +208,13 @@ module Tuile
       # *whole* rect, which dirties every cell of the bar's own row before it is
       # painted over — so {Buffer#flush} re-emits the entire row every frame
       # instead of the one or two cells that actually moved.
+      # @param canvas [Canvas] see {Component#repaint}.
       # @return [void]
-      def repaint
+      def repaint(canvas)
         return if rect.empty?
 
-        draw_text(rect.left, rect.top, StyledString.styled(glyphs(rect.width), fg: resolved_bar_color))
-        clear_background(Rect.new(rect.left, rect.top + 1, rect.width, rect.height - 1)) if rect.height > 1
+        canvas.set_text(0, 0, StyledString.styled(glyphs(rect.width), fg: resolved_bar_color))
+        canvas.fill(Rect.new(0, 1, rect.width, rect.height - 1)) if rect.height > 1
       end
 
       private

data/lib/tuile/component/radio_group.rb

@@ -12,7 +12,7 @@ module Tuile
     #
     #   rg = Component::RadioGroup.new(items: %w[Ascending Descending Unsorted])
     #   rg.value = "Descending"                      # or seed it via the ctor
-    #   rg.on_value_change = ->(order) { resort(order) }
+    #   rg.on_value_change { |e| resort(e.value) }
     #   rg.value                                     # => "Descending"
     #   rg.item_label = ->(o) { o.title }            # default :to_s
     #
@@ -72,13 +72,12 @@ module Tuile
         super()
         @item_label = :to_s.to_proc
         @value = value
-        @on_value_change = nil
 
         list = List.new
         # A List has no cursor at all by default (Cursor::None, position -1).
         list.cursor = List::Cursor.new
         list.renderer = method(:render_row)
-        list.on_item_chosen = ->(_index, item) { self.value = item }
+        list.on_item_chosen { |e| set_value(e.item, from_user: true) }
         list.items = items.to_a
         @list = list
         add_child(list, at: 0)
@@ -93,12 +92,8 @@ module Tuile
       # @return [List]
       attr_reader :list
 
-      # @param new_rect [Rect]
       # @return [void]
-      def rect=(new_rect)
-        super
-        list.rect = rect
-      end
+      def relayout = list.rect = local_rect
 
       # @return [void]
       def handle_focus
@@ -140,9 +135,10 @@ module Tuile
       # changed. The cursor stays where it is.
       # @param new_value [Object, nil] `nil` selects nothing; an item outside
       #   {#items} is kept but renders no marked row.
+      # @param from_user [Boolean] see {HasValue#set_value}.
       # @return [void]
-      def value=(new_value)
-        # HasValue#value= no-ops on an unchanged value; this guard is what also
+      def set_value(new_value, from_user:)
+        # HasValue#set_value no-ops on an unchanged value; this guard is what also
         # skips the row rebuild.
         return if value == new_value
 
@@ -172,14 +168,16 @@ module Tuile
       def select_at(index)
         return unless index.between?(0, items.size - 1)
 
-        self.value = items[index]
+        set_value(items[index], from_user: true)
       end
 
       # @param item [Object]
+      # @param _text_width [Integer] unused: a marker plus a label is as wide as
+      #   it is, and {List} ellipsizes what will not fit.
       # @return [StyledString] the item's row: its label behind a selection
       #   marker. The {List} calls this at paint time, so the marker tracks
       #   {#value} without re-rendering anything but the visible rows.
-      def render_row(item)
+      def render_row(item, _text_width)
         StyledString.plain(item == value ? "(*) " : "( ) ") + label_for(item)
       end