teksilo_widgets/grid_view/

keyboard.rs

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

//! 2D keyboard navigation for `GridView`.
//!
//! Mirrors `table_view/keyboard.rs` but for a flat-model tile grid: arrow
//! keys move by ±1 (within a row) and ±columns (between rows), with RTL
//! horizontal swap, Home/End row ends, Ctrl+Home/End document ends,
//! PageUp/Down by a viewport of rows, Tab traversal, Space/Enter to
//! select, Escape to clear focus, and Ctrl+A to select-all. Shift + any
//! navigation extends the selection range (reading-order, Finder/Explorer
//! style). Every navigation scrolls the new focus into view.

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

use teksilo_core::event::{EventResponse, Key, Modifiers, WidgetEvent};
use teksilo_core::signal::Signal;
use teksilo_core::widget::EventContext;

use super::layout::{GridLayoutStrategy, ScrollAnchor};
use crate::common::list_nav;
use crate::common::type_ahead::TypeAheadState;

/// How Tab moves out of (or within) the grid.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum GridTabTraversal {
    /// Tab releases focus to the next focusable widget in the window.
    #[default]
    OutOfGrid,
    /// Tab advances to the next tile (wrapping rows); Shift+Tab the previous.
    WithinGrid,
}

/// Everything the key handler needs, captured at build time. `col_count`
/// and `row_height` are shared `Cell`s updated by the layout pass so the
/// handler always reads the live column count.
pub(crate) struct GridKeyConfig {
    pub(crate) len_fn: Rc<dyn Fn() -> usize>,
    pub(crate) col_count: Signal<usize>,
    pub(crate) focused_index: Signal<Option<usize>>,
    pub(crate) selection: Option<crate::data_views::RowSelection>,
    /// Says the new count when Space changes how many tiles are selected.
    /// Space reaches the selection through `row_space_activate`, which runs
    /// after this handler has returned, outside the voice the grid puts
    /// around the handler itself. A tile that is not realized is selected
    /// inside the handler instead, and the voice, shared by both, then counts
    /// once. See `selection_count`.
    pub(crate) count_voice: Option<super::selection_count::SelectionCountVoice>,
    pub(crate) scroll_y: Signal<f32>,
    pub(crate) max_scroll_y: Signal<f32>,
    pub(crate) viewport_height: Rc<Cell<f32>>,
    pub(crate) viewport_width: Rc<Cell<f32>>,
    /// The grid body pane's absolute (window) origin, published each layout
    /// pass by `GridBodyPane::place_children` (`None` until the pane has laid
    /// out at least once). Lets the handler compute the focused tile's absolute
    /// rect (`origin + tile_rect - scroll`) and chase it into any *enclosing*
    /// scroll area via
    /// [`EventContext::ensure_visible`](teksilo_core::widget::EventContext::ensure_visible).
    /// Tiles are virtualized and not focusable, so the focus-driven follow
    /// never reveals the focused tile in an outer scroller. Left as `None`, the
    /// chase is skipped so a nav dispatched before the first layout can't anchor
    /// the rect at (0, 0).
    pub(crate) viewport_origin: Rc<Cell<Option<teksilo_canvas::Point>>>,
    pub(crate) strategy: Rc<dyn GridLayoutStrategy>,
    pub(crate) wrap_navigation: bool,
    pub(crate) tab_traversal: GridTabTraversal,
    /// The application's activation (Enter), index only; the app looks up the
    /// item from its own model handle. The detail band's part in an
    /// activation is `detail`'s, handled here (`activate_tile`).
    #[allow(clippy::type_complexity)]
    pub(crate) on_tile_activate: Option<Rc<dyn Fn(usize, &mut EventContext)>>,
    /// The detail band, when one is in force: Enter opens and closes it,
    /// Space closes it, ↓ from the open tile moves into it, and the grid's
    /// keys stand aside while focus is inside it.
    pub(crate) detail: Option<Rc<super::detail::DetailState>>,
    /// The non-drag reorder, bound once by the grid. `Some` exactly when the
    /// grid is reorderable. `(from, destination) -> ()`: commits through the
    /// source's own drop-accept path, follows the tile with focus and
    /// selection, reveals it and announces once. Shared with the tile's context
    /// menu and its AccessKit custom actions — see `common::ordered_move`.
    #[allow(clippy::type_complexity)]
    pub(crate) reorder_perform: Option<Rc<dyn Fn(usize, usize, &mut EventContext)>>,
    pub(crate) type_ahead_timeout: Duration,
    /// Persistent across rebuilds — see `GridView::type_ahead`.
    pub(crate) type_ahead: Rc<TypeAheadState>,
    /// Index → realized tile id. `Space` asks the focused tile whether it
    /// publishes a keyboard toggle before falling back to the selection.
    #[allow(clippy::type_complexity)]
    pub(crate) tile_map: Rc<std::cell::RefCell<Vec<(usize, teksilo_core::widget_id::WidgetId)>>>,
    /// `None` when a row isn't resident yet (lazy/windowed source) — skipped
    /// during the search rather than matched against whatever the label
    /// closure happens to compute for an absent row.
    #[allow(clippy::type_complexity)]
    pub(crate) type_ahead_label: Option<Rc<dyn Fn(usize) -> Option<String>>>,
}

/// Select all tiles, as the grid's `edit.select_all` action runs it. Declined
/// without a `Multi` selection, for an empty grid, and while focus is inside
/// the detail band: a command its content did not use is not about the tiles.
pub(crate) fn run_select_all(
    len: usize,
    selection: Option<&crate::data_views::RowSelection>,
    detail: Option<&super::detail::DetailState>,
) -> bool {
    if detail.is_some_and(|d| d.focus_within.get()) {
        return false;
    }
    match selection {
        Some(sel) if len > 0 && sel.mode() == teksilo_data::SelectionMode::Multi => {
            sel.select_all(len);
            true
        }
        _ => false,
    }
}

/// Build the `on_key` closure for a `GridView`.
pub(crate) fn build_grid_key_handler(
    cfg: GridKeyConfig,
) -> impl FnMut(&WidgetEvent, &mut EventContext) -> EventResponse + 'static {
    let ta_state = cfg.type_ahead.clone();
    move |event, ctx| {
        let WidgetEvent::KeyDown { key, modifiers, .. } = event else {
            return EventResponse::Ignored;
        };
        // A key from inside the detail band that its content did not use
        // bubbles up to here. It is not about the tiles: a list at its last
        // row letting ↓ through must not move the tile cursor behind it.
        if cfg.detail.as_ref().is_some_and(|d| d.focus_within.get()) {
            return EventResponse::Ignored;
        }
        let n = (cfg.len_fn)();
        if n == 0 {
            return EventResponse::Ignored;
        }
        let cols = cfg.col_count.get().max(1);
        let rtl = ctx.is_rtl();
        // The keyboard cursor: `focused_index` once the user has navigated or
        // clicked, else the current selection (a grid can be handed a selected
        // tile before it is ever focused). `None` = "no cursor yet", which is
        // NOT "cursor on tile 0" — the directional keys below land ON an end
        // tile rather than stepping past it.
        let cursor = cfg
            .focused_index
            .get()
            .or_else(|| {
                cfg.selection
                    .as_ref()
                    .and_then(|s| s.selected_indices().first().copied())
            })
            .map(|i| i.min(n - 1));
        // Anchor for the keys that compute *from* a tile (reorder, paging,
        // row-relative Home/End, type-ahead) rather than step in a direction.
        let current = cursor.unwrap_or(0);
        let col = current % cols;

        // The edge-and-page family, resolved once in `common::list_nav`.
        let nav = list_nav::nav_chord(*key, *modifiers, list_nav::ViewKind::TileGrid);

        // Ctrl+Shift+A deselects. Gated on `Multi` like `ListView` and
        // `TreeView`: "select all" has no reading for a control that holds at
        // most one tile, and this handler used to claim the chord even with no
        // selection model at all. Select all is the `edit.select_all` action
        // (`run_select_all`), so a plain Ctrl+A only gets here when it is not
        // bound to it.
        if modifiers.command() && *key == Key::A {
            if modifiers.shift()
                && let Some(ref sel) = cfg.selection
                && sel.mode() == teksilo_data::SelectionMode::Multi
            {
                sel.clear();
                return EventResponse::Handled;
            }
            return EventResponse::Ignored;
        }

        // Resolve the horizontal arrows, swapping under RTL.
        let logical_prev = if rtl { Key::ArrowRight } else { Key::ArrowLeft };
        let logical_next = if rtl { Key::ArrowLeft } else { Key::ArrowRight };

        // Alt+Arrow / Alt+Home / Alt+End: reorder the focused tile. The four
        // named moves come from `common::ordered_move` (shared with the tile's
        // context menu and its custom actions); a whole-row step is the grid's
        // own, because "one row down" is not one of the four.
        if modifiers.alt()
            && let Some(ref perform) = cfg.reorder_perform
        {
            let named = crate::common::ordered_move::OrderedMove::from_key(
                *key,
                *modifiers,
                crate::common::ordered_move::MoveAxis::Horizontal,
                rtl,
            )
            .and_then(|mv| mv.destination(current, n));
            let target = match named {
                Some(t) => Some(t),
                None if *key == Key::ArrowDown && current + cols < n => Some(current + cols),
                None if *key == Key::ArrowUp && current >= cols => Some(current - cols),
                None => None,
            };
            if let Some(t) = target {
                perform(current, t, ctx);
                return EventResponse::Handled;
            }
        }

        // macOS reads ⌘↓ as "open the focused item" in a list or an icon view
        // — Finder's meaning, and dead here otherwise. Off macOS this is
        // `None` and costs nothing.
        //
        // Read *after* the Alt+Arrow reorder above, not before: ⌥←/⌥→ resolve
        // to the subtree aliases, which a flat tile grid has no use for, and
        // claiming them first made keyboard reorder a dead chord on macOS.
        if let Some(alias) = list_nav::mac_alias(*key, *modifiers, rtl) {
            if alias == list_nav::MacAlias::Activate {
                activate_tile(&cfg, current, ctx);
                return EventResponse::Handled;
            }
            return EventResponse::Ignored;
        }

        // Type-ahead: a bare printable character jumps to the next match.
        // Use `to_char()` so letters (which arrive as the dedicated
        // `Key::A`..`Key::Z` variants, NOT `Key::Character`) trigger it too —
        // matching only `Key::Character` silently broke letter type-ahead.
        //
        // A search that finds nothing returns `Ignored` rather than falling
        // through to the navigation match below, so a printable key can never
        // be read as a movement — the same shape `ListView` and `TreeView`
        // use. Nothing in the current key set is both, but the fall-through
        // made that a latent hazard rather than a decision.
        if let Some(ref label_fn) = cfg.type_ahead_label
            && !modifiers.ctrl()
            && !modifiers.alt()
            && !modifiers.super_key()
            && let Some(c) = key.to_char()
        {
            return match ta_state.search(c, current, n, cfg.type_ahead_timeout, |i| label_fn(i)) {
                Some(idx) => {
                    cfg.focused_index.set(Some(idx));
                    if let Some(ref sel) = cfg.selection {
                        sel.select(idx);
                    }
                    ensure_visible(&cfg, idx, ctx);
                    EventResponse::Handled
                }
                None => EventResponse::Ignored,
            };
        }

        // With no cursor yet, a directional key lands ON the near end tile
        // (first for forward/down, last for backward/up) instead of stepping
        // past it — otherwise the very first ArrowRight would skip tile 0.
        let new_idx: Option<usize> = if *key == logical_next {
            if cursor.is_none() {
                Some(0)
            } else if !cfg.wrap_navigation && col == cols - 1 {
                None
            } else {
                Some((current + 1).min(n - 1))
            }
        } else if *key == logical_prev {
            if cursor.is_none() {
                Some(n - 1)
            } else if !cfg.wrap_navigation && col == 0 {
                None
            } else {
                Some(current.saturating_sub(1))
            }
        } else {
            match key {
                Key::ArrowDown => {
                    if cursor.is_none() {
                        Some(0)
                    } else if *modifiers == Modifiers::NONE
                        && let Some(band) =
                            cfg.detail.as_ref().and_then(|d| enterable_band(d, current))
                    {
                        // Into the open tile's band, onto its first control.
                        // The cursor stays on the tile, for ↑ to return to.
                        ctx.request_focus_into(band);
                        return EventResponse::Handled;
                    } else if current + cols < n {
                        Some(current + cols)
                    } else {
                        None
                    }
                }
                Key::ArrowUp => {
                    if cursor.is_none() {
                        Some(n - 1)
                    } else if current >= cols {
                        Some(current - cols)
                    } else {
                        None
                    }
                }
                // Home / End reach the first / last tile of the collection,
                // not the ends of the reflow row. A wrapped grid's rows change
                // with the window width, so "first tile in this row" is not a
                // target a user can form a model of — `GtkGridView` and Qt's
                // `QListView` in icon mode both resolve it absolutely for that
                // reason. The accelerator therefore adds no new destination
                // here; it only suppresses the selection, via `list_nav`.
                Key::Home | Key::End | Key::PageUp | Key::PageDown => {
                    let Some(chord) = nav else {
                        return EventResponse::Ignored;
                    };
                    Some(match chord.movement {
                        list_nav::NavMove::First | list_nav::NavMove::RowFirst => 0,
                        list_nav::NavMove::Last | list_nav::NavMove::RowLast => n - 1,
                        // Paged by real geometry rather than by
                        // `estimated_row_height`, so `VariableRowGrid` and
                        // `VirtualizedMasonry` page to the tile the user
                        // actually lands on. The shared `ensure_visible` tail
                        // then does the scrolling — this arm used to scroll
                        // too, moving the viewport twice for one keypress.
                        list_nav::NavMove::Page { down } => {
                            page_target(&cfg, current, cols, n, down)
                        }
                    })
                }
                // Ctrl+Tab / Ctrl+Shift+Tab escape the grid, so a
                // `WithinGrid` traversal is never a trap. Literal `ctrl()`,
                // macOS included: ⌘⇥ belongs to the application switcher and
                // never reaches an app. Same hatch `TableView` has.
                Key::Tab if modifiers.ctrl() => return EventResponse::Ignored,
                Key::Tab if cfg.tab_traversal == GridTabTraversal::WithinGrid => {
                    if modifiers.shift() {
                        if current == 0 {
                            None
                        } else {
                            Some(current - 1)
                        }
                    } else if current + 1 < n {
                        Some(current + 1)
                    } else {
                        None
                    }
                }
                Key::Enter => {
                    activate_tile(&cfg, current, ctx);
                    return EventResponse::Handled;
                }
                Key::Space if modifiers.ctrl() => {
                    // Ctrl+Space toggles the focused tile's selection — the
                    // keyboard equivalent of Ctrl+click. In a multiple
                    // selection it pairs with Ctrl+Arrow's cursor-only move so
                    // a user can walk the
                    // cursor without disturbing the existing selection,
                    // then Ctrl+Space to add tiles one at a time.
                    //
                    // Both halves stay on literal `ctrl()`, macOS included:
                    // ⌘Space is Spotlight and never reaches an app, and ⌘↑/⌘↓
                    // already mean something else in a Finder list. This
                    // Explorer-style cursor pair has no ⌘ counterpart, so
                    // Control keeps it reachable and out of the platform's way.
                    if let Some(ref sel) = cfg.selection {
                        sel.toggle(current);
                    }
                    cfg.focused_index.set(Some(current));
                    return EventResponse::Handled;
                }
                Key::Space if cfg.detail.as_ref().is_some_and(|d| d.is_open(current)) => {
                    // Space on the open tile closes its band, as Enter does,
                    // and leaves the selection alone.
                    if let Some(d) = &cfg.detail {
                        d.expanded.set(None);
                    }
                    cfg.focused_index.set(Some(current));
                    return EventResponse::Handled;
                }
                Key::Space => {
                    // A tile carrying a checkbox reads Space as "check this" —
                    // its control is out of the Tab order, so this is the only
                    // keyboard route to it. Otherwise: toggle in `Multi`,
                    // select in `Single`, the rule `ListView` and `TreeView`
                    // follow. (This used to select unconditionally, so Space
                    // could never unpick a tile.)
                    let selection = cfg.selection.clone();
                    let voice = cfg.count_voice.clone();
                    let fallback = std::rc::Rc::new(move |ctx: &mut EventContext| {
                        let Some(ref sel) = selection else {
                            return;
                        };
                        let pick = |_: &mut EventContext| {
                            if sel.mode() == teksilo_data::SelectionMode::Multi {
                                sel.toggle(current);
                            } else {
                                sel.select(current);
                            }
                        };
                        match &voice {
                            Some(voice) => voice.around(ctx, pick),
                            None => pick(ctx),
                        }
                    });
                    match cfg
                        .tile_map
                        .borrow()
                        .iter()
                        .find(|(i, _)| *i == current)
                        .map(|(_, id)| *id)
                    {
                        Some(tile_id) => ctx.row_space_activate(tile_id, fallback),
                        None => fallback(ctx),
                    }
                    cfg.focused_index.set(Some(current));
                    return EventResponse::Handled;
                }
                Key::Escape => {
                    cfg.focused_index.set(None);
                    return EventResponse::Handled;
                }
                _ => return EventResponse::Ignored,
            }
        };

        let Some(idx) = new_idx else {
            return EventResponse::Ignored;
        };
        cfg.focused_index.set(Some(idx));
        // What the chord does to the selection. The edge-and-page keys carry
        // their own answer from `list_nav`, where the accelerator means "move
        // the cursor, leave the selection alone" — in a multiple selection. A
        // single selection moves with the cursor (`for_cardinality`), whatever
        // the chord.
        //
        // The arrows keep reading literal `ctrl()`: ⌘Space is Spotlight and
        // ⌘↑/⌘↓ mean something else in a Finder icon view, so this pair has no
        // ⌘ counterpart to move to (see the Ctrl+Space arm above). Checked
        // against `logical_next`/`logical_prev` (already RTL-swapped) plus the
        // raw vertical keys, so the chord follows the visual arrow.
        let op = match nav {
            Some(chord) => chord.selection,
            None if modifiers.ctrl()
                && !modifiers.shift()
                && !modifiers.alt()
                && (*key == logical_next
                    || *key == logical_prev
                    || *key == Key::ArrowDown
                    || *key == Key::ArrowUp) =>
            {
                list_nav::SelectionOp::Suppress
            }
            None if modifiers.shift() => list_nav::SelectionOp::Extend,
            None => list_nav::SelectionOp::Replace,
        };
        if let Some(ref sel) = cfg.selection {
            match op.for_cardinality(sel.mode().into()) {
                list_nav::SelectionOp::Replace => sel.select(idx),
                list_nav::SelectionOp::Suppress => {}
                list_nav::SelectionOp::Extend => sel.extend_to(idx),
                list_nav::SelectionOp::ExtendAdditive => sel.extend_to_additive(idx),
            }
        }
        ensure_visible(&cfg, idx, ctx);
        EventResponse::Handled
    }
}

/// Enter, and ⌘↓ on macOS: open or close tile `current`'s detail band, then
/// run the application's activation, which sees the band as the key left it.
///
/// Opening the band selects the tile in a single selection, where the
/// selected tile is the one being looked at, and only when the application
/// has no activation of its own, which is the rule Enter follows without a
/// band. A multiple selection is left alone: Ctrl+arrows move the cursor
/// without touching it precisely so that a reader can look at a tile, and
/// opening its band must not collapse the selection onto it. Closing the
/// band leaves the selection alone. A tile with nothing to disclose, or a
/// grid with no band, follows the rule activation has without one.
fn activate_tile(cfg: &GridKeyConfig, current: usize, ctx: &mut EventContext) {
    use super::detail::Disclosure;
    cfg.focused_index.set(Some(current));
    let disclosure = cfg.detail.as_ref().map(|d| d.activate(current));
    let select = match disclosure {
        Some(Disclosure::Opened) => {
            cfg.on_tile_activate.is_none()
                && cfg
                    .selection
                    .as_ref()
                    .is_some_and(|sel| sel.mode() == teksilo_data::SelectionMode::Single)
        }
        Some(Disclosure::Closed) => false,
        Some(Disclosure::Nothing) | None => cfg.on_tile_activate.is_none(),
    };
    if select && let Some(ref sel) = cfg.selection {
        sel.select(current);
    }
    if let Some(ref cb) = cfg.on_tile_activate {
        cb(current, ctx);
    }
}

/// The band ↓ enters from tile `current`: `current`'s band, open, with a
/// control in it to take focus. Without one, ↓ is plain navigation. The
/// control is revealed as focus lands on it, by the grid's answer to the
/// framework's `ScrollIntoView`.
fn enterable_band(
    detail: &super::detail::DetailState,
    current: usize,
) -> Option<teksilo_core::widget_id::WidgetId> {
    if detail.is_open(current) && detail.enterable.get() {
        detail.band_id.get()
    } else {
        None
    }
}

/// The tile one viewport away from `current`, in the direction pressed.
///
/// Measured against the layout strategy's real tile rectangles rather than
/// `estimated_row_height`, because two of the three shipped strategies do not
/// have a single row height: `VariableRowGrid` sizes each row to its tallest
/// tile and `VirtualizedMasonry` has no rows at all. Paging by the estimate
/// landed short or long on both, and by an amount that changed as the
/// measurements converged.
///
/// The walk is per-row rather than a closed form for the same reason — with
/// variable rows there is no `rows × height` to divide by. It costs one
/// `tile_rect` per row of a single viewport, on a keypress.
fn page_target(cfg: &GridKeyConfig, current: usize, cols: usize, n: usize, down: bool) -> usize {
    let viewport = cfg.viewport_height.get();
    let width = cfg.viewport_width.get();
    let origin = cfg.strategy.tile_rect(current, width).y;
    let mut candidate = current;
    let mut probe = current;
    loop {
        probe = if down {
            match probe.checked_add(cols) {
                Some(next) if next < n => next,
                _ => break,
            }
        } else {
            match probe.checked_sub(cols) {
                Some(prev) => prev,
                None => break,
            }
        };
        let y = cfg.strategy.tile_rect(probe, width).y;
        if (y - origin).abs() > viewport {
            // One row past the viewport edge: stop at the last row inside it,
            // unless that would not move at all.
            candidate = if candidate == current {
                probe
            } else {
                candidate
            };
            break;
        }
        candidate = probe;
    }
    // Guarantee progress even when a single tile is taller than the viewport.
    if candidate == current {
        if down {
            (current + cols).min(n - 1)
        } else {
            current.saturating_sub(cols)
        }
    } else {
        candidate
    }
}

fn ensure_visible(cfg: &GridKeyConfig, idx: usize, ctx: &mut EventContext) {
    reveal_tile(
        &cfg.strategy,
        &cfg.scroll_y,
        &cfg.max_scroll_y,
        &cfg.viewport_height,
        &cfg.viewport_width,
        &cfg.viewport_origin,
        idx,
        ctx,
    );
}

/// Scroll tile `idx` into the grid's own viewport, then chase it into any
/// enclosing scroll area.
///
/// Takes the pieces rather than a [`GridKeyConfig`] because the reorder commit
/// closure — which lives in `GridView::build`, above the key handler — needs the
/// same reveal, and one reveal is what keeps the chord and the menu row leaving
/// the tile in the same place.
#[allow(clippy::too_many_arguments)]
pub(crate) fn reveal_tile(
    strategy: &Rc<dyn GridLayoutStrategy>,
    scroll_y: &Signal<f32>,
    max_scroll_y: &Signal<f32>,
    viewport_height: &Rc<Cell<f32>>,
    viewport_width: &Rc<Cell<f32>>,
    viewport_origin: &Rc<Cell<Option<teksilo_canvas::Point>>>,
    idx: usize,
    ctx: &mut EventContext,
) {
    let delta = strategy.scroll_delta_to_reveal(
        idx,
        scroll_y.get(),
        viewport_height.get(),
        viewport_width.get(),
        ScrollAnchor::Auto,
    );
    if delta.abs() > 0.01 {
        let max = max_scroll_y.get();
        let new_y = (scroll_y.get() + delta).clamp(0.0, max);
        scroll_y.set(new_y);
    }
    // Computed analytically from the layout strategy — the tile may be
    // virtualized (not realized as a live widget) — using the post-scroll offset
    // so the rect is the tile's resting on-screen position. Skipped when the
    // body pane hasn't published its origin yet (a nav before the first layout),
    // so the rect is never anchored at a stale (0, 0).
    let Some(origin) = viewport_origin.get() else {
        return;
    };
    let vp_w = viewport_width.get();
    let r = strategy.tile_rect(idx, vp_w);
    let scroll = scroll_y.get();
    let rect =
        teksilo_canvas::Rect::new(origin.x + r.x, origin.y + r.y - scroll, r.width, r.height);
    ctx.ensure_visible(rect);
}