Struct LiveImage 

pub struct LiveImage { /* private fields */ }

Shows a LiveImageSource. See the module documentation.

Implementations

impl LiveImage

pub fn new(source: impl Into<Prop<LiveImageSource>>) -> Self

Show source. A Signal<LiveImageSource> switches sources: the widget rebuilds and attaches the new one, keeping its handle’s Signals, and the window lets go of the old one’s texture at its next frame. A small picture its source committed once is kept a while instead, in case it comes back.

pub fn fit(self, fit: ImageFit) -> Self

How the picture fills its box: the CSS object-fit set. Default ImageFit::Contain. Cover, and None on a picture larger than the box, crop it to the box.

pub fn alignment(self, alignment: Alignment) -> Self

Where the picture sits in its box when the fit leaves room or crops. Leading and Trailing follow the layout direction. Default [Alignment::CENTER].

pub fn sizing(self, sizing: LiveImageSizing) -> Self

How the box is sized. Default LiveImageSizing::Aspect.

pub fn width(self, width: f32) -> Self

Pin the box’s width, in logical pixels; its height follows the picture’s aspect ratio (zero before the first frame).

pub fn height(self, height: f32) -> Self

Pin the box’s height, in logical pixels; its width follows the picture’s aspect ratio (zero before the first frame).

pub fn size(self, width: f32, height: f32) -> Self

Pin the box to width × height logical pixels.

pub fn device_pixels(self, on: bool) -> Self

Measure the picture’s own size in device pixels: one source pixel per device pixel instead of per logical pixel. The fit starts from that size too: ImageFit::None draws the whole picture at it, and ImageFit::ScaleDown never grows it past it. With sizing(Natural), fit(ImageFit::None) and scaling(ScalingFilter::Nearest), every texel lands on one device pixel, at any device scale. Default false.

pub fn scaling(self, scaling: ScalingFilter) -> Self

How the picture is sampled when drawn at another size. Default ScalingFilter::Linear; Nearest keeps an integer upscale crisp, and Trilinear keeps a thumbnail drawn below half size from aliasing.

pub fn orientation(self, orientation: ImageOrientation) -> Self

How the picture is turned or mirrored for display. A quarter turn swaps the width and height the box is sized from. Default ImageOrientation::Normal.

pub fn pixel_snap(self, on: bool) -> Self

Snap the picture’s edges to the device-pixel grid, which keeps a 1:1 picture sharp. An edge moves by less than one device pixel. Turn it off only for a picture whose box is animated, where that step would show: the placement is then left where the layout puts it, and the renderer does not snap a one-to-one picture either. Snapping applies under translations and scales; a rotated or skewed ancestor turns it off. Default true.

pub fn background(self, color: impl Into<ColorProp>) -> Self

The fill of the letterbox, and of the whole box while the source is not Live. A role or a Signal follows the theme and the window. Default transparent.

pub fn placeholder(self, text: impl Into<Prop<String>>) -> Self

Text shown centred in the box while the source is not Live (secondary text, body style, truncated to the box), and the node’s description then. Painted, so it takes no input. Default empty.

pub fn alt(self, text: impl Into<Prop<String>>) -> Self

The accessible name of the picture. A tr! string follows the locale. Give it, or call a11y_hidden: a debug build asserts one of them.

pub fn a11y_hidden(self) -> Self

Hide a decorative picture from assistive technology: what it shows is said by text beside it.

pub fn pause_when_inactive(self, pause: impl Into<Prop<bool>>) -> Self

Stop uploading while the window is inactive: not focused, or covered where the platform reports it. The picture keeps the last frame it uploaded and a commit no longer wakes the window; once the window is active again, the next frame shows the latest commit, in one upload. A change of size or status still applies, a picture with nothing of its size uploaded yet still gets its first frame, and a screenshot shows the latest commit all the same. The pause belongs to the window’s texture: while another widget of the window shows the same source unpaused, both stay live. A Signal<bool> turns it on and off as the user decides. Default false.

pub fn dim_when_disabled(self, on: bool) -> Self

Dim the picture in a disabled subtree, by the theme’s disabled_content_opacity over the widget’s background, which then fills the whole box. By default a live picture keeps its full strength when an ancestor is disabled: a VM’s screen is content, not a control. A commit still repaints nothing while dimmed. Default false.

pub fn with_handle(self, handle: &LiveImageHandle) -> Self

Drive this widget through handle, made beforehand with LiveImageHandle::new: the form a teksu! tree can use, where handle cannot be called. A handle follows one widget; handing it to a second moves it there.

pub fn handle(&self) -> LiveImageHandle

A handle to this widget, for the UI thread: its source’s size and status, its placement, and the mapping from widget-local points to source pixels. Take it before a WidgetBuilder method wraps the widget.

Trait Implementations

impl Debug for LiveImage

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

What the source and the window did, from atomics and the widget’s own state, never under the source’s lock: LiveImage { source: #3 "vm-screen" Bgrx8 720x1280 Live, gen: 5021, window_gen: 5019, sizing: Aspect, fit: Contain, orientation: Normal, scaling: Linear, content: (0, 0, 424, 754), paints: 4, paused: false }.

impl Widget for LiveImage

fn place_children( &self, bounds: Rect, _proposal: SizeProposal, _children: &mut [WidgetPlacement], ctx: &LayoutContext<'_>, )

The placement paint will draw and input maps through, computed once per layout: the edges snap in device space, through the widget’s window origin, its ancestors’ transforms and the device scale.

fn paint(&self, bounds: Rect, canvas: &mut Canvas, ctx: &PaintContext<'_>)

The background, then the picture’s one quad (emitted whatever the status, so the window takes the source’s commits), inside an opacity scope while dimmed, then the placeholder while the source is not Live.

fn build(&mut self, ctx: &mut BuildContext<'_>) -> Vec<WidgetId>

Compose child widgets. Called once after the widget is placed in the arena, and again whenever the widget is marked for rebuild — a BindingLevel::Rebuild binding, rebuild_single_widget, or a density switch. A theme or locale switch does not rebuild: set_theme and set_locale mark layout + paint dirty and leave the built subtree standing, so anything derived from the theme or the locale must be read per pass or bound to a signal rather than captured here. Takes &mut self — store child IDs, signal handles, any state needed later. Returns the list of root child IDs (empty for leaf widgets).

fn layout_response( &self, proposal: SizeProposal, ctx: &LayoutContext<'_>, ) -> LayoutResponse

Respond to the parent’s size proposal with this widget’s wanted size, grow/shrink weights, and compression floor (see [LayoutResponse]).

fn accessibility(&self, builder: &mut AccessNodeBuilder)

Declare this widget’s accessibility identity.

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

Downcast hook. Default implementation returns None; concrete widgets override with Some(self) when they want to expose their concrete type to test-level introspection or reflection. The trait already bounds on std::any::Any so concrete types satisfy the 'static requirement.

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

Mutable counterpart of as_any. Default returns None; widgets that want to expose mutable state to tests (e.g. so a test can mutate a Scene inside a SceneView post-layout) override with Some(self). Should follow the same opt-in pattern as as_any: only widgets that opt into & introspection should opt into &mut.

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

Concrete type name of this widget (e.g. "teksilo_widgets::button::Button"). The default implementation resolves at the impl site via std::any::type_name::<Self>(), so calls through &dyn Widget correctly dispatch to the monomorphized fn for the concrete type — getting the concrete name through the vtable without per-impl boilerplate.

fn cacheable_layout(&self) -> bool

Whether this widget’s layout_response may be memoized by the per-pass layout cache. Defaults to true.

fn wants_after_paint(&self) -> bool

Whether this widget wants its after_paint hook to fire each frame. Returning false (the default) saves a virtual call per widget per frame for the vast majority of widgets that don’t aggregate descendant geometry.

fn after_paint(&self, _view: &WidgetTreeView<'_>, _ctx: &PaintContext<'_>)

Called once per frame after this widget’s subtree has finished painting. Receives a read-only view of the layout-resolved arena so a parent can read its descendants’ final bounds — e.g. TitleBar aggregates its drag region and control-button rects into a single HitRegions payload for the Windows backend’s WM_NCHITTEST.

fn wants_post_paint(&self) -> bool

Whether this widget wants its post_paint hook to fire each frame. Returning false (the default) saves a virtual call per widget per frame for the vast majority of widgets that don’t draw a foreground over their children.

fn post_paint( &self, _bounds: Rect, _canvas: &mut Canvas, _ctx: &PaintContext<'_>, )

Draw a foreground layer over this widget’s children.

fn wants_descendant_redirects(&self) -> bool

Whether this widget wants the AT walker to consult its a11y_redirect_descendant hook for every descendant during AT tree emission, not just its direct arena children.

fn culls_children(&self) -> bool

Whether this widget decides, on every layout pass, which of its children exist at all.

fn a11y_redirect_descendant( &self, _self_id: WidgetId, _descendant: WidgetId, ) -> Option<NodeId>

Optional redirection hook for AT-tree placement of a child.

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

Suggest an accessible title to an enclosing container that wraps this widget as content — typically a modal / dialog shell that wants to propagate the inner content’s visible title as the shell’s own accessible name.

fn accessible_title_node(&self) -> Option<WidgetId>

The widget that paints this one’s title, when it has one.

fn initial_focus_hint(&self) -> Option<WidgetId>

Optional hint that directs initial focus to a specific descendant when this widget is the root of a deferred-built modal surface.

fn accessibility_proxy(&self) -> Option<WidgetId>

The descendant whose accessibility node stands for this widget.

fn context_menu_key_target(&self) -> Option<WidgetId>

Which descendant a keyboard request for a context menu should target.

fn children(&self) -> Vec<WidgetId>

Return the child widget IDs that this widget manages.

fn accessibility_children(&self) -> Option<Vec<WidgetId>>

Optional override for the child ORDER presented to assistive technology, when it must differ from the paint / z-order child order returned by children.

fn clips_children(&self) -> bool

Whether this widget clips its children to its bounds.

fn focus_reveal_rect(&self, _bounds: Rect) -> Option<Rect>

The rectangle (in absolute tree coordinates) that best represents this widget when the framework reveals it into an ancestor scroll area on focus gain. Returning None (the default) reveals the widget’s whole bounds — correct for most controls.

fn hit_shape(&self, _local_point: Point, _bounds: Rect) -> bool

Whether the point lies inside this widget’s actual shape, not just its rectangular bounds. Consulted by hit-testing right after the bounds check: returning false for a point that is inside the bounding box makes the widget transparent to the click there, so it falls through to whatever sibling is painted underneath (the same machinery as a fully pass-through node, but shape-aware).

fn accepts_child_hit(&self, _child: WidgetId, _point: Point) -> bool

Veto a hit on one of this widget’s direct children, per point.

fn hit_outset(&self, _kind: PointerKind, _tokens: &InputTokens) -> EdgeInsets

How far outside its own bounds this widget still absorbs a press, per edge, for the pointer that is asking.

fn hit_slop(&self, _kind: PointerKind, _tokens: &InputTokens) -> Option<HitSlop>

This widget’s own say in the miss-only slop pass, overriding the density default for its node.

fn hit_distance(&self, local_point: Point, bounds: Rect) -> Option<f32>

How far a missed press is from this widget’s actual silhouette, in the widget’s own bounds space.

fn target_regions(&self, _bounds: Rect) -> Vec<TargetRegion>

The interactive sub-regions this widget paints inside its own single node — a scroll bar’s thumb, a slider’s knob, a header cell’s filter affordance.

fn preserves_children_on_rebuild(&self) -> bool

How rebuild_single_widget treats this widget’s existing children when re-running its build().

fn tooltip_has_content(&self) -> bool

Whether this widget, used as tooltip content, currently has anything worth showing.

fn declare_shortcuts(&self) -> Vec<Shortcut>

Declare the rebindable keyboard shortcuts this widget exposes, without installing handlers. The framework calls this at arena insertion time (before build()) and at certain lazy boundaries (e.g. Switcher walks declarations on its not-yet-mounted Pending slots), so settings UIs and the ShortcutRegistry see the keystrokes the moment the owning container mounts — even if build() hasn’t run.

fn take_handler_set(&mut self) -> Option<HandlerSet>

Extract attached handler set from a WidgetWithHandlers wrapper. Called during arena insertion to transfer handlers to the WidgetNode. Default: returns None (no attached handlers).