tuile 0.9.0 → 0.11.0

data/lib/tuile/component/checkbox_group.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    # Multi-select from a set of typed items, one checkable row each. Arrows move
+    # a cursor; Space, Enter or a left click toggles the row under it:
+    #
+    #    [x] Errors
+    #    [ ] Warnings     <- cursor row, highlighted across the full width
+    #    [x] Info
+    #   ^ the composed {List}'s one-column gutter
+    #
+    #   cg = Component::CheckboxGroup.new(items: %w[Errors Warnings Info])
+    #   cg.value = %w[Errors Info]                    # any Enumerable, stored as a Set
+    #   cg.on_value_change = ->(set) { filter(set) }   # once per toggle
+    #   cg.value                                       # => #<Set: {"Errors", "Info"}>
+    #   cg.item_label = ->(level) { level.name }       # default :to_s
+    #
+    # {#value} is a **frozen `Set` of the selected items themselves** — of
+    # whatever type {#items} holds, never their labels. Frozen so `cg.value <<
+    # item` fails loudly rather than mutating the selection behind
+    # {HasValue#on_value_change}'s back; assign a new set or an `Array` instead.
+    # Treat it as *unordered*: it iterates in toggle order, so use
+    # `cg.items & cg.value.to_a` when you need {#items} order.
+    #
+    # Composes rather than subclasses, like {ComboBox}: a {List} is its single
+    # {HasContent} child, which is where the cursor, scrolling, the scrollbar and
+    # per-row mouse hit-testing come from. `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.
+    #
+    # == +items+ is chrome; +value+ is authoritative
+    # {#items=} changes only what is *presented*. It never touches {#value} and
+    # never fires {HasValue#on_value_change}, and a selected item absent from
+    # {#items} renders no checked row while surviving intact — so a form saved
+    # without the user editing anything changes nothing silently. Keeping the two
+    # in sync is the app's job: `cg.value &= cg.items.to_set` reconciles them.
+    # Same contract as {ComboBox#value}, one item at a time.
+    #
+    # There is no select-all — neither a key nor a header row. An app that wants
+    # one writes `cg.value = cg.items` behind its own affordance.
+    #
+    # == Implementation details
+    # Items need stable `#hash`/`#eql?`, since the selection is a `Set`: an item
+    # mutated after being selected becomes unfindable. Two `==`-equal items also
+    # share one selection — their rows check and uncheck together — whereas two
+    # *distinct* items that merely render the same label toggle independently,
+    # because a row resolves to an item by index.
+    #
+    # Rows repeat {Checkbox}'s `[x] `/`[ ] ` glyph convention rather than
+    # importing a constant from it.
+    #
+    # UI-thread-confined, like every component (see {Screen}).
+    class CheckboxGroup < Component
+      include HasContent
+      include HasValue
+
+      # @return [Set]
+      EMPTY_SELECTION = Set.new.freeze
+      private_constant :EMPTY_SELECTION
+
+      # @param items [Array] the items to present, one row each; also settable
+      #   via {#items=}.
+      # @param value [Enumerable, nil] the initial selection. Seeds the backing
+      #   ivar directly, so no listener fires and assignment order doesn't
+      #   matter to a form helper.
+      def initialize(items: [], value: nil)
+        super()
+        @items = items.to_a
+        @item_label = :to_s.to_proc
+        @value = coerce(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.on_item_chosen = ->(index, _line) { toggle_at(index) }
+        self.content = list
+        rebuild_rows
+      end
+
+      # @return [Array] the presented items.
+      attr_reader :items
+
+      # @return [Proc, Method] item -> row label (a `String`, {StyledString}, or
+      #   anything with `#to_s`); `:to_s` by default.
+      attr_reader :item_label
+
+      # Replaces the presented rows, leaving {#value} untouched.
+      # @param new_items [Array]
+      # @raise [TypeError] unless `new_items` is an `Array`.
+      # @return [void]
+      def items=(new_items)
+        raise TypeError, "expected Array, got #{new_items.inspect}" unless new_items.is_a?(Array)
+
+        @items = new_items
+        rebuild_rows
+      end
+
+      # @param proc [Proc, Method] item -> row label.
+      # @return [void]
+      def item_label=(proc)
+        @item_label = proc
+        rebuild_rows
+      end
+
+      # @return [Set] the frozen empty set — {HasValue#empty?} means nothing is
+      #   selected.
+      def empty_value = EMPTY_SELECTION
+
+      # Replaces the selection, firing {HasValue#on_value_change} when it really
+      # changed. Stores a frozen `Set` *copy*, so a set the caller goes on
+      # mutating can't reach in.
+      # @param new_value [Enumerable, nil] `nil` selects nothing.
+      # @raise [TypeError] unless `new_value` is an `Enumerable` or `nil`.
+      # @return [void]
+      def value=(new_value)
+        selected = coerce(new_value)
+        # HasValue#value= no-ops on an unchanged value; this guard is what also
+        # skips the row rebuild.
+        return if value == selected
+
+        super(selected)
+        rebuild_rows
+      end
+
+      # Toggles the cursor row on Space. Nothing else is claimed: the composed
+      # {List} — being the focused component — has already had its chance at the
+      # key (its arrows, Home/End, PgUp/PgDn, ^U/^D and Enter), and whatever
+      # neither of us wants bubbles on to an ancestor.
+      # @param key [String]
+      # @return [Boolean]
+      def handle_key(key)
+        return false unless key == " "
+
+        toggle_at(content.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
+      # ignored.
+      # @param index [Integer]
+      # @return [void]
+      def toggle_at(index)
+        return unless index.between?(0, @items.size - 1)
+
+        item = @items[index]
+        self.value = value.include?(item) ? value - [item] : value + [item]
+      end
+
+      # Re-renders every row from the current items, labels and selection.
+      # @return [void]
+      def rebuild_rows
+        content.lines = @items.map do |item|
+          StyledString.plain(value.include?(item) ? "[x] " : "[ ] ") + label_for(item)
+        end
+      end
+
+      # @param new_value [Enumerable, nil]
+      # @return [Set] a frozen copy; `nil` becomes {#empty_value}.
+      # @raise [TypeError] on anything else.
+      def coerce(new_value)
+        return empty_value if new_value.nil?
+        raise TypeError, "expected Enumerable, got #{new_value.inspect}" unless new_value.is_a?(Enumerable)
+
+        Set.new(new_value).freeze
+      end
+
+      # @param item [Object]
+      # @return [StyledString, String] whichever {StyledString#+} accepts on the
+      #   right — so a styled label keeps its spans and a plain one is parsed.
+      def label_for(item)
+        label = @item_label.call(item)
+        label.is_a?(StyledString) ? label : label.to_s
+      end
+    end
+  end
+end

data/lib/tuile/component/combo_box.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    # A text field with a filtering dropdown: type to narrow the candidates,
+    # arrow to move the highlight, Enter (or click) to accept. Its {#value} is
+    # the *selected item* — of whatever type the items are — not the display
+    # string, so a combo over domain objects hands back the object:
+    #
+    #   combo = Component::ComboBox.new
+    #   combo.items = User.all                       # Array of any type
+    #   combo.item_label = ->(u) { u.full_name }     # item -> shown text; default :to_s
+    #   combo.on_value_change = ->(u) { open(u) }    # fires on commit, with the item
+    #   combo.value = some_user                       # selects it; field shows its label
+    #
+    # It's the assembly you'd otherwise wire by hand — a {TextField} plus a
+    # non-modal {Popup} over a {List} — promoted to one component. Give it a
+    # single-row {#rect}; it paints the field across that row with a `▾` in the
+    # last column and floats the dropdown above or below.
+    #
+    # == The two values
+    # {#value} (the committed selection) and the field's typed text (a transient
+    # *query*) are deliberately distinct. Keystrokes move the query and refilter
+    # the list; only Enter/click commits, and only a commit changes {#value} and
+    # fires {#on_value_change}. An uncommitted query reverts to the current
+    # value's label when the dropdown is dismissed (ESC) or the combo loses
+    # focus. Selecting by list index (not by matching the label back) is what
+    # lets two items share a label and still resolve to the right object.
+    #
+    # The dropdown is a {ListDropdown}, tinted to read as a floating panel; see
+    # it for the theming knob.
+    #
+    # UI-thread-confined, like every component (see {Screen}).
+    class ComboBox < Component
+      include HasContent
+      include HasValue
+
+      # @param items [Array] the candidate items (any type); also settable via
+      #   {#items=}.
+      def initialize(items: [])
+        super()
+        @value = nil
+        @on_value_change = nil
+        @items = items.to_a
+        @item_label = :to_s.to_proc
+        @filtered = []
+        @suppressing_filter = false
+
+        field = TextField.new
+        field.on_change = ->(_text) { refill unless @suppressing_filter }
+        field.on_key = method(:field_key)
+        self.content = field
+
+        @overlay = ListDropdown.new
+        @overlay.on_item_chosen = ->(index, _line) { commit(index) }
+      end
+
+      # @return [Array] the candidate items.
+      attr_reader :items
+
+      # @return [Proc, Method] item -> shown label (a `String` or
+      #   {StyledString}); the field shows its `#to_s`, the list its styled form.
+      attr_reader :item_label
+
+      # @param new_items [Array]
+      # @return [void]
+      def items=(new_items)
+        raise TypeError, "expected Array, got #{new_items.inspect}" unless new_items.is_a?(Array)
+
+        @items = new_items
+        refill if @overlay.open?
+        invalidate
+      end
+
+      # @param proc [Proc, Method] item -> shown label.
+      # @return [void]
+      def item_label=(proc)
+        @item_label = proc
+        sync_field(display_for(value)) # re-render the current selection
+        invalidate
+      end
+
+      # Selects `new_value` programmatically: updates the field to its label
+      # *without* opening the dropdown, then fires {#on_value_change}. `nil`
+      # clears the selection (blank field). The value need not be in {#items}.
+      # @param new_value [Object]
+      # @return [void]
+      def value=(new_value)
+        return if value == new_value
+
+        sync_field(display_for(new_value))
+        super
+      end
+
+      # @return [Point, nil] the field's caret position (the combo delegates the
+      #   hardware cursor to its field).
+      def cursor_position = content.cursor_position
+
+      # @return [String]
+      def keyboard_hint = "↑↓ #{screen.theme.hint("select")}  ⏎ #{screen.theme.hint("accept")}"
+
+      # Re-anchors the (open) dropdown after {HasContent#rect=} has resized the
+      # field via {#layout}.
+      # @param new_rect [Rect]
+      # @return [void]
+      def rect=(new_rect)
+        super
+        anchor if @overlay.open?
+      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
+      # the (non-focusable) {ListDropdown}, so closing the overlay repairs no
+      # focus.
+      # @param flag [Boolean]
+      # @return [void]
+      def active=(flag)
+        was = active?
+        super
+        return unless was && !active?
+
+        close_menu
+        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
+        end
+      end
+
+      # @return [void]
+      def repaint
+        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))
+      end
+
+      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]
+      # @return [void]
+      def layout(field)
+        field.rect = Rect.new(rect.left, rect.top, [rect.width - 1, 0].max, [rect.height, 1].min)
+      end
+
+      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
+      end
+
+      # Recomputes the matches for the current query, opening the dropdown when
+      # there are any (and preselecting the current value's row) or closing it
+      # when there are none.
+      # @return [void]
+      def refill
+        @filtered = matching(content.text)
+        if @filtered.empty?
+          close_menu
+        else
+          @overlay.lines = @filtered.map { |item| @item_label.call(item) }
+          @overlay.cursor = List::Cursor.new(position: @filtered.index(value) || 0)
+          @overlay.open unless @overlay.open?
+          anchor
+        end
+      end
+
+      # Items whose label contains `query` (case-insensitive). A query still
+      # equal to the current value's label — the resting state, or a fresh
+      # open — is treated as "show everything", so Down opens the full list.
+      # @param query [String]
+      # @return [Array]
+      def matching(query)
+        return @items if query.empty? || query == display_for(value)
+
+        needle = query.downcase
+        @items.select { |item| @item_label.call(item).to_s.downcase.include?(needle) }
+      end
+
+      # Commits the item at the menu's `index`: closes the dropdown and adopts
+      # it as {#value} (which repaints the field with its label).
+      # @param index [Integer]
+      # @return [void]
+      def commit(index)
+        item = @filtered[index]
+        close_menu
+        self.value = item
+      end
+
+      # @return [void]
+      def open_menu = refill
+
+      # @return [void]
+      def close_menu = (@overlay.close if @overlay.open?)
+
+      # @return [void]
+      def revert_query = sync_field(display_for(value))
+
+      # Sets the field's text without triggering a refilter — for programmatic
+      # value changes and query reverts, which must not spring the dropdown.
+      # Parks the caret at the end: `text=` only *clamps* the caret, so a
+      # shorter query replaced by a longer label would otherwise strand it
+      # mid-word (commit "Go", then pick "Kotlin" → caret after "Ko").
+      # @param text [String]
+      # @return [void]
+      def sync_field(text)
+        @suppressing_filter = true
+        content.text = text
+        content.caret = content.text.length
+      ensure
+        @suppressing_filter = false
+      end
+
+      # @param item [Object]
+      # @return [String] the plain-text label for `item`, or "" for nil.
+      def display_for(item) = item.nil? ? "" : @item_label.call(item).to_s
+
+      # Places the dropdown at the combo's own width, so both its edges line up
+      # with the field — at the cost of the scrollbar taking its column from the
+      # labels, which ellipsize a column earlier once the list scrolls. That is
+      # the trade a measuring driver ({Select}) makes the other way.
+      # @return [void]
+      def anchor = @overlay.anchor_to(rect, rows: @filtered.size)
+    end
+  end
+end

data/lib/tuile/component/float_field.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    # A single-line field whose {#value} is a `Float` (or `nil` when empty) —
+    # the {IntegerField} twin, one Ruby type over. Give it a single-row {#rect}:
+    #
+    #   field = Component::FloatField.new
+    #   field.on_value_change = ->(x) { puts x.inspect }  # Float or nil, per change
+    #   field.value = 19.99                               # field shows "19.99"
+    #   field.clear                                       # empties it; value => nil
+    #
+    # Only `0`–`9`, one leading `-` and one `.` can be typed; any other
+    # printable key is dropped without moving the caret. Up/Down step by `1.0`
+    # (an empty field counting as `0.0`). A `Float` is a binary double, so this
+    # is the wrong field for money — hold that as `Integer` cents in an
+    # {IntegerField} — and range checks (`min`/`max`) belong to a forms layer,
+    # not here.
+    #
+    # == Implementation details
+    # {#value} is a *derived parse*: the buffer is the single source of truth,
+    # recomputed on read and left exactly as typed (`"007"` keeps its zeros).
+    # It reads `nil` for a buffer that isn't a number (`""`, a lone `"-"`) but
+    # `1.0` / `0.5` for a half-typed `"1."` / `".5"`, so reaching for the
+    # decimal point doesn't blink the value to `nil` and back through
+    # {#on_value_change} — which fires per keystroke, but only on a real *value*
+    # change (`"7"`→`"07"` is silent). The parse also accepts the exponent
+    # `Float#to_s` writes for extreme magnitudes, so `value = 1e-5` round-trips
+    # through the `"1.0e-05"` it displays, though no key types an `e`.
+    #
+    # 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`.
+    #
+    # UI-thread-confined, like every component (see {Screen}).
+    class FloatField < Component
+      include HasContent
+      include HasValue
+
+      # A buffer {#value} parses: an optional sign, digits with an optional
+      # fractional part (either side may be empty, but not both), and the
+      # exponent {#value=} can write.
+      # @return [Regexp]
+      NUMERIC = /\A-?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?\z/
+      private_constant :NUMERIC
+
+      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
+      end
+
+      # @return [Float, nil] the parsed buffer; `nil` when empty or not a
+      #   number (e.g. a lone `"-"`).
+      def value
+        text = content.text
+        text.match?(NUMERIC) ? text.to_f : nil
+      end
+
+      # Writes `new_value` into the buffer and parks the caret at its end; fires
+      # {#on_value_change} only if the value actually changed.
+      # @param new_value [Numeric, nil] `nil` empties the field; anything else
+      #   is coerced with `Float()`, so an `Integer` `3` shows as `"3.0"`.
+      # @raise [ArgumentError] on a non-numeric `String`, a NaN or an infinity.
+      # @raise [TypeError] on a value `Float()` won't take at all (an `Array`).
+      # @return [void]
+      def value=(new_value)
+        content.text = new_value.nil? ? "" : coerce(new_value).to_s
+        content.caret = content.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)
+
+      private
+
+      # @param new_value [Numeric]
+      # @return [Float]
+      # @raise [ArgumentError] on a NaN or an infinity — `Float::NAN.to_s` is
+      #   `"NaN"`, which no parse reads back, so writing one would silently
+      #   turn the value `nil`.
+      def coerce(new_value)
+        float = Float(new_value)
+        raise ArgumentError, "value must be finite, got #{float}" unless float.finite?
+
+        float
+      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.0)
+        when Keys::DOWN_ARROW then step(-1.0)
+        else return Keys.printable?(key) && !accepts?(key)
+        end
+        true
+      end
+
+      # Nudges {#value} by `delta`, treating an empty/un-parseable field as
+      # `0.0`.
+      # @param delta [Float]
+      # @return [void]
+      def step(delta) = (self.value = (value || 0.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 (`"7"`→`"07"`) 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/has_caption.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    # The chrome text a component *wears* — a {Window}'s border title, a
+    # {Button}'s label — as opposed to the value it *holds*.
+    #
+    #   button.caption = "Submit"
+    #   window.caption = StyledString.styled("Settings", fg: Color::RED)
+    #
+    # Tuile's naming split, which decides what a new component gets:
+    # **caption** is chrome, authored by the app; **text** is the value the
+    # user edits (aliased to {HasValue#value} on {AbstractStringField}). A
+    # component may carry both, hence two mixins.
+    #
+    # Includers own the *rendering* — clipping, width arithmetic, decoration
+    # such as {Window}'s `[key]-` shortcut prefix; this holds only the text.
+    #
+    # == Implementation details
+    # Being a mixin is what lets tree-walking code find "the {Button} captioned
+    # Submit" via `is_a?(HasCaption)` plus a caption compare, rather than a
+    # hardcoded list of classes that happen to respond to `caption`. Don't
+    # collapse it back into per-class accessors.
+    module HasCaption
+      # Read through *this* method, never `@caption` — the ivar stays nil until
+      # the first non-empty set ({#caption=} short-circuits when unchanged).
+      # @return [StyledString] the caption; empty when never set.
+      def caption = @caption || StyledString::EMPTY
+
+      # Sets the caption and invalidates the component. No-op when unchanged. A
+      # `String` is parsed via {StyledString.parse} (embedded ANSI is honored);
+      # a {StyledString} is used as-is; `nil` clears it.
+      # @param new_caption [String, StyledString, nil]
+      # @return [void]
+      def caption=(new_caption)
+        new_caption = StyledString.parse(new_caption)
+        return if caption == new_caption
+
+        @caption = new_caption
+        invalidate
+      end
+    end
+  end
+end

data/lib/tuile/component/has_content.rb

@@ -15,9 +15,6 @@ module Tuile
         content.handle_mouse(event) if !content.nil? && content.rect.contains?(event.point)
       end
 
-      # @return [Array<Component>]
-      def children = content.nil? ? [] : [content]
-
       # Sets the new content of this component. Updates `@content` itself;
       # including classes may still override to add behaviour (e.g. a
       # special-cased Array input) but should call `super` to perform the
@@ -34,10 +31,13 @@ module Tuile
         end
 
         old = self.content
-        old&.parent = nil
+        # Detached without notifying, and notified at the very end: the focus
+        # repair in on_child_removed cascades into whatever occupies the slot
+        # *now*, so it has to see the new content (window_spec pins it).
+        detach_child(old) unless old.nil?
         @content = content
         unless content.nil?
-          content.parent = self
+          add_child(content, at: 0) # content paints beneath a Window's footer
           content.invalidate
           layout(content)
         end