tuile 0.16.0 → 0.17.0

data/lib/tuile/component/abstract_wrapping_field.rb

@@ -12,8 +12,8 @@ module Tuile
     #
     #     def value = Integer(editor.text, 10) rescue nil
     #
-    #     def value=(new_value)
-    #       editor.text = new_value.nil? ? "" : new_value.to_s
+    #     def set_value(new_value, from_user:)
+    #       editor.set_value(new_value.nil? ? "" : new_value.to_s, from_user:)
     #       editor.caret = editor.text.length
     #     end
     #
@@ -37,7 +37,7 @@ module Tuile
     # editor is how a test reaches a state no public setter produces:
     #
     #   editor = Testing.get(Component::TextField, in: field)
-    #   editor.text = "-"          # bad input; field.value still reads nil
+    #   editor.value = "-"         # bad input; field.value still reads nil
     #
     # A knob that is *editor-shaped* rather than a concept of this field's own
     # domain is **not** forwarded, and the subclass sets it on its editor
@@ -55,7 +55,7 @@ module Tuile
     # by ENTER never moves focus at all. Override it to canonicalize a buffer
     # the user typed loosely:
     #
-    #   def commit = (self.value = value unless value.nil?)   # rewrite in the canonical form
+    #   def commit = (set_value(value, from_user: true) unless value.nil?)   # rewrite canonically
     #
     # ENTER is committed and then **left to keep bubbling**, so a scope's
     # default button still sees it; only an {#on_enter} of this field's own
@@ -67,18 +67,26 @@ module Tuile
     # two gestures, so a form is never handed a half-typed date that happens to
     # parse ({DateField}, {TimeField}).
     #
+    # == Who made the change
+    # The editor's own event says whether the user moved the buffer, and this
+    # field's notice passes that on: a subclass writes the editor through
+    # {AbstractStringField#set_value} with the `from_user:` it was handed, and
+    # the edit route relays it. The commit gestures announce as the user's —
+    # an approximation for the one commit code can cause, a programmatic
+    # `screen.focused =` moving focus off this field.
+    #
     # == Implementation details
-    # - **{HasValue#value} and {#value=} raise until overridden.** The inherited
+    # - **{HasValue#value} and {#set_value} raise until overridden.** The inherited
     #   pair stores into `@value` and never touches the editor, so a subclass
     #   that defined only one would silently half-work.
     # - **{HasValue#empty_value} is called during construction**, to seed the
     #   change guard, so it must not depend on subclass state that `super` has
     #   not set yet. In practice it is a constant per class.
-    # - **The editor's `on_change` and `on_enter` slots are claimed** — for that
-    #   guard, and to commit before an app's ENTER handler runs. A slot cannot
-    #   be shared, so a subclass reacting to buffer edits overrides
-    #   {#handle_editor_change} (every edit), {#value=} or {#commit} rather than
-    #   reassigning either.
+    # - **The editor's `on_value_change` and `on_enter` slots carry this field's own
+    #   listeners** — for that guard, and to commit before an app's ENTER handler
+    #   runs. They are lists, so nothing an app adds displaces them; a subclass
+    #   reacting to buffer edits still overrides {#handle_editor_change} (every
+    #   edit), {#set_value} or {#commit}, which run in a defined order.
     # - **Not for a field whose editor is a *filter*.** This base assumes the
     #   buffer is a rendering of the value, so an edit may change the value.
     #   {ComboBox} breaks both halves — its text is a transient query and only a
@@ -98,13 +106,19 @@ module Tuile
 
         @editor = editor
         @last_value = empty_value
-        @on_enter = nil
+        # Held so the transition block can unsubscribe the same object it added:
+        # a lambda is only equal to itself.
+        @enter_bridge = lambda do
+          commit_and_notify
+          on_enter.fire(EnterEvent.new(source: self))
+        end
         # One widget, one surface: the editor paints no well of its own, so this
-        # field's bg_color reaches the cells the editor paints.
-        editor.bg_color = BG_INHERIT
-        editor.on_change = lambda do |_text|
+        # field's well covers it and its bg_color reaches the cells the editor paints.
+        editor.bg_color = ComponentBackground::INHERIT
+        bg.default_color = ComponentBackground::INPUT_WELL
+        editor.on_value_change do |e|
           handle_editor_change
-          fire_if_changed if notify_on_edit?
+          fire_if_changed(from_user: e.from_user?) if notify_on_edit?
         end
         add_child(editor, at: 0)
       end
@@ -113,12 +127,14 @@ module Tuile
       # @raise [NotImplementedError] unless the subclass overrides it.
       def value = raise(NotImplementedError, "#{self.class} must implement value")
 
-      # Writes `new_value` into the editor's buffer.
+      # Writes `new_value` into the editor's buffer, passing `from_user` on to
+      # {AbstractStringField#set_value}.
       # @param new_value [Object]
+      # @param from_user [Boolean] see {HasValue#set_value}.
       # @return [void]
       # @raise [NotImplementedError] unless the subclass overrides it.
-      def value=(new_value)
-        raise(NotImplementedError, "#{self.class} must implement value=")
+      def set_value(new_value, from_user:)
+        raise(NotImplementedError, "#{self.class} must implement set_value")
       end
 
       # Empties the *input*, not just the value — a field holding bad input
@@ -130,7 +146,7 @@ module Tuile
         # Announced here rather than through the editor's change, so a field
         # holding its notice ({#notify_on_edit?}) still reports an emptying as
         # it happens: emptying is not a half-typed prefix.
-        fire_if_changed
+        fire_if_changed(from_user: false)
       end
 
       # @return [String, nil] the hint the editor paints while empty
@@ -144,26 +160,28 @@ module Tuile
         editor.placeholder = text
       end
 
-      # @return [Proc, Method, nil] fired when ENTER is pressed, *after*
-      #   {#commit}; see {TextField#on_enter}.
-      attr_reader :on_enter
+      # What {#on_enter} fires.
+      #
+      # @!attribute [r] source
+      #   @return [AbstractWrappingField] the field ENTER reached.
+      EnterEvent = Data.define(:source) { include Tuile::Event }
 
-      # @param callback [Proc, Method, nil]
-      # @return [void]
-      def on_enter=(callback)
-        @on_enter = callback
-        # Wrapped rather than forwarded, so an app's ENTER handler reads a
-        # committed buffer. A nil callback leaves the editor's own slot nil,
-        # which is what keeps ENTER *bubbling* — see {#handle_key?}.
-        editor.on_enter = callback && lambda do
-          commit_and_notify
-          callback.call
-        end
+      # @!method on_enter
+      #   Fired with an {EnterEvent} when ENTER is pressed, *after* {#commit};
+      #   see {TextField#on_enter}.
+      #
+      #   **Empty means the field declines ENTER**, which keeps it bubbling to
+      #   the scope's default button — see {#handle_key?}. The editor's own slot
+      #   is claimed only while this one is non-empty, by a bridge that commits
+      #   first, so a listener here always reads a committed buffer.
+      #   @return [Listeners]
+      listener :on_enter do |claimed|
+        claimed ? editor.on_enter << @enter_bridge : editor.on_enter.remove(@enter_bridge)
       end
 
       # Commits on ENTER, and leaves the key unconsumed so it keeps bubbling.
       #
-      # The editor declines ENTER whenever {#on_enter} is nil, so the key
+      # The editor declines ENTER whenever {#on_enter} is empty, so the key
       # reaches this field instead — and it must be committed on the way past,
       # or the form default button it is bubbling towards acts on an
       # uncommitted buffer.
@@ -198,13 +216,6 @@ module Tuile
         screen.focused = editor if editor.focusable?
       end
 
-      # @param new_rect [Rect]
-      # @return [void]
-      def rect=(new_rect)
-        super
-        layout(editor)
-      end
-
       protected
 
       # @return [AbstractStringField] the wrapped editor.
@@ -225,14 +236,14 @@ module Tuile
       #
       # Only the *push* settles: {HasValue#value} stays a live parse of the
       # buffer either way. And overriding this is half the job — {#commit} is
-      # covered here, but the field must fire from its own `value=` too, or a
+      # covered here, but the field must fire from its own `set_value` too, or a
       # programmatic write and an Up/Down step go unannounced until the next
       # commit.
       # @return [Boolean]
       def notify_on_edit? = true
 
       # Called whenever the editor's buffer changes, however the characters
-      # arrived — a typed key, a paste, or a {#value=} of this field's own. It
+      # arrived — a typed key, a paste, or a {#set_value} of this field's own. It
       # is named for the *editor*, not for the user, because those last two are
       # not input. No-op by default; override it to drop state that describes
       # the *previous* buffer, as a field latching whether its input has settled
@@ -242,15 +253,8 @@ module Tuile
 
       # Places the editor across the whole rect; override to reserve cells for a
       # face of your own.
-      # @param editor [Component]
       # @return [void]
-      def layout(editor) = (editor.rect = rect)
-
-      # The field well the face sits on — the editor is marked
-      # {Component::BG_INHERIT}, so this one covers it (exactly one well per
-      # widget) and {Component#bg_color} set here reaches the cells it paints.
-      # @return [Color]
-      def default_bg_color = active? ? screen.theme.active_bg_color : screen.theme.input_bg_color
+      def relayout = (editor.rect = local_rect)
 
       private
 
@@ -260,19 +264,20 @@ module Tuile
       # @return [void]
       def commit_and_notify
         commit
-        fire_if_changed
+        fire_if_changed(from_user: true)
       end
 
       # Re-emits {HasValue#on_value_change}, but only when {#value} differs from
       # the last one fired — so a buffer edit that leaves the value alone
       # (`"7"`→`"07"`) stays silent.
+      # @param from_user [Boolean] what the write that moved the buffer declared.
       # @return [void]
-      def fire_if_changed
+      def fire_if_changed(from_user:)
         v = value
         return if v == @last_value
 
         @last_value = v
-        on_value_change&.call(v)
+        on_value_change.fire(HasValue::ValueChangeEvent.new(source: self, value: v, from_user:))
       end
     end
   end

data/lib/tuile/component/big_decimal_field.rb

@@ -18,7 +18,7 @@ module Tuile
     # would round. Give it a single-row {#rect}:
     #
     #   price = Component::BigDecimalField.new
-    #   price.on_value_change = ->(d) { total.value = d }   # BigDecimal or nil
+    #   price.on_value_change { |e| total.value = e.value }   # BigDecimal or nil
     #   price.value = BigDecimal("19.99")                   # field shows "19.99"
     #   price.value = 19.99                                 # ArgumentError: a Float can't be exact
     #
@@ -98,8 +98,8 @@ module Tuile
       def initialize
         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) }
+        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
@@ -118,9 +118,10 @@ module Tuile
       #   decimal you wrote, which is the whole reason to use this field), a
       #   non-numeric `String`, a NaN or an infinity.
       # @raise [TypeError] on a value `BigDecimal()` won't take at all.
+      # @param from_user [Boolean] see {HasValue#set_value}.
       # @return [void]
-      def value=(new_value)
-        editor.text = new_value.nil? ? "" : coerce(new_value).to_s("F")
+      def set_value(new_value, from_user:)
+        editor.set_value(new_value.nil? ? "" : coerce(new_value).to_s("F"), from_user:)
         editor.caret = editor.text.length
       end
 
@@ -166,7 +167,7 @@ module Tuile
       # zero.
       # @param delta [Integer]
       # @return [void]
-      def step(delta) = (self.value = (value || BigDecimal(0)) + delta)
+      def step(delta) = set_value((value || BigDecimal(0)) + delta, from_user: true)
     end
   end
 end

data/lib/tuile/component/button.rb

@@ -20,17 +20,24 @@ module Tuile
 
       # @param caption [String, StyledString, nil] the button's label, coerced
       #   the same way {HasCaption#caption=} coerces it.
-      # @yield optional `on_click` callback; same as assigning {#on_click=}.
-      def initialize(caption = nil, &on_click)
+      # @yield optional `on_click` listener; same as registering one on {#on_click}.
+      def initialize(caption = nil, &listener)
         super()
         self.caption = caption
-        @on_click = on_click
+        on_click << listener if listener
       end
 
-      # Callback fired when the button is activated (Enter, Space, or
-      # left-click). The callable receives no arguments.
-      # @return [Proc, Method, nil] no-arg callable, or nil.
-      attr_accessor :on_click
+      # What {#on_click} fires.
+      #
+      # @!attribute [r] source
+      #   @return [Button] the button that was activated.
+      ClickEvent = Data.define(:source) { include Tuile::Event }
+
+      # @!method on_click
+      #   Fired with a {ClickEvent} when the button is activated — Enter, Space
+      #   or a left click within {#extent}.
+      #   @return [Listeners]
+      listener :on_click
 
       def focusable? = true
 
@@ -41,7 +48,7 @@ module Tuile
       def handle_key?(key)
         case key
         when Keys::ENTER, " "
-          @on_click&.call
+          on_click.fire(ClickEvent.new(source: self))
           true
         else
           false
@@ -65,18 +72,19 @@ module Tuile
       def handle_mouse_down?(event)
         return false unless event.button == :left
 
-        @on_click&.call
+        on_click.fire(ClickEvent.new(source: self))
         true
       end
 
+      # @param canvas [Canvas] see {Component#repaint}.
       # @return [void]
-      def repaint
+      def repaint(canvas)
         super
         return if rect.empty?
 
         label = (StyledString.plain("[ ") + caption + StyledString.plain(" ]")).ellipsize(rect.width)
         label = label.with_bg(screen.theme.active_bg_color) if active?
-        draw_text(rect.left, rect.top, label)
+        canvas.set_text(0, 0, label)
       end
     end
   end

data/lib/tuile/component/checkbox.rb

@@ -8,7 +8,7 @@ module Tuile
     #   [ ] Enable syslog forwarding
     #
     #   cb = Component::Checkbox.new("Enable syslog forwarding", value: true)
-    #   cb.on_value_change = ->(on) { config.syslog = on }
+    #   cb.on_value_change { |e| config.syslog = e.value }
     #   cb.toggle       # unchecks it, firing the listener with false
     #   cb.checked?     # => false
     #
@@ -60,9 +60,10 @@ module Tuile
       # whatever a caller assigns — and `cb.value = nil` on a fresh checkbox is
       # the no-op it looks like rather than a spurious change event.
       # @param new_value [Object] anything; truthiness decides.
+      # @param from_user [Boolean] see {HasValue#set_value}.
       # @return [void]
-      def value=(new_value)
-        super(new_value ? true : false)
+      def set_value(new_value, from_user:)
+        super(new_value ? true : false, from_user:)
       end
 
       # @return [Boolean] {#value} under its domain word — `license.checked?`
@@ -70,15 +71,15 @@ module Tuile
       def checked? = value
 
       # {#value=} under its domain word. A delegator rather than an `alias`, so it
-      # keeps routing through the one write path even if a subclass overrides
-      # {#value=} (an `alias` would freeze this onto the body defined here).
+      # keeps routing through the one write path, {#set_value}.
       # @param new_value [Object] anything; truthiness decides.
       # @return [void]
       def checked=(new_value)
         self.value = new_value
       end
 
-      # Flips {#value}.
+      # Flips {#value} — programmatically; Space, Enter and a click flip it as
+      # the user's ({HasValue::ValueChangeEvent#from_user?}).
       # @return [void]
       def toggle = (self.value = !value)
 
@@ -105,7 +106,7 @@ module Tuile
       def handle_key?(key)
         return false unless [" ", Keys::ENTER].include?(key)
 
-        toggle
+        set_value(!value, from_user: true)
         true
       end
 
@@ -116,18 +117,19 @@ module Tuile
       def handle_mouse_down?(event)
         return false unless event.button == :left
 
-        toggle
+        set_value(!value, from_user: true)
         true
       end
 
+      # @param canvas [Canvas] see {Component#repaint}.
       # @return [void]
-      def repaint
+      def repaint(canvas)
         super
         return if rect.empty?
 
         label = (StyledString.plain(value ? "[x] " : "[ ] ") + caption).ellipsize(rect.width)
         label = label.with_bg(screen.theme.active_bg_color) if active?
-        draw_text(rect.left, rect.top, label)
+        canvas.set_text(0, 0, label)
       end
     end
   end

data/lib/tuile/component/checkbox_group.rb

@@ -12,7 +12,7 @@ module Tuile
     #
     #   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.on_value_change { |e| filter(e.value) }    # once per toggle
     #   cg.value                                       # => #<Set: {"Errors", "Info"}>
     #   cg.item_label = ->(level) { level.name }       # default :to_s
     #
@@ -69,13 +69,12 @@ module Tuile
         super()
         @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.renderer = method(:render_row)
-        list.on_item_chosen = ->(_index, item) { toggle(item) }
+        list.on_item_chosen { |e| toggle(e.item) }
         list.items = items.to_a
         @list = list
         add_child(list, at: 0)
@@ -90,12 +89,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
@@ -135,15 +130,16 @@ module Tuile
       # 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.
+      # @param from_user [Boolean] see {HasValue#set_value}.
       # @raise [TypeError] unless `new_value` is an `Enumerable` or `nil`.
       # @return [void]
-      def value=(new_value)
+      def set_value(new_value, from_user:)
         selected = coerce(new_value)
-        # HasValue#value= no-ops on an unchanged value; this guard is what also
+        # HasValue#set_value no-ops on an unchanged value; this guard is what also
         # skips the row rebuild.
         return if value == selected
 
-        super(selected)
+        super(selected, from_user:)
         list.refresh_rows
       end
 
@@ -177,14 +173,16 @@ module Tuile
       # @param item [Object]
       # @return [void]
       def toggle(item)
-        self.value = value.include?(item) ? value - [item] : value + [item]
+        set_value(value.include?(item) ? value - [item] : value + [item], from_user: true)
       end
 
       # @param item [Object]
+      # @param _text_width [Integer] unused: a box 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 checkmark box.
       #   The {List} calls this at paint time, so the boxes track {#value}
       #   without re-rendering anything but the visible rows.
-      def render_row(item)
+      def render_row(item, _text_width)
         StyledString.plain(value.include?(item) ? "[x] " : "[ ] ") + label_for(item)
       end
 

data/lib/tuile/component/combo_box.rb

@@ -10,7 +10,7 @@ module Tuile
     #   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.on_value_change { |e| open(e.value) }   # 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
@@ -36,7 +36,7 @@ module Tuile
     # ({#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
+    #   field.value = "ap"         # type a query without a real loop
     #
     # UI-thread-confined, like every component (see {Screen}).
     class ComboBox < Component
@@ -48,29 +48,32 @@ module Tuile
       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
-        # 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 }
+        # One widget, one surface: the inner field paints no well of its own, so
+        # this combo's well covers it and the `▾` alike, and the combo's own
+        # bg_color reaches the cells the field paints.
+        @field.bg_color = ComponentBackground::INHERIT
+        bg.default_color = ComponentBackground::INPUT_WELL
+        # Only the user's typing filters: a programmatic write to the field
+        # ({#sync_field}) must not spring the dropdown open.
+        @field.on_value_change { |e| refill if e.from_user? }
         # 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)
+        @field.escape_clears_focus = false
+        @field.on_escape { @overlay.open? ? dismiss_menu : screen.focused = nil }
 
         @overlay = ListDropdown.new
         # Outside-click dismissal spans the owner chain, so a click on this
         # combo's dropdown must not dismiss a dialog the combo sits in.
         @overlay.owner = self
-        @overlay.renderer = ->(item) { @item_label.call(item) }
-        @overlay.on_item_chosen = ->(_index, item) { commit(item) }
+        @overlay.renderer = ->(item, _text_width) { @item_label.call(item) }
+        @overlay.list.on_item_chosen { |e| commit(e.item) }
+        add_child(@field, at: 0)
       end
 
       # @return [Array] the candidate items.
@@ -102,8 +105,9 @@ module Tuile
       # *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]
+      # @param from_user [Boolean] see {HasValue#set_value}.
       # @return [void]
-      def value=(new_value)
+      def set_value(new_value, from_user:)
         return if value == new_value
 
         sync_field(display_for(new_value))
@@ -127,15 +131,12 @@ module Tuile
         field.placeholder = text
       end
 
-      # Resizes the field and re-anchors the dropdown if it is open.
-      # @param new_rect [Rect]
+      # Resizes the field; the open dropdown follows the combo by itself.
       # @return [void]
-      def rect=(new_rect)
-        super
+      def relayout
         # 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?
+        field.rect = Rect.new(0, 0, [rect.width - 1, 0].max, [rect.height, 1].min)
       end
 
       # @return [void]
@@ -198,21 +199,15 @@ module Tuile
         true
       end
 
+      # @param canvas [Canvas] see {Component#repaint}.
       # @return [void]
-      def repaint
+      def repaint(canvas)
         super
         return if rect.empty?
 
-        draw_char(rect.left + rect.width - 1, rect.top, "▾")
+        canvas.set_char(rect.width - 1, 0, "▾")
       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
@@ -223,8 +218,9 @@ module Tuile
       # 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`).
+      # @param _canvas [Canvas] the surface to paint onto.
       # @return [void]
-      def clear_inside_extent = nil
+      def clear_inside_extent(_canvas) = nil
 
       private
 
@@ -250,7 +246,6 @@ module Tuile
         else
           @overlay.items = @filtered
           @overlay.cursor = List::Cursor.new(position: @filtered.index(value) || 0)
-          @overlay.open unless @overlay.open?
           anchor
         end
       end
@@ -273,7 +268,7 @@ module Tuile
       # @return [void]
       def commit(item)
         close_menu
-        self.value = item
+        set_value(item, from_user: true)
       end
 
       # @return [void]
@@ -287,20 +282,15 @@ 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
-      # `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
+      # The write is `from_user: false`, which is all the field's listener
+      # checks. Parks the caret at the end: `value=` 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
-        field.text = text
+        field.value = text
         field.caret = field.text.length
-      ensure
-        @suppressing_filter = false
       end
 
       # @param item [Object]
@@ -312,7 +302,7 @@ module Tuile
       # 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(extent_rect, rows: @filtered.size)
+      def anchor = @overlay.anchor_to(self)
     end
   end
 end