teksilo_widgets/

checkbox.rs

// SPDX-License-Identifier: MPL-2.0
// SPDX-FileCopyrightText: 2026 FernTech

//! Checkbox — a two-state or tristate checkbox with an optional label.
//!
//! `Checkbox` renders a square (or rounded-square / circle) toggle box
//! alongside an optional label and caption. Two modes are supported:
//!
//! - **Two-state** ([`Checkbox::new`]): toggles a `Signal<bool>` between
//!   `true` (checked) and `false` (unchecked) on click or Space.
//! - **Tristate** ([`Checkbox::tristate`]): cycles a `Signal<CheckState>`
//!   between `Checked` and `Unchecked` on user interaction; the
//!   `Indeterminate` state is set only by external sources such as
//!   `TreeCheckedModel` aggregation — clicking from `Indeterminate` goes
//!   to `Checked`, not a further third state.
//!
//! Chrome (box shape, fill, focus ring) is driven by the active
//! `CheckboxStyle`; three visual variants are available via
//! [`CheckboxVariant`].
//!
//! ## Label styling
//!
//! The label is `Body` / `Primary` and the caption `Small` / `Secondary` by
//! default. [`Checkbox::label_style`] / [`Checkbox::label_color`] and
//! [`Checkbox::caption_style`] / [`Checkbox::caption_color`] override them.
//! A theme role colour still dims when the checkbox is disabled; a literal
//! `Color` stays as given.
//!
//! ## Touch and pen
//!
//! The pressed state comes from the framework press
//! (`docs/touch-and-pen.md` §7.1) rather than from this widget: sliding off
//! abandons it, sliding back on restores it, and a pan claimant winning the
//! press clears it with no release. Before the controls sweep `is_pressed`
//! could only ever be set by a keyboard `Space`, so a mouse-down showed no
//! pressed chrome at all — themes that paint one (IntUI's checked box, Material
//! 3's state layer) now get it from every pointer.
//!
//! The 24 dp `MinSize` around the 19 dp glyph already meets the WCAG 2.2
//! SC 2.5.8 floor at Compact and follows the density ladder above it, so no
//! hit-widening mechanism is involved.
//!
//! ## Accessibility
//!
//! Announces as `Role::CheckBox`. A label is required in debug builds
//! unless `.labelled_externally()` is set (for embedding inside a composite
//! row that owns the AT name). Keyboard: Space toggles; lone-KeyUp guard
//! prevents spurious toggle when focus is restored after a shortcut.
//!
//! ```rust
//! # use teksilo_widgets::Checkbox;
//! # use teksilo_core::signal::Signal;
//! # use teksilo_i18n::lit;
//! let checked = Signal::new(false);
//! let _cb = Checkbox::new(checked)
//!     .label(lit!("Accept terms and conditions"));
//! ```

use std::cell::Cell;
use std::rc::Rc;

use teksilo_canvas::{Rect, Size, SizeProposal};
use teksilo_core::accessibility::AccessNodeBuilder;
use teksilo_core::binding::BindingLevel;
use teksilo_core::build_context::BuildContext;
use teksilo_core::event::{EventResponse, Key, WidgetEvent};
use teksilo_core::signal::{Prop, Signal};
use teksilo_core::styles::{
    CheckboxState, CheckboxStyleConfig, CheckboxVariant, SharedCheckboxStyle,
};
use teksilo_core::widget::{CursorIcon, EventContext, LayoutContext, Widget, WidgetPlacement};
use teksilo_core::widget_builder::HandlerSet;
use teksilo_core::widget_id::WidgetId;
use teksilo_data::CheckState;
use teksilo_tokens::{TextRole, TextStyleRole, VAlignment};

use crate::button::InteractionState;
use crate::primitives::{HStack, MinSize, TextWidget, VStack};
use teksilo_i18n::LocalizedString;

// ---------------------------------------------------------------------------
// Internal state wrapper
// ---------------------------------------------------------------------------

/// Wraps either a bool state (two-state) or a CheckState state (tristate).
#[derive(Clone)]
enum CheckKind {
    TwoState(Signal<bool>),
    TriState(Signal<CheckState>),
}

impl CheckKind {
    fn check_state(&self) -> CheckState {
        match self {
            CheckKind::TwoState(s) => CheckState::from(s.get()),
            CheckKind::TriState(s) => s.get(),
        }
    }

    /// A reactive `Signal<CheckState>` that tracks the underlying
    /// mutable root of either variant. Used to compose multi-source
    /// derived visuals (e.g. box colors that depend on both interaction
    /// state and check state) so they dirty-track the check-state
    /// source in addition to the interaction source.
    fn check_state_signal(&self) -> Signal<CheckState> {
        match self {
            CheckKind::TwoState(s) => s.map(|b| CheckState::from(*b)),
            CheckKind::TriState(s) => s.clone(),
        }
    }

    /// Flip, and report the checked-ness the activation produced. Activation
    /// never yields `Indeterminate` (see below), so a `bool` is lossless for
    /// both kinds and `Checkbox::on_change` can take one.
    fn toggle(&self) -> bool {
        match self {
            CheckKind::TwoState(s) => {
                let current = s.get();
                s.set(!current);
                !current
            }
            CheckKind::TriState(s) => {
                // User clicks toggle Checked ↔ Unchecked. The
                // `Indeterminate` state is reserved for external
                // sources (e.g. `TreeCheckedModel` aggregation when
                // descendants are mixed) — the user can't *set* a
                // checkbox to "half"; clicking from Indeterminate
                // checks the whole. This matches the Outlook /
                // Files-app folder-checkbox semantic.
                let current = s.get();
                let next = if matches!(current, CheckState::Checked) {
                    CheckState::Unchecked
                } else {
                    CheckState::Checked
                };
                s.set(next);
                matches!(next, CheckState::Checked)
            }
        }
    }
}

impl std::fmt::Debug for CheckKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            CheckKind::TwoState(_) => write!(f, "TwoState"),
            CheckKind::TriState(_) => write!(f, "TriState"),
        }
    }
}

// ---------------------------------------------------------------------------
// Checkbox
// ---------------------------------------------------------------------------

/// A checkbox that toggles a `Signal<bool>` or cycles a `Signal<CheckState>`.
pub struct Checkbox {
    label: Option<LocalizedString>,
    caption: Option<LocalizedString>,
    kind: CheckKind,
    /// Enabled state, static or reactive; forwarded into the arena at
    /// build time. After build the arena is the single source of
    /// truth — see `IconButton::enabled` for the architectural
    /// rationale.
    enabled: Prop<bool>,
    /// When true, the checkbox renders only the box (no visual label /
    /// caption next to it) AND its `accessibility(builder)` skips the
    /// missing-label `debug_assert` — the parent composite is responsible
    /// for providing the AT name (typically via its own `set_name(...)`
    /// or an `access_label*` override). Used by `StandardListItem` /
    /// `StandardTreeItem`.
    labelled_externally: bool,
    label_style: teksilo_core::color_prop::TextStyleProp,
    label_color: teksilo_core::color_prop::ColorProp,
    caption_style: teksilo_core::color_prop::TextStyleProp,
    caption_color: teksilo_core::color_prop::ColorProp,
    tooltip_text: Option<LocalizedString>,
    rich_tooltip_source: Option<crate::tooltip::RichTooltipSource>,
    composite_tooltip_content: Option<Box<dyn teksilo_core::widget::Widget>>,
    variant: CheckboxVariant,
    style_override: Option<SharedCheckboxStyle>,
    on_change: Option<Rc<dyn Fn(bool, &mut EventContext)>>,
    root_child_id: Option<WidgetId>,
}

impl Checkbox {
    /// Create a two-state checkbox bound to a `Signal<bool>`.
    pub fn new(checked: Signal<bool>) -> Self {
        Self {
            label: None,
            caption: None,
            kind: CheckKind::TwoState(checked),
            enabled: Prop::Static(true),
            labelled_externally: false,
            label_style: TextStyleRole::Body.into(),
            label_color: TextRole::Primary.into(),
            caption_style: TextStyleRole::Small.into(),
            caption_color: TextRole::Secondary.into(),
            tooltip_text: None,
            rich_tooltip_source: None,
            composite_tooltip_content: None,
            variant: CheckboxVariant::default(),
            style_override: None,
            on_change: None,
            root_child_id: None,
        }
    }

    /// Create a tristate checkbox bound to a `Signal<CheckState>`.
    ///
    /// User clicks toggle Checked ↔ Unchecked (clicking from Indeterminate
    /// checks the whole). The `Indeterminate` state is reserved for external
    /// sources — `TreeCheckedModel` aggregation when descendants are mixed,
    /// "select all" indicators, etc. Matches the Outlook / Files-app
    /// folder-checkbox semantic. Useful for parent checkboxes in tree views.
    pub fn tristate(state: Signal<CheckState>) -> Self {
        Self {
            label: None,
            caption: None,
            kind: CheckKind::TriState(state),
            enabled: Prop::Static(true),
            labelled_externally: false,
            label_style: TextStyleRole::Body.into(),
            label_color: TextRole::Primary.into(),
            caption_style: TextStyleRole::Small.into(),
            caption_color: TextRole::Secondary.into(),
            tooltip_text: None,
            rich_tooltip_source: None,
            composite_tooltip_content: None,
            variant: CheckboxVariant::default(),
            style_override: None,
            on_change: None,
            root_child_id: None,
        }
    }

    /// Run `f` when the **user** checks or unchecks this box, with the
    /// checked-ness the activation produced and an `EventContext`, so it can do
    /// what a bare `Signal` write cannot (`ctx.send_intent(...)`,
    /// `ctx.set_theme(...)`, opening a window). Fires for the pointer, for
    /// `Space`, for an assistive-technology `Click`, and for `Space` on a data
    /// view's focused row.
    ///
    /// Does **not** fire for programmatic writes to the bound signal — there is
    /// no event in flight to carry. Observe the signal for that. The signal
    /// stays the source of truth either way: it is written first, and `f` sees
    /// the value it now holds.
    ///
    /// A tristate checkbox reports a `bool` too: activation cycles
    /// `Checked` ↔ `Unchecked` only, and `Indeterminate` is external-source-only.
    pub fn on_change(mut self, f: impl Fn(bool, &mut EventContext) + 'static) -> Self {
        self.on_change = Some(Rc::new(f));
        self
    }

    /// Declare that this checkbox's accessible name comes from an
    /// ancestor, suppressing the visual label/caption AND the
    /// debug-time "missing accessible label" assertion. Use it when
    /// the checkbox is embedded inside a composite that owns the
    /// row's name (e.g. `StandardListItem` / `StandardTreeItem`,
    /// where the row's `accessibility(builder)` calls `set_name(...)`
    /// with the row label).
    ///
    /// **A11y contract:** the caller MUST guarantee that an
    /// addressable AT ancestor provides the name — either via that
    /// ancestor's own `accessibility()` impl or a builder-level
    /// `.access_label*` override. Without it the AT tree exposes a
    /// `Role::CheckBox` node with no name; screen readers announce
    /// "checkbox, checked" with no context. The Outlook /
    /// Files-app row pattern (where the row label covers the
    /// embedded checkbox) is the supported use case.
    ///
    /// Spelled the same way on [`Toggle`](crate::toggle::Toggle).
    pub fn labelled_externally(mut self) -> Self {
        self.labelled_externally = true;
        self
    }

    /// Set the visible label rendered to the right of the checkbox box,
    /// also used as the AT name. Required unless `.labelled_externally()` is set.
    pub fn label(mut self, label: impl Into<LocalizedString>) -> Self {
        let ls: LocalizedString = label.into();
        self.label = Some(ls);
        self
    }

    /// Secondary explanatory text rendered below the label, left-aligned
    /// with the label (not the box). Uses the `small` / `text_secondary`
    /// style. Has no effect unless `label(...)` is also set.
    pub fn caption(mut self, text: impl Into<LocalizedString>) -> Self {
        let ls: LocalizedString = text.into();
        self.caption = Some(ls);
        self
    }

    /// Override the label's text style (font, size, weight). Accepts a
    /// `TextStyleRole`, a `TextStyle`, or a `Signal` of either. Default is
    /// `TextStyleRole::Body`.
    pub fn label_style(
        mut self,
        style: impl Into<teksilo_core::color_prop::TextStyleProp>,
    ) -> Self {
        self.label_style = style.into();
        self
    }

    /// Override the label's text color. Accepts `Color`, a theme role, or a
    /// `Signal` of either. Default is `TextRole::Primary`. A role still dims
    /// to the disabled color when the checkbox is disabled; a literal `Color`
    /// stays as given.
    pub fn label_color(mut self, color: impl Into<teksilo_core::color_prop::ColorProp>) -> Self {
        self.label_color = color.into();
        self
    }

    /// Override the caption's text style. Default is `TextStyleRole::Small`.
    pub fn caption_style(
        mut self,
        style: impl Into<teksilo_core::color_prop::TextStyleProp>,
    ) -> Self {
        self.caption_style = style.into();
        self
    }

    /// Override the caption's text color. Accepts `Color`, a theme role, or
    /// a `Signal` of either. Default is `TextRole::Secondary`. A role still
    /// dims to the disabled color when the checkbox is disabled; a literal
    /// `Color` stays as given.
    pub fn caption_color(mut self, color: impl Into<teksilo_core::color_prop::ColorProp>) -> Self {
        self.caption_color = color.into();
        self
    }

    /// Set the enabled state, statically or reactively. Forwarded to the
    /// arena via `ctx.enabled_when(self_id, self.enabled.clone())` at
    /// build time — a bound `Signal<bool>` updates live.
    pub fn enabled(mut self, enabled: impl Into<Prop<bool>>) -> Self {
        self.enabled = enabled.into();
        self
    }

    /// Pick the design-language variant. Default `Square`. The active
    /// `CheckboxStyle` impl decides what the variant means visually
    /// (the IntUI `RecipeCheckboxStyle` honours all three variants
    /// directly via corner-shape changes).
    pub fn variant(mut self, variant: CheckboxVariant) -> Self {
        self.variant = variant;
        self
    }

    /// Per-call style override. Replaces the theme-wide default
    /// `CheckboxStyle` for just this Checkbox instance — same role as
    /// `Button::style(...)`.
    pub fn style(mut self, style: impl teksilo_core::styles::CheckboxStyle) -> Self {
        self.style_override = Some(Rc::new(style));
        self
    }

    /// Attach a plain tooltip shown after a hover delay.
    /// Clears any previously set rich or composite tooltip (last-call wins).
    pub fn tooltip(mut self, text: impl Into<LocalizedString>) -> Self {
        self.tooltip_text = Some(text.into());
        self.rich_tooltip_source = None;
        self.composite_tooltip_content = None;
        self
    }

    /// Attach a rich tooltip resolved from the app-wide tooltip
    /// registry. See [`Button::rich_tooltip`](crate::button::Button::rich_tooltip).
    pub fn rich_tooltip(mut self, key: impl Into<String>) -> Self {
        self.rich_tooltip_source = Some(crate::tooltip::RichTooltipSource::Key(key.into()));
        self.tooltip_text = None;
        self.composite_tooltip_content = None;
        self
    }

    /// Attach a rich tooltip driven by inline `TooltipContent`.
    pub fn rich_tooltip_content(mut self, content: crate::tooltip::TooltipContent) -> Self {
        self.rich_tooltip_source = Some(crate::tooltip::RichTooltipSource::Content(content));
        self.tooltip_text = None;
        self.composite_tooltip_content = None;
        self
    }

    /// Attach a composite tooltip — third tier, hosting an arbitrary
    /// widget tree. See [`Button::composite_tooltip`](crate::button::Button::composite_tooltip).
    pub fn composite_tooltip(
        mut self,
        content: impl teksilo_core::widget::Widget + 'static,
    ) -> Self {
        self.composite_tooltip_content = Some(Box::new(content));
        self.tooltip_text = None;
        self.rich_tooltip_source = None;
        self
    }

    fn check_state(&self) -> CheckState {
        self.kind.check_state()
    }
}

impl std::fmt::Debug for Checkbox {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Checkbox")
            .field("label", &self.label)
            .field("caption", &self.caption)
            .field("kind", &self.kind)
            .field("enabled", &self.enabled.get())
            .finish()
    }
}

// ---------------------------------------------------------------------------
// Widget
// ---------------------------------------------------------------------------

// Interaction state is Button's shared `InteractionState` — local to this
// widget's handlers; the active `CheckboxStyle` only sees the four derived
// boolean signals (is_hovered, is_pressed, is_focused, is_disabled).
impl Widget for Checkbox {
    fn build(&mut self, ctx: &mut BuildContext) -> Vec<WidgetId> {
        use crate::styles::recipe_checkbox_style as cb_dims;
        let kind = self.kind.clone();
        let variant = self.variant;
        let self_id = ctx.self_id();

        // Forward the enabled state into the arena. After this point
        // the arena is the single source of truth (same architecture
        // as IconButton — leaves consume `effective_enabled` at paint
        // time, events are gated on `is_enabled`, a11y walker reads it).
        ctx.enabled_when(self_id, self.enabled.clone());
        let effective_enabled = ctx.effective_enabled_signal(self_id);

        // Interaction signal seeded to Idle — the arena's enabled-state
        // is consulted separately via `effective_enabled`.
        let interaction = ctx.signal(InteractionState::Idle);

        // Bridge the widget-side `CheckState` (teksilo-data) to the style-
        // protocol-side `CheckboxState` (teksilo-core). The mapping is 1-to-1;
        // `.map()` registers the upstream root so the body repaints when
        // the check state flips.
        let style_state = kind.check_state_signal().map(|cs| match *cs {
            CheckState::Unchecked => CheckboxState::Unchecked,
            CheckState::Checked => CheckboxState::Checked,
            CheckState::Indeterminate => CheckboxState::Indeterminate,
        });
        // The body's repaint is not a walk of the accessibility tree, and
        // `accessibility()` reads the state only when one happens: without this
        // a change reaches no platform until something unrelated re-walks it.
        kind.check_state_signal().bind_to(
            self_id,
            ctx.binding_registry(),
            BindingLevel::AccessibilityOnly,
        );

        let is_hovered = interaction.map(|s| matches!(s, InteractionState::Hovered));
        let is_pressed = interaction.map(|s| matches!(s, InteractionState::Pressed));
        // `:focus-visible`: reveal the focus ring during keyboard navigation
        // only, not on a mouse click. Gate raw focus on the input-modality
        // signal (true after a key event, false after pointer-down).
        let is_focused = interaction
            .map(|s| matches!(s, InteractionState::Focused))
            .and(&ctx.focus_visible());
        // is_disabled derives from the arena (not from interaction).
        let is_disabled = effective_enabled.map(|on| !*on);

        let style: SharedCheckboxStyle = self
            .style_override
            .clone()
            .or_else(|| ctx.theme().style_slots.checkbox.clone())
            .unwrap_or_else(|| {
                Rc::new(crate::styles::RecipeCheckboxStyle::for_tokens(
                    &ctx.theme().input,
                ))
            });
        let cfg = CheckboxStyleConfig {
            state: style_state,
            is_hovered,
            is_pressed,
            is_focused,
            is_disabled,
            variant,
        };
        let body_id = style.make_body(&cfg, ctx);

        let mut row = HStack::new()
            .spacing(cb_dims::CHECKBOX_LABEL_GAP)
            .child(body_id);
        if !self.labelled_externally
            && let Some(ref label) = self.label
        {
            let label_widget = TextWidget::new(label.clone())
                .style(self.label_style.clone())
                .color(self.label_color.clone())
                .single_line()
                .a11y_hidden();
            let label_id = ctx.add(label_widget);

            let label_column_id = if let Some(ref caption) = self.caption {
                let caption_widget = TextWidget::new(caption.clone())
                    .style(self.caption_style.clone())
                    .color(self.caption_color.clone())
                    .a11y_hidden();
                let caption_id = ctx.add(caption_widget);
                ctx.add(VStack::new().spacing(2.0).child(label_id).child(caption_id))
            } else {
                label_id
            };
            row = row.child(label_column_id);
        }
        // When a caption is present, top-align the row so the box sits next
        // to the label's first line rather than the center of both lines.
        if self.caption.is_some() && self.label.is_some() {
            row = row.alignment(VAlignment::Top);
        }

        // The hit box comes from the same recipe the chrome was built from, so
        // a density switch moves both together.
        let style_recipe = crate::styles::CheckboxRecipe::for_tokens(&ctx.theme().input);
        let row_id = ctx.add(row);
        let root_id = ctx
            .add(MinSize::new(style_recipe.box_hit_area, style_recipe.box_hit_area).child(row_id));

        if let Some(content) = self.composite_tooltip_content.take() {
            let delay = ctx.theme().motion.tooltip_delay_heavy;
            crate::tooltip::attach_composite_tooltip_boxed(ctx, root_id, content, delay);
        } else if let Some(source) = self.rich_tooltip_source.take() {
            let delay = ctx.theme().motion.tooltip_delay;
            crate::tooltip::attach_rich_tooltip_source(ctx, root_id, source, delay);
        } else if let Some(tooltip_text) = self.tooltip_text.clone() {
            let delay = ctx.theme().motion.tooltip_delay;
            crate::tooltip::attach_plain_tooltip(ctx, root_id, tooltip_text, delay);
        }

        self.root_child_id = Some(root_id);

        // --- V2 attached handlers ---
        let kind_tap = self.kind.clone();
        let kind_key = self.kind.clone();
        let kind_access = self.kind.clone();
        let changed_tap = self.on_change.clone();
        let changed_key = self.on_change.clone();
        let changed_access = self.on_change.clone();
        let int_tap = interaction.clone();
        let int_hover = interaction.clone();
        let int_key = interaction.clone();
        let int_focus = interaction.clone();

        // The pointer press is the framework's, not this control's own: the
        // router knows about a press that slid off its target, one that slid
        // back on, and one a pan claimant took away with no release to reset
        // from — none of which a `PointerDown` / `PointerUp` pair here can
        // see. `docs/touch-and-pen.md` §7.1. `pointer_over` carries the hover
        // truth across the press, so a press that ends without an activation
        // rests on the right state.
        let pointer_over = Rc::new(Cell::new(false));
        crate::button::bind_press_interaction(ctx, interaction.clone(), pointer_over.clone());

        // Framework gates events on `arena.is_enabled(self_id)`, so
        // these closures only run when the widget is effectively
        // enabled. The old `if !enabled { return; }` snapshot guards
        // are gone.
        let handler_set = HandlerSet::new()
            .on_tap({
                let hovering = pointer_over.clone();
                move |_pos, ctx: &mut EventContext| {
                    let now = kind_tap.toggle();
                    if let Some(ref f) = changed_tap {
                        f(now, ctx);
                    }
                    // A mouse or a pen is still over the control after the
                    // release; a finger is gone and sends no hover-leave to
                    // correct a `Hovered` state with.
                    int_tap.set(if ctx.pointer_kind().hovers() {
                        hovering.set(true);
                        InteractionState::Hovered
                    } else {
                        InteractionState::Idle
                    });
                }
            })
            .on_hover({
                let hovering = pointer_over.clone();
                move |entered: bool, _ctx: &mut EventContext| {
                    hovering.set(entered);
                    if entered {
                        int_hover.set(InteractionState::Hovered);
                    } else {
                        int_hover.set(InteractionState::Idle);
                    }
                }
            })
            .on_key({
                move |event: &WidgetEvent, ctx: &mut EventContext| -> EventResponse {
                    match event {
                        WidgetEvent::KeyDown {
                            key: Key::Space, ..
                        } => {
                            int_key.set(InteractionState::Pressed);
                            EventResponse::Handled
                        }
                        WidgetEvent::KeyUp {
                            key: Key::Space, ..
                        } => {
                            // Lone-KeyUp guard: only toggle if we saw the
                            // matching KeyDown (state is Pressed). A stray KeyUp
                            // — e.g. a shortcut consumed the KeyDown and focus
                            // returned here — must NOT toggle.
                            if int_key.get() != InteractionState::Pressed {
                                return EventResponse::Ignored;
                            }
                            let now = kind_key.toggle();
                            if let Some(ref f) = changed_key {
                                f(now, ctx);
                            }
                            int_key.set(InteractionState::Focused);
                            EventResponse::Handled
                        }
                        _ => EventResponse::Ignored,
                    }
                }
            })
            .on_focus({
                move |gained: bool, _ctx: &mut EventContext| {
                    if gained {
                        if int_focus.get() == InteractionState::Idle {
                            int_focus.set(InteractionState::Focused);
                        }
                    } else {
                        int_focus.set(InteractionState::Idle);
                    }
                }
            })
            .on_access_action({
                move |action: teksilo_core::accesskit::Action,
                      ctx: &mut EventContext|
                      -> EventResponse {
                    if action == teksilo_core::accesskit::Action::Click {
                        let now = kind_access.toggle();
                        if let Some(ref f) = changed_access {
                            f(now, ctx);
                        }
                        EventResponse::Handled
                    } else {
                        EventResponse::Ignored
                    }
                }
            })
            // Focus walker skips disabled subtrees on its own.
            .focusable(true)
            .cursor(CursorIcon::Pointer);

        ctx.apply_self_handlers(handler_set);

        // Publish the toggle for the data views' `Space`.
        //
        // A row, cell or tile in a data view is not a focus target and its
        // subtree is kept out of the Tab order — a listbox or grid is one Tab
        // stop, and a per-row stop would make the Tab order follow the scroll
        // position. That leaves a checkbox inside one with no keyboard route,
        // so the view asks the focused row/cell/tile what `Space` should do
        // and finds this. Published by the checkbox itself rather than by each
        // row type, so it works for a hand-written cell delegate too.
        //
        // Costs nothing outside a data view: the marker is only ever read by
        // one, and a standalone checkbox keeps its own focus and its own
        // Space/Enter handling above.
        {
            let kind_space = self.kind.clone();
            let changed_space = self.on_change.clone();
            ctx.set_keyboard_toggle(
                ctx.self_id(),
                std::rc::Rc::new(move |ctx: &mut EventContext| {
                    let now = kind_space.toggle();
                    if let Some(ref f) = changed_space {
                        f(now, ctx);
                    }
                }),
            );
        }

        vec![root_id]
    }

    fn layout_response(
        &self,
        proposal: SizeProposal,
        ctx: &LayoutContext,
    ) -> teksilo_core::widget::LayoutResponse {
        if let Some(root) = self.root_child_id
            && let Some(size) = ctx.child_size(root, proposal)
        {
            return (size).into();
        }
        proposal.resolve(0.0, 0.0).into()
    }

    fn place_children(
        &self,
        bounds: Rect,
        _proposal: SizeProposal,
        children: &mut [WidgetPlacement],
        _ctx: &LayoutContext,
    ) {
        for child in children.iter_mut() {
            child.origin = teksilo_canvas::Point::new(bounds.x, bounds.y);
            child.size = Size::new(bounds.width, bounds.height);
        }
    }

    fn accessibility(&self, builder: &mut AccessNodeBuilder) {
        debug_assert!(
            self.label.is_some() || self.labelled_externally,
            "Checkbox is missing an accessible label — \
             screen readers will announce \"checkbox\" with no context. \
             Call .label(...) when constructing the widget, or \
             .labelled_externally() when embedded in a composite that \
             owns the AT name."
        );
        builder.set_role(teksilo_core::accesskit::Role::CheckBox);
        if let Some(ref label) = self.label {
            builder.set_name(label.resolve_now());
        }
        if let Some(ref caption) = self.caption {
            builder.set_description(caption.resolve_now());
        }
        match self.check_state() {
            CheckState::Checked => builder.set_toggled(true),
            CheckState::Unchecked => builder.set_toggled(false),
            CheckState::Indeterminate => {
                // AccessKit's Toggled::Mixed maps to ARIA "mixed"
                builder
                    .inner_mut()
                    .set_toggled(teksilo_core::accesskit::Toggled::Mixed);
            }
        }
        // Framework's accessibility walker calls `set_disabled` based
        // on `arena.is_enabled(self_id)` — no need to mirror here.
        builder.add_action(teksilo_core::accesskit::Action::Click);
        builder.add_action(teksilo_core::accesskit::Action::Focus);
    }

    fn children(&self) -> Vec<WidgetId> {
        self.root_child_id.into_iter().collect()
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;
    use teksilo_core::event::Modifiers;
    use teksilo_core::widget_tree::WidgetTree;
    use teksilo_i18n::lit;

    /// Records the size every text run was shaped at, so a test can see which
    /// style reached the label and which the caption. The mock backend
    /// ignores styles.
    struct StyleSpy {
        inner: teksilo_canvas::MockTextBackend,
        shaped: Rc<std::cell::RefCell<Vec<(String, f32)>>>,
    }

    impl teksilo_canvas::TextBackend for StyleSpy {
        fn layout_single_line(
            &mut self,
            text: &str,
            style: &teksilo_tokens::TextStyle,
            max_width: Option<f32>,
        ) -> teksilo_canvas::TextLayout {
            self.shaped
                .borrow_mut()
                .push((text.to_string(), style.size));
            self.inner.layout_single_line(text, style, max_width)
        }

        fn ensure_glyphs(
            &mut self,
            layout: &teksilo_canvas::TextLayout,
        ) -> Vec<teksilo_canvas::GlyphQuad> {
            self.inner.ensure_glyphs(layout)
        }
    }

    fn spy_tree() -> (WidgetTree, Rc<std::cell::RefCell<Vec<(String, f32)>>>) {
        let shaped = Rc::new(std::cell::RefCell::new(Vec::new()));
        let backend = StyleSpy {
            inner: teksilo_canvas::MockTextBackend::new(),
            shaped: shaped.clone(),
        };
        let tree = WidgetTree::new()
            .with_theme(teksilo_core::presets::intui::light())
            .with_text_backend(Rc::new(std::cell::RefCell::new(backend)));
        (tree, shaped)
    }

    fn size_of(shaped: &Rc<std::cell::RefCell<Vec<(String, f32)>>>, text: &str) -> f32 {
        shaped
            .borrow()
            .iter()
            .rev()
            .find(|(t, _)| t == text)
            .unwrap_or_else(|| panic!("`{text}` was never shaped"))
            .1
    }

    #[test]
    fn label_and_caption_styles_reach_the_text() {
        let big = teksilo_tokens::TextStyle {
            size: 31.0,
            ..Default::default()
        };
        let (mut tree, shaped) = spy_tree();
        let _w = tree.add(
            Checkbox::new(Signal::new(false))
                .label(lit!("Lbl"))
                .caption(lit!("Cap"))
                .label_style(big.clone())
                .caption_style(TextStyleRole::BodyBold),
        );
        tree.layout(SizeProposal::exact(300.0, 100.0));
        tree.render();
        assert_eq!(size_of(&shaped, "Lbl"), 31.0);
        let heading = teksilo_core::presets::intui::light()
            .typography
            .body_bold
            .size;
        assert_eq!(size_of(&shaped, "Cap"), heading);

        let (mut tree, shaped) = spy_tree();
        let _w = tree.add(
            Checkbox::new(Signal::new(false))
                .label(lit!("Lbl"))
                .caption(lit!("Cap")),
        );
        tree.layout(SizeProposal::exact(300.0, 100.0));
        tree.render();
        let typography = teksilo_core::presets::intui::light().typography;
        assert_eq!(
            size_of(&shaped, "Lbl"),
            typography.body.size,
            "default label"
        );
        assert_eq!(
            size_of(&shaped, "Cap"),
            typography.small.size,
            "default caption"
        );
    }

    #[test]
    fn label_and_caption_colors_apply_and_a_role_still_dims_when_disabled() {
        use std::cell::RefCell;
        use teksilo_canvas::MockTextBackend;
        let theme = teksilo_core::presets::intui::light();
        let accent = theme.colors.accent.to_array();
        let error = theme.colors.text_error.to_array();
        let disabled = theme.colors.text_disabled.to_array();
        let colors = |enabled: bool| {
            let mut tree = WidgetTree::new()
                .with_theme(theme.clone())
                .with_text_backend(Rc::new(RefCell::new(MockTextBackend::new())));
            let _w = tree.add(
                Checkbox::new(Signal::new(false))
                    .label(lit!("Lbl"))
                    .caption(lit!("Cap"))
                    .label_color(TextRole::Accent)
                    .caption_color(TextRole::Error)
                    .enabled(enabled),
            );
            tree.layout(SizeProposal::exact(300.0, 100.0));
            tree.render()
                .glyphs
                .iter()
                .map(|g| g.color)
                .collect::<Vec<_>>()
        };
        let on = colors(true);
        assert!(on.contains(&accent), "label takes label_color: {on:?}");
        assert!(on.contains(&error), "caption takes caption_color: {on:?}");
        let off = colors(false);
        assert!(
            !off.contains(&accent) && !off.contains(&error) && off.contains(&disabled),
            "disabled dims the role colours: {off:?}"
        );
    }

    #[test]
    fn focus_ring_only_under_focus_visible() {
        // `:focus-visible`: the focus border shows during keyboard navigation
        // but not on a pointer click. Programmatic focus leaves `focus_visible`
        // false → no border; a key press flips the modality and reveals it.
        let theme = teksilo_core::presets::intui::light();
        let ring = theme.colors.border_focused.to_array();
        let mut tree = WidgetTree::new().with_theme(theme);
        let cb = tree.add(Checkbox::new(Signal::new(false)).label(lit!("A")));
        tree.layout(SizeProposal::exact(200.0, 80.0));

        tree.focus(cb);
        assert!(
            !frame_has_color(&tree.render(), ring),
            "no focus border while focus-visible is false (pointer modality)",
        );

        tree.press_key(Key::ArrowDown, Modifiers::NONE);
        assert!(
            frame_has_color(&tree.render(), ring),
            "focus border shows under keyboard modality",
        );
    }

    /// Whether `color` appears in any color-bearing layer of the frame.
    fn frame_has_color(frame: &teksilo_canvas::RenderFrame, color: [f32; 4]) -> bool {
        frame.shapes.iter().any(|s| s.color == color)
            || frame.decorations.iter().any(|d| d.color == color)
            || frame.cosmetic_lines.iter().any(|l| l.color == color)
    }

    // --- Two-state tests ---

    #[test]
    fn click_toggles_bool_state() {
        let checked = Signal::new(false);
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let cb = tree.add(Checkbox::new(checked.clone()).label(lit!("Accept")));
        tree.layout(SizeProposal::exact(200.0, 80.0));

        assert!(!checked.get());
        tree.click(cb);
        assert!(checked.get());
        tree.click(cb);
        assert!(!checked.get());
    }

    #[test]
    fn space_toggles_bool_state() {
        let checked = Signal::new(false);
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let cb = tree.add(Checkbox::new(checked.clone()).label(lit!("Accept")));
        tree.layout(SizeProposal::exact(200.0, 80.0));

        tree.focus(cb);
        tree.press_key(Key::Space, Modifiers::NONE);
        assert!(checked.get());
        tree.press_key(Key::Space, Modifiers::NONE);
        assert!(!checked.get());
    }

    #[test]
    fn a_reader_is_told_each_change_as_it_happens() {
        // Space, a screen reader's own click and a write from the app each
        // changed the box and told no platform: its state reached the tree only
        // when something unrelated walked it again, most often the next focus
        // move, where Orca's "checked" was cut by the new focus.
        use crate::common::heard_test::{Heard, Listener};
        use teksilo_core::accesskit::Toggled;

        let state = Signal::new(CheckState::Unchecked);
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let cb = tree.add(Checkbox::tristate(state.clone()).label(lit!("Accept")));
        let p = SizeProposal::exact(200.0, 80.0);
        tree.layout(p);
        tree.focus(cb);
        tree.layout(p);
        let mut listener = Listener::attach(&mut tree);

        tree.press_key(Key::Space, Modifiers::NONE);
        tree.layout(p);
        assert_eq!(
            listener.heard(&mut tree),
            vec![Heard::FocusToggled(Toggled::True)],
            "Space"
        );

        tree.dispatch_access_action(
            teksilo_core::accessibility::widget_id_to_node_id(cb),
            teksilo_core::accesskit::Action::Click,
            None,
            &mut teksilo_core::NoopWindowOps,
        );
        tree.layout(p);
        assert_eq!(
            listener.heard(&mut tree),
            vec![Heard::FocusToggled(Toggled::False)],
            "a screen reader's click"
        );

        state.set(CheckState::Indeterminate);
        tree.layout(p);
        assert_eq!(
            listener.heard(&mut tree),
            vec![Heard::FocusToggled(Toggled::Mixed)],
            "a write from the app"
        );
    }

    #[test]
    fn on_change_fires_for_every_user_path_and_reports_the_new_value() {
        use std::cell::RefCell;
        use std::rc::Rc;

        let checked = Signal::new(false);
        let seen: Rc<RefCell<Vec<bool>>> = Rc::new(RefCell::new(Vec::new()));
        let sink = seen.clone();
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let cb = tree.add(
            Checkbox::new(checked.clone())
                .label(lit!("Accept"))
                .on_change(move |now, _ctx| sink.borrow_mut().push(now)),
        );
        tree.layout(SizeProposal::exact(200.0, 80.0));

        tree.click(cb);
        tree.focus(cb);
        tree.press_key(Key::Space, Modifiers::NONE);
        tree.dispatch_access_action(
            teksilo_core::accessibility::widget_id_to_node_id(cb),
            teksilo_core::accesskit::Action::Click,
            None,
            &mut teksilo_core::NoopWindowOps,
        );

        // Pointer, keyboard, assistive technology — and each reports the value
        // the activation produced, not the one before it.
        assert_eq!(*seen.borrow(), vec![true, false, true]);
        assert!(checked.get());
    }

    #[test]
    fn on_change_is_silent_for_a_programmatic_write() {
        use std::cell::Cell;
        use std::rc::Rc;

        let checked = Signal::new(false);
        let fired = Rc::new(Cell::new(false));
        let sink = fired.clone();
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let _cb = tree.add(
            Checkbox::new(checked.clone())
                .label(lit!("Accept"))
                .on_change(move |_now, _ctx| sink.set(true)),
        );
        tree.layout(SizeProposal::exact(200.0, 80.0));

        // No event in flight to carry, so nothing to report. Observe the
        // signal for this direction.
        checked.set(true);
        assert!(!fired.get());
    }

    #[test]
    fn on_change_reports_a_bool_from_a_tristate() {
        use std::cell::RefCell;
        use std::rc::Rc;

        let state = Signal::new(CheckState::Indeterminate);
        let seen: Rc<RefCell<Vec<bool>>> = Rc::new(RefCell::new(Vec::new()));
        let sink = seen.clone();
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let cb = tree.add(
            Checkbox::tristate(state.clone())
                .label(lit!("All"))
                .on_change(move |now, _ctx| sink.borrow_mut().push(now)),
        );
        tree.layout(SizeProposal::exact(200.0, 80.0));

        // Activation from Indeterminate checks the whole, then unchecks; it
        // never produces Indeterminate, which is why a bool is lossless here.
        tree.click(cb);
        tree.click(cb);
        assert_eq!(*seen.borrow(), vec![true, false]);
        assert_eq!(state.get(), CheckState::Unchecked);
    }

    #[test]
    fn lone_keyup_does_not_toggle() {
        // Lone-KeyUp guard: a KeyUp with no matching KeyDown (e.g. a shortcut
        // consumed the KeyDown, then focus returned here) must NOT toggle.
        let checked = Signal::new(false);
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let cb = tree.add(Checkbox::new(checked.clone()).label(lit!("Accept")));
        tree.layout(SizeProposal::exact(200.0, 80.0));
        tree.focus(cb);

        tree.dispatch_event(WidgetEvent::KeyUp {
            key: Key::Space,
            modifiers: Modifiers::NONE,
        });
        assert!(!checked.get(), "a lone KeyUp must not toggle the checkbox");

        // A matched pair still toggles.
        tree.press_key(Key::Space, Modifiers::NONE);
        assert!(checked.get());
    }

    #[test]
    fn disabled_ignores_click() {
        let checked = Signal::new(false);
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let cb = tree.add(
            Checkbox::new(checked.clone())
                .label(lit!("Accept"))
                .enabled(false),
        );
        tree.layout(SizeProposal::exact(200.0, 80.0));

        tree.click(cb);
        assert!(!checked.get());
    }

    #[test]
    fn two_state_accessibility() {
        let checked = Signal::new(true);
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let cb = tree.add(Checkbox::new(checked).label(lit!("Accept")));
        tree.layout(SizeProposal::exact(200.0, 80.0));

        let info = tree.accessibility_node(cb);
        assert_eq!(info.role(), teksilo_core::accesskit::Role::CheckBox);
        assert_eq!(info.name(), Some("Accept"));
        assert!(info.is_toggled());
    }

    // --- Tristate tests ---

    #[test]
    fn tristate_user_click_toggles_two_states() {
        // User clicks only toggle Checked ↔ Unchecked. Indeterminate is
        // reserved for external sources (TreeCheckedModel aggregation, etc.)
        // — clicking from Indeterminate checks the whole. Outlook / Files-app
        // folder-checkbox semantic.
        let state = Signal::new(CheckState::Unchecked);
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let cb = tree.add(Checkbox::tristate(state.clone()).label(lit!("Select All")));
        tree.layout(SizeProposal::exact(200.0, 80.0));

        assert_eq!(state.get(), CheckState::Unchecked);
        tree.click(cb);
        assert_eq!(state.get(), CheckState::Checked);
        tree.click(cb);
        assert_eq!(state.get(), CheckState::Unchecked);

        // Clicking from Indeterminate checks the whole, NOT cycles.
        state.set(CheckState::Indeterminate);
        tree.click(cb);
        assert_eq!(state.get(), CheckState::Checked);
    }

    #[test]
    fn tristate_space_toggles_two_states() {
        let state = Signal::new(CheckState::Unchecked);
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let cb = tree.add(Checkbox::tristate(state.clone()).label(lit!("Select All")));
        tree.layout(SizeProposal::exact(200.0, 80.0));

        tree.focus(cb);
        tree.press_key(Key::Space, Modifiers::NONE);
        assert_eq!(state.get(), CheckState::Checked);
        tree.press_key(Key::Space, Modifiers::NONE);
        assert_eq!(state.get(), CheckState::Unchecked);
    }

    #[test]
    fn tristate_indeterminate_shows_filled_background() {
        // Indeterminate is_filled() == true, so it should have a primary background
        let state = Signal::new(CheckState::Indeterminate);
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        tree.add(Checkbox::tristate(state).label(lit!("Partial")));
        tree.layout(SizeProposal::exact(200.0, 80.0));
        let frame = tree.render();
        let primary = teksilo_core::presets::intui::light()
            .colors
            .accent
            .to_array();
        assert!(
            frame.shapes.iter().any(|s| s.color == primary),
            "indeterminate checkbox should have primary-colored background"
        );
    }

    #[test]
    fn check_state_conversions() {
        assert_eq!(CheckState::from(true), CheckState::Checked);
        assert_eq!(CheckState::from(false), CheckState::Unchecked);
        assert!(CheckState::Checked.is_filled());
        assert!(CheckState::Indeterminate.is_filled());
        assert!(!CheckState::Unchecked.is_filled());
    }

    #[test]
    fn disabled_has_disabled_colors() {
        let checked = Signal::new(true);
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        tree.add(
            Checkbox::new(checked)
                .label(lit!("Disabled"))
                .enabled(false),
        );
        tree.layout(SizeProposal::exact(200.0, 80.0));
        let frame = tree.render();
        let disabled_fill = teksilo_core::presets::intui::light()
            .colors
            .accent_disabled
            .to_array();
        assert!(
            frame.shapes.iter().any(|s| s.color == disabled_fill),
            "disabled checkbox should render with disabled_fill color"
        );
    }

    #[test]
    fn accessibility_has_actions() {
        let checked = Signal::new(false);
        let mut tree = WidgetTree::new().with_theme(teksilo_core::presets::intui::light());
        let cb = tree.add(Checkbox::new(checked).label(lit!("Accept")));
        tree.layout(SizeProposal::exact(200.0, 80.0));
        let info = tree.accessibility_node(cb);
        assert!(
            info.actions()
                .contains(&teksilo_core::accesskit::Action::Click)
        );
    }

    // -----------------------------------------------------------------
    // The framework press (docs/touch-and-pen.md §7.1)
    // -----------------------------------------------------------------

    /// A `CheckboxStyle` that hands the press and hover signals its chrome
    /// reads back to the test.
    struct PressProbe(std::rc::Rc<std::cell::RefCell<Option<(Signal<bool>, Signal<bool>)>>>);

    impl teksilo_core::styles::CheckboxStyle for PressProbe {
        fn make_body(
            &self,
            cfg: &teksilo_core::styles::CheckboxStyleConfig,
            ctx: &mut BuildContext,
        ) -> WidgetId {
            *self.0.borrow_mut() = Some((cfg.is_pressed.clone(), cfg.is_hovered.clone()));
            ctx.add(crate::primitives::FixedSize::new().width(19.0).height(19.0))
        }
    }

    #[allow(clippy::type_complexity)]
    fn probed_checkbox_with_hover() -> (
        WidgetTree,
        WidgetId,
        Signal<bool>,
        Signal<bool>,
        Signal<bool>,
    ) {
        let probe: std::rc::Rc<std::cell::RefCell<Option<(Signal<bool>, Signal<bool>)>>> =
            std::rc::Rc::new(std::cell::RefCell::new(None));
        let checked = Signal::new(false);
        let mut theme = teksilo_core::presets::intui::light();
        theme.style_slots.checkbox = Some(std::rc::Rc::new(PressProbe(probe.clone())));
        let mut tree = WidgetTree::new().with_theme(theme);
        let cb = tree.add(Checkbox::new(checked.clone()).label(lit!("Ready")));
        tree.layout(SizeProposal::exact(200.0, 60.0));
        let (pressed, hovered) = probe.borrow().clone().expect("style ran");
        (tree, cb, pressed, hovered, checked)
    }

    fn probed_checkbox() -> (WidgetTree, WidgetId, Signal<bool>, Signal<bool>) {
        let (tree, cb, pressed, _hovered, checked) = probed_checkbox_with_hover();
        (tree, cb, pressed, checked)
    }

    /// A mouse press now lights the checkbox's own `is_pressed` — the signal
    /// the style has always been handed, and which until the controls sweep
    /// only a keyboard `Space` could ever set. The toggle still lands on the
    /// release.
    #[test]
    fn a_mouse_press_lights_the_pressed_state_and_the_release_toggles() {
        let (mut tree, cb, pressed, checked) = probed_checkbox();
        let at = tree.bounds(cb).center();
        tree.pointer_move(at);
        tree.pointer_down_button(at, teksilo_core::event::PointerButton::Primary);
        assert!(pressed.get(), "the press shows");
        assert!(!checked.get(), "and has not toggled anything yet");
        tree.pointer_up_button(at, teksilo_core::event::PointerButton::Primary);
        assert!(!pressed.get());
        assert!(checked.get(), "the release toggles");
    }

    /// A finger: the press lights, the release toggles, and — with no hover to
    /// clear it — the control rests idle rather than stuck in the hover tint a
    /// finger never earned.
    #[test]
    fn a_touch_tap_toggles_on_release() {
        use crate::button::press_test_support::{finger, touch};
        use teksilo_core::pointer::PointerPhase;

        let (mut tree, cb, pressed, checked) = probed_checkbox();
        let at = tree.bounds(cb).center();
        let id = finger();
        tree.dispatch_pointer(touch(id, PointerPhase::Down, at, 0));
        assert!(pressed.get());
        assert!(!checked.get());
        tree.dispatch_pointer(touch(id, PointerPhase::Up, at, 30));
        assert!(checked.get());
        assert!(!pressed.get());
    }

    /// Sliding off abandons the press visual and the toggle; sliding back on
    /// restores the visual (WCAG 2.2 SC 2.5.2's abort gesture, reversible).
    #[test]
    fn a_touch_press_disarms_on_slide_off_and_re_arms_on_re_entry() {
        use crate::button::press_test_support::{finger, touch};
        use teksilo_core::pointer::PointerPhase;

        let (mut tree, cb, pressed, checked) = probed_checkbox();
        let bounds = tree.bounds(cb);
        let at = bounds.center();
        let away = teksilo_canvas::Point::new(at.x, bounds.y + bounds.height + 80.0);
        let id = finger();
        tree.dispatch_pointer(touch(id, PointerPhase::Down, at, 0));
        tree.dispatch_pointer(touch(id, PointerPhase::Move, away, 20));
        assert!(!pressed.get(), "the press left its target");
        tree.dispatch_pointer(touch(id, PointerPhase::Move, at, 40));
        assert!(pressed.get(), "and came back");
        tree.dispatch_pointer(touch(id, PointerPhase::Up, away, 60));
        assert!(!checked.get(), "a release off the control toggles nothing");
    }

    /// Where the checkbox comes to rest after a toggle — the `on_tap` copy of
    /// the button family's resting-state rule, which lives in this file rather
    /// than being shared, and so has to be pinned here too.
    ///
    /// The pressed transitions are shared (`button::bind_press_interaction`);
    /// this one is not. A mouse is still over the box when it lifts, so the
    /// box rests hovered; a finger is gone and sends no hover-leave, so it
    /// rests idle. Asserted through `CheckboxStyleConfig::is_hovered`, the
    /// signal the chrome tints from.
    #[test]
    fn a_mouse_toggle_rests_hovered_and_a_finger_toggle_rests_idle() {
        use crate::button::press_test_support::touch_tap;

        let (mut tree, cb, pressed, hovered, checked) = probed_checkbox_with_hover();
        let at = tree.bounds(cb).center();
        tree.pointer_move(at);
        assert!(hovered.get(), "the pointer arrived over the box");
        tree.pointer_down_button(at, teksilo_core::event::PointerButton::Primary);
        tree.pointer_up_button(at, teksilo_core::event::PointerButton::Primary);
        assert!(checked.get(), "the release toggled");
        assert!(!pressed.get());
        assert!(
            hovered.get(),
            "a mouse that clicked the box is still on it, so it rests hovered",
        );

        let (mut tree, cb, pressed, hovered, checked) = probed_checkbox_with_hover();
        let at = tree.bounds(cb).center();
        touch_tap(&mut tree, at);
        assert!(checked.get(), "the contact toggled on its release");
        assert!(!pressed.get());
        assert!(
            !hovered.get(),
            "a finger leaves nothing behind, so the box must rest idle",
        );
    }

    /// The hit area is the 24 dp box the recipe reserves around a 19 dp glyph,
    /// so the checkbox needs no widening mechanism at all.
    #[test]
    fn the_checkbox_hit_box_clears_the_conformance_floor_at_compact() {
        let theme = teksilo_core::presets::intui::light();
        let floor = theme.input.min_target_conformance;
        let mut tree = WidgetTree::new().with_theme(theme);
        let cb = tree.add(Checkbox::new(Signal::new(false)));
        tree.layout(SizeProposal::exact(200.0, 60.0));
        let b = tree.bounds(cb);
        assert!(
            b.width >= floor && b.height >= floor,
            "a bare Compact Checkbox measured {}x{}",
            b.width,
            b.height,
        );
    }
}