Guide API
Skip to main content

Table

Struct Table 

Source
pub struct Table { /* private fields */ }
Expand description

A multi-column table view. See the module docs.

Implementations§

Source§

impl Table

Source

pub fn toggle_column_command(col: usize) -> Command

The command that shows or hides model column col when it reaches the focused table — what the column popup’s items post. Bind it to a key or a menu item to toggle a column directly; like the popup, it never hides the last visible column, and it broadcasts Command::TABLE_COLUMNS_CHANGED.

Source

pub fn column_layout(&self) -> Vec<ColumnState>

Every column’s state, in model order: the display position, width, flex weight, fixed flag and hidden flag. Store it and hand it to set_column_layout to restore what the user arranged.

Source

pub fn set_column_layout(&mut self, layout: &[ColumnState])

Restore a column_layout. Entries for unknown columns are ignored; the columns layout does not name keep their state and follow the named ones in their current order. Widths are clamped to the column’s min_width (at least 1) and to MAX_COLUMN_WIDTH. Does not broadcast; the bars catch up on the table’s next event.

Source§

impl Table

Source

pub fn is_editing(&self) -> bool

Whether a cell editor is open.

Source

pub fn cursor_column(&self) -> Option<usize>

The model column under the cell cursor, None when no visible column is editable.

Source

pub fn cancel_edit(&mut self, ctx: &mut Context<'_>)

Close the editor without storing its text.

Source§

impl Table

Source

pub fn new( bounds: Rect, columns: Vec<ColumnSpec>, v_scroll_bar: Option<ViewId>, ) -> Self

A table at bounds (header on the first row, rows below) with columns, wired to the optional vertical scroll bar v_scroll_bar. It starts with an empty model; add rows with with_model or, after insertion, set_model.

Source

pub fn with_h_bar(self, h_bar: ViewId) -> Self

Builder: wire the horizontal scroll bar h_bar (an external sibling, like the vertical one). Its range is the columns’ overflow past the view: 0 while they fit. The table publishes range and steps itself.

Source

pub fn h_offset(&self) -> i32

How far the columns are scrolled to the left, in display cells (0 when they fit).

Source

pub fn set_h_offset(&mut self, offset: i32, ctx: &mut Context<'_>)

Scroll the columns to offset display cells (clamped to the overflow) and move the horizontal bar with them.

Source

pub fn with_model(self, model: Box<dyn TableModel>) -> Self

Builder: the initial rows (no Context needed; the table publishes them to its scroll bar on its first event).

Source

pub fn with_selection_mode(self, mode: SelectionMode) -> Self

Builder: the selection mode (default SelectionMode::Single).

Source

pub fn selection_mode(&self) -> SelectionMode

The selection mode.

Source

pub fn with_separators(self, separators: Separators) -> Self

Builder: which column separators to draw (see Separators). The default, Separators::Off, leaves the one-cell separators blank; Separators::Header draws the theme’s vertical frame glyph (│ by default) in the header row only, making the resize handle visible; Separators::All draws the header rule and the same rule between every row’s cells as well. When the columns leave spare width, the header also rules the cell after the last column (its resize handle); the rows leave that cell blank.

Source

pub fn separators(&self) -> Separators

The column separators drawn between the table’s columns.

Source

pub fn model(&self) -> Ref<'_, dyn TableModel>

The current model.

Source

pub fn set_model(&mut self, model: Box<dyn TableModel>, ctx: &mut Context<'_>)

Replace the rows. Focus stays on the same RowKey when it still exists (else the focused position is clamped into the new rows), the sort is re-applied, marks of vanished rows are dropped, and the scroll bar’s range is updated. Does not broadcast.

Source

pub fn row_order(&self) -> Vec<usize>

The display order: model row indices, top to bottom.

Source

pub fn focused_row(&self) -> Option<usize>

The model index of the focused row, None when there are no rows.

Source

pub fn focused_key(&self) -> Option<RowKey>

The key of the focused row, None when there are no rows.

Source

pub fn set_focused_key(&mut self, key: &RowKey, ctx: &mut Context<'_>) -> bool

Move focus to the row with key (scrolling it into view). Returns false if no row has that key.

Source

pub fn sort_spec(&self) -> Option<(usize, SortDir)>

The current sort: column and direction, None for model order.

Source

pub fn sort_by(&mut self, col: usize, dir: SortDir, ctx: &mut Context<'_>)

Sort by column col (an index into the columns) in dir, keeping focus on its row. An out-of-range column is ignored. Does not broadcast.

Source

pub fn clear_sort(&mut self, ctx: &mut Context<'_>)

Back to model order, keeping focus on its row. Does not broadcast.

Source

pub fn set_column_hidden(&mut self, col: usize, hidden: bool)

Hide or show column col. A hidden column takes no space; a hidden sort column keeps ordering the rows (its marker is just not shown).

Source

pub fn is_column_hidden(&self, col: usize) -> bool

Whether column col is hidden (false for an unknown column).

Source

pub fn selected_keys(&self) -> Vec<RowKey>

The keys of the marked rows, in model order (multi mode; empty in single mode unless set programmatically).

Source

pub fn set_selected_keys(&mut self, keys: impl IntoIterator<Item = RowKey>)

Replace the marks with keys; keys without a row are ignored. Does not broadcast.

Source

pub fn clear_selection(&mut self)

Clear every mark, leaving focus where it is. Does not broadcast.

Trait Implementations§

Source§

impl View for Table

Source§

fn set_state(&mut self, flag: StateFlag, enable: bool, ctx: &mut Context<'_>)

Publish the rows to the scroll bar if that is still pending, then let the group fan the flag out. The owner sends Active to every child when its window or dialog activates, so a table publishes even when no event ever reaches it (another control holds focus).

Source§

fn draw(&mut self, ctx: &mut DrawCtx<'_>)

Remember where the table sits on screen (for the drag tracking and the column popup), then draw the header and the rows.

Source§

fn valid(&mut self, cmd: Command, ctx: &mut Context<'_>) -> bool

With a cell editor open, Command::CANCEL cancels the edit and any other command commits it first — a dialog’s OK, but also a window’s Command::CLOSE and the program’s Command::QUIT, as C++ TInputLine::valid validates for every command but cmCancel. A refused text shows its box and vetoes the command, so closing never drops what the field shows. Command::VALID and a focus release leave the edit alone, and an edit whose cell is gone is discarded. Then the children are checked as usual.

The Command::TABLE_CELL_EDITED broadcast of a commit made here is queued; when the command closes a modal dialog, it is delivered after the dialog is gone. Views outside the dialog receive it, but its source names a table that no longer exists and views inside the dialog never see it.

Source§

fn change_bounds(&mut self, bounds: Rect)

Resize the header and the body (grow modes), and mark the bars for a re-publish: the new size changes the vertical page step and the horizontal range. Every framework resize path then calls on_bounds_changed, which publishes at once. The mark is a fallback for app code that calls change_bounds directly: the publish then runs on the table’s next event.

Source§

fn on_bounds_changed(&mut self, ctx: &mut Context<'_>)

Re-publish the bars for the new size, and hand the hook on to the children the group re-bounded (the header and body publish nothing themselves; this keeps the group’s cascade intact for any child).

Source§

fn value(&self) -> Option<FieldValue>

Single mode: the focused row’s key as FieldValue::Text ("" with no rows). Multi mode: the marked keys as a FieldValue::List of Text, in model order.

Source§

fn set_value(&mut self, v: FieldValue)

Accepts the shapes value produces: single mode focuses the row with the Text key (unknown keys are ignored), multi mode replaces the marks with the List of Text keys. Other shapes are ignored. Without a Context the scroll bar catches up on its next sync; prefer set_value_ctx.

Source§

fn set_value_ctx(&mut self, v: FieldValue, ctx: &mut Context<'_>)

Like set_value, but a single-mode focus move also updates the scroll bar.

Source§

fn handle_event(&mut self, ev: &mut Event, ctx: &mut Context<'_>)

Handle an event. The base is a no-op (the event passes through). Read more
Source§

fn as_any_mut(&mut self) -> Option<&mut dyn Any>

Downcast hook for the rare parent→child push that needs the concrete type (e.g. a window pushing its zoomed flag to its frame). Base returns None; only views that must be reached concretely override it. (Any requires 'static, which every view is.)
Source§

fn state(&self) -> &ViewState

Borrow the embedded ViewState (the view’s data members).
Source§

fn state_mut(&mut self) -> &mut ViewState

Mutably borrow the embedded ViewState.
Source§

fn set_modal_answer(&mut self, cmd: Command)

Stash the user’s choice from an async modal message box this view requested via Context::request_message_box (the answer_to/RouteModalAnswer round-trip). Default: no-op. Overridden by views that drive a Yes/No/Cancel prompt out of valid (e.g. FileEditor caches it for the re-validate).
Source§

fn set_modal_data(&mut self, data: FieldValue)

Deliver a finished modal’s typed result record to the view that launched it. Defaulted no-op; a launcher view overrides it to load the record. Two producers call it: Read more
Source§

fn awaken(&mut self)

Post-construction initialization hook. Called once after the view has been inserted into its group and the group’s layout is complete — the earliest point at which a view may safely resolve sibling ids or run initialization that requires a fully-wired tree. Override when a widget needs to do work that cannot happen during construction (e.g. reading a linked control’s current value). Base is a no-op.
Source§

fn size_limits(&self, owner_size: Point) -> (Point, Point)

The (min, max) size this view may take inside an owner of owner_size. Read more
Source§

fn calc_bounds(&mut self, owner_size: Point, delta: Point) -> Rect

The new bounds after the owner resized to owner_size (delta = new - old). Computes the size limits via the overridable size_limits hook — so a widget override (e.g. a window’s minimum) participates — then delegates the grow math to ViewState::calc_bounds (the single source). Returns the bounds; it does not apply them (change_bounds does).
Source§

fn cursor_request(&self) -> Option<Point>

The view-local hardware-cursor position this view wants shown, or None to hide it. Base: Some(cursor) iff the view is focused with a visible cursor, else None. Read more
Source§

fn caret_size(&self) -> u8

The caret size this view wants while its cursor is shown, as a percentage of the character cell (1..=100). Base: CARET_INSERT (a block) when the cursor_ins state is set, else CARET_NORMAL (the normal caret). The event loop reads it along the same focused chain as cursor_request; Group overrides it to descend into its current child. Read more
Source§

fn find_mut(&mut self, id: ViewId) -> Option<&mut dyn View>

Resolve id to a descendant of this view (never self — the parent identifies a view by id). A leaf has no descendants, so the base returns None; a Group overrides to search its children and recurse; a Group-embedding view delegates to its inner group. This is the “tree-walk via Context” — the uniform way the event loop / a capture handler acts on a view it holds only by id (move a window’s bounds, flip the dragging flag, …).
Source§

fn remove_descendant(&mut self, id: ViewId, ctx: &mut Context<'_>) -> bool

Remove the descendant named by id from whichever group owns it. Returns true if it was found+removed. Distinct from find_mut because removal happens in the owner’s child Vec (a view cannot remove itself — it doesn’t know its owner) and must run the owning group’s reset_current. Base: false (a leaf owns nothing).
Source§

fn focus_descendant(&mut self, id: ViewId, ctx: &mut Context<'_>) -> bool

Focus (select) the descendant named by id within whichever group owns it — the tree-op behind a label focusing its linked control. Returns true if id was found in this subtree (selectable or not — finding it stops the walk). Distinct from find_mut because focusing happens in the owning group (a view cannot select itself within itself): the owning Group calls focus_child after applying the selectable gate. Base: false (a leaf owns nothing). Read more
Source§

fn has_focusable_leaf(&self) -> bool

Whether this view’s subtree contains a focusable leaf (visible, enabled, selectable). Base: whether THIS view is itself a focusable leaf; Group overrides to recurse into children; wrapper views delegate. Used by the hierarchical Tab traversal to skip selectable-but-empty subtrees.
Source§

fn focus_to_edge(&mut self, backward: bool, ctx: &mut Context<'_>) -> bool

Focus the first (Tab, backward = false) or last (Shift-Tab, backward = true) focusable leaf in this view’s subtree, establishing the full focus path down to it. Returns true if a focusable leaf was focused. Read more
Source§

fn reset_current(&mut self, ctx: &mut Context<'_>)

Establish this view’s INTERNAL currency — for a group-bearing view, set its current child to the first visible+selectable child. The insert-time currency cascade cannot run inside the context-less Group::insert, so exec_view calls this on a freshly-inserted modal BEFORE focusing it, so the modal’s first selectable child is current on open (otherwise the modal is keyboard-dead until a nav event — see the seam note in exec_view). Base: no-op (a leaf has no internal currency); Group overrides; Window/Dialog delegate.
Source§

fn settle_currency(&mut self, ctx: &mut Context<'_>)

Run any pending insert-time reset-current cascades in this subtree. Read more
Source§

fn set_visible_descendant( &mut self, id: ViewId, visible: bool, ctx: &mut Context<'_>, ) -> bool

Tree-op: set the visible flag of the descendant named by id from its OWNING group, running the owning group’s currency tail. Toggling visibility on a selectable view re-picks the owner’s current child, in both directions (show and hide). Returns true if id was found in this subtree. Read more
Source§

fn number(&self) -> Option<i16>

The window number for Alt-N selection. Base views are unnumbered (None); Window overrides to return its number when > 0 (0 means unnumbered → None).
Source§

fn grabs_focus_on_click(&self) -> bool

Whether a mouse-down inside this view should auto-select (focus) it — the per-view opt-out for the group’s mouse-down auto-select (see Group::route_event). Default true (the common case); a Button overrides to return its grab-focus flag. A view returning false is not focused by a click but still receives the click (so it can act, e.g. press, without becoming the current view).
Source§

fn select_window_num(&mut self, num: i16, ctx: &mut Context<'_>) -> bool

Tree-op: ask this subtree to select the window numbered num. Returns whether one matched. Consistent with the find_mut / remove_descendant tree-op family: the live loop holds a subtree only by id (here, the desktop) and asks it to act. Default: no-op (false). Desktop overrides.
Source§

fn tile(&mut self, r: Rect)

Tree-op: lay this subtree’s tileable windows out in a grid (the tile command). Base: no-op (only Desktop lays out windows). r is the desktop-local layout rect. Mirrors select_window_num: the live loop drives the desktop by id through &mut dyn View.
Source§

fn cascade(&mut self, r: Rect)

Tree-op: lay this subtree’s tileable windows out cascaded (the cascade command). Base: no-op; Desktop overrides.
Source§

fn apply_scroll_sync( &mut self, h: Option<i32>, v: Option<i32>, ctx: &mut Context<'_>, )

The shared scrollbar read-sync broker hook. Defaulted no-op; scroll-aware widgets override it to apply a freshly-read scrollbar delta to themselves. The pump passes the horizontal/vertical scrollbar values (None if that bar is absent or unresolved), each read via View::value. Overridden by the list viewers (delegate to list_viewer::apply_scroll), Scroller, the outline viewer, and the editor — every sibling-scrollbar read sync routes through this one method instead of a pump downcast. Read more
Source§

fn update_menu_commands(&mut self, cs: &CommandSet)

The menu command-graying broker hook. Defaulted no-op; menu views override to re-gray their menu tree against the program’s live disabled-command set (denylist — the argument is the set of commands currently disabled; an item grays iff its command is in it). The free fn menu::menu_view::update_menu_commands implements the re-gray walk. Read more
Source§

fn set_menu_current(&mut self, current: Option<usize>)

The menu-highlight write-back hook. Defaulted no-op; menu views (MenuBar / MenuBox) override to set their MenuViewState::current — the write-only display cache their draw reads to pick the selected colour. Read more
Source§

fn get_help_ctx(&self) -> HelpCtx

The effective help context for status-line switching. Returns HelpCtx::DRAGGING while the view is being dragged, otherwise the view’s own ViewState::help_ctx. Read more
Source§

fn descendant_global_bounds(&self, id: ViewId, acc: Point) -> Option<Rect>

Resolve descendant id to its absolute bounds, given acc = this view’s own absolute origin. Base returns None (a leaf owns no descendants); a Group overrides to walk its children accumulating origins, and a Group-embedding view delegates to its inner group. The THistory open path needs its linked input line’s bounds in the root/absolute frame, because exec_view root-inserts the modal and the modal frame hit-tests in absolute coords (the documented ROOT-INSERT + (0,0) caveat). Mirrors find_mut’s recursion but returns geometry, not a borrow.
Source§

fn set_indicator_value(&mut self, location: Point, modified: bool)

The editor→indicator status-push broker hook. Defaulted no-op; the editor’s status Indicator overrides it to store the new cursor location + modified flag. Driven by Deferred::IndicatorSetValue: the editor (a leaf) cannot reach its indicator sibling inline, so it requests this and the pump calls the method by id — virtual dispatch, not a downcast.
Source§

fn apply_page_sync(&mut self, idx: usize, ctx: &mut Context<'_>)

The tab-bar→page-stack switch broker hook. Defaulted no-op; PageStack overrides it to make page idx active. Driven by Deferred::PageStackSync: the pump reads the bound tab bar’s value and calls this method by id — virtual dispatch, not a downcast.

Auto Trait Implementations§

§

impl !RefUnwindSafe for Table

§

impl !Send for Table

§

impl !Sync for Table

§

impl !UnwindSafe for Table

§

impl Freeze for Table

§

impl Unpin for Table

§

impl UnsafeUnpin for Table

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.