Struct NavList
pub struct NavList { /* private fields */ }Expand description
The navigation list. See the module docs.
Implementations§
pub fn new(sections: Vec<NavSection>) -> NavList
pub fn with_id(self, id: impl Into<String>) -> NavList
pub fn with_id(self, id: impl Into<String>) -> NavList
Give the list a stable id for tests and inspection.
pub fn with_accessible_name(self, name: impl Into<String>) -> NavList
pub fn with_accessible_name(self, name: impl Into<String>) -> NavList
The name the list is announced by (“Mailboxes”, “Settings”).
pub fn selected(self, id: &str) -> NavList
pub fn selected(self, id: &str) -> NavList
Choose id and bring its row into view. Does not report through
Self::on_select.
pub fn bind_selection(self, state: &LocalState<Option<String>>) -> NavList
pub fn bind_selection(self, state: &LocalState<Option<String>>) -> NavList
Keep the chosen destination in state: the list shows what the state
holds (and brings it into view) and writes the person’s choice back.
pub fn follow(
self,
source: impl FnMut() -> Option<(Vec<NavSection>, Option<String>)> + 'static,
) -> NavList
pub fn follow( self, source: impl FnMut() -> Option<(Vec<NavSection>, Option<String>)> + 'static, ) -> NavList
Keep the list in step with app state: source answers the sections
and the chosen destination, read now and at every sync and update. A
choice the person makes shows until the state answers it; a state that
chooses otherwise wins.
pub fn on_select(self, f: impl FnMut(String) + 'static) -> NavList
pub fn on_select(self, f: impl FnMut(String) + 'static) -> NavList
Called with the item id when the person chooses a destination.
pub fn selection_actions(
self,
bindings: impl IntoIterator<Item = (String, ActionBinding<()>)>,
) -> NavList
pub fn selection_actions( self, bindings: impl IntoIterator<Item = (String, ActionBinding<()>)>, ) -> NavList
Bind each destination to its published typed action. Bound rows route
selection through host custody; unbound rows keep on_select behavior.
pub fn item_actions(
self,
actions: Vec<NavAction>,
on_action: impl FnMut(&str, &str) + 'static,
) -> NavList
pub fn item_actions( self, actions: Vec<NavAction>, on_action: impl FnMut(&str, &str) + 'static, ) -> NavList
Actions shown on hover and focus at the trailing edge of every item
that has not opted out (NavItem::without_actions); reported with
the item id and the action id through on_action. An action that
opens the menu asks for the row’s
menu instead.
pub fn on_section_action(self, f: impl FnMut(&str, &str) + 'static) -> NavList
pub fn on_section_action(self, f: impl FnMut(&str, &str) + 'static) -> NavList
Called with the section id and the action id when a section header’s trailing action is pressed.
pub fn on_rename(self, f: impl FnMut(&str, String) + 'static) -> NavList
pub fn on_rename(self, f: impl FnMut(&str, String) + 'static) -> NavList
Called with the item id and the new label when the person renames an editable item (F2 or a double click).
pub fn on_check(self, f: impl FnMut(&str, bool) + 'static) -> NavList
pub fn on_check(self, f: impl FnMut(&str, bool) + 'static) -> NavList
Called with the item id and its new state when the person toggles a
checkable row (NavItem::checked): a click anywhere on it, or
Space or Enter.
pub fn on_expand(self, f: impl FnMut(&str, bool) + 'static) -> NavList
pub fn on_expand(self, f: impl FnMut(&str, bool) + 'static) -> NavList
Called with the item or section id and whether it is now open when the person folds or unfolds it, so the app can keep what was folded.
pub fn on_delete(self, f: impl FnMut(String) + 'static) -> NavList
pub fn on_delete(self, f: impl FnMut(String) + 'static) -> NavList
Called with the focused item’s id when the person presses Delete (never Backspace, which belongs to whatever editor sits beside the list).
Called when the person asks for an item’s menu: a right click or a
long press on its row, the Menu key or Shift+F10 on it, or an item
action that opens the menu. It
receives the item id, the row’s lift (hand it to
ContextMenu::anchor_row so the row stays marked) and where the menu
opens: the pointer, or the bottom-leading corner of the row or the
action.
pub fn on_move(self, f: impl FnMut(&str, NavDrop) + 'static) -> NavList
pub fn on_move(self, f: impl FnMut(&str, NavDrop) + 'static) -> NavList
Let the person drag items: into an item marked
NavItem::drop_target, or before and after items in the same
section. The app moves the item in its own data and hands the list
its new sections (Self::set_sections).
pub fn rail(self) -> NavList
pub fn rail(self) -> NavList
An icon-over-label compact rail (a workspace switcher, a channel rail). Section titles give way to space; counts become a mark; captions wrap to a second line before they elide.
pub fn set_sections(&mut self, sections: Vec<NavSection>)
pub fn set_sections(&mut self, sections: Vec<NavSection>)
Replace the destinations, keeping the selection, expansion and focus of every id that is still there.
pub fn set_selected(&mut self, id: Option<&str>)
pub fn set_selected(&mut self, id: Option<&str>)
Choose id (or nothing) without reporting it, and bring its row
into view (once the list has a viewport, if it has none yet).
pub fn selected_id(&self) -> Option<String>
pub fn selected_id(&self) -> Option<String>
The chosen destination.
pub fn set_expanded(&mut self, id: &str, open: bool)
pub fn set_expanded(&mut self, id: &str, open: bool)
Open or fold item or section id without reporting it.
pub fn is_expanded(&self, id: &str) -> bool
pub fn is_expanded(&self, id: &str) -> bool
Whether item or section id is open.
pub fn row_rect(&self, id: &str) -> Option<Rect>
pub fn row_rect(&self, id: &str) -> Option<Rect>
The painted rect of item id’s row, edge to edge of the list, when
it is in view.
pub fn row_lift_rect(&self, id: &str) -> Option<Rect>
pub fn row_lift_rect(&self, id: &str) -> Option<Rect>
The lift of item id’s row: where its hover and selection paint.
Hand it to ContextMenu::anchor_row so a menu marks the row.
pub fn item_action_rect(&self, id: &str, action: &str) -> Option<Rect>
pub fn item_action_rect(&self, id: &str, action: &str) -> Option<Rect>
Where item action action sits on item id’s row (whether or not
the row is hovered), to open a menu at it with open_anchored.
pub fn stage_drag(&mut self, id: &str, before: &str)
pub fn stage_drag(&mut self, id: &str, before: &str)
Show item id being dragged to just before item before, for a
capture: the row lifts under a resting pointer and the drop line
shows. Nothing moves unless the person releases it. Needs
Self::on_move.
pub fn set_filter(&mut self, query: &str)
pub fn set_filter(&mut self, query: &str)
Narrow the filterable sections to query (an empty query shows
everything). The shell’s filter field calls this; an app with its own
field may too.
pub fn visible_item_ids(&self) -> Vec<String>
pub fn visible_item_ids(&self) -> Vec<String>
Stable item ids in the current expanded and filtered row order. Section headers are omitted. Inspection reads the same rows that the retained navigation tree renders and exposes to accessibility.
Trait Implementations§
§fn install_control_custody(
&mut self,
domain: &ControlDomain,
attachment: CustodyAttachment,
)
fn install_control_custody( &mut self, domain: &ControlDomain, attachment: CustodyAttachment, )
Bind retained producers before their first callback. Private holders
must override this; child traversal alone never certifies full coverage.
§fn take_control_invocation(&mut self) -> Option<ControlInvocation>
fn take_control_invocation(&mut self) -> Option<ControlInvocation>
Drain one queued action-bound control intent from this subtree.
§fn control_action_bindings(&self) -> Vec<ControlBindingMetadata>
fn control_action_bindings(&self) -> Vec<ControlBindingMetadata>
Inventory action-native and explicitly legacy controls. A widget that
owns an emitter prepends its
metadata
to its descendants’ inventory.§fn refresh_control_action_availability(
&mut self,
allowed: &HashSet<ActionAddress>,
)
fn refresh_control_action_availability( &mut self, allowed: &HashSet<ActionAddress>, )
Push the fresh local permission-filtered action surface into every
retained control: refresh this widget’s own emitter, then its children.
§fn take_attributed_control_invocation(
&mut self,
) -> Option<(ControlInvocation, Option<InvocationId>)>
fn take_attributed_control_invocation( &mut self, ) -> Option<(ControlInvocation, Option<InvocationId>)>
Self::take_control_invocation, with the effect invocation the
intent continues when an effect’s handler or completion queued it:
the host applies it for that invocation’s invoker.§fn on_control_invocation_result(
&mut self,
address: &ActionAddress,
result: &Result<ResourceOperationStart, DoorError>,
)
fn on_control_invocation_result( &mut self, address: &ActionAddress, result: &Result<ResourceOperationStart, DoorError>, )
Report the admission result of one queued local control invocation.
Accepted means queued, not completed; confirmation remains an error
while the host offers its normal confirmation UI. This notification
grants no document authority and must not retry the invocation itself.§fn action_control_bindings(&self) -> Vec<ControlBindingMetadata>
fn action_control_bindings(&self) -> Vec<ControlBindingMetadata>
Action-emitter bindings in the same order and exposure as the full
inventory. Custom private inventories keep their authoritative default;
wrappers can avoid allocating semantic-only accessibility snapshots.
§fn has_action_control_bindings(&self) -> bool
fn has_action_control_bindings(&self) -> bool
Whether this exposed subtree contains controls consuming action
availability. An override must match whether
control_action_bindings
contains an Action, including the same modal child exposure,
regardless of current availability.§fn has_pending_control_invocation(&self) -> bool
fn has_pending_control_invocation(&self) -> bool
Local control intent queued behind asynchronous startup preparation.
A scheduling hint only; the host still checks live authority.
fn provide<'a>(&'a self, request: &mut Request<'a, '_>)
fn provide_mut<'a>(&'a mut self, request: &mut RequestMut<'a, '_>)
fn build_layout( &mut self, taffy: &mut TaffyTree, theme: &Theme, node_map: &mut HashMap<NodeId, *mut dyn Widget>, ) -> NodeId
fn sync(&mut self, state: &(dyn Any + 'static), path: &(dyn Any + 'static))
fn update( &mut self, state: &(dyn Any + 'static), path: &(dyn Any + 'static), ) -> bool
fn accessibility(&self) -> Option<AccessNode>
fn name(&self) -> &'static str
fn as_any(&self) -> Option<&(dyn Any + 'static)>
fn as_any_mut(&mut self) -> Option<&mut (dyn Any + 'static)>
§fn take_structure_change(&mut self) -> StructureChange
fn take_structure_change(&mut self) -> StructureChange
A decorator’s structure flag is its own
Decorator::take_structure_dirty
(which may add flags of its own), so by default it says
super::StructureChange::Rebuild; one that adds no flags forwards
its inner widget’s change by overriding this.§fn view_only_scroll(&self, _event: &WindowEvent) -> bool
fn view_only_scroll(&self, _event: &WindowEvent) -> bool
Decorators must opt in themselves: an outer handler can change what
its inner widget declares even when the inner scroll is view-only.
fn native_input_snapshot( &self, state: &(dyn Any + 'static), path: &(dyn Any + 'static), ) -> Option<Value>
fn callback_binding(&self) -> Option<CallbackBinding>
fn has_separate_document_owner(&self) -> bool
fn history_owner(&self) -> Option<HistoryOwner>
fn record_owners(&self) -> Vec<HistoryOwner>
fn layout_info(&self) -> Option<LayoutInfo>
fn children(&self) -> Vec<&dyn Widget>
fn for_each_child(&self, visitor: &mut dyn FnMut(&dyn Widget))
fn local_resource_operation_handlers(&self) -> &'static [&'static str]
fn resource_operation_handlers(&self) -> HashSet<String>
fn test_id(&self) -> Option<&str>
fn test_rects(&self) -> Vec<(String, Rect)>
fn get_rect(&self) -> Rect
fn paint_bounds(&self) -> Rect
fn child_clip_rect(&self) -> Option<Rect>
fn keeps_undo_step_open(&self) -> bool
fn cursor_shape(&self, point: Point) -> Option<CursorIcon>
fn claims_raw_touch(&self, point: Point) -> bool
fn tooltip(&self) -> Option<&str>
fn tooltip_side(&self) -> TooltipSide
fn tooltip_target_at(&self, point: Point) -> Option<(Rect, String)>
fn is_focusable(&self) -> bool
fn is_focused(&self) -> bool
fn wants_tab_input(&self) -> bool
fn ime_cursor_rect(&self) -> Option<Rect>
fn traps_focus(&self) -> bool
fn synthetic_accessibility_rect(&self, path: &[usize]) -> Option<Rect>
fn accessibility_child_parent(&self, child_index: usize) -> Option<usize>
fn accessibility_child_path(&self, child_index: usize) -> Option<Vec<usize>>
fn accessibility_represents_child(&self, child_index: usize) -> bool
fn is_enabled(&self) -> bool
fn ime_requires_deferred_ack(&self) -> bool
fn ime_edit_fingerprint(&self, key: &[u8; 32]) -> Option<[u8; 32]>
fn ime_purpose(&self) -> Option<ImePurpose>
fn ime_multiline(&self) -> bool
fn presented(&self) -> bool
fn opening(&self) -> bool
fn text_review(&self) -> Option<(usize, String)>
fn dev_route(&self) -> Option<RouteSnapshot>
fn appearance_intent(&self) -> Option<AppearanceIntent>
fn needs_idle_sync(&self) -> bool
fn wants_pointer_capture(&self) -> bool
fn needs_animation_frame(&self) -> bool
fn next_wake_deadline(&self) -> Option<Instant>
fn modal_capture(&self) -> Option<Rect>
fn has_pending_visual_work(&self) -> bool
fn has_transient_feedback(&self) -> bool
fn needs_redraw(&self) -> bool
fn collect_damage(&self, regions: &mut Vec<Rect>)
fn damage_covers_own_box(&self) -> bool
fn is_layout_dirty(&self) -> bool
fn layout_needs_measure(&self) -> bool
fn is_default_keyboard_focus(&self) -> bool
fn keyboard_input_scope(&self) -> Option<u64>
fn primary_vertical_scroll(&self) -> Option<PrimaryScrollRegion>
fn semantic_readers(&self) -> &'static [RegisteredSemanticReader]
fn set_platform_conventions(&mut self, conventions: PlatformConventions)
fn set_interaction_environment(&mut self, environment: InteractionEnvironment)
fn settle(&mut self, edits: &mut Edits<'_>, path: &ExId)
fn measure( &mut self, known: Size<Option<f32>>, available: Size<AvailableSpace>, text_renderer: &mut TextRenderer, ) -> Size<f32>
fn adjust_layout_style( &mut self, taffy: &mut TaffyTree, node: NodeId, text: &mut TextRenderer, ) -> bool
fn apply_layout(&mut self, taffy: &TaffyTree, node: NodeId, origin: Point)
fn draw( &mut self, scene: &mut Scene, transform: Affine, text_renderer: &mut TextRenderer, theme: &Theme, presence: &PresenceCtx, )
fn observe_physical_input(&mut self, input: PhysicalInput)
fn handle_event(&mut self, event: &WindowEvent, ctx: &mut EventCtx<'_>)
fn children_mut(&mut self) -> Vec<&mut dyn Widget>
fn reveal_descendant(&mut self, target: *const dyn Widget) -> bool
fn take_action_palette_request(&mut self) -> Option<ActionAddress>
fn take_search_request(&mut self) -> bool
fn take_committed_action(&mut self) -> Option<Vec<ChangeHash>>
fn set_undo_status(&mut self, status: &mut dyn FnMut() -> UndoStatus)
fn take_undo_request(&mut self) -> Option<UndoRequest>
fn handle_local_undo_request(&mut self, request: UndoRequest) -> bool
fn set_focus(&mut self, focused: bool)
fn set_invalid(&mut self, invalid: bool)
fn focus_synthetic_accessibility(&mut self, path: &[usize]) -> bool
fn perform_action( &mut self, action: &Action, key_path: &[u64], state: &mut Edits<'_>, path: &(dyn Any + 'static), ) -> bool
fn perform_semantic_action( &mut self, target: &str, action: &Action, state: &mut Edits<'_>, path: &(dyn Any + 'static), ) -> bool
fn start_deferred_text(&mut self) -> Option<Receipt>
fn commit_deferred_text(&mut self, text: &str) -> Option<Receipt>
fn on_external_event( &mut self, payload: &str, state: &mut Edits<'_>, root: &(dyn Any + 'static), )
fn take_focus_reset(&mut self) -> bool
fn take_accessibility_request(&mut self) -> Option<AccessibilityRequest>
fn restore_dev_route(&mut self, route: &RouteSnapshot) -> bool
fn set_motion_reduced(&mut self, reduced: bool)
fn apply_room_action( &mut self, doc: &mut Edits<'_>, type_id: &str, payload: &[u8], ) -> bool
fn start_operation( &mut self, op: &ResourceOperation<'_>, doc: &mut Edits<'_>, path: &ExId, ) -> Result<Option<ResourceOperationStart>, String>
fn poll_resource_operation( &mut self, invocation: InvocationId, cancellation_requested: bool, doc: &AutoCommit, path: &ExId, ) -> Option<InvocationUpdate>
fn take_structure_dirty(&mut self) -> bool
fn mark_drawn(&mut self)
fn release_scene_cache(&mut self)
fn draw_overlay( &mut self, scene: &mut Scene, transform: Affine, text_renderer: &mut TextRenderer, theme: &Theme, presence: &PresenceCtx, )
fn apply_primary_vertical_scroll( &mut self, action: PrimaryScrollAction, ) -> PrimaryScrollResult
fn focus_requested(&mut self, target: Option<NodeId>, tree: &TaffyTree)
fn mount_native_views(&mut self, host: &NativeViewHost<'_>)
fn native_view_frame_start(&mut self)
fn unmount_native_views(&mut self)
§fn set_filter(&mut self, query: &str)
fn set_filter(&mut self, query: &str)
Show only what matches
query; an empty query shows everything.
Match the way search does (crate::search::ListIndex) so a filter
and the platform search agree on what “matches” means.§fn filter_count(&self) -> Option<FilterCount>
fn filter_count(&self) -> Option<FilterCount>
How many rows the current filter leaves, for the field’s counter.
§fn search_scope(&self) -> Option<ScopeDecl>
fn search_scope(&self) -> Option<ScopeDecl>
The part of the app the view shows, which “Search everywhere”
narrows the platform search to.
None searches the whole app.Auto Trait Implementations§
Blanket Implementations§
§impl<T> AudiencePresentationWidgetExt for T
impl<T> AudiencePresentationWidgetExt for T
fn audience_presentation_request(&self) -> Option<AudiencePresentationRequest>
fn on_audience_presentation_changed(&mut self, active: bool)
fn draw_audience_presentation( &mut self, scene: &mut Scene, transform: Affine, text_renderer: &mut TextRenderer, theme: &Theme, rect: Rect, ) -> bool
fn handle_audience_presentation_event( &mut self, event: &WindowEvent, state: &mut Edits<'_>, path: &ExId, ) -> bool
fn on_audience_presentation_closed(&mut self)
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
§impl<T> CompleteContentWidgetExt for T
impl<T> CompleteContentWidgetExt for T
fn complete_content_size(&self) -> Option<Size>
fn draw_complete_content( &mut self, scene: &mut Scene, bounds: Rect, transform: Affine, text_renderer: &mut TextRenderer, theme: &Theme, presence: &PresenceCtx, ) -> bool
§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
§fn into_any(self: Box<T>) -> Box<dyn 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>
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)
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)
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.§impl<T> FloatingSurfaceWidgetExt for T
impl<T> FloatingSurfaceWidgetExt for T
fn on_floating_surface_focus_changed(&mut self, id: Option<&str>, focused: bool)
fn on_floating_surface_ime_source_changed(&mut self, id: Option<&str>)
fn on_floating_surface_event_source(&mut self, id: Option<&str>)
fn floating_surface_accessibility(&self, id: &str) -> Option<AccessNode>
fn perform_floating_surface_accessibility_action( &mut self, id: &str, target: &str, action: &Action, state: &mut Edits<'_>, path: &ExId, ) -> bool
fn floating_surface_ime(&self, id: &str) -> Option<(ImePurpose, Rect)>
fn take_floating_surface_request(&mut self) -> Option<FloatingSurfaceRequest>
fn take_capture_studio_request(&mut self) -> Option<CaptureMode>
fn take_floating_surface_source_updates(&mut self) -> Vec<(String, Rect)>
fn draw_floating_surfaces( &mut self, scene: &mut Scene, transform: Affine, text_renderer: &mut TextRenderer, theme: &Theme, presence: &PresenceCtx, )
fn draw_floating_surface( &mut self, id: &str, scene: &mut Scene, transform: Affine, text_renderer: &mut TextRenderer, theme: &Theme, presence: &PresenceCtx, ) -> bool
fn floating_surface_presentations(&self) -> Vec<FloatingSurfacePresentation>
fn active_floating_surface_ids(&self) -> Vec<String>
fn set_floating_surface_bounds(&mut self, bounds: Rect)
fn on_floating_surface_host_message( &mut self, message: &FloatingSurfaceHostMessage, )
§impl<T> FullscreenWidgetExt for T
impl<T> FullscreenWidgetExt for T
fn fullscreen_intent(&self) -> Option<bool>
fn fullscreen_params(&self) -> FullscreenRequest
fn on_fullscreen_changed(&mut self, active: bool)
Source§impl<W> HostDelivery for W
impl<W> HostDelivery for W
Source§fn start_encoded(
&mut self,
kind: OperationKind,
type_id: &str,
payload: &[u8],
doc: &mut AutoCommit,
path: &ExId,
) -> Result<Option<Effected>, String>
fn start_encoded( &mut self, kind: OperationKind, type_id: &str, payload: &[u8], doc: &mut AutoCommit, path: &ExId, ) -> Result<Option<Effected>, String>
Source§fn deliver_control(
&mut self,
kind: OperationKind,
control: &str,
doc: &mut AutoCommit,
path: &ObjId,
) -> Result<Option<Effected>, String>
fn deliver_control( &mut self, kind: OperationKind, control: &str, doc: &mut AutoCommit, path: &ObjId, ) -> Result<Option<Effected>, String>
Hand back the invocation of the toolkit control
control (its id,
as its tilo.control: resource names it). Read more§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
Converts
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read more§impl<T> Pointable for T
impl<T> Pointable for T
§impl<F, T, S> SimdInto<T, S> for Fwhere
T: SimdFrom<F, S>,
S: Simd,
impl<F, T, S> SimdInto<T, S> for Fwhere
T: SimdFrom<F, S>,
S: Simd,
§impl<T> Widget for Twhere
T: Decorator,
impl<T> Widget for Twhere
T: Decorator,
§fn provide<'a>(&'a self, request: &mut Request<'a, '_>)
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, '_>)
fn provide_mut<'a>(&'a mut self, request: &mut RequestMut<'a, '_>)
Exclusive counterpart to
Widget::provide.fn build_layout( &mut self, taffy: &mut TaffyTree, theme: &Theme, node_map: &mut HashMap<NodeId, *mut dyn Widget>, ) -> NodeId
§fn as_any(&self) -> Option<&(dyn Any + 'static)>
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 as_any_mut(&mut self) -> Option<&mut (dyn Any + 'static)>
§fn take_structure_change(&mut self) -> StructureChange
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 view_only_scroll(&self, event: &WindowEvent) -> bool
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/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 synchronization/publication path.§fn native_input_snapshot(
&self,
state: &(dyn Any + 'static),
path: &(dyn Any + 'static),
) -> Option<Value>
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 callback_binding(&self) -> Option<CallbackBinding>
fn callback_binding(&self) -> Option<CallbackBinding>
Runtime binding inherited by descendants in a matching layout topology.
§fn has_separate_document_owner(&self) -> bool
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. Read more
§fn history_owner(&self) -> Option<HistoryOwner>
fn history_owner(&self) -> Option<HistoryOwner>
Opaque actual custody for framework History source registration.
§fn record_owners(&self) -> Vec<HistoryOwner>
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 room (
crate::record::person). They take no part in this
widget’s history or controls.§fn layout_info(&self) -> Option<LayoutInfo>
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 children(&self) -> Vec<&dyn Widget>
§fn for_each_child(&self, visitor: &mut dyn FnMut(&dyn Widget))
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 local_resource_operation_handlers(&self) -> &'static [&'static str]
fn local_resource_operation_handlers(&self) -> &'static [&'static str]
Effect/view operation type ids this widget can actually dispatch. Read more
fn resource_operation_handlers(&self) -> HashSet<String>
fn name(&self) -> &str
§fn test_id(&self) -> Option<&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 test_rects(&self) -> Vec<(String, Rect)>
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 get_rect(&self) -> Rect
fn get_rect(&self) -> Rect
The rectangle this widget occupies. The default, for widgets that
keep no geometry, is empty.
§fn paint_bounds(&self) -> Rect
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.§fn child_clip_rect(&self) -> Option<Rect>
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 keeps_undo_step_open(&self) -> bool
fn keeps_undo_step_open(&self) -> bool
Whether the undo step this widget’s last reported boundary opened
stays open for the actions that continue it — the rest of a word
typed a keystroke at a time. A hosted component then closes the step
at the widget’s next boundary, or before an undo, a save or a merge,
instead of after this event. Answered by the widget itself, never its
children.
§fn cursor_shape(&self, point: Point) -> Option<CursorIcon>
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 claims_raw_touch(&self, point: Point) -> bool
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). Read more§fn tooltip(&self) -> Option<&str>
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
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 tooltip_target_at(&self, point: Point) -> Option<(Rect, String)>
fn is_focusable(&self) -> bool
fn is_focused(&self) -> bool
§fn wants_tab_input(&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.
§fn ime_cursor_rect(&self) -> Option<Rect>
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 traps_focus(&self) -> bool
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 accessibility(&self) -> Option<AccessNode>
fn accessibility(&self) -> Option<AccessNode>
Role, name/description/value, and
AccessState. Default None means
presentational: the node is skipped and children reparent onto the
parent. State must be derived, not stored so it can’t drift from
draw; names must already be i18n!-resolved.§fn synthetic_accessibility_rect(&self, path: &[usize]) -> Option<Rect>
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 accessibility_child_parent(&self, child_index: usize) -> Option<usize>
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>>
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. Read more§fn accessibility_represents_child(&self, child_index: usize) -> bool
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 is_enabled(&self) -> bool
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
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_edit_fingerprint(&self, key: &[u8; 32]) -> Option<[u8; 32]>
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_purpose(&self) -> Option<ImePurpose>
fn ime_purpose(&self) -> Option<ImePurpose>
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. Read more§fn ime_multiline(&self) -> bool
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 presented(&self) -> bool
fn presented(&self) -> bool
Default
true; the exception is a widget standing in for a process
that has started but not drawn. Must latch: once true, never
false again for the same content, or an un-presenting widget would
make a window vanish mid-resize. What shows meanwhile is decided by
Widget::opening.§fn opening(&self) -> bool
fn opening(&self) -> bool
True once waiting long enough, while not yet
presented, that showing nothing would read as
broken. Delayed so a fast open never flashes an indicator.§fn text_review(&self) -> Option<(usize, String)>
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.Which directions
Self::on_nav_gesture would consume now. A widget
that owns history overrides this beside on_nav_gesture.§fn dev_route(&self) -> Option<RouteSnapshot>
fn dev_route(&self) -> Option<RouteSnapshot>
§fn appearance_intent(&self) -> Option<AppearanceIntent>
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 needs_idle_sync(&self) -> bool
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 needs_animation_frame(&self) -> bool
fn needs_animation_frame(&self) -> bool
App polls this in Event::AboutToWait; without it a curve would
freeze partway until an unrelated event woke it again.§fn next_wake_deadline(&self) -> Option<Instant>
fn next_wake_deadline(&self) -> Option<Instant>
Earliest wall-clock deadline at which this subtree needs a sync/redraw
even if there is no input. Unlike
needs_animation_frame, this keeps
the event loop asleep until the requested instant and is appropriate
for filesystem/status polling rather than animation.§fn modal_capture(&self) -> Option<Rect>
fn modal_capture(&self) -> Option<Rect>
Some(rect) when this subtree holds an open modal, its panel box.
While any widget reports Some, the host suppresses its own global
focus shortcuts and swallows unhandled pointer presses so nothing
behind the modal is clickable. Containers MUST forward (the default
does, via first Some among children).§fn has_pending_visual_work(&self) -> bool
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
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 needs_redraw(&self) -> bool
fn needs_redraw(&self) -> bool
Default
true (dirty every frame). Opt into incremental redraw by
tracking a dirty: bool, setting it in handle_event/sync, and
clearing it in mark_drawn(). Containers MUST forward: dirty iff any
descendant is.§fn collect_damage(&self, regions: &mut Vec<Rect>)
fn collect_damage(&self, regions: &mut Vec<Rect>)
Logical-pixel bounds whose visual output differs from the last frame. Read more
§fn damage_covers_own_box(&self) -> bool
fn damage_covers_own_box(&self) -> bool
Whether, after this frame’s draw, this widget’s own
Self::collect_damage covers every pixel a relayout changed by
moving or resizing its layout box: a host that repaints where moved
widgets were and are may then leave this widget’s box to it (its
children’s boxes still count). A block editor that grew by a
paragraph says where its blocks were and are; the default does not
claim it.§fn is_layout_dirty(&self) -> bool
fn is_layout_dirty(&self) -> bool
Default
true; widgets with a fixed intrinsic size should override
to false unless a size-affecting mutation landed. Containers MUST
forward: layout-dirty iff any descendant is.§fn layout_needs_measure(&self) -> bool
fn layout_needs_measure(&self) -> bool
Whether a
layout_dirty frame needs taffy to re-solve sizes
(compute_layout) rather than just reposition already-solved boxes.
Scrollable is the motivating override: it translates its origin
in apply_layout without changing any taffy size, so re-solving on
every scroll frame is pure waste.§fn is_default_keyboard_focus(&self) -> bool
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>
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 primary_vertical_scroll(&self) -> Option<PrimaryScrollRegion>
fn primary_vertical_scroll(&self) -> Option<PrimaryScrollRegion>
Explicit app-owned region; never search secondary children implicitly.
§fn semantic_readers(&self) -> &'static [RegisteredSemanticReader]
fn semantic_readers(&self) -> &'static [RegisteredSemanticReader]
Inert immutable-reader registrations owned by this actual widget.
Registration alone supplies no qualified owner frame or disclosure.
§fn set_platform_conventions(&mut self, conventions: PlatformConventions)
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)
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 sync(&mut self, state: &(dyn Any + 'static), path: &(dyn Any + 'static))
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 update(
&mut self,
state: &(dyn Any + 'static),
path: &(dyn Any + 'static),
) -> bool
fn update( &mut self, state: &(dyn Any + 'static), path: &(dyn Any + 'static), ) -> bool
Notice, between frames, state that lives outside the document (a
chrome revision, a momentum scroll still ticking) and report whether
anything changed. The default updates every child
Widget::children_mut returns, without short-circuiting, so a
container never freezes its descendants at build-time state; a widget
overrides it to check state of its own and then forward.§fn settle(&mut self, edits: &mut Edits<'_>, path: &ExId)
fn settle(&mut self, edits: &mut Edits<'_>, path: &ExId)
Apply, after the sync pass, what the widget took up there and must
write: a worker’s answer, a chooser’s file, an event a child queued.
Writes go only through typed actions on
edits (a resource’s
dispatcher); the host syncs again when the document changed. The
default settles the children Widget::children_mut returns.fn measure( &mut self, known: Size<Option<f32>>, available: Size<AvailableSpace>, text_renderer: &mut TextRenderer, ) -> Size<f32>
§fn adjust_layout_style(
&mut self,
taffy: &mut TaffyTree,
node: NodeId,
text: &mut TextRenderer,
) -> bool
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 apply_layout(&mut self, taffy: &TaffyTree, node: NodeId, origin: Point)
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,
)
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 observe_physical_input(&mut self, input: PhysicalInput)
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 handle_event(&mut self, event: &WindowEvent, ctx: &mut EventCtx<'_>)
fn handle_event(&mut self, event: &WindowEvent, ctx: &mut EventCtx<'_>)
Handle one input event with the runtime services for this retained node.
fn children_mut(&mut self) -> Vec<&mut dyn Widget>
§fn reveal_descendant(&mut self, target: *const dyn Widget) -> bool
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 take_action_palette_request(&mut self) -> Option<ActionAddress>
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
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 take_committed_action(&mut self) -> Option<Vec<ChangeHash>>
fn take_committed_action(&mut self) -> Option<Vec<ChangeHash>>
The affordance-driven twin of the Ctrl+K palette: when a widget’s own
control dispatches the same
tilo_actions action its
ActionSpec exports, it reports the
document heads captured just before here, so the host can record
one undo boundary the same way a palette dispatch does. Rising-edge:
reading MUST clear it.§fn set_undo_status(&mut self, status: &mut dyn FnMut() -> UndoStatus)
fn set_undo_status(&mut self, status: &mut dyn FnMut() -> UndoStatus)
Host → widget: the live state of the undo history, published once per
frame to every laid-out widget. Read more
§fn take_undo_request(&mut self) -> Option<UndoRequest>
fn take_undo_request(&mut self) -> Option<UndoRequest>
Widget → host: an undo or redo the user asked for. Read more
§fn handle_local_undo_request(&mut self, request: UndoRequest) -> bool
fn handle_local_undo_request(&mut self, request: UndoRequest) -> bool
Offer a host keyboard undo/redo shortcut to focused widget-local
history before the application document consumes it. Read more
fn set_focus(&mut self, focused: bool)
§fn set_invalid(&mut self, invalid: bool)
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_synthetic_accessibility(&mut self, path: &[usize]) -> bool
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 perform_action(
&mut self,
action: &Action,
key_path: &[u64],
state: &mut Edits<'_>,
path: &(dyn Any + 'static),
) -> bool
fn perform_action( &mut self, action: &Action, key_path: &[u64], state: &mut Edits<'_>, path: &(dyn Any + 'static), ) -> bool
Perform an accessibility
Action on this
widget, or on one of its synthetic accessibility nodes. May mutate
the CRDT like handle_event. Read more§fn perform_semantic_action(
&mut self,
target: &str,
action: &Action,
state: &mut Edits<'_>,
path: &(dyn Any + 'static),
) -> bool
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. Read more§fn start_deferred_text(&mut self) -> Option<Receipt>
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>
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 on_external_event(
&mut self,
payload: &str,
state: &mut Edits<'_>,
root: &(dyn Any + 'static),
)
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.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 take_focus_reset(&mut self) -> bool
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>
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 restore_dev_route(&mut self, route: &RouteSnapshot) -> bool
fn restore_dev_route(&mut self, route: &RouteSnapshot) -> bool
Put
route back. Returns whether a router in this subtree accepted it. Read more§fn set_motion_reduced(&mut self, reduced: bool)
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. Read more
§fn apply_room_action(
&mut self,
doc: &mut Edits<'_>,
type_id: &str,
payload: &[u8],
) -> bool
fn apply_room_action( &mut self, doc: &mut Edits<'_>, type_id: &str, payload: &[u8], ) -> bool
Apply an action another app in this room published, if this app owns
the document — lets an app address a document it doesn’t hold by
saying what should happen instead of writing bytes directly, keeping
each document to one writer. An unrecognised
type_id is silently
declined, not an error.§fn start_operation(
&mut self,
op: &ResourceOperation<'_>,
doc: &mut Edits<'_>,
path: &ExId,
) -> Result<Option<ResourceOperationStart>, String>
fn start_operation( &mut self, op: &ResourceOperation<'_>, doc: &mut Edits<'_>, path: &ExId, ) -> Result<Option<ResourceOperationStart>, String>
Admit an exported effect or view operation: the one entry every
handler implements. Document operations never enter it. Read more
§fn poll_resource_operation(
&mut self,
invocation: InvocationId,
cancellation_requested: bool,
doc: &AutoCommit,
path: &ExId,
) -> Option<InvocationUpdate>
fn poll_resource_operation( &mut self, invocation: InvocationId, cancellation_requested: bool, doc: &AutoCommit, path: &ExId, ) -> Option<InvocationUpdate>
Poll one admitted operation without blocking the UI thread. Read more
§fn take_structure_dirty(&mut self) -> bool
fn take_structure_dirty(&mut self) -> bool
True if this subtree’s structural composition (children
inserted/removed) changed since the last frame; the App rebuilds the
taffy tree when so. Reading clears it. The default drains every
retained child (no short-circuit, so no child keeps a stale flag) and
reports whether any was dirty; a leaf has no children and reports
false. A container that changes its own child list sets its own flag
and ORs it with this traversal.§fn mark_drawn(&mut self)
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 release_scene_cache(&mut self)
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 draw_overlay(
&mut self,
scene: &mut Scene,
transform: Affine,
text_renderer: &mut TextRenderer,
theme: &Theme,
presence: &PresenceCtx,
)
fn draw_overlay( &mut self, scene: &mut Scene, transform: Affine, text_renderer: &mut TextRenderer, theme: &Theme, presence: &PresenceCtx, )
Top-layer pass, run once after the whole
draw
recursion, so anything emitted here composites above every sibling
regardless of tree order — the toolkit’s overlay mechanism for
content that escapes its layout box (an open Dropdown, a
popover). Default recurses children_mut.fn apply_primary_vertical_scroll( &mut self, action: PrimaryScrollAction, ) -> PrimaryScrollResult
§fn focus_requested(&mut self, target: Option<NodeId>, tree: &TaffyTree)
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 mount_native_views(&mut self, host: &NativeViewHost<'_>)
fn mount_native_views(&mut self, host: &NativeViewHost<'_>)
Attach native child views through this owner’s retained lifecycle topology. Read more
§fn native_view_frame_start(&mut self)
fn native_view_frame_start(&mut self)
Begin a native-view frame through this owner’s retained lifecycle topology.
§fn unmount_native_views(&mut self)
fn unmount_native_views(&mut self)
Tear native children down while their parent window still exists.