Struct Embedded 

pub struct Embedded<W>
where
    W: Widget,
{ /* private fields */ }

A widget laid out and driven by the widget that owns it.

Implementations

impl<W> Embedded<W>

where W: Widget + 'static,

pub fn new(widget: W) -> Embedded<W>

pub fn filling(self) -> Embedded<W>

The child takes exactly the rectangle it is laid out in, rather than its content’s height: a viewport of its own (a terminal, a viewer) that scrolls inside the rectangle the owner gives it.

pub fn set_transform(&mut self, transform: Affine)

Place the child’s own space in the owner’s: layout rectangles are in the child’s space, and it is drawn, hit and its caret reported through transform (a slide’s text box scaled onto the canvas).

pub fn set_text_color(&mut self, color: Option<AlphaColor<Srgb>>)

Paint the child’s text in color rather than the theme’s (a text box coloured by its slide).

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

Where the child’s caret is, in the owner’s space, for the input method’s candidate window.

pub fn widget(&self) -> &W

The hosted widget.

pub fn widget_mut(&mut self) -> &mut W

The hosted widget, mutably.

pub fn rect(&self) -> Rect

Where the widget was last laid out, at the height it wanted, in the owner’s space.

pub fn layout( &mut self, rect: Rect, theme: &Theme, text: &mut TextRenderer, ) -> f64

Lay the widget out at rect’s width and origin, as tall as its content wants (at least rect’s height); returns that height.

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

Paint the widget where it was last laid out.

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

Paint what the widget floats over everything (its menus, a link’s popover). Call from the owner’s own draw_overlay, so it lands in the window’s top layer, above the rest of the owner’s paint.

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

The panel the child has open over everything, in the owner’s space (Widget::modal_capture): while there is one, the owner routes every pointer and key event to the child, which takes the panel’s.

pub fn handle_event( &mut self, event: &WindowEvent, scale_factor: f64, modifiers: &Modifiers, state: &mut Edits<'_>, path: &ExId, handled: &mut bool, )

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

Write what the child took up in the sync pass or left to do after its last event (Widget::settle): the formatting a keystroke closed, a toolbar’s change made outside an input event. Call from the owner’s own settle, which the host runs every frame; a child that is never settled writes those only with its next event.

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

When the child next needs a sync with no input (Widget::next_wake_deadline): a spelling squiggle settling, the suggestion for the word under the caret. The owner reports it as its own.

pub fn needs_animation_frame(&self) -> bool

Whether the child is animating (Widget::needs_animation_frame).

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

The pointer shape the child shows at point, in the owner’s space (the text beam over a text box drawn scaled onto a canvas).

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

What the child holds for the input method (Widget::ime_content).

pub fn ime_multiline(&self) -> bool

Whether the child takes line feeds as text (Widget::ime_multiline).

pub fn take_focus_request(&mut self) -> bool

Whether the child asked for keyboard focus (a press on a field) since the last call. The owner takes the host’s focus in response (*ctx.focus_target = Some(ctx.node_id)) and keeps routing keys and the input method to the child.

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

The child’s accessibility tree in the owner’s space, for a canvas that draws the child to include among its own nodes: assistive technology then reads and edits the child as it would anywhere else. The child’s own node is given its rectangle, since it has no widget of the owner’s tree to take one from.

pub fn perform_action( &mut self, action: &Action, key_path: &[u64], edits: &mut Edits<'_>, path: &(dyn Any + 'static), ) -> bool

An assistive technology operates a node of Self::accessibility: key_path is relative to the child’s own node (Widget::perform_action).

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

An assistive technology operates a node of Self::accessibility that names its target (Widget::perform_semantic_action).

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

Where the person is in the child (a caret, a selection), for the owner to publish to collaborators as its own (crate::presence::capability::PublishesPresence).

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

What the person has selected in the child, for asking an agent about it (crate::presence::capability::PublishesPresence::shared_selection).

pub fn sync(&mut self, state: &AutoCommit, path: &ExId)

Bring the widget up to date with the document.