Struct NodeMut 

pub struct NodeMut<'a, Msg> { /* private fields */ }

Adjusts the node just added. Every method changes the node in place, so the result can be ignored or chained.

Implementations

impl<'a, Msg> NodeMut<'a, Msg>

pub fn id(self, name: impl Into<String>) -> Self

Names the node. Name widgets whose position among their siblings can change (list rows, optional widgets) so their state and focus follow them.

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

Sets the width.

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

Sets the height.

pub fn fill(self) -> Self

Takes all space left in both directions.

pub fn fill_width(self) -> Self

Takes all width left.

pub fn fill_height(self) -> Self

Takes all height left.

pub fn padding(self, padding: Padding) -> Self

Keeps padding free inside the node.

pub fn gap(self, cells: u16) -> Self

Leaves cells between the children of a row or column.

pub fn justify(self, align: Align) -> Self

Places children along the main axis of a row or column (both axes of a stack).

pub fn selectable(self, selectable: bool) -> Self

Whether a mouse drag may select text in this node. Nothing is selectable unless asked: true makes the node a selection region, so a drag that starts inside it selects text within the node only (widgets such as CodeView and Markdown are regions by themselves). false keeps selection out of the node and everything inside it, also out of regions within it, e.g. for a secret shown inside a selectable log.

pub fn align(self, align: Align) -> Self

Places children across the main axis of a row or column.

impl<Msg: Clone + 'static> NodeMut<'_, Msg>

pub fn on_action( self, scope: Scope, action: impl Into<String>, message: Msg, ) -> Self

While keyboard focus is on this node or inside it, a key bound to the keymap action action of scope sends message instead of reaching App::action.

This is how an application tells where a shortcut was pressed. With focus elsewhere the same key reaches App::action as usual, so one key can mean two things: leave a terminal while inside it, go back into it from outside. The focus in force when the key arrives decides, however it got there (tab, a click, Command::focus), so nothing has to be tracked in application state.

The innermost node that answers the action wins. The key must first get past the focused widgets: a widget that uses it (a text field typing a character) keeps it, and a Terminal lets it out only for actions named with its pass_through. The actions the runtime owns (quit, focus-next, focus-prev, debug, copy, paste, toggle-panel) are not answered here. Call once per action.

use qframe::env::Env;
use qframe::prelude::*;
use qframe::widgets::TextInput;

#[derive(Clone, Debug, PartialEq)]
enum Msg {
    Leave,
    Enter,
}

struct Editor;

impl App for Editor {
    type Msg = Msg;

    fn update(&mut self, msg: Msg) -> Command<Msg> {
        match msg {
            Msg::Leave => Command::focus("files"),
            Msg::Enter => Command::focus("note"),
        }
    }

    fn view(&self, ui: &mut View<'_, Msg>) {
        ui.add(List::new(["notes.md", "todo.md"].map(ListItem::new))).id("files");
        ui.add(TextInput::new("")).id("note").on_action(Scope::App, "switch", Msg::Leave);
    }

    // Reached only while focus is outside the note.
    fn action(&self, name: &str) -> Option<Msg> {
        (name == "switch").then_some(Msg::Enter)
    }
}

let mut env = Env::builtin();
env.keymap_mut().bind(Scope::App, "switch", &["alt+s".parse().unwrap()]);
let mut app = Harness::with_env(Editor, env, 30, 3);
app.press("alt+s");
assert!(app.is_focused("note"));
app.press("alt+s");
assert!(app.is_focused("files"));