tuile 0.14.0 → 0.16.0

data/lib/tuile/component/big_decimal_field.rb

@@ -22,10 +22,12 @@ module Tuile
     #   price.value = BigDecimal("19.99")                   # field shows "19.99"
     #   price.value = 19.99                                 # ArgumentError: a Float can't be exact
     #
-    # Only `0`–`9`, one leading `-` and one `.` can be typed; any other
-    # printable key is dropped without moving the caret. Up/Down step by one.
-    # Range checks (`min`/`max`) and a display scale (`19.9` → `19.90`) belong
-    # to a forms layer, not here — nothing rounds or pads what you typed.
+    # The buffer only ever holds `0`–`9`, one leading `-` and one `.`: a key
+    # that would break that is dropped without moving the caret, and so is a
+    # *paste* that would (`"$19.99"` lands nothing, rather than sieving through
+    # as a price the user never copied). Up/Down step by one. Range checks
+    # (`min`/`max`) and a display scale (`19.9` → `19.90`) belong to a forms
+    # layer, not here — nothing rounds or pads what you typed.
     #
     # Requires the `bigdecimal` gem, which Tuile does *not* depend on: it is a
     # bundled gem from Ruby 3.4 on, so a `Gemfile` naming it is what puts it on
@@ -48,14 +50,18 @@ module Tuile
     # `Float` is refused on both, and display goes through `to_s("F")` — plain
     # notation, never `BigDecimal#to_s`'s `"0.1999e2"`.
     #
-    # It *composes* a {TextField} (its single {HasContent} child) rather than
-    # subclassing one, so its face carries only the typed {HasValue} seam,
-    # never the widget's `String`-typed `text`.
+    # It *wraps* a {TextField} rather than subclassing one, so its face carries
+    # only the typed {HasValue} seam and never the widget's `String`-typed
+    # `text`; {AbstractWrappingField} supplies the wrapping.
     #
     # UI-thread-confined, like every component (see {Screen}).
-    class BigDecimalField < Component
-      include HasContent
-      include HasValue
+    class BigDecimalField < AbstractWrappingField
+      include HasBadInput
+
+      # @return [String] what {#bad_input_message} reports for a buffer that is
+      #   typeable but not a decimal.
+      BAD_INPUT_MESSAGE = "not a decimal number"
+      private_constant :BAD_INPUT_MESSAGE
 
       # A buffer {#value} parses: an optional sign and digits with an optional
       # fractional part (either side may be empty, but not both). No exponent —
@@ -64,19 +70,42 @@ module Tuile
       NUMERIC = /\A-?(?:\d+(?:\.\d*)?|\.\d+)\z/
       private_constant :NUMERIC
 
+      # The face: a {TextField} that admits only the buffers a decimal can be
+      # typed through, however the characters arrive.
+      class Field < TextField
+        # Buffers reachable by typing a decimal: an optional leading `-` and
+        # digits with at most one `.`. Looser than {NUMERIC} on purpose —
+        # `""`, `"-"` and `"1."` are members, or the values past them could not
+        # be typed at all.
+        # @return [Regexp]
+        TYPEABLE = /\A-?\d*(?:\.\d*)?\z/
+        private_constant :TYPEABLE
+
+        protected
+
+        # Accepts the insertion only if the whole resulting buffer is still
+        # typeable, so a pasted `"$19.99"` is dropped rather than sieved into
+        # `"19.99"` — a price the user never copied.
+        # @param str [String]
+        # @return [Boolean] true if the text changed.
+        def insert_text(str)
+          return false unless TYPEABLE.match?(@text.dup.insert(@caret, str))
+
+          super
+        end
+      end
+
       def initialize
-        super()
-        @last_value = nil
-        field = TextField.new
-        field.on_change = ->(_text) { fire_if_changed }
-        field.on_key = method(:field_key)
-        self.content = field
+        super(Field.new)
+        # Not the general on_key interceptor: that slot stays free for the app.
+        editor.on_key_up = -> { step(1) }
+        editor.on_key_down = -> { step(-1) }
       end
 
       # @return [::BigDecimal, nil] the parsed buffer; `nil` when empty or not a
       #   number (e.g. a lone `"-"`).
       def value
-        text = content.text
+        text = editor.text
         text.match?(NUMERIC) ? BigDecimal(normalize(text)) : nil
       end
 
@@ -91,34 +120,18 @@ module Tuile
       # @raise [TypeError] on a value `BigDecimal()` won't take at all.
       # @return [void]
       def value=(new_value)
-        content.text = new_value.nil? ? "" : coerce(new_value).to_s("F")
-        content.caret = content.text.length
+        editor.text = new_value.nil? ? "" : coerce(new_value).to_s("F")
+        editor.caret = editor.text.length
       end
 
       # `nil`, not `""`: a numeric field with no parseable number is empty.
       # @return [nil]
       def empty_value = nil
 
-      # @return [Point, nil] the field's caret (the hardware cursor is delegated
-      #   to the inner field).
-      def cursor_position = content.cursor_position
-
-      # Fired when ENTER is pressed in the field; see {TextField#on_enter}.
-      # @return [Proc, Method, nil] no-arg callable, or nil.
-      def on_enter = content.on_enter
-
-      # @param callback [Proc, Method, nil]
-      # @return [void]
-      def on_enter=(callback)
-        content.on_enter = callback
-      end
-
-      protected
-
-      # Places the wrapped field across the whole rect ({HasContent} hook).
-      # @param field [Component]
-      # @return [void]
-      def layout(field) = (field.rect = rect)
+      # `"-"`, `"."` and `"-."` are typeable and parse to nothing; an *empty*
+      # buffer is empty, not bad ({HasBadInput}).
+      # @return [String, nil]
+      def bad_input_message = value.nil? && !editor.text.empty? ? BAD_INPUT_MESSAGE : nil
 
       private
 
@@ -149,51 +162,11 @@ module Tuile
         big
       end
 
-      # The field's key interceptor, consulted *before* the field acts on the
-      # key — which is what lets a rejected character be swallowed without the
-      # caret ever moving.
-      # @param key [String]
-      # @return [Boolean] true to consume the key.
-      def field_key(key)
-        case key
-        when Keys::UP_ARROW then step(1)
-        when Keys::DOWN_ARROW then step(-1)
-        else return Keys.printable?(key) && !accepts?(key)
-        end
-        true
-      end
-
       # Nudges {#value} by `delta`, treating an empty/un-parseable field as
       # zero.
       # @param delta [Integer]
       # @return [void]
       def step(delta) = (self.value = (value || BigDecimal(0)) + delta)
-
-      # Whether `char` may be inserted. Deliberately shallow: it keeps the
-      # buffer *typeable* rather than always-valid — a transient `"-"` or
-      # `"1."` has to be reachable — and {#value} decides what parses.
-      # @param char [String] a single printable character.
-      # @return [Boolean]
-      def accepts?(char)
-        case char
-        when /\A[0-9]\z/ then true
-        when "-" then content.caret.zero? && !content.text.start_with?("-")
-        when "." then !content.text.include?(".")
-        else false
-        end
-      end
-
-      # Re-emits {#on_value_change} with the freshly-parsed {#value}, but only
-      # when it differs from the last one fired — so a buffer edit that leaves
-      # the value unchanged (`"1.0"`→`"1.00"`) stays silent.
-      # @return [void]
-      def fire_if_changed
-        v = value
-        return if v == @last_value
-
-        @last_value = v
-        on_value_change&.call(v)
-      end
     end
   end
 end

data/lib/tuile/component/button.rb

@@ -9,7 +9,7 @@ module Tuile
     #
     # Buttons are tab stops — Tab and Shift+Tab will land on them as part of
     # the standard focus cycle. Click-to-focus also works via the inherited
-    # {Component#handle_mouse}.
+    # {Component#handle_mouse_down?}.
     #
     # Assign a {#rect} (typically by the surrounding {Layout}) wide enough to
     # show `[ caption ]` — that natural width is `caption.display_width + 4`.
@@ -38,7 +38,7 @@ module Tuile
 
       # @param key [String]
       # @return [Boolean]
-      def handle_key(key)
+      def handle_key?(key)
         case key
         when Keys::ENTER, " "
           @on_click&.call
@@ -52,7 +52,7 @@ module Tuile
       # columns, clipped to {#rect}. Both the focus highlight and the click hit
       # test use it, so a click on the blank tail of an over-wide rect — or on a
       # lower row, when the rect is taller than one — does not fire {#on_click}.
-      # It still *focuses*: {Component#handle_mouse}'s click-to-focus is ungated
+      # It still *focuses*: {Mouse::Router}'s click-to-focus is ungated
       # by geometry. Same rule as {Checkbox#extent}, which documents the two
       # traps behind it.
       # @return [Size]
@@ -60,13 +60,13 @@ module Tuile
 
       # Fires {#on_click} on a left click within {#extent}; `super` runs first, so
       # a click anywhere in {#rect} still focuses.
-      # @param event [MouseEvent]
-      # @return [void]
-      def handle_mouse(event)
-        super
-        return unless event.button == :left && extent_rect.contains?(event.point)
+      # @param event [Mouse::DownEvent]
+      # @return [Boolean]
+      def handle_mouse_down?(event)
+        return false unless event.button == :left
 
         @on_click&.call
+        true
       end
 
       # @return [void]

data/lib/tuile/component/checkbox.rb

@@ -89,7 +89,7 @@ module Tuile
       #
       # Both the focus highlight and the click hit test use it, so a click on the
       # blank tail — or on a lower row, when the rect is taller than one — does
-      # not toggle. It still *focuses*: {Component#handle_mouse}'s click-to-focus
+      # not toggle. It still *focuses*: {Mouse::Router}'s click-to-focus
       # is ungated by geometry, and the tail is the field's own row.
       #
       # The extent ignores {Component#bg_color}: an inherited tint paints the dead
@@ -102,22 +102,22 @@ module Tuile
       # to an ancestor.
       # @param key [String]
       # @return [Boolean]
-      def handle_key(key)
+      def handle_key?(key)
         return false unless [" ", Keys::ENTER].include?(key)
 
         toggle
         true
       end
 
-      # Toggles on a left click within {#extent}; `super` runs first, so a click
-      # anywhere in {#rect} still focuses.
-      # @param event [MouseEvent]
-      # @return [void]
-      def handle_mouse(event)
-        super
-        return unless event.button == :left && extent_rect.contains?(event.point)
+      # Toggles on a left press; a press on the dead tail past {#extent} focuses
+      # the checkbox without reaching here.
+      # @param event [Mouse::DownEvent]
+      # @return [Boolean]
+      def handle_mouse_down?(event)
+        return false unless event.button == :left
 
         toggle
+        true
       end
 
       # @return [void]

data/lib/tuile/component/checkbox_group.rb

@@ -24,12 +24,12 @@ module Tuile
     # `cg.items & cg.value.to_a` when you need {#items} order.
     #
     # Composes rather than subclasses, like {ComboBox}: a {List} of the items is
-    # its single {HasContent} child, which is where the cursor, scrolling, the
-    # scrollbar and per-row mouse hit-testing come from — the group only supplies
-    # the {List#renderer} that puts the box in front of the label. `content` is
-    # that list, so an app can tune it (`scrollbar_visibility`,
-    # `show_cursor_when_inactive`, …). Rows beyond {#rect}'s height scroll; the
-    # inner list is the tab stop, not the group.
+    # its single child, which is where the cursor, scrolling, the scrollbar and
+    # per-row mouse hit-testing come from — the group only supplies the
+    # {List#renderer} that puts the box in front of the label. {#list} is that
+    # list, exposed read-only so an app can tune it (`scrollbar_visibility`,
+    # `show_cursor_when_inactive`, …) but never swap it out. Rows beyond
+    # {#rect}'s height scroll; the inner list is the tab stop, not the group.
     #
     # == +items+ is chrome; +value+ is authoritative
     # {#items=} changes only what is *presented*. It never touches {#value} and
@@ -54,7 +54,6 @@ module Tuile
     #
     # UI-thread-confined, like every component (see {Screen}).
     class CheckboxGroup < Component
-      include HasContent
       include HasValue
 
       # @return [Set]
@@ -78,11 +77,36 @@ module Tuile
         list.renderer = method(:render_row)
         list.on_item_chosen = ->(_index, item) { toggle(item) }
         list.items = items.to_a
-        self.content = list
+        @list = list
+        add_child(list, at: 0)
+      end
+
+      # The composed {List}: an app may *tune* it — its scrollbar, its cursor,
+      # `show_cursor_when_inactive` — but never replace it, since this group's
+      # renderer and selection are wired into this one (`design/decisions.md`
+      # `D_has_content`). Those knobs are {List} concepts rather than group
+      # concepts, which is why they are reached here instead of forwarded
+      # (`D_wrapping_field`).
+      # @return [List]
+      attr_reader :list
+
+      # @param new_rect [Rect]
+      # @return [void]
+      def rect=(new_rect)
+        super
+        list.rect = rect
+      end
+
+      # @return [void]
+      def handle_focus
+        super
+        # The list is what the arrows drive, so it takes the focus this group
+        # was given; the group itself claims only Space.
+        screen.focused = list if list.focusable?
       end
 
       # @return [Array] the presented items.
-      def items = content.items
+      def items = list.items
 
       # @return [Proc, Method] item -> row label (a `String`, {StyledString}, or
       #   anything with `#to_s`); `:to_s` by default.
@@ -93,14 +117,14 @@ module Tuile
       # @raise [TypeError] unless `new_items` is an `Array`.
       # @return [void]
       def items=(new_items)
-        content.items = new_items
+        list.items = new_items
       end
 
       # @param proc [Proc, Method] item -> row label.
       # @return [void]
       def item_label=(proc)
         @item_label = proc
-        content.refresh_rows
+        list.refresh_rows
       end
 
       # @return [Set] the frozen empty set — {HasValue#empty?} means nothing is
@@ -120,7 +144,7 @@ module Tuile
         return if value == selected
 
         super(selected)
-        content.refresh_rows
+        list.refresh_rows
       end
 
       # Toggles the cursor row on Space. Nothing else is claimed: the composed
@@ -129,20 +153,13 @@ module Tuile
       # neither of us wants bubbles on to an ancestor.
       # @param key [String]
       # @return [Boolean]
-      def handle_key(key)
+      def handle_key?(key)
         return false unless key == " "
 
-        toggle_at(content.cursor.position)
+        toggle_at(list.cursor.position)
         true
       end
 
-      protected
-
-      # Places the composed list across the whole rect ({HasContent} hook).
-      # @param list [Component]
-      # @return [void]
-      def layout(list) = (list.rect = rect)
-
       private
 
       # Flips membership of the item on row `index`; an index outside {#items} is

data/lib/tuile/component/combo_box.rb

@@ -30,10 +30,18 @@ module Tuile
     # The dropdown is a {ListDropdown}, tinted to read as a floating panel; see
     # it for the theming knob.
     #
+    # == The inner field is private machinery
+    # It has no public accessor: its buffer is the *query*, so swapping the field
+    # would break the filtering. What is worth reaching is re-exposed here
+    # ({#placeholder}, {#cursor_position}); a **spec** reaches the field itself:
+    #
+    #   field = Testing.get(Component::TextField, in: combo)
+    #   field.text = "ap"          # type a query without a real loop
+    #
     # UI-thread-confined, like every component (see {Screen}).
     class ComboBox < Component
-      include HasContent
       include HasValue
+      include HasPlaceholder
 
       # @param items [Array] the candidate items (any type); also settable via
       #   {#items=}.
@@ -46,10 +54,16 @@ module Tuile
         @filtered = []
         @suppressing_filter = false
 
-        field = TextField.new
-        field.on_change = ->(_text) { refill unless @suppressing_filter }
-        field.on_key = method(:field_key)
-        self.content = field
+        @field = TextField.new
+        # One widget, one surface: this field paints no well of its own, so the
+        # composed field's own bg_color reaches the cells the field paints.
+        @field.bg_color = BG_INHERIT
+        @field.on_change = ->(_text) { refill unless @suppressing_filter }
+        # ESC is the one key this combo wants that the field consumes itself, so
+        # it cannot arrive by bubbling the way {#handle_key?}'s do. With no menu
+        # open it keeps the field's own meaning: cancel text entry.
+        @field.on_escape = -> { @overlay.open? ? dismiss_menu : screen.focused = nil }
+        add_child(@field, at: 0)
 
         @overlay = ListDropdown.new
         # Outside-click dismissal spans the owner chain, so a click on this
@@ -98,19 +112,39 @@ module Tuile
 
       # @return [Point, nil] the field's caret position (the combo delegates the
       #   hardware cursor to its field).
-      def cursor_position = content.cursor_position
+      def cursor_position = field.cursor_position
+
+      # The hint the inner field paints while empty ({HasPlaceholder}) — for a
+      # combo that means while nothing is selected *and* nothing is typed, so it
+      # reads as a prompt for the query: `"type to filter"`.
+      # @return [String, nil]
+      def placeholder = field.placeholder
 
-      # @return [String]
+      # @param text [String, nil]
+      # @return [void]
+      # @raise [TypeError] unless `text` is a String or nil.
+      def placeholder=(text)
+        field.placeholder = text
+      end
 
-      # Re-anchors the (open) dropdown after {HasContent#rect=} has resized the
-      # field via {#layout}.
+      # Resizes the field and re-anchors the dropdown if it is open.
       # @param new_rect [Rect]
       # @return [void]
       def rect=(new_rect)
         super
+        # One row, or none at all when the combo itself was given none — a
+        # starved parent must not hand out a rect it doesn't own.
+        field.rect = Rect.new(rect.left, rect.top, [rect.width - 1, 0].max, [rect.height, 1].min)
         anchor if @overlay.open?
       end
 
+      # @return [void]
+      def handle_focus
+        super
+        # The field is what edits, so it takes the focus the combo was given.
+        screen.focused = field if field.focusable?
+      end
+
       # Closes the dropdown and reverts an uncommitted query when the combo
       # leaves the focus chain — so tabbing away doesn't strand an open menu or
       # a half-typed filter. Safe against re-entrancy: focus never sits inside
@@ -127,15 +161,41 @@ module Tuile
         revert_query
       end
 
-      # @param event [MouseEvent]
-      # @return [void]
-      def handle_mouse(event)
-        if content.rect.contains?(event.point)
-          content.handle_mouse(event)
-        elsif event.button == :left && rect.contains?(event.point) # the ▾ cell
-          content.focus
-          @overlay.open? ? close_menu : open_menu
+      # Moves the dropdown's highlight ({ListDropdown::MOVE_KEYS}) and commits on
+      # Enter while it is open; opens it on Down or Enter while it is closed.
+      #
+      # These arrive by **bubbling**: the inner field is what holds focus, and it
+      # declines every one of them (it claims no Up/Down and no Enter of its
+      # own), so they reach this ancestor untouched while printable keys and the
+      # editing keys are consumed below and never get here. ESC is the exception
+      # — the field consumes it, so the combo takes it through
+      # {AbstractStringField#on_escape} instead.
+      # @param key [String]
+      # @return [Boolean] true if consumed.
+      def handle_key?(key)
+        if @overlay.open?
+          return true if @overlay.move(key)
+          return false unless key == Keys::ENTER
+
+          @overlay.choose
+        else
+          return false unless [Keys::DOWN_ARROW, Keys::ENTER].include?(key)
+
+          open_menu
         end
+        true
+      end
+
+      # Toggles the dropdown on a left press on the ▾ cell — the only cell of
+      # this component's own that is not the field's.
+      # @param event [Mouse::DownEvent]
+      # @return [Boolean]
+      def handle_mouse_down?(event)
+        return false unless event.button == :left
+
+        field.focus
+        @overlay.open? ? close_menu : open_menu
+        true
       end
 
       # @return [void]
@@ -143,10 +203,16 @@ module Tuile
         super
         return if rect.empty?
 
-        well = active? ? screen.theme.active_bg_color : screen.theme.input_bg_color
-        draw_char(rect.left + rect.width - 1, rect.top, "▾", StyledString::Style::DEFAULT.with(bg: well))
+        draw_char(rect.left + rect.width - 1, rect.top, "▾")
       end
 
+      # The field well the whole face sits on — the inner {Component::TextField}
+      # is marked {Component::BG_INHERIT} so this one covers both it and the `▾`
+      # (exactly one well per widget), which is what makes {Component#bg_color}
+      # on the ComboBox reach the cells the field paints.
+      # @return [Color]
+      def default_bg_color = active? ? screen.theme.active_bg_color : screen.theme.input_bg_color
+
       # The one row this combo paints — the full width, at the top of {#rect}.
       # A single-slot container hands its content the whole inner rect, so a
       # ComboBox is routinely assigned more height than it uses; the dropdown
@@ -154,46 +220,23 @@ module Tuile
       # @return [Size]
       def extent = Size.new(rect.width, 1)
 
-      protected
-
-      # Field spans the row bar the last column, which the `▾` occupies
-      # ({HasContent} layout hook). One row, or none at all when the combo itself
-      # was given none — a starved parent must not hand out a rect it doesn't own.
-      # @param field [Component]
+      # Declines the default's blank: `field` covers every column of the face but
+      # the last, and this combo paints the `▾` into that one, so blanking would
+      # only dirty a cell it is about to repaint (`D_progress_bar`).
       # @return [void]
-      def layout(field)
-        field.rect = Rect.new(rect.left, rect.top, [rect.width - 1, 0].max, [rect.height, 1].min)
-      end
+      def clear_inside_extent = nil
 
       private
 
-      # The field's key interceptor: while the dropdown is open forwards movement
-      # to it ({ListDropdown#move}), commits on Enter ({ListDropdown#choose}),
-      # and dismisses on ESC (reverting the query); opens it on Down or Enter
-      # when closed. Everything else (printable keys, editing) falls through to
-      # the field, whose {TextField#on_change} refilters.
-      # @param key [String]
-      # @return [Boolean] true if consumed.
-      def field_key(key)
-        if @overlay.open?
-          if @overlay.move(key)
-            true
-          elsif key == Keys::ENTER
-            @overlay.choose
-            true
-          elsif key == Keys::ESC
-            close_menu
-            revert_query
-            true
-          else
-            false
-          end
-        elsif [Keys::DOWN_ARROW, Keys::ENTER].include?(key)
-          open_menu
-          true
-        else
-          false
-        end
+      # @return [TextField] the inner field, holding the query.
+      attr_reader :field
+
+      # Dismisses the dropdown and puts the current value's label back in the
+      # field, undoing an uncommitted query.
+      # @return [void]
+      def dismiss_menu
+        close_menu
+        revert_query
       end
 
       # Recomputes the matches for the current query, opening the dropdown when
@@ -201,7 +244,7 @@ module Tuile
       # when there are none.
       # @return [void]
       def refill
-        @filtered = matching(content.text)
+        @filtered = matching(field.text)
         if @filtered.empty?
           close_menu
         else
@@ -245,7 +288,7 @@ module Tuile
       # Sets the field's text without triggering a refilter — for programmatic
       # value changes and query reverts, which must not spring the dropdown.
       # Every programmatic write to the field goes through here; a direct
-      # `content.text =` reaches the field's `on_change` and pops the dropdown
+      # `field.text =` reaches the field's `on_change` and pops the dropdown
       # open on a {#value=} the user never asked to browse.
       # Parks the caret at the end: `text=` only *clamps* the caret, so a
       # shorter query replaced by a longer label would otherwise strand it
@@ -254,8 +297,8 @@ module Tuile
       # @return [void]
       def sync_field(text)
         @suppressing_filter = true
-        content.text = text
-        content.caret = content.text.length
+        field.text = text
+        field.caret = field.text.length
       ensure
         @suppressing_filter = false
       end

data/lib/tuile/component/confirm_window.rb

@@ -44,7 +44,7 @@ module Tuile
     # There is deliberately no content slot: the body is prose ({#message=}
     # takes a component for the rare rich body, but the dialog then cannot
     # measure it). A dialog collecting *input* is not a confirm dialog — build a
-    # `Popup.new(content: your_layout)`. See `DECISIONS.md` `D_confirm_window`
+    # `Popup.new(content: your_layout)`. See `design/decisions.md` `D_confirm_window`
     # for the API rationale.
     class ConfirmWindow < Window
       # Keys handed to the message body from anywhere in the dialog, so it
@@ -221,9 +221,11 @@ module Tuile
       end
 
       # Focus lands on the first button rather than cascading into the message
-      # body, which sits before the button row in the tree.
+      # body, which sits before the button row in the tree. `super` is reached
+      # only when there is no button to take it: {HasContent#handle_focus} *is*
+      # the cascade this override exists to skip.
       # @return [void]
-      def on_focus
+      def handle_focus
         first = @actions.keys.first
         if first.nil?
           super
@@ -239,11 +241,11 @@ module Tuile
       # before this runs.
       # @param key [String]
       # @return [Boolean] true if the key was handled.
-      def handle_key(key)
+      def handle_key?(key)
         case key
         when Keys::LEFT_ARROW then return focus_button_step(-1)
         when Keys::RIGHT_ARROW then return focus_button_step(1)
-        when *BODY_SCROLL_KEYS then return @body_slot.content&.handle_key(key) || false
+        when *BODY_SCROLL_KEYS then return @body_slot.content&.handle_key?(key) || false
         end
 
         target = @mnemonics[key.downcase]