Struct BlockEditor 

pub struct BlockEditor { /* private fields */ }

Implementations

impl BlockEditor

pub fn new() -> BlockEditor

Starts with one empty paragraph — there must be a block to focus.

pub fn with_id(self, id: &str) -> BlockEditor

Answer to id (Widget::test_id): the key of the field it edits, by which its window gives it the keyboard.

pub fn with_empty_hint(self, hint: &str) -> BlockEditor

pub fn with_wrap_lines(self, wrap: bool) -> BlockEditor

pub fn with_compact_paragraph_spacing(self, compact: bool) -> BlockEditor

pub fn set_empty_hint(&mut self, hint: &str)

pub fn set_tooltip_viewport(&mut self, viewport: Option<Rect>)

Restrict tooltip targets to the host’s visible document viewport. Hosts must refresh this after scrolling or resizing, using the same window-coordinate clip as painting (including the handle gutter).

pub fn set_viewport_height(&mut self, height: Option<f64>) -> bool

The height of the host’s visible document area (a scrolling host’s viewport, not the editor’s content extent). An image preview is never taller than IMAGE_VIEWPORT_FRACTION of it, so a large picture leaves room to see and drag past it. Hosts refresh it before layout; returns whether it changed, so a host can lay out again.

pub fn empty_hint(&self) -> &str

pub fn take_edit_ops(&mut self) -> Vec<BlockEditOp>

The user’s edits since the owner last took them, as semantic block operations for the owner to submit as actions. The editor never writes the document itself.

pub fn take_pending_semantic_ops(&mut self) -> Vec<BlockEditOp>

Drain UUID-addressed edits requested through synthetic AT controls.

pub fn from_markdown(md: &str) -> BlockEditor

Minimal markdown parser; empty input still produces one empty paragraph.

pub fn to_markdown(&self) -> String

Inverse of from_markdown; round-trip is byte-stable.

pub fn is_dirty(&mut self) -> bool

Drains per-block + edit-pending dirty; structure_dirty is only peeked here, and stays set until take_structure_dirty.

pub fn is_focused(&self) -> bool

pub fn suppress_caret_paint(&mut self, suppressed: bool)

Hide insertion carets while a modal owns input; retain editing state.

pub fn set_focus(&mut self, focused: bool)

pub fn blocks(&self) -> &[Block]

pub fn content_bottom(&self) -> f64

Lowest painted edge, including formula previews that intentionally sit below their editable source line inside the same layout child.

pub fn blocks_mut(&mut self) -> &mut Vec<Block>

For tests + notes-app persistence to seed blocks directly; production code should prefer the public mutators.

pub fn take_edit_scope(&mut self) -> EditScope

Which blocks the person may have changed since the last call: a host that owns the document compares only those with what it presented. Plain typing in a paragraph names that paragraph and its neighbours; anything else (a structural edit, a pointer, an action, direct access to the blocks) may have changed any block.

pub fn note_edit_anywhere(&mut self)

Treat any block as possibly changed: for a host that changes blocks through Self::blocks_mut or other direct access.

pub fn set_blocks(&mut self, blocks: Vec<Block>)

For the notes app’s markdown parser, which produces a richer representation (inline marks) than this widget’s from_markdown.

pub fn with_read_only(self, read_only: bool) -> BlockEditor

Show the blocks without taking input or focus: a read-only view of rich text (a sent message, a comment reply).

pub fn handle_gutter(&self, theme: &Theme) -> f64

The handle gutter of a block document: the lane its drag handles hang in, outside the text column, as wide as a handle and the gap to the text. Zero when the editor shows no handles. A page that holds the editor keeps its one content gutter outside this lane: it places the editor’s rect on its gutter and lines its title and metadata up with the text (Self::text_inset in from the rect), so a hovered handle stands a full gutter clear of the sidebar or window edge.

pub fn text_inset(&self, theme: &Theme) -> f64

How far a paragraph’s text starts inside the editor’s rect: the handle gutter (when shown) or the lines’ own text inset, whichever is wider. Every block kind starts at this edge, so a host lines a title, a caption or a composer’s controls up with it instead of measuring a laid-out caret.

pub fn with_block_handles(self, shown: bool) -> BlockEditor

Show or hide the drag handle beside each block. A composer or a read-only row has none: its blocks are not rearranged by dragging.

pub fn with_flush_text(self) -> BlockEditor

Set the text flush with the editor’s edge, without the document’s inset: a read-only body under a name, a quote or chips, all starting at one edge.

pub fn set_mention_paint( &mut self, paint: Option<Rc<dyn Fn(&str) -> MentionColors>>, )

Paint mentions in the colours paint gives each participant.

pub fn insert_text(&mut self, text: &str) -> bool

Put text at the caret of the focused block, replacing a selection within it: an emoji picked from a menu, a pasted snippet. Returns whether there was a block to put it in.

pub fn insert_mention(&mut self, id: &str, label: &str) -> bool

Put a mention of the participant id, shown as label (@Ada), at the caret of the focused block, followed by a space. The label is one marked run, so it reads back as a reference, not as text that happens to start with @.

pub fn text_before_caret(&self) -> Option<&str>

The focused block’s text before the caret: what an autocomplete reads its query from (@ad while a mention is typed).

pub fn select_before_caret(&mut self, bytes: usize)

Select the bytes before the caret in the focused block, so the next insertion replaces them (the typed @ad a picked mention replaces).

pub fn set_read_only(&mut self, read_only: bool)

Stop or resume taking input and focus.

pub fn with_text_align(self, align: TextAlign) -> BlockEditor

Align every line within the editor’s width: a text box whose alignment belongs to the box rather than to each paragraph.

pub fn set_text_align(&mut self, align: TextAlign)

Change how every line is aligned.

pub fn text_align(&self) -> TextAlign

How every line is aligned.

pub fn with_body_size(self, px: f32) -> BlockEditor

Size body text at px logical pixels; every other kind keeps its size relative to body text.

pub fn set_body_size(&mut self, px: f32)

Change the body text size (see Self::with_body_size).

pub fn body_size(&self) -> f32

The body text size, in logical pixels.

pub fn is_read_only(&self) -> bool

Whether the editor shows its blocks without taking input.

pub fn select_all(&mut self)

Select every block’s text, as Ctrl+A does.

pub fn has_open_popup(&self) -> bool

Whether a menu or popover of the editor is open and takes Escape and Enter itself (the slash menu, a link picker).

pub fn mention_picker_open(&self) -> bool

pub fn mention_picker_rect(&self) -> Option<Rect>

The @ picker’s panel as last painted, while it is open: an owner that routes pointer presses itself sends the ones over it here.

pub fn set_popover_bounds(&mut self, bounds: Option<Rect>)

Keep the editor’s popovers inside bounds (normally its window): the @ list, the slash menu and the link picker open above the caret where there is no room below.

pub fn set_mention_people(&mut self, people: Vec<MentionCandidate>)

Participants the owner’s record knows of beyond the workspace’s roster (someone who wrote here and has since left), offered at @ too.

pub fn local_author(&self) -> Option<&str>

The id local edits are attributed to, if any.

pub fn set_local_author(&mut self, author: Option<String>)

pub fn bind_existing_blocks( &mut self, state: &AutoCommit, list: ExId, ) -> Result<(), ThawError>

Bind a canonical existing list without initializing its durable contents.

Errors

Rejects malformed identities, kinds or Text objects before installing local state.

pub fn bind_existing_block_objects( &mut self, state: &AutoCommit, objects: &[ExId], ) -> Result<(), ThawError>

Adopt an action owner’s ordered projection of existing block objects.

The owner resolves hierarchy and ordering, then reprojects after document changes. Storage order need not match display order, and moving an object never requires replacing its collaborative Text. Like list binding, this method is read-only and local edits are emitted as semantic operations.

Errors

Rejects malformed or duplicate identities and non-Text bodies before changing the editor. The owner supplies its visible canonical block Maps.

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

pub fn is_composing(&self) -> bool

Whether the active source line or projected table cell owns an IME preedit.

pub fn focused_table_cell(&self) -> Option<(String, usize, usize)>

pub fn take_find_reveal(&mut self) -> Option<Rect>

Where the window’s search last made a match current, once, for the host to scroll into view; None when nothing moved since.

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

Let the window’s search replace in this document: its host applies what Self::take_find_replace hands it through its own edit path.

pub fn take_find_replace(&mut self) -> Option<FindReplace>

The replacement the window’s search asked for since the last call, for the host to validate against its blocks and apply as one edit.

pub fn focus_block(&mut self, idx: usize, cursor_at: CursorPlacement)

pub fn split_at_cursor(&mut self, idx: usize, split_at: usize)

Splitting at byte 0 of an empty block still produces two blocks — how the user gets a blank line by hitting Enter twice.

pub fn merge_with_previous(&mut self, idx: usize)

No-op at idx == 0. The surviving block keeps the previous block’s kind — backspacing a paragraph into a heading folds the text into the heading, not the reverse.

pub fn delete_empty(&mut self, idx: usize)

Never deletes the last block — the editor always retains at least one paragraph to receive focus.

pub fn try_promote_to_heading(&mut self, idx: usize) -> bool

The caller must restrict when this runs — it must only fire on the keystroke right after an empty paragraph, or typing # mid-paragraph would promote wrongly; see handle_event.

pub fn try_promote_to_quote(&mut self, idx: usize) -> bool

Converts a freshly typed > paragraph prefix into a semantic quote.

pub fn insert_link(&mut self, target: &str) -> bool

Link the focused block’s selection to target, or, with nothing selected, insert target at the caret as its own linked text. false when no block is focused or target is blank.

pub fn insert_link_to(&mut self, target: &str, label: &str) -> bool

Link the focused block’s selection to the address target, labelled label — the text the person reads, which for a resource is its name while target is the address that reaches it. With nothing selected, label is inserted at the caret already linked. false when no block is focused or target is blank.

pub fn focused_kind(&self) -> Option<&BlockKind>

pub fn try_convert_to(&mut self, idx: usize, new_kind: BlockKind) -> bool

Preserve authored formatting, caret, binding and outline context. A divider holds no text, so turning a block that has some into one puts a divider above it instead: converting never deletes writing.

pub fn try_indent(&mut self, idx: usize, delta: i8) -> bool

Shift an item and all descendants together, preserving their relative depths. Clamp the entire operation rather than flattening deep children.

pub fn selected_block_range(&self) -> Option<Range<usize>>

Selected roots and their descendants, including entire code fences. A selection ending at column zero does not include that block.

pub fn block_group_range(&self, index: usize) -> Option<Range<usize>>

One block’s complete authored fence and outline descendants.

pub fn selected_block_move(&self, up: bool) -> Option<(Range<usize>, usize)>

Plan a selected sibling batch’s move past its adjacent sibling subtree. Returns the source rows and the insertion boundary in the current order. A move never implicitly changes a root’s parent or splits a code fence.

pub fn set_slash_commands( &mut self, link_pages: bool, host: &[SlashHostCommand], )

Offer the slash commands this host answers besides the block kinds: with link_pages, a link to another page (the host also gives the pages, Self::set_link_pages); and each of host, which the host carries out when Self::take_slash_request hands it over.

pub fn with_slash_commands( self, link_pages: bool, host: &[SlashHostCommand], ) -> BlockEditor

Self::set_slash_commands, as a builder.

pub fn take_slash_request(&mut self) -> Option<SlashRequest>

The slash command the person chose that only the host can carry out, once. The /query is already gone from the block.

pub fn link_block_to_page(&mut self, id: &str, page: &PageEntry) -> bool

Make block id read as a link to page: its text becomes the page’s title, linked. What a host does when it made a page from the block (SlashHostCommand::Page).

pub fn draw_overlay( &mut self, scene: &mut Scene, transform: Affine, text_renderer: &mut TextRenderer, theme: &Theme, )

Host calls this AFTER the main draw pass — popovers must paint last so they land above every other widget.

pub fn accessibility_shared_with( &self, control: Option<&RowControl<'_>>, ) -> Option<SharedAccessNode>

Widget::accessibility_shared, with control added to every block’s row. Each row is the one of the last frame while nothing it is built from changed (Self::access_rows), so a keystroke builds the row of the block it typed into, not the document’s.

pub fn hover_handle(&self) -> Option<Rect>

Where the drag handle the pointer’s block shows was painted, if any: it follows the pointer, not the text, so a host that copies a scroll of the text repaints it where it is and where it was.

pub fn pointer_chrome(&self) -> Vec<Rect>

Everything the last draw may have painted for where the pointer is rather than where the text is: the hovered block’s drag handle, the copy chrome of each code run (lit under the pointer), each table’s add-row and add-column controls (shown under it) and each image’s button (shown under it). The text moves under a resting pointer, so a host that copies a scroll of the text repaints these where they are and where they were.

pub fn block_drag_active(&self) -> bool

Whether a block is being dragged by its handle (past the click threshold). Such a drag near the edge of the editor’s visible area needs Self::tick_block_drag every frame.

pub fn tick_block_drag(&mut self, viewport: Rect, elapsed: Duration) -> f64

How far the host should scroll its document, in logical pixels (positive is down), for the elapsed since the last tick: nonzero while the pointer of an active block drag is in the edge band of viewport, faster the closer to the edge. The editor does not own its scrolling; the host scrolls, lays the editor out again and the drop target follows the pointer (Self::retarget_block_drag runs with that layout).

pub fn retarget_block_drag(&mut self)

Point the active drag’s drop target at the block under the pointer, now that the blocks have moved under it (the host scrolled).

pub fn set_link_pages(&mut self, pages: Vec<PageEntry>)

pub fn set_image_store(&mut self, store: Option<ImageStore>)

Supply an asynchronous, host-policy-owned image loader. The editor never performs filesystem or network access itself.

pub fn link_popover(&self) -> &FilterMenu<PageEntry>

pub fn link_at_point(&self, point: Point) -> Option<LinkTarget>

Resolve a link against the exact geometry produced by the live draw. A stale layout intentionally refuses rather than approximating with a different theme or font.

pub fn set_transclusion_previews( &mut self, previews: HashMap<Uuid, TransclusionPreview>, )

pub fn take_transclusion_open(&mut self) -> Option<Uuid>

pub fn take_external_link_open(&mut self) -> Option<String>

pub fn take_resource_link_open(&mut self) -> Option<String>

The tilo://open#… address of the resource link activated since the last call (a click, Enter, or assistive technology’s activate), for the host to open in the app that keeps it.

pub fn take_pasted_images(&mut self) -> Vec<ClipboardImage>

Images for legacy hosts which insert after the caret. Canonical hosts use Self::take_image_paste_requests to replace the captured selection.

pub fn take_image_paste_requests(&mut self) -> Vec<ImagePasteRequest>

Drain image intents without changing text. The host validates the image and applies asset storage and the captured replacement in one action.

pub fn document_caret_rect(&self) -> Option<Rect>

Where the caret is in the document, for a host that keeps it in view while editing: the focused block’s caret, never an open overlay’s field (the slash menu, a link popover, find), whose own rect says nothing about where the person is writing.

pub fn slash_menu_visible(&self) -> bool

So the host can avoid stealing focus from the popover.

pub fn try_toggle_check(&mut self, idx: usize) -> Option<bool>

No-op for non-Checklist kinds.

impl BlockEditor

pub fn document_selection(&self) -> Option<DocumentSelection>

pub fn select_document_range( &mut self, anchor: DocumentPosition, cursor: DocumentPosition, )

Set and paint a document range using UTF-8 byte offsets. Positions are clamped to existing block/character boundaries.

pub fn retain_block_selection(&mut self, ids: Vec<String>, reverse: bool)

Retain the exact batch after a structural command, including empty rows. Missing or interleaved IDs refuse restoration instead of selecting peers.

pub fn clear_document_selection(&mut self)

Clear selection and its keyboard/drag anchors without changing text.

pub fn selected_text(&self) -> Option<String>

Plain-text serialization uses a newline for every crossed block boundary, matching browser/contenteditable clipboard behavior.

pub fn replace_document_selection(&mut self, replacement: &str) -> bool

Replace a cross-block selection with normalized plain text. All local mutations happen in this call, so the host commits one Automerge undo boundary for the originating key/IME event.

impl BlockEditor

pub fn selected_content(&self) -> Option<Vec<BlockContent>>

The document selection as blocks: the blocks it spans, the first and last cut to where it starts and ends, each with its marks.

pub fn replace_document_selection_with_blocks( &mut self, pasted: Vec<BlockContent>, ) -> bool

Replace the document selection with formatted pasted blocks: the first joins the words before the selection, the last the words after it, and the ones between stand as blocks of their own kinds. One edit, as Self::replace_document_selection is.

impl BlockEditor

pub fn toggle_mark(&mut self, mark: Mark) -> bool

Toggle mark as a toolbar button does: over the selection, across every paragraph it spans, or, with nothing selected, for the text typed next. The change is an edit of the blocks it touched, which the host writes like a keystroke’s. false when no block is focused.

pub fn toggle_list(&mut self, ordered: bool) -> bool

Toggle a list as a toolbar button does: the selected paragraphs, or the focused one, become a bulleted list (a numbered one when ordered), each keeping its depth; when every one of them already is that list, they become paragraphs again. Code and tables stay what they are. false when nothing changed.

pub fn active_marks(&self) -> Vec<Mark>

The marks a toolbar shows as on: those covering the whole selection in the focused block, or the caret, with the ones set for the text typed next.

impl BlockEditor

pub fn drag_handles_fading(&self) -> bool

Whether the drag handles are fading and need frames: the part of crate::widget::Widget::needs_animation_frame a host that answers that itself forwards.

impl BlockEditor

pub fn settle_typing(&mut self) -> bool

Make the change the last keystroke asked for once it is written: the correction its word boundary made, the formatting of the markdown it closed. The host calls this when it settles the frame after the keystroke (and before the next input), so the change is an undo step of its own. Whether anything changed.

impl BlockEditor

pub fn reading_markdown(markdown: &str) -> BlockEditor

A document read from Markdown, as a reader shows it: the blocks Self::from_markdown makes, with every inline span its delimiters close (**bold**, *italic*, `code`, ~~struck~~) formatted and its delimiters gone, by the same rules as typing them (markdown_input::detect_inline). An answer an agent writes in Markdown reads as text, never as its source.

impl BlockEditor

pub fn present_blocks(&mut self, blocks: &[BlockContent]) -> bool

Show blocks as the owning model has them now: after a collaborator’s edit, an undo, or the host’s read-back of an edit it applied. A block whose id stays keeps its widget, with the caret carried past text inserted or removed before it; focus and a selection follow their block’s id. Returns whether anything changed.

Edits the person makes still arrive as the editor’s own blocks (Self::blocks); a host that owns the document compares them with what it presented, applies the difference to its model, and presents the result.

pub fn present_changed( &mut self, changed: &[(usize, &BlockContent)], ) -> Option<bool>

Show new content for some blocks, the rest as they are: changed pairs a block’s index with what it shows now, and each index must still hold the block with that content’s id. For an owning model that knows which paragraphs an edit touched, so a keystroke’s read-back costs the blocks it changed, not the document. Returns None, presenting nothing, when a pair names another block (the order changed: present everything with Self::present_blocks), otherwise whether anything changed.

pub fn rename_block(&mut self, from: &str, to: &str) -> bool

Give block from the id to: the owning model named a block the editor created (the paragraph an Enter split off) when it applied the edit. Returns whether a block was renamed.

pub fn set_presence_key(&mut self, key: Rc<dyn Fn(&str) -> PresenceKey>)

Address blocks in presence by the owning model’s keys (a resource selection, say) rather than the editor’s own, so a collaborator’s caret lands in the same paragraph of the same resource.

impl BlockEditor

pub fn show_rich_text(&mut self, rich: &RichText) -> bool

Show rich read-only, each reference as it reads for the person reading.

pub fn on_open_reference(&mut self, open: impl FnMut(&str) + 'static)

Run open with the reference activated, each time one is.

pub fn reference_hits(&self) -> &[(Rect, String)]

The references painted in the last draw, with where each was painted.

pub fn reference_at(&self, point: Point) -> Option<&str>

The reference painted at point, when one is.

impl BlockEditor

pub fn text_menu(&self) -> Option<&ContextMenu>

The text menu, while it is open: where a host places it or finds its rows.

pub fn open_text_menu(&mut self, at: Point) -> bool

Open the text menu at at (the editor’s coordinates) on the words there: over the selection when at is in it, else over the word under it, selected. false when no editable words are at at.

Trait Implementations

impl Default for BlockEditor

fn default() -> BlockEditor

Returns the “default value” for a type.

impl Described for BlockEditor

type Props = BlockEditorProps

fn from_props(key: &str, props: BlockEditorProps) -> BlockEditor

The widget of props, with key its stable id.

fn set_props(&mut self, props: BlockEditorProps) -> bool

Take changed props in place, damaging what they change: false when this widget cannot and is to be built again.

fn slot_views(&mut self, slot: &str) -> Option<&mut dyn SlotViews>

The views of its slot slot, to change by key in place: None when a change of what the slot holds builds the widget again.

fn part_views( &mut self, slot: &str, key: &str, of: &str, ) -> Option<&mut dyn SlotViews>

The views its slot slot holds for the part key — a part being a component the slot takes, whose props the widget reads — in that part’s own view slot of, to change them by key where they stand. None when a change inside a part builds the widget again.

impl Findable for BlockEditor

The window’s search finds in the document in place: every match is painted, and the current one is scrolled into view by the host (BlockEditor::take_find_reveal). The person’s caret, selection and the document stay as they are.

fn replaces_later(&self) -> bool

The host applies a replacement as one edit on its next frame (BlockEditor::take_find_replace).

fn find(&mut self, query: &str, options: FindOptions) -> Vec<FindMatch>

Every match of query under options, in reading order, and keep them to paint. An empty query clears the matches.

fn reveal(&mut self, index: usize)

Make match index the current one: scroll it into view and paint it emphasised (see paint_find_match).

fn mark_current(&mut self, index: usize)

Paint match index emphasised without moving the view: the content changed under the find and the current match kept its place. A view that keeps its current match across Self::find needs nothing.

fn clear_find(&mut self)

The bar closed: stop painting matches.

fn supports_replace(&self) -> bool

Whether this view can replace text; the bar then offers a replace row.

fn replace(&mut self, index: usize, with: &str) -> bool

Replace match index with with. Returns whether it changed the content; an edit goes through the view’s own actions, so it is undoable.

fn replace_all(&mut self, with: &str) -> usize

Replace every match; returns how many changed.

fn content_revision(&self) -> u64

A number that changes whenever the content under the bar changes (an edit, a page’s text arriving). The bar finds again on its next FindBar::drive when it moved, keeping the current match, so the counter never lags the content. The default never changes; such a view calls FindBar::refresh itself.

fn set_find_cover(&mut self, _cover: Option<Rect>)

What of the view the window’s search covers while its options stand open over it, in the view’s own coordinates (None: nothing). A view that scrolls reveals its current match clear of it, scrolling past its start where the match stands too near it; the search shows the current match again whenever the cover changes.

fn supports_hex(&self) -> bool

Whether this view shows bytes, so the bar offers a text/hex mode.

fn supports_regex(&self) -> bool

Whether this view can match a regular expression, so the bar offers the toggle for it (FindMode::Regex).

fn step(&mut self, _forward: bool) -> bool

Step to the next (or previous) match in a view whose engine owns the matches (a web page). Return true when the view stepped itself; it then reports the new position with FindBar::set_results. The default false lets the bar step through the matches find returned.

fn take_engine_results(&mut self) -> Option<(usize, Option<usize>)>

Where a view whose engine finds on its own (see Self::step) says its matches are, when it said so since the last call: (total, current), current 0-based. The bar’s counter follows on its next FindBar::drive.

fn take_own_find(&mut self) -> Option<OwnFind>

The find this view ran on its own since the last call (OwnFind), which the window’s search takes over: it shows the query and keeps the match the view went to.

impl PublishesPresence for BlockEditor

fn shared_selection(&self) -> Option<SharedSelection>

The selection for an agent. Keyed by the owning model’s ids, it is placed in the caret’s block in characters (a selection spanning blocks shares its part there, as presence does) and the excerpt is exactly that text. Otherwise the blocks are no resource items, and the whole selected text travels without a place.

fn presence_payload(&self) -> Option<(PresenceKey, PresencePayload)>

Outbound presence (typically caret/selection) broadcast while this widget holds focus; the host polls the focused widget after each event and diffs it out to peers.

fn presence_key(&self) -> Option<PresenceKey>

Stable identity for presence and permission lookup.

fn composing_payload(&self) -> Option<(PresenceKey, PresencePayload)>

Whether this widget is composing a message where it stands (a conversation’s composer holding a draft): published under the key beside it, so a reader can say “… is typing”. Ephemeral, a presence frame; never what the draft says.

impl Widget for BlockEditor

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

The described component’s instance, for the generic adapter to take new props in place and for a harness to read it by type.

fn draw_overlay( &mut self, scene: &mut Scene, transform: Affine, text_renderer: &mut TextRenderer, theme: &Theme, presence: &PresenceCtx, )

The editor’s popovers, in the window’s top layer — unless its owner painted them itself this frame, inside its own scroll and clip.

fn settle(&mut self, edits: &mut Edits<'_>, path: &ExId)

The frame after a keystroke makes what it left to do (formatting the markdown it closed, the correction its word boundary asked for).

fn for_each_layout_child(&self, visitor: &mut dyn FnMut(&dyn Widget)) -> bool

The one leaf the block stack is measured through, and the image buttons.

fn next_wake_deadline(&self) -> Option<Instant>

Block lines are not children, so their fields’ timers (a settling squiggle, a suggestion for the word under the caret) are collected here alongside the children’s.

fn modal_capture(&self) -> Option<Rect>

The open text menu is modal; else whatever a child holds open.

fn perform_action( &mut self, action: &Action, _key_path: &[u64], _state: &mut Edits<'_>, _path: &(dyn Any + 'static), ) -> bool

Assistive technology sets the whole text (one paragraph, line breaks kept) or selects by grapheme offsets into the text, paragraphs joined by a line break.

fn accessibility(&self) -> Option<AccessNode>

Block contents are not surfaced as a value — a screen reader walks the per-block subtree instead.

fn accessibility_root(&self) -> Option<AccessNode>

The document’s own node without its blocks: what focus capture and focus order ask of the editor on every frame.

fn accessibility_hidden(&self) -> bool

The document node above is never hidden; answer without building every block’s subtree.

fn layout_needs_measure(&self) -> bool

What Self::is_layout_dirty reads, and a pending structure change. dirty is not in it: that is paint (a caret, a selection, a menu), which no line’s size follows.

fn damage_covers_own_box(&self) -> bool

Its damage after a draw says where each block was and is, or repaints where the editor painted then and paints now.

fn is_layout_dirty(&self) -> bool

The editor is a column of one taffy node per line; its own margins and formula minimums are styles set at build time (a structural change), so its size can only move when a line’s does. Forwarded per line rather than through children(), which the editor does not expose, so an idle document re-measures nothing.

fn update( &mut self, state: &(dyn Any + 'static), path: &(dyn Any + 'static), ) -> bool

A document’s body reports what the person typed and shows what the field got from elsewhere.

fn provide<'a>(&'a self, request: &mut Request<'a, '_>)

Answer a request for a capability this widget takes part in (see capability). Declare capabilities with crate::provides!.

fn provide_mut<'a>(&'a mut self, request: &mut RequestMut<'a, '_>)

Exclusive counterpart to Widget::provide.

fn sync(&mut self, state: &(dyn Any + 'static), path: &(dyn Any + 'static))

Pull model state into this widget before layout. The default syncs the children Widget::children_mut returns; a widget overrides it only to read state of its own, or to sync children it does not expose there.

fn build_layout( &mut self, taffy: &mut TaffyTree, theme: &Theme, node_map: &mut HashMap<NodeId, *mut dyn Widget>, ) -> NodeId

fn apply_layout(&mut self, taffy: &TaffyTree, node: NodeId, origin: Point)

Take the geometry layout gave this node. The default keeps none, for widgets that neither draw nor hit-test.

fn draw( &mut self, scene: &mut Scene, transform: Affine, text_renderer: &mut TextRenderer, theme: &Theme, presence: &PresenceCtx, )

Paint into scene. The default paints nothing.

fn handle_event(&mut self, event: &WindowEvent, ctx: &mut EventCtx<'_>)

Handle one input event with the runtime services for this retained node.

fn name(&self) -> &'static str

fn test_id(&self) -> Option<&str>

Stable id for the e2e test harness; None falls back to a path-based key. Must be unique across the live tree — the registry resolves on first match, so a duplicate shadows the second occurrence.

fn get_rect(&self) -> Rect

The rectangle this widget occupies. The default, for widgets that keep no geometry, is empty.

fn children(&self) -> Vec<&dyn Widget>

fn children_mut(&mut self) -> Vec<&mut dyn Widget>

fn needs_animation_frame(&self) -> bool

App polls this in Event::AboutToWait; without it a curve would freeze until an unrelated event woke it.

fn cursor_shape(&self, point: Point) -> Option<CursorIcon>

point is logical coords, same space as Widget::get_rect; None defers to the default arrow. The host hit-tests the whole tree via node_map and picks the smallest-area claim, so containers need not override this.

fn is_focusable(&self) -> bool

fn wants_tab_input(&self) -> bool

Whether a focused widget owns Tab instead of the host’s focus traversal. This is deliberately opt-in: ordinary form fields and controls retain platform-standard Tab/Shift+Tab navigation, while a code editor or terminal can receive the key for indentation or completion. A widget around the focus may claim it too: a sheet that walks its own controls with Tab.

fn tooltip_target_at(&self, point: Point) -> Option<(Rect, String)>

fn set_focus(&mut self, focused: bool)

fn is_focused(&self) -> bool

fn ime_cursor_rect(&self) -> Option<Rect>

Caret rectangle for the platform input method, in window-logical coordinates. Returning Some enables IME for the focused widget and positions its candidate window; non-text controls keep the default None and therefore disable IME.

fn ime_edit_fingerprint(&self, key: &[u8; 32]) -> Option<[u8; 32]>

Opaque local invalidation of deferred input, including selection edits that leave the caret rectangle unchanged. The host supplies an ephemeral secret key; no text or selection is retained in the resulting digest. The default shares the accessibility door and excludes protected or read-only controls. Text controls can override it to avoid cloning text.

fn ime_content(&self) -> Option<InputContent>

The focused widget wants platform text input (Wayland text-input-v3, native IMEs elsewhere). None is intentionally the default: enabling an IME for buttons, canvas tools or games makes the compositor raise an on-screen keyboard over content that cannot accept the committed text.

fn ime_multiline(&self) -> bool

Whether the original focused editor accepts line feeds as text. This is field policy, never inferred from a multiline accessibility presentation. Wrappers inherit only one unambiguous child at their active IME caret.

fn accessibility_shared(&self) -> Option<SharedAccessNode>

Self::accessibility with its synthetic children shared, for a widget that keeps them between frames: each child it did not change is handed over as the very Arc of the last frame, which the semantic tree takes as unchanged without copying or comparing it.

fn perform_semantic_action( &mut self, target: &str, action: &Action, state: &mut Edits<'_>, path: &(dyn Any + 'static), ) -> bool

Handle an action addressed to a synthetic accessibility child created by this widget. target is the opaque stable value supplied through AccessNode::with_action_target.

fn needs_redraw(&self) -> bool

Default false (clean). A widget is clean until something it reads changes: a leaf that keeps state says so by tracking a dirty: bool (set in handle_event/sync, cleared in mark_drawn()), and one that paints from the people on the document reads the frame’s presence (crate::presence::frame::frame). Containers MUST forward: dirty iff any descendant is.

fn collect_damage(&self, regions: &mut Vec<Rect>)

Logical-pixel bounds whose visual output differs from the last frame.

fn release_scene_cache(&mut self)

Release retained encoded-scene storage in this subtree without marking its visual/model state dirty. Outer caches call this after a successful reuse: while the outer display list is authoritative, keeping byte-for-byte descendant encodings only duplicates memory. A later outer rebuild causes descendants to record/cache normally.

fn mark_drawn(&mut self)

Called after this widget’s scene lands in the composed frame, to clear a dirty flag. Default forwards to children.

fn take_structure_dirty(&mut self) -> bool

True if this subtree’s structural composition changed since the last frame; reading clears it. The default drains every retained child and reports whether any was dirty.

fn native_input_snapshot( &self, _state: &(dyn Any + 'static), _path: &(dyn Any + 'static), ) -> Option<Value>

Read-only state evidence for opt-in scheduled native input diagnostics. Called only around diagnostic inputs, never during ordinary input or paint. Keep this inexpensive and root-local; snapshots may be logged verbatim. This verifies widget state, not rendered pixels or display presentation.

fn view_only_scroll(&self, _event: &WindowEvent) -> bool

Opt in only when this wheel event changes scroll geometry and nothing else: no document edit, focus or selection, action availability, resource declaration, pending command or work that requires sync. The runner still lays out, paints and refreshes accessibility geometry; unknown handlers stay on the full path.

fn primary_vertical_scroll(&self) -> Option<PrimaryScrollRegion>

Explicit app-owned region; never search secondary children implicitly.

fn apply_primary_vertical_scroll( &mut self, _action: PrimaryScrollAction, ) -> PrimaryScrollResult

fn callback_binding(&self) -> Option<CallbackBinding>

Runtime binding inherited by descendants in a matching layout topology.

fn has_separate_document_owner(&self) -> bool

Whether this widget introduces a document owner distinct from the runner’s outer State. This is a compatibility check, never identity or authority for history access or restore.

fn history_owner(&self) -> Option<HistoryOwner>

Opaque actual custody for framework History source registration.

fn record_owners(&self) -> Vec<HistoryOwner>

Records this widget keeps open beside the document it shows, each synced on its own route: a framework app’s records in the person’s own workspace (crate::record::person). They take no part in this widget’s history or controls.

fn mount_native_views(&mut self, host: &NativeViewHost<'_>)

Attach native child views through this owner’s retained lifecycle topology. Presentation containers with inactive or hidden live descendants override this traversal so lifecycle ownership stays independent of drawing and input visibility.

fn unmount_native_views(&mut self)

Tear native children down while their parent window still exists.

fn native_view_frame_start(&mut self)

Begin a native-view frame through this owner’s retained lifecycle topology.

fn set_platform_conventions(&mut self, conventions: PlatformConventions)

Receive host-selected platform conventions. The default propagates to retained children, keeping target-OS branches out of app code.

fn set_interaction_environment(&mut self, environment: InteractionEnvironment)

Receive the host’s current input capabilities. The default propagates through retained containers, so app code does not need device branches.

fn set_window_bar_control(&mut self, in_bar: bool)

Tell this widget whether it stands in a window bar. A bar’s controls are drawn at the bar’s control height whatever the pointer; the target a finger needs reaches beyond the drawn shape, invisibly. The default propagates to children.

fn measure( &mut self, _known: Size<Option<f32>>, _available: Size<AvailableSpace>, _text_renderer: &mut TextRenderer, ) -> Size<f32>

fn layout_info(&self) -> Option<LayoutInfo>

Read-only resolved decisions for widgets with an explicit layout policy. None means the widget has no such policy; ordinary manual widgets remain valid. Values are available after build/settlement and carry real origins.

fn adjust_layout_style( &mut self, _taffy: &mut TaffyTree, _node: NodeId, _text: &mut TextRenderer, ) -> bool

Adjust this node’s style using its allocated size, before final geometry is applied. Return true only when the style changed (or an inherited decision child hooks read). An override may measure its owned children through ordinary references, entering their callback binding when present. Never reenter descendants through the raw node map while borrowing their parent, change topology, or build another layout tree. The shared host solver visits every registered widget, repeats layout at most eight times and skips a frame that does not settle.

fn observe_physical_input(&mut self, _input: PhysicalInput)

Observe this app’s ordinary foreground physical input before framework shortcuts consume it. Keep feedback ephemeral; this is not an input grant.

fn for_each_child(&self, visitor: &mut dyn FnMut(&dyn Widget))

Allocation-free read-only child traversal. Existing custom containers inherit a compatibility adapter over Self::children; toolkit containers override this to walk their retained storage directly.

fn for_each_child_in_clip(&self, visitor: &mut dyn FnMut(&dyn Widget))

The children of Self::for_each_child that may paint inside the layout_clip in effect: what a scroll view’s damage and copy plan need. Every child by default; a long column visits only those near the clip, so a frame costs what is shown, not what the column holds.

fn for_each_hosted_child(&self, _visitor: &mut dyn FnMut(&dyn Widget))

Children this widget keeps in the retained tree but does not route input to: a subtree it does not own and answers the person’s events for itself, like a host drawing another widget’s card over the windows. Inspection, named controls and the accessibility tree walk these after the children Self::children lists, so what is walked there keeps the paths, sibling indices and registry entries it had.

fn window_slot(&self, _id: String) -> Option<ToolbarAction>

This control as an action of the window’s bar, sent back as id (crate::window_toolbar::ToolbarAction): a button’s icon and name. None for anything that is not a button.

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

Downcast to the concrete widget, for hosts and tests that reach a known widget through dyn Widget. Default None (a widget may borrow and so not be 'static); a widget opts in with Some(self), and a Decorator answers itself.

fn stands_for(&self, address: *const ()) -> bool

Whether this widget is the one at address, or stands in the tree for it: a Decorator stands for every widget it wraps, so a scroller drawn inside one is found where the decorator is (crate::scroll_copy::offer).

fn focus_reveal_context(&self) -> Option<Rect>

Context that should remain visible with a focused descendant, such as a form control and its validation message. Opt-in scroll containers use this block when it fits; otherwise they prioritise the control.

fn reveal_descendant(&mut self, target: *const dyn Widget) -> bool

Reveal a newly keyboard-focused descendant inside any enclosing viewport. Containers override this to scroll; ordinary widgets simply recurse toward the target and report whether it was found.

fn test_rects(&self) -> Vec<(String, Rect)>

Named hit rects for widgets that paint several affordances into one rect instead of composing children. Same space as Widget::get_rect; zero-area entries are dropped.

fn child_clip_rect(&self) -> Option<Rect>

Absolute logical clip applied to ordinary children during painting and pointer routing. Inspectors and enclosing scroll regions must respect this boundary instead of treating clipped descendants as visible extent.

fn snap_points(&self, axis: ScrollAxis, out: &mut Vec<f32>)

Offsets along axis that this widget, as a scroll view’s content, offers it to settle on, measured from its own leading edge: a board’s lanes (crate::widget::Board). None leaves a scroller stopping wherever the hand left it.

fn take_action_palette_request(&mut self) -> Option<ActionAddress>

One-shot request to open the host’s action palette directly at a typed resource action. Parameter collection and permission checks remain host policy; widgets only name an address already present in resources().

fn take_search_request(&mut self) -> bool

One-shot request to open the host’s search palette, the same one the platform search shortcut opens. An app’s own search button latches it so search stays one shared host surface rather than an app overlay.

fn claims_raw_touch(&self, _point: Point) -> bool

Opt out of touch-to-pointer emulation for contacts that begin at point (logical coords, same space as Widget::get_rect).

fn touch_claim(&self, _point: Point) -> TouchClaim

What a one-finger contact that begins at point (logical coords) means here, when a drag moves something rather than scrolling.

fn tooltip(&self) -> Option<&str>

Revealed after a dwell over the widget’s rect, via the toolkit’s one tooltip mechanism (crate::widget::tooltip::TooltipHost), hit-tested like cursor_shape so containers need not forward it. An icon-only control should also use this as its accessible name.

fn tooltip_side(&self) -> TooltipSide

Which side of the control its tooltip goes: below by default, beside it for a control in a vertical rail.

fn is_default_keyboard_focus(&self) -> bool

Preferred control when its app is explicitly activated without a valid saved control. Hosts still enforce visibility, enabled state and scope.

fn keyboard_input_scope(&self) -> Option<u64>

Exact app instance whose non-text shortcuts this subtree owns when activation has no control target. Unbound desktop chrome may declare the active tab; component boundaries default to their captured owner.

fn set_full_bleed(&mut self, _full_bleed: bool)

The window holding this content fills its display (a maximized window): it has nothing beside it to round its corners against or to set it apart from, so content that frames or clips itself to the window’s shape draws edge to edge instead. A client surface drawn that way, last and unclipped, is one the display can scan out directly. Content that frames nothing ignores it.

fn set_invalid(&mut self, _invalid: bool)

The form’s validation verdict for this control, set by Field::with_error: an invalid control edges itself in danger ink and reports invalid to assistive technology. Controls without a field face ignore it.

fn focus_requested(&mut self, target: Option<NodeId>, tree: &TaffyTree)

An explicit runner focus request, after resolving the actual keyboard owner. Retained flags and layout restoration are not user gestures. Containers can observe this to reveal the owning viewport.

fn context_menu_anchor(&self) -> Option<Rect>

The box a context menu opened from the keyboard stands against: the item that has the keyboard, so the menu opens under it rather than under the whole widget. A widget that holds items (a list) answers for the one with the keyboard; None leaves the menu to stand under the focused widget’s own box.

fn traps_focus(&self) -> bool

While any widget answers true, the host restricts Tab/directional focus to this subtree (wrapping at the ends) and restores the prior focus once it goes back to false. Default false.

fn scopes_keyboard_focus(&self) -> bool

Whether Tab and directional focus travel stay inside this subtree while no trap holds focus: the content of the focused desktop window, so keyboard travel cycles through the app the person is in and never wanders onto the desktop’s chrome (its bars, menus and window titles), which the keyboard reaches through its own shortcuts. Unlike Self::traps_focus it moves no focus when it starts or ends, and pointer input is unaffected. Default false.

fn take_app_activation(&mut self) -> Option<u64>

One-shot (reading MUST clear it): the app instance the person just brought forward (a window they opened, clicked or switched to), whose keyboard focus the host restores, or puts on its default control, so what they type next reaches it. Default forwards the first request found among the children.

fn take_focus_request(&mut self) -> Option<String>

One-shot (reading MUST clear it): the test id of the control this subtree asks to take the keyboard once the runner laid it out, such as the first field of a view a person’s press just opened, so what they type next lands there. The runner focuses it as a press focuses a control, blurring any other; a control it does not find (or that takes no focus) leaves focus where it is. Default forwards the first request found among the children.

fn synthetic_accessibility_rect(&self, _path: &[usize]) -> Option<Rect>

Geometry for an immediate-mode semantic child from AccessNode::children. The path is its child-index path beneath this widget’s accessibility node. Returning a rect lets AccessKit activation inject the same click as pointer input.

fn focus_synthetic_accessibility(&mut self, _path: &[usize]) -> bool

Move this widget’s own immediate-mode focus to a synthetic semantic child. Retained widgets continue to use the ordinary taffy focus path.

fn accessibility_child_parent(&self, _child_index: usize) -> Option<usize>

Reparent one retained children entry beneath a synthetic child returned by accessibility. The returned index addresses AccessNode::children for this frame. Collections use this to place a real interactive row delegate inside its virtual ListItem/TreeItem instead of exporting a duplicate.

fn accessibility_child_path(&self, child_index: usize) -> Option<Vec<usize>>

Reparent one retained children entry beneath a nested path of synthetic children returned by accessibility.

fn accessibility_represents_child(&self, _child_index: usize) -> bool

Whether one retained children entry is already represented in this widget’s own synthetic accessibility tree, so the bridge must not export it a second time. A host that publishes a child’s semantics itself (to add its own controls inside the same dialog) answers true for that child; assistive technology then sees one copy, not two.

fn lays_out_child(&self, _child_index: usize) -> bool

Whether this widget lays one retained children entry out itself (an Embedded part of a painted page) rather than through the window’s layout, which then gives it no node. The accessibility walk reaches such a child, and every widget inside it, through this widget’s node.

fn accessibility_child_description(&self, _child_index: usize) -> Option<String>

What describes one retained children entry to assistive technology, when this widget holds the words for it: a row’s secondary line is its trailing switch’s description. The bridge sets it as that child’s node’s description unless the child describes itself.

fn is_enabled(&self) -> bool

A disabled (false) widget is excluded from focus traversal, must reject input in handle_event, and renders dimmed (see DISABLED_ALPHA).

fn ime_requires_deferred_ack(&self) -> bool

This field needs a host that consumes deferred receipts. Ordinary native Wayland windows must not advertise it until they have that delivery path.

fn ime_refuses_ordinary_commits(&self) -> bool

Ordinary input-method commits (a composing keyboard IME, the on-screen keyboard) cannot reach this field: its text arrives only through deferred receipts (a browser page field), so hosts keep standard text input closed outside a dictation session. A field that needs deferred receipts for dictation but turns an ordinary commit into its own acknowledged edit (Terminal’s native editor) does not refuse them.

fn start_deferred_text(&mut self) -> Option<Receipt>

Begin one bounded deferred session after explicit host consent, preserving the existing original-field fingerprint. This grants no microphone access.

fn commit_deferred_text(&mut self, text: &str) -> Option<Receipt>

A private asynchronous final. None leaves ordinary synchronous IME dispatch to the host. A receipt binds this original field and must be acknowledged before the host releases its private recovery transcript.

fn presented(&self) -> bool

Default true; false only for a widget standing in for a window’s content whose first frame has not drawn. Must latch: once true, never false again for the same content.

fn arrives_from(&self) -> Source

Where this content’s first frame comes from while it has not presented: this device (an app starting here), another device or a host. A frame from this device may hold the window’s first frame up to one frame budget; any other reserves the window’s place and says where it comes from after a while.

fn arrival_progress(&self) -> Option<Progress>

How much of what this content’s first frame waits on has come, when that measures itself (its app downloaded before it starts).

fn arrival_shape(&self) -> SkeletonShape

The shape this content declares for the placeholder standing in for its first frame. Undeclared, the placeholder is the ground alone: nothing guesses what a window will show.

fn text_review(&self) -> Option<(usize, String)>

(caret_byte, text), byte offset on a char boundary. The host diffs this before/after an event so caret-only moves (arrows, Home/End) get announced, not just typing.

fn on_external_event( &mut self, _payload: &str, _state: &mut Edits<'_>, _root: &(dyn Any + 'static), )

Delivers an out-of-band string payload from crate::app::UserEvent::External (e.g. a worker thread streaming output into a status log). Default no-op; the App redraws and re-syncs after dispatch, so mutating state here is enough.

fn on_nav_gesture( &mut self, dir: NavDirection, state: &(dyn Any + 'static), path: &(dyn Any + 'static), ) -> bool

Global back/forward gesture (swipe/edge-pull), recognised by crate::gesture::NavGestureRecognizer and delivered to the whole tree; return true once consumed. Default forwards to children, so a widget that owns history becomes swipe-navigable for free.

fn nav_availability(&self) -> NavAvailability

Which directions Self::on_nav_gesture would consume now. A widget that owns history overrides this beside on_nav_gesture.

fn take_focus_reset(&mut self) -> bool

One-shot (reading MUST clear it) signal to move focus to this subtree’s first focusable widget after the next rebuild. Only consulted under crate::app::App::autofocus_on_structure_change; a wizard raises it on step transitions.

fn take_accessibility_request(&mut self) -> Option<AccessibilityRequest>

One-shot (reading MUST clear it) request to change the window’s accessibility preferences, raised by a control the person used. The host applies it before the next frame. Default forwards the first request found among the children.

fn dev_route(&self) -> Option<RouteSnapshot>

Route history when this widget, or one it contains, is a Router.

fn restore_dev_route(&mut self, route: &RouteSnapshot) -> bool

Put route back. Returns whether a router in this subtree accepted it.

fn appearance_intent(&self) -> Option<AppearanceIntent>

Theme/high-contrast/reduced-motion/scale, polled under crate::app::App::appearance_reconcile — how a settings pane re-themes the running app live without a back-channel. Level-triggered; the App recurses Self::children itself, so containers need not forward it. First Some wins.

fn minimum_window_width(&self) -> Option<f64>

The narrowest this window still works at, in logical pixels: the minimum of its compact layout (a NavShell answers with one column at a time). The host states it to the window system, so the desktop stops a resize there. None: no opinion. The host walks the tree itself (minimum_window_width), so containers need not forward it; the first Some wins.

fn preferred_window_size(&self) -> Option<(f64, f64)>

The whole size this window wants, in logical pixels, when the app is the window’s only content and knows how big it must be: the on-screen keyboard parked to a strip. The host states it as the window’s minimum and maximum, so the desktop shapes the surface to it. None: the window is the user’s and the app lays itself out in whatever it gets.

fn set_motion_reduced(&mut self, reduced: bool)

Apply the effective reduced-motion preference before the host asks this subtree whether it needs another animation frame. The default forwards recursively, making the preference a framework policy instead of an optional convention that every container has to remember to implement.

fn needs_idle_sync(&self) -> bool

Whether sync still needs to run on idle frames without input or collab events — e.g. waiting out a document-adoption grace window.

fn wants_pointer_capture(&self) -> bool

fn disclosing(&self) -> Option<Disclosing>

While this widget is a band on its way in or out (motion::Disclosure: an in-window banner arriving or leaving), or a content-sized container one moves in, how far what follows it is drawn from where it is laid out. A moving band stands out of the layout; its container places it (Self::place_disclosing) and draws the widgets after it lower by transform, so they move with the band’s edge instead of being laid out again every frame. None at rest (the default).

fn place_disclosing(&mut self, _slot: Rect)

Where a band on its way (Disclosing::Band) stands while it is out of the layout: its slot’s top and width (slot’s height is zero), set by its container after each layout.

fn is_band(&self) -> bool

A band that comes and goes (an in-window banner): when its view stops building it, its column draws it leaving (widget::Disclosing). Its column leaves it out of its identity across rebuilds.

fn note_placement(&mut self, _placement: Placement)

Where a band stands in its column, set by the column after each layout: what it leaves when dropped, so the column a rebuild makes can draw it leaving.

fn animation_detail(&self) -> Option<String>

Why this widget itself asks for animation frames, for diagnostics that name a desktop which keeps painting. None when it has nothing to add to its name and geometry.

fn holds_frame_until(&self, now: Instant) -> Option<Instant>

Until when the frame that would show this subtree waits for data it reads from this device (crate::arriving): a local read that has not answered and is still inside its frame budget. The host keeps the frame on screen until then, or until the data lands, so the person never sees the space empty and then filled. Containers forward (the default does).

fn serve_deadline(&mut self, _now: Instant) -> bool

A deadline this subtree asked for (Self::next_wake_deadline) is due at now: do the work it was for, and say whether anything changed. The default says it did.

fn dismiss_presented_modal(&mut self) -> bool

Close every modal this subtree presents, as its own way out does (a host whose surface is a modal sheet calls it when the shell takes the sheet down). Whether any was presented; containers forward.

fn presents_modal(&self) -> bool

Whether this subtree presents a modal still drawn (arriving, open or leaving): the counterpart of Widget::dismiss_presented_modal.

fn take_structure_change(&mut self) -> StructureChange

Self::take_structure_dirty, saying whether the frame’s damage can still describe the rebuild (StructureChange::Described). Reading clears what take_structure_dirty clears; the two must agree on whether there is a change. The default is the flag, as a StructureChange::Rebuild: only a widget that knows every pixel its change touches lands in its own damage says less, and a container forwards a child’s StructureChange::Described only by overriding this.

fn remount_children(&mut self, remount: &mut Remount<'_>) -> bool

Carry out a StructureChange::Children this widget or one under it reported, in the retained layout tree, through remount (see remount). Returns false when it cannot be carried out in place: the host then rebuilds its tree, and the change is carried out by Self::build_layout. A widget reports such a change until either has carried it out. The default carries out its children’s.

fn has_pending_visual_work(&self) -> bool

Work already requested by this view whose completion will replace a placeholder. Unlike animations, this can be awaited by still captures.

fn has_transient_feedback(&self) -> bool

Temporary feedback currently presented, such as a save acknowledgement. Captures may intentionally include it; scene-invariance checks can wait for it to disappear separately from unfinished placeholder work.

fn mark_children_drawn(&mut self)

Rest this widget’s children after a frame drew them, for a widget that keeps its own dirty flag: it clears the flag itself, then calls this.

fn composition_follows_allocation(&self) -> bool

Whether this widget composes its children from the size it was last allocated (it reads its own rect while building its layout: a compact layout under a width, a count of columns, an inset from a drawer). A window resize then needs a second composition against the new allocation, as well as the re-solve every resize gets. Widgets that compose independently of their allocation, or that report take_structure_dirty themselves when a new allocation changes what they show, keep the default: a resize re-solves the retained tree in place instead of recomposing all of it.

fn paint_bounds(&self) -> Rect

Everything this widget paints, children included; draw_child skips the draw when it misses the viewport. Override for widgets that paint past their own rect.