Struct FocusLabel 

pub struct FocusLabel {
    pub rect: Rect,
    /* private fields */
}

A single-line caption that carries a keyboard mnemonic and hands focus to the field beside it when that mnemonic is pressed.

Mark the mnemonic with &, exactly like a MenuBar label: FocusLabel::new(rect, "Last &name:") renders Last name: with the n underlined and listens for Alt+N. When that combination is pressed anywhere in the surrounding container, focus jumps to the next focusable widget added to the same parent — the classic “buddy label” convention. Place the label immediately before the field it describes:

use saudade::*;

let form = Container::new(220, 60)
    // Alt+N focuses the field that follows…
    .add(FocusLabel::new(Rect::new(8, 8, 80, 20), "Last &name:"))
    .add(TextInput::new(Rect::new(92, 6, 120, 22)));

A FocusLabel is not itself focusable and never takes focus; it only redirects it. Without a & marker it behaves like a plain, static Label (minus word wrapping).

Fields

rect: Rect

Implementations

impl FocusLabel

pub fn new(rect: Rect, text: impl AsRef<str>) -> Self

Create a label from a rect and a &-marked caption. The character after the first unescaped & is shown underlined and bound as the mnemonic; && prints a literal ampersand.

pub fn with_color(self, color: Color) -> Self

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

pub fn with_background(self, color: Color) -> Self

Paint a solid fill across the label’s rectangle before the text — handy to keep it legible over a window background pattern. See Label::with_background.

pub fn mnemonic(&self) -> Option<char>

The mnemonic letter this label listens for, if any (ASCII-lowercased).

Trait Implementations

impl Widget for FocusLabel

fn accepts_accelerators(&self) -> bool

Listen for accelerators only when there’s a mnemonic to match — so a marker-less caption doesn’t draw keyboard traffic it will never use.

fn bounds(&self) -> Rect

Logical bounds relative to the window root, in saudade pixels.

fn layout(&mut self, bounds: Rect)

Position the widget inside the rectangle the parent has allocated.

fn paint(&mut self, painter: &mut Painter<'_>, theme: &Theme)

Render the widget in the normal pass.

fn event(&mut self, event: &Event, ctx: &mut EventCtx)

Handle a typed input event. Default: ignore.

fn paint_overlay(&mut self, _painter: &mut Painter<'_>, _theme: &Theme)

Render anything that needs to float on top of every sibling — open menu popups, tooltips, drag previews. Runs after every widget’s regular paint is finished. Default: no-op.

fn on_cancel(&mut self, _ctx: &mut EventCtx)

Called when the widget is cancelled — closed by Escape or a window’s close button (which the runtime maps to Escape), with no child consuming that Escape first — rather than dismissed by its own request. A hosting Modal calls it on its content just before tearing it down; the runtime calls it on the root widget when the main window is closed, so a dialog used directly as the window root gets the same hook. It does not fire when the content asked to be dismissed itself (e.g. an OK / Cancel button calling EventCtx::request_dismiss), since that path already chose what to commit or revert. A dialog that previews edits live overrides this to roll them back. Default: no-op.

fn captures_pointer(&self) -> bool

Internal hook for capture-on-press dispatch. Default: never captured. Implementations like Button override this so pointer events keep flowing to them while a press is in progress, even if the cursor leaves the widget’s bounds.

fn focusable(&self) -> bool

true if this widget accepts keyboard focus. The parent container remembers the last focusable widget the user clicked, and routes keyboard events only there.

fn set_focused(&mut self, _focused: bool)

Inform the widget that it has gained or lost keyboard focus. Default: ignore. Editing widgets override this to show/hide their cursor or to commit pending input.

fn popup_request(&self) -> Option<PopupRequest>

Ask the runtime to host a popup window for this widget. Returning Some makes the runtime open (or move) a borderless top-level window at the indicated logical-coord rect so the popup can extend past the main window’s edges. Container widgets propagate this from their children. Default: no popup.

fn collect_popups(&self, out: &mut Vec<PopupRequest>)

Collect every popup this widget and its descendants currently want the runtime to host, outermost first.

fn focus_first(&mut self) -> bool

Try to give keyboard focus to this widget or one of its descendants. Returns true if a focusable target was located and now holds focus.

fn wants_ticks(&self) -> bool

true if this widget needs periodic Event::Tick events to drive an animation. The runtime polls this after every dispatch and, while any widget in the tree wants ticks, fires Tick at roughly 60 Hz. Container widgets propagate from children. Default: no animation.