Struct GridState 

pub struct GridState {

    pub data: GridData,
    pub config: GridConfig,
    pub window: Option<RowWindow>,
    pub resolved_formats: Vec<ResolvedColumnFormat>,
    pub display_indices: Arc<Vec<usize>>,
    pub selection: Selection,
    pub sort: Option<(usize, SortDirection)>,
    pub filters: Vec<ColumnFilter>,
    pub scroll_handle: ScrollHandle,
    pub focus_handle: FocusHandle,
    pub bounds: Bounds<Pixels>,
    pub row_height: f32,
    pub header_height: f32,
    pub row_header_width: f32,
    pub font_size: f32,
    pub char_width: f32,
    pub theme: GridTheme,
    pub is_dragging: bool,
    pub drag_start: Option<Point<Pixels>>,
    pub drag_start_hit: Option<HitResult>,
    pub scroll_at_click: Option<Point<Pixels>>,
    pub last_mouse_pos: Option<Point<Pixels>>,
    pub status_bar_height: f32,
    pub debug_bar_enabled: bool,
    pub click_pos: Option<Point<Pixels>>,
    pub click_hit: Option<HitResult>,
    pub hover_hit: Option<HitResult>,
    pub resizing_col: Option<usize>,
    pub resize_start_x: f32,
    pub resize_start_width: f32,
    pub context_menu: Option<ContextMenu>,
    pub filter_panel: Option<FilterPanel>,
    pub pending_action: Option<(MenuAction, usize)>,
    pub scrollbar_drag: Option<ScrollbarAxis>,
    pub scrollbar_drag_start_offset: f32,
    pub scrollbar_drag_start_pos: f32,
    /* private fields */
}

Complete grid state owned by a GPUI Entity<GridState>.

Fields

data: GridData

config: GridConfig

window: Option<RowWindow>

When Some, the grid is in windowed-row mode (see RowWindow).

resolved_formats: Vec<ResolvedColumnFormat>

Cached resolved-format list, kept in sync with data.columns and config. Paint, copy, and filter read this directly instead of recomputing per cell.

display_indices: Arc<Vec<usize>>

selection: Selection

sort: Option<(usize, SortDirection)>

filters: Vec<ColumnFilter>

scroll_handle: ScrollHandle

focus_handle: FocusHandle

bounds: Bounds<Pixels>

row_height: f32

header_height: f32

row_header_width: f32

font_size: f32

char_width: f32

theme: GridTheme

is_dragging: bool

drag_start: Option<Point<Pixels>>

drag_start_hit: Option<HitResult>

scroll_at_click: Option<Point<Pixels>>

last_mouse_pos: Option<Point<Pixels>>

status_bar_height: f32

debug_bar_enabled: bool

When true, the debug status bar is painted at the bottom of the grid showing click position, scroll offset, and hovered cell. Off by default; enable via [SqllyDataTableBuilder::debug_bar] or GridState::set_debug_bar_enabled.

click_pos: Option<Point<Pixels>>

click_hit: Option<HitResult>

hover_hit: Option<HitResult>

resizing_col: Option<usize>

resize_start_x: f32

resize_start_width: f32

context_menu: Option<ContextMenu>

filter_panel: Option<FilterPanel>

pending_action: Option<(MenuAction, usize)>

scrollbar_drag: Option<ScrollbarAxis>

scrollbar_drag_start_offset: f32

scrollbar_drag_start_pos: f32

Implementations

impl GridState

pub fn new( data: GridData, config: GridConfig, focus_handle: FocusHandle, ) -> Self

pub fn set_config(&mut self, config: GridConfig)

pub fn append_rows( &mut self, rows: Vec<Vec<CellValue>>, ) -> Result<(), GridDataError>

Append rows to the grid in place — the streaming-results fast path.

Rows are validated against the rectangular invariant, then appended to the canonical data.rows, the paint-path data_rows snapshot, and the display order. With no active sort or per-column filter this is O(new rows): the fresh indices are pushed onto display_indices directly. When a sort or filter is active, GridState::recompute re-derives the full display order so the new rows land in the right place.

The data_rows Arc is extended via Arc::make_mut; a clone only occurs if a paint or context-menu snapshot is still alive, so repeated appends stay cheap. Selection, scroll position, filters, and sort state are untouched.

Errors

Returns GridDataError::RaggedRow (with the would-be absolute row index) if any incoming row’s length differs from the column count; the grid is left unmodified in that case.

pub fn display_row_count(&self) -> usize

Number of rows the grid PRESENTS — the basis for the scrollbar, row numbers, hit-testing, and selection clamping. Equal to the sort/filter display order length normally, or the virtual total in windowed mode.

pub fn resident_row_for_display(&self, display_row: usize) -> Option<usize>

Maps a display-row index to an index into data.rows. Normal mode goes through the sort/filter display order; windowed mode subtracts the window offset. None when the display row is out of range or not currently resident (windowed rows that have not been paged in).

pub fn set_row_window( &mut self, total_rows: usize, offset: usize, rows: Vec<Vec<CellValue>>, ) -> Result<(), GridDataError>

Enter (or update) windowed-row mode: the grid presents total_rows virtual rows while holding only rows in memory, positioned so that rows[0] is virtual row offset. Replaces the resident rows, the paint snapshot, and the display order in one step; selection and scroll position (both in virtual space) are untouched. Clears any active sort/filter — they are unsupported while windowed.

Errors

Returns GridDataError::RaggedRow if any incoming row’s length differs from the column count; the grid is left unmodified.

pub fn visible_row_range(&self) -> (usize, usize)

The half-open display-row range currently visible in the viewport, derived from the scroll offset and painted bounds — the same math the paint pass uses. Hosts drive window paging from this: when the range nears the resident window’s edges, page more rows in via GridState::set_row_window. Returns (0, 0) before first paint.

pub fn set_debug_bar_enabled(&mut self, enabled: bool)

Enable or disable the debug status bar at runtime. When enabled, a bar is painted at the bottom of the grid showing click position, scroll offset, and hovered cell coordinates.

pub fn is_busy(&self) -> bool

Whether a background task is currently running (the loading overlay is shown).

pub fn busy(&self) -> Option<&BusyState>

The current busy state, if any.

pub fn set_busy(&mut self, label: impl Into<String>)

Show the loading overlay with the given label and indeterminate progress. Call GridState::clear_busy to hide it. For work that should run off the UI thread, prefer GridState::spawn_background, which manages this automatically.

pub fn set_busy_progress(&mut self, progress: f32)

Update the determinate progress (0.0..=1.0) of the current busy state. No-op if not busy.

pub fn clear_busy(&mut self)

Hide the loading overlay.

pub fn spawn_background<R, W, D>( &mut self, cx: &mut App, label: impl Into<String>, work: W, on_done: D, )

where R: Send + 'static, W: FnOnce() -> R + Send + 'static, D: FnOnce(R, &mut GridState, &mut App) + 'static,

Run work on a background thread, showing the loading overlay labelled label for the duration, then deliver the result back on the UI thread via on_done (which receives &mut GridState and &mut App).

This is the recommended way to do expensive work triggered from a context-menu action (e.g. building an export from a large selection): the right-click stays instant, the work does not block the UI, and a loading indicator is shown until it completes.

work and its result R must be Send + 'static; on_done runs on the UI thread and need not be Send. A cloned ContextMenuRequest can be moved into work (it is Send + Sync + 'static).

If this state has no entity handle yet (constructed via GridState::new directly, e.g. in tests rather than through the builder), work runs synchronously as a fallback.

pub fn recompute(&mut self)

pub fn toggle_sort(&mut self, col: usize)

pub fn handle_mouse_down(&mut self, pos: Point<Pixels>, shift: bool)

pub fn execute_action(&mut self, action: MenuAction, col: usize, cx: &mut App)

pub fn open_filter_panel(&mut self, col: usize, _anchor: Option<Point<Pixels>>)

Open the rich per-column filter popover for col, seeding its working state from any filter already committed on that column. The overlay is rendered by widget.rs as a deferred + anchored element so it can paint and receive events outside the grid’s own layout bounds, exactly like the right-click context menu.

anchor overrides the panel’s spawn position; pass the original context-menu / header right-click position so the panel doesn’t jump to the mouse’s current location (which by now has moved to the menu item). Falls back to last_mouse_pos when None.

pub fn apply_filter_panel(&mut self)

Commit the panel’s working state to Self::filters and re-filter. Called automatically on every interaction (auto-apply).

pub fn maybe_auto_apply(&mut self)

Apply immediately — the panel always auto-applies.

pub fn clear_filter_panel(&mut self)

Reset both the committed filter for the panel’s column and the panel’s working state (all values checked, no operator), then re-filter.

pub fn set_panel_sort(&mut self, direction: SortDirection)

Set the sort direction on the panel’s column (the panel’s Sort buttons). Clicking the already-active direction turns the sort off.

pub fn toggle_filter_value(&mut self, index: usize)

Toggle the checked state of a single distinct value row (by index into FilterPanel::distinct), then auto-apply if enabled.

pub fn toggle_filter_select_all(&mut self)

Toggle every distinct value row at once, then auto-apply if enabled. Mirrors the “(Select All)” checkbox. Operates on all values regardless of the active search, so searching never changes what “(Select All)” does.

pub fn set_filter_operator(&mut self, op_index: usize)

Select an operator by its index in FilterPanel::op_labels, close the dropdown, and auto-apply if enabled.

pub fn toggle_filter_op_menu(&mut self)

Toggle the operator dropdown’s expanded state.

pub fn set_filter_focus(&mut self, focus: FilterInput)

Point keyboard focus at one of the panel’s text fields.

pub fn toggle_filter_auto_apply(&mut self)

Toggle the panel’s auto-apply flag; kept for API completeness.

pub fn drag_screen_rect(&self) -> Option<(Point<Pixels>, Point<Pixels>)>

pub fn handle_mouse_move( &mut self, pos: Point<Pixels>, pressed_button: Option<MouseButton>, )

pub fn handle_scroll_drag(&mut self)

pub fn handle_mouse_up(&mut self)

pub fn apply_edge_scroll(&mut self) -> bool

pub fn select_all(&mut self)

pub fn copy_selection(&self, with_headers: bool, cx: &mut App)

pub fn page_up(&mut self)

pub fn page_down(&mut self)

pub fn handle_key(&mut self, keystroke: &Keystroke)

pub fn wants_edge_scroll_tick(&self) -> bool

Trait Implementations

impl Debug for GridState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.