Skip to main content

Window

Struct Window 

Source
pub struct Window(/* private fields */);
Expand description

Top-level window. Children added with other widgets’ new(&window, ..). A handle to a Window; Copy, and inert once the widget is destroyed.

Implementations§

Source§

impl Window

Source

pub fn new(title: &str) -> Window

A hidden top-level window; add widgets to it and call Window::show.

Examples found in repository?
examples/hello.rs (line 5)
3fn main() {
4    let app = App::new("hello").expect("init");
5    let win = Window::new("Hello, rungui");
6    let col = VBox::new(win);
7    let label = Label::new(col, "Hello, wörld! こんにちは");
8    let name = TextInput::new(col);
9    name.set_placeholder("Your name");
10    let button = Button::new(col, "Greet");
11    button.on_click(move || label.set_text(&format!("Hello, {}!", name.text())));
12    win.show();
13    app.run();
14}
More examples
Hide additional examples
examples/smoke_layout.rs (line 8)
6fn main() {
7    let app = App::new("smoke-layout").expect("init");
8    let w = Window::new("smoke-layout");
9    w.set_position(120, 90);
10    let col = VBox::new(w);
11    let mono = TextInput::new(col);
12    mono.set_monospace(true);
13    mono.set_text("monospace entry");
14    let hs = Splitter::new(col, Orientation::Horizontal);
15    hs.set_position(200);
16    hs.set_min_pane_sizes(60, 60);
17    let area = TextArea::new(hs);
18    area.set_monospace(true);
19    area.set_wrap(false);
20    area.set_text("a long line that does not wrap: 0123456789 0123456789 0123456789 0123456789\n");
21    let table = Table::new(hs);
22    table.set_columns(&[Column::new("Name").width(80), Column::new("Size")]);
23    table.set_rows(&[vec!["a", "1"], vec!["b", "2"]]);
24    let vs = Splitter::new(col, Orientation::Vertical);
25    let tree = Tree::new(vs);
26    let r = tree.add(None, "root");
27    tree.add(Some(r), "kid");
28    let list = ListBox::new(vs);
29    list.set_items(&["one", "two"]);
30    table.on_select(|i| println!("TABLE_SEL {i:?}"));
31    tree.on_select(|n| println!("TREE_SEL {}", n.is_some()));
32    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
33    hs.on_move(|p| println!("HSPLIT {p}"));
34    vs.on_move(|p| println!("VSPLIT {p}"));
35    w.on_move(|x, y| println!("MOVED {x} {y}"));
36    w.on_resize(|w, h| println!("RESIZED {w} {h}"));
37    w.on_close(|| {
38        App::quit();
39        true
40    });
41    w.show();
42    let _t = Timer::once(600, move || {
43        println!("POS {:?}", w.position());
44        for (n, b) in [
45            ("hs", hs.bounds()),
46            ("vs", vs.bounds()),
47            ("table", table.bounds()),
48            ("tree", tree.bounds()),
49            ("area", area.bounds()),
50        ] {
51            println!("BOUNDS {n} {} {} {} {}", b.x, b.y, b.w, b.h);
52        }
53        println!("HPOS {} VPOS {}", hs.position(), vs.position());
54        println!(
55            "MONO {} {} WRAP {}",
56            mono.monospace(),
57            area.monospace(),
58            area.wrap()
59        );
60        println!("READY");
61    });
62    app.run();
63    println!("BYE");
64}
examples/smoke_dialogs.rs (line 7)
5fn main() {
6    let app = App::new("smoke-dialogs").expect("init");
7    let win = Window::new("smoke-dialogs");
8    let col = VBox::new(win);
9    let field = TextInput::new(col);
10    field.on_activate(|| println!("ACTIVATE"));
11    let ask = Button::new(col, "Ask");
12    ask.on_click(move || {
13        let r = Prompt::new("Rename").message("New name?").initial("old").run(Some(win));
14        println!("PROMPT {r:?}");
15    });
16    let modal = Button::new(col, "Modal");
17    modal.on_click(move || {
18        let d = Window::new("smoke-modal");
19        Label::new(d, "modal window");
20        let close = Button::new(d, "Close");
21        close.on_click(move || d.hide());
22        d.on_cancel(move || {
23            println!("MODAL_CANCEL");
24            d.hide();
25        });
26        println!("MODAL_OPEN");
27        d.run_modal(Some(win));
28        println!("MODAL_DONE");
29        d.destroy();
30    });
31    let list = ListBox::new(col);
32    list.set_items(&["one", "two", "three", "four", "five"]);
33    list.set_multi_select(true);
34    list.on_selection(|s| println!("LIST_SEL {s:?}"));
35    let table = Table::new(col);
36    table.set_columns(&[Column::new("Name").width(100)]);
37    table.set_rows(&[vec!["a"], vec!["b"], vec!["c"], vec!["d"]]);
38    table.set_multi_select(true);
39    table.on_selection(|s| println!("TABLE_SEL {s:?}"));
40    let cal = Calendar::new(col);
41    cal.set_date(Date::new(2031, 7, 4).unwrap());
42    cal.on_change(|d| println!("DATE {}-{:02}-{:02}", d.year, d.month, d.day));
43    win.on_close(|| {
44        App::quit();
45        true
46    });
47    win.show();
48    println!("TODAY {:?}", Date::today().is_valid());
49    let _t = Timer::once(600, move || {
50        for (n, w) in [
51            ("field", field.bounds()),
52            ("ask", ask.bounds()),
53            ("modal", modal.bounds()),
54            ("list", list.bounds()),
55            ("table", table.bounds()),
56            ("cal", cal.bounds()),
57        ] {
58            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
59        }
60        println!("READY");
61    });
62    let _exit = std::env::var("RUNGUI_EXIT_AFTER_MS")
63        .ok()
64        .and_then(|v| v.parse::<u32>().ok())
65        .map(|ms| Timer::once(ms, App::quit));
66    app.run();
67    println!("BYE");
68}
examples/smoke_controls.rs (line 7)
5fn main() {
6    let app = App::new("smoke").expect("init");
7    let a = Window::new("smoke-a");
8    let col = VBox::new(a);
9    let btn = Button::new(col, "Press ünï");
10    let txt = TextInput::new(col);
11    let chk = CheckBox::new(col, "Check");
12    let list = ListBox::new(col);
13    list.set_items(&["one", "two", "three"]);
14    let slider = Slider::new(col, 0.0, 100.0);
15    let combo = ComboBox::new(col);
16    combo.set_items(&["x", "y"]);
17    let dlg = Button::new(col, "Dialog");
18    dlg.on_click(move || {
19        let r = message_box(
20            Some(a),
21            MessageKind::Question,
22            Buttons::YesNo,
23            "Title ü",
24            "Really?",
25        );
26        println!("DIALOG {r:?}");
27    });
28    let g = RadioGroup::new();
29    let ra = RadioButton::new(col, &g, "Ra");
30    let rb = RadioButton::new(col, &g, "Rb");
31    ra.set_checked(true);
32    ra.on_toggle(|v| println!("RA {v}"));
33    rb.on_toggle(|v| println!("RB {v}"));
34    let table = Table::new(col);
35    table.set_columns(&[
36        Column::new("Name").width(80).sortable(true),
37        Column::new("Size").align(ColumnAlign::Right),
38    ]);
39    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
40    table.on_select(|i| println!("TABLE_SEL {i:?}"));
41    table.on_column_click(|c| println!("TABLE_COL {c}"));
42    let tree = Tree::new(col);
43    let root = tree.add(None, "root");
44    let kid = tree.add(Some(root), "kid");
45    let lazy = tree.add(None, "lazy");
46    tree.set_has_children(lazy, true);
47    let _ = kid;
48    tree.on_select(|n| println!("TREE_SEL {}", n.is_some()));
49    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
50    a.set_context_menu({
51        let p = PopupMenu::new();
52        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
53        p
54    });
55    btn.on_click(|| println!("CLICK"));
56    txt.on_change(|t| println!("TEXT {t}"));
57    chk.on_toggle(|b| println!("TOGGLE {b}"));
58    list.on_select(|i| println!("SELECT {i:?}"));
59    slider.on_change(|v| println!("VALUE {v:.0}"));
60    combo.on_select(|i| println!("COMBO {i:?}"));
61    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
62    a.on_close(|| {
63        println!("CLOSE_REQUESTED");
64        true
65    });
66
67    let b = Window::new("smoke-b");
68    let bar = MenuBar::new(b);
69    let file = Menu::new(bar, "File");
70    let item = MenuItem::new(file, "Quit");
71    item.set_accel("Ctrl+Q");
72    item.on_click(|| {
73        println!("MENU_QUIT");
74        App::quit();
75    });
76    let ck = CheckMenuItem::new(file, "Flag");
77    ck.on_toggle(|v| println!("MENUTOGGLE {v}"));
78    Label::new(b, "second window");
79
80    a.show();
81    b.show();
82    println!(
83        "HANDLE {}",
84        a.native_handle().is_some() && btn.native_handle().is_some()
85    );
86    let _t = Timer::once(600, move || {
87        for (n, w) in [
88            ("btn", btn.bounds()),
89            ("txt", txt.bounds()),
90            ("chk", chk.bounds()),
91            ("list", list.bounds()),
92            ("slider", slider.bounds()),
93            ("combo", combo.bounds()),
94            ("dlg", dlg.bounds()),
95            ("rb", rb.bounds()),
96            ("table", table.bounds()),
97            ("tree", tree.bounds()),
98        ] {
99            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
100        }
101        println!("READY");
102    });
103    // CI: RUNGUI_EXIT_AFTER_MS=n quits the loop after n ms so a startup crash shows up as a failure.
104    let _exit = std::env::var("RUNGUI_EXIT_AFTER_MS")
105        .ok()
106        .and_then(|v| v.parse::<u32>().ok())
107        .map(|ms| Timer::once(ms, App::quit));
108    app.run();
109    println!("BYE");
110}
examples/smoke_cocoa.rs (line 8)
6fn main() {
7    let app = App::new("smoke-cocoa").expect("init");
8    let a = Window::new("cc-a");
9    let bar = MenuBar::new(a);
10    let file = Menu::new(bar, "File");
11    let flag = CheckMenuItem::new(file, "Flag");
12    flag.set_accel("Ctrl+K");
13    flag.on_toggle(|v| println!("MENUTOGGLE {v}"));
14    let go = MenuItem::new(file, "Go");
15    go.set_accel("Ctrl+Shift+G");
16    go.on_click(|| println!("MENU_GO"));
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(|| {
20        println!("MENU_QUIT");
21        App::quit();
22    });
23
24    let col = VBox::new(a);
25    let row = HBox::new(col);
26    let btn = Button::new(row, "Press ünï");
27    let spin = SpinBox::new(row, 0.0, 10.0, 1.0);
28    let txt = TextInput::new(col);
29    let chk = CheckBox::new(col, "Monospace");
30    let hs = Splitter::new(col, Orientation::Horizontal);
31    let ta1 = TextArea::new(hs);
32    let ta2 = TextArea::new(hs);
33    ta2.set_text(
34        "long line without wrapping: 0123456789 0123456789 0123456789 0123456789 0123456789",
35    );
36    ta2.set_wrap(false);
37    hs.set_position(200);
38    hs.set_min_pane_sizes(60, 60);
39    let slider = Slider::new(col, 0.0, 100.0);
40    let combo = ComboBox::new(col);
41    combo.set_items(&["x", "y", "z"]);
42    let tabs = Tabs::new(col);
43    let p1 = tabs.add_page("First");
44    let p2 = tabs.add_page("Second");
45    Label::new(p1, "page one");
46    Label::new(p2, "page two");
47    let vs = Splitter::new(col, Orientation::Vertical);
48    let table = Table::new(vs);
49    table.set_columns(&[
50        Column::new("Name").width(80).sortable(true),
51        Column::new("Size").align(ColumnAlign::Right),
52    ]);
53    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
54    let tree = Tree::new(vs);
55    let root = tree.add(None, "root");
56    tree.add(Some(root), "kid");
57    let lazy = tree.add(None, "lazy");
58    tree.set_has_children(lazy, true);
59    vs.set_position(100);
60    vs.set_min_pane_sizes(40, 40);
61
62    btn.on_click(|| println!("CLICK"));
63    spin.on_change(|v| println!("SPIN {v}"));
64    txt.on_change(|t| println!("TEXT {t}"));
65    ta1.on_change(|t| println!("AREA {}", t.replace('\n', "|")));
66    chk.on_toggle(move |on| {
67        println!("MONO {on}");
68        txt.set_monospace(on);
69        ta1.set_monospace(on);
70    });
71    hs.on_move(|p| println!("HSPLIT {p}"));
72    vs.on_move(|p| println!("VSPLIT {p}"));
73    slider.on_change(|v| println!("VALUE {v:.0}"));
74    combo.on_select(|i| println!("COMBO {i:?}"));
75    tabs.on_select(|i| println!("TAB {i:?}"));
76    table.on_select(|i| println!("TABLE_SEL {i:?}"));
77    table.on_column_click(move |c| {
78        let ascending = table.sort_indicator() != Some((c, true));
79        let mut rows = table.rows();
80        rows.sort_by(|x, y| x[c].cmp(&y[c]));
81        if !ascending {
82            rows.reverse();
83        }
84        table.set_rows(&rows);
85        table.set_sort_indicator(Some((c, ascending)));
86        println!(
87            "TABLE_COL {c} {} {}",
88            if ascending { "asc" } else { "desc" },
89            rows[0][0]
90        );
91    });
92    tree.on_select(move |n| println!("TREE_SEL {}", n.is_some()));
93    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
94    a.set_context_menu({
95        let p = PopupMenu::new();
96        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
97        p
98    });
99    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
100    a.on_move(|x, y| println!("MOVED {x} {y}"));
101    a.set_min_size(300, 400);
102    a.set_position(220, 100);
103    a.set_size(560, 700);
104    a.on_close(|| {
105        println!("CLOSE_REQUESTED");
106        true
107    });
108    a.show();
109    println!(
110        "HANDLE {}",
111        a.native_handle().is_some() && btn.native_handle().is_some()
112    );
113    let _t = Timer::once(700, move || {
114        for (n, w) in [
115            ("btn", btn.bounds()),
116            ("spin", spin.bounds()),
117            ("txt", txt.bounds()),
118            ("chk", chk.bounds()),
119            ("hs", hs.bounds()),
120            ("slider", slider.bounds()),
121            ("combo", combo.bounds()),
122            ("tabs", tabs.bounds()),
123            ("vs", vs.bounds()),
124            ("table", table.bounds()),
125            ("tree", tree.bounds()),
126        ] {
127            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
128        }
129        println!("SPLITPOS h {} v {}", hs.position(), vs.position());
130        println!("READY");
131    });
132    app.run();
133    println!("BYE");
134}
examples/file_manager/app.rs (line 163)
162pub fn build(opts: Options) -> Rc<Fm> {
163    let win = Window::new("File Manager");
164    win.set_size(1000, 700);
165    win.set_min_size(640, 420);
166
167    // ---- menus (accelerators are the keyboard interface; there is no key-event API)
168    let bar = MenuBar::new(win);
169    let file = Menu::new(bar, "File");
170    let new_folder = MenuItem::new(file, "New Folder");
171    new_folder.set_accel("F7");
172    let rename = MenuItem::new(file, "Rename");
173    rename.set_accel("F2");
174    MenuSeparator::new(file);
175    let copy = MenuItem::new(file, "Copy to Other Pane");
176    copy.set_accel("F5");
177    let mv = MenuItem::new(file, "Move to Other Pane");
178    mv.set_accel("F6");
179    let delete = MenuItem::new(file, "Delete");
180    delete.set_accel("F8");
181    MenuSeparator::new(file);
182    let quit = MenuItem::new(file, "Quit");
183    quit.set_accel("Ctrl+Q");
184    let view = Menu::new(bar, "View");
185    let hidden = CheckMenuItem::new(view, "Show Hidden Files");
186    hidden.set_accel("Ctrl+H");
187    let refresh_item = MenuItem::new(view, "Refresh");
188    refresh_item.set_accel("Ctrl+R");
189    let go = Menu::new(bar, "Go");
190    let up_item = MenuItem::new(go, "Up One Level");
191    up_item.set_accel("Alt+Up");
192    let home_item = MenuItem::new(go, "Home Folder");
193    home_item.set_accel("Alt+Home");
194    let switch = MenuItem::new(go, "Switch Active Pane");
195    switch.set_accel("F9");
196    let helpm = Menu::new(bar, "Help");
197    let about = MenuItem::new(helpm, "About");
198
199    // ---- layout
200    let root = VBox::new(win);
201    root.set_spacing(6);
202    root.set_expand(1.0); // a window stacks its children vertically; give the whole area to this one
203
204    let tools = HBox::new(root);
205    tools.set_spacing(6);
206    let up = Button::new(tools, "\u{2191} Up");
207    up.set_tooltip("Go to the parent folder (Alt+Up)");
208    let refresh = Button::new(tools, "Refresh");
209    refresh.set_tooltip("Reload both panes (Ctrl+R)");
210    let path = TextInput::new(tools);
211    path.set_expand(1.0);
212    path.set_monospace(true);
213    path.set_tooltip("Type a folder path to open it in the active pane");
214    path.set_a11y_name("Path of the active pane");
215    let copy_btn = Button::new(tools, "Copy \u{2192}");
216    copy_btn.set_tooltip("Copy the selected item to the other pane (F5)");
217    let move_btn = Button::new(tools, "Move \u{2192}");
218    move_btn.set_tooltip("Move the selected item to the other pane (F6)");
219
220    let body = Splitter::new(root, Orientation::Horizontal);
221    body.set_expand(1.0);
222    let tree = Tree::new(body);
223    tree.set_a11y_name("Folders");
224    let right = Splitter::new(body, Orientation::Vertical);
225    let panes = Splitter::new(right, Orientation::Horizontal);
226    let mut tables = Vec::new();
227    let mut pane_labels = Vec::new();
228    for (i, n) in PANE_NAMES.iter().enumerate() {
229        let col = VBox::new(panes);
230        col.set_spacing(2);
231        pane_labels.push(Label::new(col, ""));
232        let t = Table::new(col);
233        t.set_expand(1.0);
234        t.set_a11y_name(&format!("Files, pane {n}"));
235        t.set_columns(&[
236            Column::new("Name").width(125).sortable(true),
237            Column::new("Size")
238                .width(62)
239                .align(ColumnAlign::Right)
240                .sortable(true),
241            Column::new("Modified").width(128).sortable(true),
242            Column::new("Kind").width(90).sortable(true),
243        ]);
244        let _ = i;
245        tables.push(t);
246    }
247    let pv = VBox::new(right);
248    pv.set_spacing(2);
249    let preview_title = Label::new(pv, "Preview");
250    let pv_row = HBox::new(pv);
251    pv_row.set_expand(1.0);
252    let image = Image::new(pv_row);
253    image.set_visible(false);
254    image.set_align(Align::Start);
255    let preview = TextArea::new(pv_row);
256    preview.set_expand(1.0);
257    preview.set_read_only(true);
258    preview.set_monospace(true);
259    preview.set_wrap(false);
260    preview.set_a11y_name("Preview");
261
262    let sbar = HBox::new(root);
263    let status = Label::new(sbar, "");
264    status.set_expand(1.0);
265    let tag = Label::new(sbar, "");
266
267    body.set_position(170);
268    body.set_min_pane_sizes(100, 300);
269    right.set_position(400);
270    right.set_min_pane_sizes(120, 80);
271    panes.set_min_pane_sizes(180, 180);
272
273    // ---- context menu shared by both tables
274    let popup = PopupMenu::new();
275    let ctx_open = MenuItem::new(popup, "Open");
276    let ctx_rename = MenuItem::new(popup, "Rename...");
277    let ctx_delete = MenuItem::new(popup, "Delete...");
278    MenuSeparator::new(popup);
279    let ctx_copy = MenuItem::new(popup, "Copy to Other Pane");
280    let ctx_new = MenuItem::new(popup, "New Folder...");
281    for t in &tables {
282        t.set_context_menu(popup);
283    }
284
285    let ui = Ui {
286        win,
287        body,
288        right,
289        panes,
290        tree,
291        tables: [tables[0], tables[1]],
292        pane_labels: [pane_labels[0], pane_labels[1]],
293        path,
294        up,
295        refresh,
296        copy_btn,
297        move_btn,
298        preview_title,
299        preview,
300        image,
301        status,
302        tag,
303        popup,
304        items: Items {
305            new_folder,
306            rename,
307            copy,
308            mv,
309            delete,
310            quit,
311            hidden,
312            refresh: refresh_item,
313            up: up_item,
314            home: home_item,
315            switch,
316            about,
317            ctx_open,
318            ctx_rename,
319            ctx_delete,
320            ctx_copy,
321            ctx_new,
322        },
323    };
324    let fm = Rc::new(Fm {
325        ui,
326        st: RefCell::new(State::default()),
327        quiet: Cell::new(0),
328        typing: Cell::new(false),
329        dialog_ui: Cell::new(None),
330    });
331    fm.wire();
332    fm.init_tree();
333    {
334        let mut st = fm.st.borrow_mut();
335        for p in &opts.dirs {
336            st.panes.push(Pane {
337                path: p.clone(),
338                entries: vec![],
339                sort: (SortKey::Name, true),
340                mtime: None,
341                truncated: false,
342            });
343        }
344    }
345    for (i, p) in opts.dirs.iter().enumerate() {
346        if !fm.navigate(i, p.clone(), None, true, false) {
347            // an unreadable start directory falls back to the home folder, then to "/"
348            let fallback = home_dir().unwrap_or_else(|| PathBuf::from("/"));
349            fm.navigate(i, fallback, None, true, false);
350        }
351    }
352    fm.set_active(0);
353    let first = fm.path_of(0);
354    fm.tree_reveal(&first);
355    fm.ui.win.show();
356    fm
357}
358
359impl Fm {
360    fn wire(self: &Rc<Self>) {
361        let u = &self.ui;
362        let it = u.items;
363        macro_rules! click {
364            ($btn:expr, $f:ident) => {{
365                let fm = self.clone();
366                $btn.on_click(move || fm.$f());
367            }};
368        }
369        click!(it.new_folder, op_new_folder);
370        click!(it.ctx_new, op_new_folder);
371        click!(it.rename, op_rename);
372        click!(it.ctx_rename, op_rename);
373        click!(it.delete, op_delete);
374        click!(it.ctx_delete, op_delete);
375        click!(it.copy, op_copy);
376        click!(it.ctx_copy, op_copy);
377        click!(u.copy_btn, op_copy);
378        click!(it.mv, op_move);
379        click!(u.move_btn, op_move);
380        click!(it.ctx_open, op_open);
381        click!(it.refresh, refresh_all);
382        click!(u.refresh, refresh_all);
383        click!(it.up, go_up);
384        click!(u.up, go_up);
385        click!(it.home, go_home);
386        click!(it.switch, switch_pane);
387        click!(it.about, about);
388        it.quit.on_click(App::quit);
389        {
390            let fm = self.clone();
391            it.hidden.on_toggle(move |on| fm.set_show_hidden(on));
392        }
393        for i in 0..2 {
394            let t = u.tables[i];
395            let fm = self.clone();
396            t.on_select(move |r| fm.on_row_selected(i, r));
397            let fm = self.clone();
398            t.on_activate(move |r| fm.on_row_activated(i, r));
399            let fm = self.clone();
400            t.on_column_click(move |c| fm.sort_by_column(i, c));
401            let fm = self.clone();
402            t.on_context_menu(move |_, _| fm.prepare_context_menu(i));
403        }
404        {
405            let fm = self.clone();
406            u.path.on_change(move |text| fm.on_path_typed(text));
407        }
408        {
409            let fm = self.clone();
410            u.tree.on_select(move |n| fm.on_tree_selected(n));
411            let fm = self.clone();
412            u.tree.on_expand(move |n, open| {
413                if open {
414                    fm.tree_load(n);
415                }
416            });
417        }
418        {
419            let fm = self.clone();
420            u.win.on_resize(move |w, h| {
421                trace!("RESIZE {w} {h}");
422                fm.relabel_soon();
423            });
424            for sp in [u.body, u.right, u.panes] {
425                let fm = self.clone();
426                sp.on_move(move |_| fm.relabel_soon());
427            }
428        }
429        // pick up changes made by other programs
430        let fm = self.clone();
431        Timer::every(1500, move || fm.poll());
432        // report geometry once the first layout has happened
433        let fm = self.clone();
434        Timer::once(500, move || {
435            fm.print_bounds();
436            trace!("READY");
437        });
438    }
439
440    // ---------------------------------------------------------------- state helpers
441
442    pub fn path_of(&self, pane: usize) -> PathBuf {
443        self.st
444            .borrow()
445            .panes
446            .get(pane)
447            .map(|p| p.path.clone())
448            .unwrap_or_default()
449    }
450
451    pub fn active(&self) -> usize {
452        self.st.borrow().active
453    }
454
455    fn entry_at(&self, pane: usize, row: usize) -> Option<Entry> {
456        self.st.borrow().panes.get(pane)?.entries.get(row).cloned()
457    }
458
459    /// The selected entry of `pane`, or None (nothing selected). The ".." row counts.
460    pub fn selected(&self, pane: usize) -> Option<Entry> {
461        let row = self.ui.tables[pane].selected()?;
462        self.entry_at(pane, row)
463    }
464
465    /// The selected real item (not "..") of the active pane.
466    fn target(&self) -> Option<Entry> {
467        self.selected(self.active()).filter(|e| !e.is_parent)
468    }
469
470    pub fn say(&self, msg: &str) {
471        self.ui.status.set_text(msg);
472        trace!("STATUS {msg}");
473    }
474
475    fn quietly<R>(&self, f: impl FnOnce() -> R) -> R {
476        self.quiet.set(self.quiet.get() + 1);
477        let r = f();
478        self.quiet.set(self.quiet.get() - 1);
479        r
480    }
481
482    // ---------------------------------------------------------------- navigation
483
484    /// Show `path` in `pane`. `select` picks a row afterwards (e.g. the folder we came from).
485    /// `reveal` also selects the folder in the tree. Returns false (and says why) on failure.
486    pub fn navigate(
487        self: &Rc<Self>,
488        pane: usize,
489        path: PathBuf,
490        select: Option<PathBuf>,
491        reveal: bool,
492        from_box: bool,
493    ) -> bool {
494        let hidden = self.st.borrow().show_hidden;
495        let listing = match fsm::read_dir(&path, hidden) {
496            Ok(l) => l,
497            Err(e) => {
498                self.say(&format!("Cannot open {}: {}", path.display(), e));
499                trace!("ERROR NAV {} {}", PANE_NAMES[pane], path.display());
500                return false;
501            }
502        };
503        let n = listing.entries.len();
504        let truncated = listing.truncated;
505        {
506            let mut st = self.st.borrow_mut();
507            let Some(p) = st.panes.get_mut(pane) else {
508                return false;
509            };
510            let mut entries = listing.entries;
511            fsm::sort_entries(&mut entries, p.sort.0, p.sort.1);
512            if let Some(parent) = Entry::parent_of(&path) {
513                entries.insert(0, parent);
514            }
515            p.mtime = std::fs::metadata(&path).and_then(|m| m.modified()).ok();
516            p.entries = entries;
517            p.path = path.clone();
518            p.truncated = truncated;
519        }
520        self.populate(pane, select.as_deref());
521        self.typing.set(from_box);
522        self.set_active(pane);
523        self.refresh_labels();
524        self.typing.set(false);
525        if reveal {
526            self.tree_reveal(&path);
527        }
528        // select + preview the requested row, else preview the directory itself
529        let row = select.and_then(|s| {
530            self.st.borrow().panes[pane]
531                .entries
532                .iter()
533                .position(|e| e.path == s)
534        });
535        match row {
536            Some(r) => self.on_row_selected(pane, Some(r)),
537            None => {
538                self.show_preview(Entry::from_path(&path));
539                self.update_status();
540            }
541        }
542        trace!("NAV {} {} {}", PANE_NAMES[pane], path.display(), n);
543        if truncated {
544            self.say(&format!(
545                "Showing only the first {} entries of {}",
546                fsm::MAX_ENTRIES,
547                path.display()
548            ));
549        }
550        true
551    }
552
553    /// Re-read `pane`, keeping the selected item selected when it still exists.
554    fn reload(self: &Rc<Self>, pane: usize, keep: Option<PathBuf>) {
555        let path = self.path_of(pane);
556        let keep = keep.or_else(|| self.selected(pane).map(|e| e.path));
557        if self.navigate_quiet(pane, &path, keep.clone()) {
558            return;
559        }
560        // the directory vanished: climb to the nearest one that exists
561        let mut p = path.clone();
562        while let Some(parent) = p.parent().map(Path::to_path_buf) {
563            if parent.is_dir() && self.navigate(pane, parent.clone(), Some(p.clone()), true, false)
564            {
565                return;
566            }
567            p = parent;
568        }
569    }
570
571    /// Like `navigate` for the same directory but without the active-pane, tree and preview churn
572    /// unless the selection changed. Returns false if the directory cannot be read.
573    fn navigate_quiet(self: &Rc<Self>, pane: usize, path: &Path, keep: Option<PathBuf>) -> bool {
574        let hidden = self.st.borrow().show_hidden;
575        let Ok(listing) = fsm::read_dir(path, hidden) else {
576            return false;
577        };
578        {
579            let mut st = self.st.borrow_mut();
580            let p = &mut st.panes[pane];
581            let mut entries = listing.entries;
582            fsm::sort_entries(&mut entries, p.sort.0, p.sort.1);
583            if let Some(parent) = Entry::parent_of(path) {
584                entries.insert(0, parent);
585            }
586            p.mtime = std::fs::metadata(path).and_then(|m| m.modified()).ok();
587            p.entries = entries;
588            p.truncated = listing.truncated;
589        }
590        self.populate(pane, keep.as_deref());
591        if pane == self.active() {
592            let row = keep.and_then(|s| {
593                self.st.borrow().panes[pane]
594                    .entries
595                    .iter()
596                    .position(|e| e.path == s)
597            });
598            self.show_preview(
599                row.and_then(|r| self.entry_at(pane, r))
600                    .or_else(|| Entry::from_path(path)),
601            );
602        }
603        self.update_status();
604        true
605    }
606
607    #[allow(dead_code)] // used by tests/file_manager_mock.rs
608    /// Test helper: navigate without touching the tree.
609    pub fn navigate_for_test(self: &Rc<Self>, pane: usize, path: PathBuf) -> bool {
610        self.navigate(pane, path, None, false, false)
611    }
612
613    pub fn refresh_all(self: &Rc<Self>) {
614        for i in 0..2 {
615            self.reload(i, None);
616        }
617        self.say("Refreshed");
618        trace!("REFRESH");
619    }
620
621    /// Timer: reload panes whose directory changed on disk.
622    fn poll(self: &Rc<Self>) {
623        #[allow(clippy::needless_range_loop)]
624        for i in 0..2 {
625            let (path, old) = {
626                let st = self.st.borrow();
627                match st.panes.get(i) {
628                    Some(p) => (p.path.clone(), p.mtime),
629                    None => return,
630                }
631            };
632            let now = std::fs::metadata(&path).and_then(|m| m.modified()).ok();
633            if now != old {
634                trace!("CHANGED {}", PANE_NAMES[i]);
635                self.reload(i, None);
636            }
637        }
638    }
639
640    pub fn go_up(self: &Rc<Self>) {
641        let a = self.active();
642        let cur = self.path_of(a);
643        if let Some(parent) = cur.parent() {
644            self.navigate(a, parent.to_path_buf(), Some(cur.clone()), true, false);
645        }
646    }
647
648    fn go_home(self: &Rc<Self>) {
649        if let Some(h) = home_dir() {
650            let a = self.active();
651            self.navigate(a, h, None, true, false);
652        }
653    }
654
655    fn switch_pane(self: &Rc<Self>) {
656        let other = 1 - self.active();
657        self.set_active(other);
658        self.ui.tables[other].focus();
659    }
660
661    fn set_show_hidden(self: &Rc<Self>, on: bool) {
662        self.st.borrow_mut().show_hidden = on;
663        trace!("HIDDEN {on}");
664        for i in 0..2 {
665            self.reload(i, None);
666        }
667        // rebuild the folder tree so hidden folders appear or vanish too
668        self.init_tree();
669        let a = self.active();
670        let p = self.path_of(a);
671        self.tree_reveal(&p);
672    }
673
674    fn on_path_typed(self: &Rc<Self>, text: &str) {
675        if self.typing.get() {
676            return;
677        }
678        let a = self.active();
679        let t = text.trim();
680        if t.is_empty() || Path::new(t) == self.path_of(a) {
681            return;
682        }
683        let p = PathBuf::from(t);
684        if p.is_dir() {
685            self.navigate(a, p, None, true, true);
686        }
687    }
688
689    pub fn set_active(&self, pane: usize) {
690        let changed = {
691            let mut st = self.st.borrow_mut();
692            let c = st.active != pane;
693            st.active = pane;
694            c
695        };
696        self.refresh_labels();
697        if changed {
698            trace!("ACTIVE {}", PANE_NAMES[pane]);
699        }
700    }
701
702    /// The pane captions depend on the pane widths, which are known only after layout.
703    fn relabel_soon(self: &Rc<Self>) {
704        let fm = self.clone();
705        Timer::once(10, move || fm.refresh_labels());
706    }
707
708    /// Pane captions, path box, window title and the active-pane tag.
709    fn refresh_labels(&self) {
710        let (active, paths) = {
711            let st = self.st.borrow();
712            (
713                st.active,
714                st.panes.iter().map(|p| p.path.clone()).collect::<Vec<_>>(),
715            )
716        };
717        for (i, p) in paths.iter().enumerate() {
718            let mark = if i == active { "\u{25B6}" } else { " " };
719            // labels do not clip, so fit the path to the pane (about 7 px per character)
720            let room = (self.ui.tables[i].bounds().w / 7).max(12) as usize;
721            let head = format!("{mark} {}  ", PANE_NAMES[i]);
722            let path = fsm::ellipsize_path(
723                &p.display().to_string(),
724                room.saturating_sub(head.chars().count()),
725            );
726            self.ui.pane_labels[i].set_text(&format!("{head}{path}"));
727        }
728        let cur = paths.get(active).cloned().unwrap_or_default();
729        let text = cur.display().to_string();
730        if self.ui.path.text() != text && !self.typing.get() {
731            self.ui.path.set_text(&text);
732        }
733        let name = cur
734            .file_name()
735            .map(|n| n.to_string_lossy().into_owned())
736            .unwrap_or_else(|| text.clone());
737        self.ui
738            .win
739            .set_title(&format!("{name} [{}] - File Manager", PANE_NAMES[active]));
740        self.ui
741            .tag
742            .set_text(&format!("  Active pane: {}", PANE_NAMES[active]));
743        self.ui.up.set_enabled(cur.parent().is_some());
744    }
745
746    // ---------------------------------------------------------------- table
747
748    /// Fill a pane's table from its entries. Uses one `batch` so huge directories send one update.
749    fn populate(&self, pane: usize, select: Option<&Path>) {
750        let (rows, sort, sel) = {
751            let st = self.st.borrow();
752            let p = &st.panes[pane];
753            let rows: Vec<Vec<String>> = p.entries.iter().map(row_of).collect();
754            (
755                rows,
756                p.sort,
757                select.and_then(|s| p.entries.iter().position(|e| e.path == s)),
758            )
759        };
760        let t = self.ui.tables[pane];
761        self.quietly(|| {
762            t.batch(|t| t.set_rows(&rows));
763            t.set_sort_indicator(Some((sort.0.column(), sort.1)));
764            t.set_selected(sel);
765        });
766    }
767
768    fn sort_by_column(self: &Rc<Self>, pane: usize, col: usize) {
769        let key = SortKey::from_column(col);
770        let keep = self.selected(pane).map(|e| e.path);
771        {
772            let mut st = self.st.borrow_mut();
773            let Some(p) = st.panes.get_mut(pane) else {
774                return;
775            };
776            let asc = if p.sort.0 == key { !p.sort.1 } else { true };
777            p.sort = (key, asc);
778            let has_parent = p.entries.first().is_some_and(|e| e.is_parent);
779            fsm::sort_entries(&mut p.entries[has_parent as usize..], key, asc);
780        }
781        self.populate(pane, keep.as_deref());
782        let (k, asc) = self.st.borrow().panes[pane].sort;
783        trace!(
784            "SORT {} {} {}",
785            PANE_NAMES[pane],
786            k.column(),
787            if asc { "asc" } else { "desc" }
788        );
789    }
790
791    fn on_row_selected(self: &Rc<Self>, pane: usize, row: Option<usize>) {
792        if self.quiet.get() > 0 {
793            return;
794        }
795        self.set_active(pane);
796        let e = row.and_then(|r| self.entry_at(pane, r));
797        if let Some(e) = &e {
798            trace!("SELECT {} {}", PANE_NAMES[pane], e.name);
799        }
800        self.show_preview(e);
801        self.update_status();
802    }
803
804    fn on_row_activated(self: &Rc<Self>, pane: usize, row: usize) {
805        self.set_active(pane);
806        let Some(e) = self.entry_at(pane, row) else {
807            return;
808        };
809        self.open_entry(pane, e);
810    }
811
812    fn open_entry(self: &Rc<Self>, pane: usize, e: Entry) {
813        if e.is_dir {
814            let from = self.path_of(pane);
815            let select = e.is_parent.then_some(from);
816            self.navigate(pane, e.path, select, true, false);
817        } else {
818            trace!("OPEN {} {}", PANE_NAMES[pane], e.name);
819            self.show_preview(Some(e));
820        }
821    }
822
823    fn op_open(self: &Rc<Self>) {
824        if let Some(e) = self.selected(self.active()) {
825            self.open_entry(self.active(), e);
826        }
827    }
828
829    /// Runs just before the popup is shown: right-clicking a pane makes it the active one.
830    fn prepare_context_menu(&self, pane: usize) {
831        self.set_active(pane);
832        let sel = self.selected(pane);
833        let real = sel.as_ref().is_some_and(|e| !e.is_parent);
834        let it = self.ui.items;
835        it.ctx_open.set_enabled(sel.is_some());
836        it.ctx_rename.set_enabled(real);
837        it.ctx_delete.set_enabled(real);
838        it.ctx_copy.set_enabled(real);
839    }
840
841    // ---------------------------------------------------------------- preview and status
842
843    fn show_preview(&self, e: Option<Entry>) {
844        let u = &self.ui;
845        let Some(e) = e else {
846            u.preview_title.set_text("Preview");
847            u.preview.set_text("");
848            u.image.set_image(None);
849            u.image.set_visible(false);
850            return;
851        };
852        let p = fsm::preview(&e);
853        let (what, extra) = match &p {
854            Preview::Text { truncated, .. } => (
855                "text",
856                if *truncated {
857                    format!(" (first {} KB)", fsm::PREVIEW_LIMIT / 1024)
858                } else {
859                    String::new()
860                },
861            ),
862            Preview::Hex { .. } => (
863                "binary",
864                format!(" (hex dump of the first {} bytes)", fsm::HEX_LIMIT),
865            ),
866            Preview::Dir(_) => ("folder", String::new()),
867            Preview::Image { img, .. } => ("image", format!(" ({} x {})", img.w, img.h)),
868            Preview::Error(_) => ("error", String::new()),
869        };
870        u.preview_title.set_text(&format!(
871            "Preview: {}{extra}",
872            if e.is_parent { ".." } else { &e.name }
873        ));
874        u.preview.set_text(p.body());
875        match &p {
876            Preview::Image { img, .. } => {
877                u.image.set_image(Some(&scaled(img)));
878                u.image.set_visible(true);
879            }
880            _ => {
881                u.image.set_image(None);
882                u.image.set_visible(false);
883            }
884        }
885        trace!("PREVIEW {what} {} {}", p.shown_bytes(), e.name);
886    }
887
888    fn update_status(&self) {
889        let a = self.active();
890        let (n, dirs, total, trunc, sel) = {
891            let st = self.st.borrow();
892            let p = &st.panes[a];
893            let real: Vec<&Entry> = p.entries.iter().filter(|e| !e.is_parent).collect();
894            let dirs = real.iter().filter(|e| e.is_dir).count();
895            let total: u64 = real.iter().filter(|e| !e.is_dir).map(|e| e.size).sum();
896            (real.len(), dirs, total, p.truncated, p.entries.len())
897        };
898        let _ = sel;
899        let mut s = format!(
900            "{n} items ({dirs} folders, {} files), {} in files",
901            n - dirs,
902            fsm::human_size(total)
903        );
904        if trunc {
905            s.push_str(" (truncated)");
906        }
907        if let Some(e) = self.selected(a) {
908            s.push_str(&format!("   |   {}", fsm::describe(&e)));
909        }
910        self.ui.status.set_text(&s);
911        trace!("STATUS {s}");
912    }
913
914    fn print_bounds(&self) {
915        if !tracing() {
916            return;
917        }
918        let u = &self.ui;
919        let (b, ids): (Rect, Vec<(&str, Widget)>) = (
920            u.win.bounds(),
921            vec![
922                ("tree", *u.tree),
923                ("tableA", *u.tables[0]),
924                ("tableB", *u.tables[1]),
925                ("labelA", *u.pane_labels[0]),
926                ("labelB", *u.pane_labels[1]),
927                ("preview", *u.preview),
928                ("image", *u.image),
929                ("path", *u.path),
930                ("up", *u.up),
931                ("refresh", *u.refresh),
932                ("copy", *u.copy_btn),
933                ("move", *u.move_btn),
934                ("status", *u.status),
935                ("body", *u.body),
936                ("right", *u.right),
937                ("panes", *u.panes),
938            ],
939        );
940        let _ = b;
941        for (n, w) in ids {
942            let r = w.bounds();
943            println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
944        }
945    }
946
947    // ---------------------------------------------------------------- tree
948
949    fn init_tree(self: &Rc<Self>) {
950        let t = self.ui.tree;
951        t.clear();
952        let mut roots: Vec<(String, PathBuf)> = Vec::new();
953        if let Some(h) = home_dir() {
954            roots.push(("Home".into(), h));
955        }
956        #[cfg(windows)]
957        for d in b'A'..=b'Z' {
958            let p = PathBuf::from(format!("{}:\\", d as char));
959            if p.is_dir() {
960                roots.push((format!("{}:\\", d as char), p));
961            }
962        }
963        #[cfg(not(windows))]
964        roots.push(("File System (/)".into(), PathBuf::from("/")));
965        let mut st = self.st.borrow_mut();
966        st.node_paths.clear();
967        st.loaded.clear();
968        for (name, p) in roots {
969            let n = t.add(None, &name);
970            t.set_has_children(n, true);
971            st.node_paths.insert(n, p);
972        }
973    }
974
975    pub fn node_path(&self, n: TreeNodeId) -> Option<PathBuf> {
976        self.st.borrow().node_paths.get(&n).cloned()
977    }
978
979    /// Add the sub-folders of `node` the first time it is needed.
980    pub fn tree_load(&self, node: TreeNodeId) {
981        let Some(path) = self.node_path(node) else {
982            return;
983        };
984        if !self.st.borrow_mut().loaded.insert(node) {
985            return;
986        }
987        let hidden = self.st.borrow().show_hidden;
988        let dirs = fsm::subdirs(&path, hidden);
989        let t = self.ui.tree;
990        let mut new = Vec::new();
991        t.batch(|t| {
992            for d in &dirs {
993                let c = t.add(Some(node), &d.name);
994                t.set_has_children(c, true);
995                new.push((c, d.path.clone()));
996            }
997            t.set_has_children(node, !dirs.is_empty());
998        });
999        self.st.borrow_mut().node_paths.extend(new);
1000    }
1001
1002    /// Expand the tree down to `path` and select it (no callbacks fire).
1003    fn tree_reveal(&self, path: &Path) {
1004        let t = self.ui.tree;
1005        let mut best: Option<(TreeNodeId, usize)> = None;
1006        for r in t.children(None) {
1007            if let Some(rp) = self.node_path(r) {
1008                let depth = rp.components().count();
1009                if path.starts_with(&rp) && best.is_none_or(|(_, d)| depth > d) {
1010                    best = Some((r, depth));
1011                }
1012            }
1013        }
1014        let Some((mut node, _)) = best else { return };
1015        let Some(root_path) = self.node_path(node) else {
1016            return;
1017        };
1018        let Ok(rest) = path.strip_prefix(&root_path) else {
1019            return;
1020        };
1021        let mut cur = root_path;
1022        for comp in rest.components() {
1023            self.tree_load(node);
1024            cur.push(comp);
1025            match t
1026                .children(Some(node))
1027                .into_iter()
1028                .find(|c| self.node_path(*c).as_deref() == Some(cur.as_path()))
1029            {
1030                Some(c) => node = c,
1031                None => break,
1032            }
1033        }
1034        self.tree_load(node); // set_selected expands its ancestors; the node itself must not show a placeholder
1035        t.set_selected(Some(node));
1036    }
1037
1038    fn on_tree_selected(self: &Rc<Self>, n: Option<TreeNodeId>) {
1039        let Some(path) = n.and_then(|n| self.node_path(n)) else {
1040            return;
1041        };
1042        let a = self.active();
1043        if path != self.path_of(a) {
1044            trace!("TREE {}", path.display());
1045            self.navigate(a, path, None, false, false);
1046        }
1047    }
1048
1049    // ---------------------------------------------------------------- operations
1050
1051    fn confirm(&self, title: &str, text: &str) -> bool {
1052        message_box(
1053            Some(self.ui.win),
1054            MessageKind::Question,
1055            Buttons::YesNo,
1056            title,
1057            text,
1058        ) == Answer::Yes
1059    }
1060
1061    /// Reload every pane showing `dir` (or all, if `dir` is None) and select `select` in the active one.
1062    fn refresh_after(self: &Rc<Self>, select: Option<PathBuf>) {
1063        let a = self.active();
1064        for i in 0..2 {
1065            let keep = if i == a { select.clone() } else { None };
1066            self.reload(i, keep);
1067        }
1068    }
1069
1070    fn op_new_folder(self: &Rc<Self>) {
1071        let a = self.active();
1072        let dir = self.path_of(a);
1073        self.dialog(
1074            "New Folder",
1075            "Name of the new folder:",
1076            "New Folder",
1077            move |fm, name| {
1078                let p = fsm::make_dir(&dir, name)?;
1079                trace!("MKDIR {}", p.display());
1080                fm.refresh_after(Some(p));
1081                fm.say(&format!("Created folder \"{name}\""));
1082                Ok(())
1083            },
1084        );
1085    }
1086
1087    fn op_rename(self: &Rc<Self>) {
1088        let Some(e) = self.target() else {
1089            self.say("Select an item to rename first");
1090            return;
1091        };
1092        let old = e
1093            .path
1094            .file_name()
1095            .map(|n| n.to_string_lossy().into_owned())
1096            .unwrap_or_default();
1097        let (prompt, initial) = (format!("New name for \"{old}\":"), old.clone());
1098        self.dialog("Rename", &prompt, &initial, move |fm, name| {
1099            let p = fsm::rename_path(&e.path, name)?;
1100            trace!("RENAME {} {}", e.name, name);
1101            fm.refresh_after(Some(p));
1102            fm.say(&format!("Renamed \"{old}\" to \"{name}\""));
1103            Ok(())
1104        });
1105    }
1106
1107    fn op_delete(self: &Rc<Self>) {
1108        let Some(e) = self.target() else {
1109            self.say("Select an item to delete first");
1110            return;
1111        };
1112        let what = if e.is_dir && !e.is_link {
1113            "folder and everything in it"
1114        } else {
1115            "item"
1116        };
1117        if !self.confirm(
1118            "Delete",
1119            &format!(
1120                "Delete the {what} \"{}\"?\n\nThis cannot be undone.",
1121                e.name
1122            ),
1123        ) {
1124            self.say("Delete cancelled");
1125            return;
1126        }
1127        match fsm::remove_path(&e.path) {
1128            Ok(()) => {
1129                trace!("DELETE {}", e.name);
1130                self.refresh_after(None);
1131                self.say(&format!("Deleted \"{}\"", e.name));
1132            }
1133            Err(err) => {
1134                trace!("ERROR DELETE {}", e.name);
1135                self.say(&format!("Cannot delete \"{}\": {err}", e.name));
1136            }
1137        }
1138    }
1139
1140    fn op_copy(self: &Rc<Self>) {
1141        self.transfer(false)
1142    }
1143
1144    fn op_move(self: &Rc<Self>) {
1145        self.transfer(true)
1146    }
1147
1148    fn transfer(self: &Rc<Self>, mv: bool) {
1149        let verb = if mv { "Move" } else { "Copy" };
1150        let Some(e) = self.target() else {
1151            self.say(&format!("Select an item to {} first", verb.to_lowercase()));
1152            return;
1153        };
1154        let a = self.active();
1155        let dst_dir = self.path_of(1 - a);
1156        let dest = match fsm::check_transfer(&e.path, &dst_dir) {
1157            Ok(d) => d,
1158            Err(err) => {
1159                self.say(&err);
1160                return;
1161            }
1162        };
1163        if std::fs::symlink_metadata(&dest).is_ok() {
1164            if !self.confirm(
1165                "Overwrite",
1166                &format!(
1167                    "\"{}\" already exists in {}.\n\nReplace it?",
1168                    e.name,
1169                    dst_dir.display()
1170                ),
1171            ) {
1172                self.say(&format!("{verb} cancelled"));
1173                return;
1174            }
1175            if let Err(err) = fsm::remove_path(&dest) {
1176                self.say(&format!("Cannot replace \"{}\": {err}", e.name));
1177                return;
1178            }
1179        }
1180        let r = if mv {
1181            fsm::move_into(&e.path, &dst_dir)
1182        } else {
1183            fsm::copy_into(&e.path, &dst_dir)
1184        };
1185        match r {
1186            Ok(new) => {
1187                trace!("{} {} {}", verb.to_uppercase(), e.name, dst_dir.display());
1188                // both panes re-read; the other pane shows the new item selected
1189                self.reload(a, None);
1190                self.reload(1 - a, Some(new));
1191                self.say(&format!(
1192                    "{} \"{}\" to {}",
1193                    if mv { "Moved" } else { "Copied" },
1194                    e.name,
1195                    dst_dir.display()
1196                ));
1197            }
1198            Err(err) => {
1199                trace!("ERROR {} {}", verb.to_uppercase(), e.name);
1200                self.say(&err);
1201            }
1202        }
1203    }
1204
1205    fn about(&self) {
1206        message_box(
1207            Some(self.ui.win),
1208            MessageKind::Info,
1209            Buttons::Ok,
1210            "About File Manager",
1211            "A dual-pane file manager written with rungui's public API only.\n\nF2 rename, F5 copy, F6 move, F7 new folder, F8 delete,\nF9 switch pane, Ctrl+H hidden files, Ctrl+R refresh.\nTimes are shown in UTC.",
1212        );
1213    }
1214
1215    // ---------------------------------------------------------------- the rename / new folder dialog
1216
1217    /// A small window with a text field and OK / Cancel (rungui has no input-dialog API).
1218    /// `action` returns an error message to keep the dialog open.
1219    fn dialog(
1220        self: &Rc<Self>,
1221        title: &str,
1222        prompt: &str,
1223        initial: &str,
1224        action: impl Fn(&Rc<Fm>, &str) -> std::result::Result<(), String> + 'static,
1225    ) {
1226        if let Some(old) = self.st.borrow_mut().dialog.take() {
1227            old.destroy();
1228        }
1229        let w = Window::new(title);
1230        w.set_size(380, 150);
1231        w.set_resizable(false);
1232        let col = VBox::new(w);
1233        col.set_spacing(8);
1234        Label::new(col, prompt);
1235        let input = TextInput::new(col);
1236        input.set_text(initial);
1237        input.set_a11y_name(title);
1238        let err = Label::new(col, "");
1239        let row = HBox::new(col);
1240        row.set_spacing(8);
1241        Spacer::new(row);
1242        let cancel = Button::new(row, "Cancel");
1243        let ok = Button::new(row, "OK");
1244        self.st.borrow_mut().dialog = Some(w);
1245        self.dialog_ui.set(Some((w, input, ok, cancel)));
1246        trace!("DIALOG open {title}");
1247        {
1248            let fm = self.clone();
1249            ok.on_click(move || {
1250                let text = input.text();
1251                match action(&fm, text.trim()) {
1252                    Ok(()) => {
1253                        trace!("DIALOG done");
1254                        fm.st.borrow_mut().dialog = None;
1255                        w.destroy();
1256                    }
1257                    Err(e) => {
1258                        trace!("DIALOG error {e}");
1259                        err.set_text(&e);
1260                    }
1261                }
1262            });
1263            let fm = self.clone();
1264            cancel.on_click(move || {
1265                trace!("DIALOG cancel");
1266                fm.st.borrow_mut().dialog = None;
1267                w.destroy();
1268            });
1269            let fm = self.clone();
1270            w.on_close(move || {
1271                fm.st.borrow_mut().dialog = None;
1272                true
1273            });
1274        }
1275        w.show();
1276        input.focus();
1277        if tracing() {
1278            Timer::once(300, move || {
1279                for (n, wd) in [
1280                    ("dlg_input", *input),
1281                    ("dlg_ok", *ok),
1282                    ("dlg_cancel", *cancel),
1283                ] {
1284                    let r = wd.bounds();
1285                    println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
1286                }
1287            });
1288        }
1289    }
Source

pub fn set_title(&self, t: &str)

Change the title.

Examples found in repository?
examples/file_manager/app.rs (line 739)
709    fn refresh_labels(&self) {
710        let (active, paths) = {
711            let st = self.st.borrow();
712            (
713                st.active,
714                st.panes.iter().map(|p| p.path.clone()).collect::<Vec<_>>(),
715            )
716        };
717        for (i, p) in paths.iter().enumerate() {
718            let mark = if i == active { "\u{25B6}" } else { " " };
719            // labels do not clip, so fit the path to the pane (about 7 px per character)
720            let room = (self.ui.tables[i].bounds().w / 7).max(12) as usize;
721            let head = format!("{mark} {}  ", PANE_NAMES[i]);
722            let path = fsm::ellipsize_path(
723                &p.display().to_string(),
724                room.saturating_sub(head.chars().count()),
725            );
726            self.ui.pane_labels[i].set_text(&format!("{head}{path}"));
727        }
728        let cur = paths.get(active).cloned().unwrap_or_default();
729        let text = cur.display().to_string();
730        if self.ui.path.text() != text && !self.typing.get() {
731            self.ui.path.set_text(&text);
732        }
733        let name = cur
734            .file_name()
735            .map(|n| n.to_string_lossy().into_owned())
736            .unwrap_or_else(|| text.clone());
737        self.ui
738            .win
739            .set_title(&format!("{name} [{}] - File Manager", PANE_NAMES[active]));
740        self.ui
741            .tag
742            .set_text(&format!("  Active pane: {}", PANE_NAMES[active]));
743        self.ui.up.set_enabled(cur.parent().is_some());
744    }
Source

pub fn title(&self) -> String

The title.

Source

pub fn set_size(&self, w: i32, h: i32)

Client-area size in logical pixels. Without this call the window sizes itself to its content.

Examples found in repository?
examples/smoke_cocoa.rs (line 103)
6fn main() {
7    let app = App::new("smoke-cocoa").expect("init");
8    let a = Window::new("cc-a");
9    let bar = MenuBar::new(a);
10    let file = Menu::new(bar, "File");
11    let flag = CheckMenuItem::new(file, "Flag");
12    flag.set_accel("Ctrl+K");
13    flag.on_toggle(|v| println!("MENUTOGGLE {v}"));
14    let go = MenuItem::new(file, "Go");
15    go.set_accel("Ctrl+Shift+G");
16    go.on_click(|| println!("MENU_GO"));
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(|| {
20        println!("MENU_QUIT");
21        App::quit();
22    });
23
24    let col = VBox::new(a);
25    let row = HBox::new(col);
26    let btn = Button::new(row, "Press ünï");
27    let spin = SpinBox::new(row, 0.0, 10.0, 1.0);
28    let txt = TextInput::new(col);
29    let chk = CheckBox::new(col, "Monospace");
30    let hs = Splitter::new(col, Orientation::Horizontal);
31    let ta1 = TextArea::new(hs);
32    let ta2 = TextArea::new(hs);
33    ta2.set_text(
34        "long line without wrapping: 0123456789 0123456789 0123456789 0123456789 0123456789",
35    );
36    ta2.set_wrap(false);
37    hs.set_position(200);
38    hs.set_min_pane_sizes(60, 60);
39    let slider = Slider::new(col, 0.0, 100.0);
40    let combo = ComboBox::new(col);
41    combo.set_items(&["x", "y", "z"]);
42    let tabs = Tabs::new(col);
43    let p1 = tabs.add_page("First");
44    let p2 = tabs.add_page("Second");
45    Label::new(p1, "page one");
46    Label::new(p2, "page two");
47    let vs = Splitter::new(col, Orientation::Vertical);
48    let table = Table::new(vs);
49    table.set_columns(&[
50        Column::new("Name").width(80).sortable(true),
51        Column::new("Size").align(ColumnAlign::Right),
52    ]);
53    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
54    let tree = Tree::new(vs);
55    let root = tree.add(None, "root");
56    tree.add(Some(root), "kid");
57    let lazy = tree.add(None, "lazy");
58    tree.set_has_children(lazy, true);
59    vs.set_position(100);
60    vs.set_min_pane_sizes(40, 40);
61
62    btn.on_click(|| println!("CLICK"));
63    spin.on_change(|v| println!("SPIN {v}"));
64    txt.on_change(|t| println!("TEXT {t}"));
65    ta1.on_change(|t| println!("AREA {}", t.replace('\n', "|")));
66    chk.on_toggle(move |on| {
67        println!("MONO {on}");
68        txt.set_monospace(on);
69        ta1.set_monospace(on);
70    });
71    hs.on_move(|p| println!("HSPLIT {p}"));
72    vs.on_move(|p| println!("VSPLIT {p}"));
73    slider.on_change(|v| println!("VALUE {v:.0}"));
74    combo.on_select(|i| println!("COMBO {i:?}"));
75    tabs.on_select(|i| println!("TAB {i:?}"));
76    table.on_select(|i| println!("TABLE_SEL {i:?}"));
77    table.on_column_click(move |c| {
78        let ascending = table.sort_indicator() != Some((c, true));
79        let mut rows = table.rows();
80        rows.sort_by(|x, y| x[c].cmp(&y[c]));
81        if !ascending {
82            rows.reverse();
83        }
84        table.set_rows(&rows);
85        table.set_sort_indicator(Some((c, ascending)));
86        println!(
87            "TABLE_COL {c} {} {}",
88            if ascending { "asc" } else { "desc" },
89            rows[0][0]
90        );
91    });
92    tree.on_select(move |n| println!("TREE_SEL {}", n.is_some()));
93    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
94    a.set_context_menu({
95        let p = PopupMenu::new();
96        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
97        p
98    });
99    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
100    a.on_move(|x, y| println!("MOVED {x} {y}"));
101    a.set_min_size(300, 400);
102    a.set_position(220, 100);
103    a.set_size(560, 700);
104    a.on_close(|| {
105        println!("CLOSE_REQUESTED");
106        true
107    });
108    a.show();
109    println!(
110        "HANDLE {}",
111        a.native_handle().is_some() && btn.native_handle().is_some()
112    );
113    let _t = Timer::once(700, move || {
114        for (n, w) in [
115            ("btn", btn.bounds()),
116            ("spin", spin.bounds()),
117            ("txt", txt.bounds()),
118            ("chk", chk.bounds()),
119            ("hs", hs.bounds()),
120            ("slider", slider.bounds()),
121            ("combo", combo.bounds()),
122            ("tabs", tabs.bounds()),
123            ("vs", vs.bounds()),
124            ("table", table.bounds()),
125            ("tree", tree.bounds()),
126        ] {
127            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
128        }
129        println!("SPLITPOS h {} v {}", hs.position(), vs.position());
130        println!("READY");
131    });
132    app.run();
133    println!("BYE");
134}
More examples
Hide additional examples
examples/file_manager/app.rs (line 164)
162pub fn build(opts: Options) -> Rc<Fm> {
163    let win = Window::new("File Manager");
164    win.set_size(1000, 700);
165    win.set_min_size(640, 420);
166
167    // ---- menus (accelerators are the keyboard interface; there is no key-event API)
168    let bar = MenuBar::new(win);
169    let file = Menu::new(bar, "File");
170    let new_folder = MenuItem::new(file, "New Folder");
171    new_folder.set_accel("F7");
172    let rename = MenuItem::new(file, "Rename");
173    rename.set_accel("F2");
174    MenuSeparator::new(file);
175    let copy = MenuItem::new(file, "Copy to Other Pane");
176    copy.set_accel("F5");
177    let mv = MenuItem::new(file, "Move to Other Pane");
178    mv.set_accel("F6");
179    let delete = MenuItem::new(file, "Delete");
180    delete.set_accel("F8");
181    MenuSeparator::new(file);
182    let quit = MenuItem::new(file, "Quit");
183    quit.set_accel("Ctrl+Q");
184    let view = Menu::new(bar, "View");
185    let hidden = CheckMenuItem::new(view, "Show Hidden Files");
186    hidden.set_accel("Ctrl+H");
187    let refresh_item = MenuItem::new(view, "Refresh");
188    refresh_item.set_accel("Ctrl+R");
189    let go = Menu::new(bar, "Go");
190    let up_item = MenuItem::new(go, "Up One Level");
191    up_item.set_accel("Alt+Up");
192    let home_item = MenuItem::new(go, "Home Folder");
193    home_item.set_accel("Alt+Home");
194    let switch = MenuItem::new(go, "Switch Active Pane");
195    switch.set_accel("F9");
196    let helpm = Menu::new(bar, "Help");
197    let about = MenuItem::new(helpm, "About");
198
199    // ---- layout
200    let root = VBox::new(win);
201    root.set_spacing(6);
202    root.set_expand(1.0); // a window stacks its children vertically; give the whole area to this one
203
204    let tools = HBox::new(root);
205    tools.set_spacing(6);
206    let up = Button::new(tools, "\u{2191} Up");
207    up.set_tooltip("Go to the parent folder (Alt+Up)");
208    let refresh = Button::new(tools, "Refresh");
209    refresh.set_tooltip("Reload both panes (Ctrl+R)");
210    let path = TextInput::new(tools);
211    path.set_expand(1.0);
212    path.set_monospace(true);
213    path.set_tooltip("Type a folder path to open it in the active pane");
214    path.set_a11y_name("Path of the active pane");
215    let copy_btn = Button::new(tools, "Copy \u{2192}");
216    copy_btn.set_tooltip("Copy the selected item to the other pane (F5)");
217    let move_btn = Button::new(tools, "Move \u{2192}");
218    move_btn.set_tooltip("Move the selected item to the other pane (F6)");
219
220    let body = Splitter::new(root, Orientation::Horizontal);
221    body.set_expand(1.0);
222    let tree = Tree::new(body);
223    tree.set_a11y_name("Folders");
224    let right = Splitter::new(body, Orientation::Vertical);
225    let panes = Splitter::new(right, Orientation::Horizontal);
226    let mut tables = Vec::new();
227    let mut pane_labels = Vec::new();
228    for (i, n) in PANE_NAMES.iter().enumerate() {
229        let col = VBox::new(panes);
230        col.set_spacing(2);
231        pane_labels.push(Label::new(col, ""));
232        let t = Table::new(col);
233        t.set_expand(1.0);
234        t.set_a11y_name(&format!("Files, pane {n}"));
235        t.set_columns(&[
236            Column::new("Name").width(125).sortable(true),
237            Column::new("Size")
238                .width(62)
239                .align(ColumnAlign::Right)
240                .sortable(true),
241            Column::new("Modified").width(128).sortable(true),
242            Column::new("Kind").width(90).sortable(true),
243        ]);
244        let _ = i;
245        tables.push(t);
246    }
247    let pv = VBox::new(right);
248    pv.set_spacing(2);
249    let preview_title = Label::new(pv, "Preview");
250    let pv_row = HBox::new(pv);
251    pv_row.set_expand(1.0);
252    let image = Image::new(pv_row);
253    image.set_visible(false);
254    image.set_align(Align::Start);
255    let preview = TextArea::new(pv_row);
256    preview.set_expand(1.0);
257    preview.set_read_only(true);
258    preview.set_monospace(true);
259    preview.set_wrap(false);
260    preview.set_a11y_name("Preview");
261
262    let sbar = HBox::new(root);
263    let status = Label::new(sbar, "");
264    status.set_expand(1.0);
265    let tag = Label::new(sbar, "");
266
267    body.set_position(170);
268    body.set_min_pane_sizes(100, 300);
269    right.set_position(400);
270    right.set_min_pane_sizes(120, 80);
271    panes.set_min_pane_sizes(180, 180);
272
273    // ---- context menu shared by both tables
274    let popup = PopupMenu::new();
275    let ctx_open = MenuItem::new(popup, "Open");
276    let ctx_rename = MenuItem::new(popup, "Rename...");
277    let ctx_delete = MenuItem::new(popup, "Delete...");
278    MenuSeparator::new(popup);
279    let ctx_copy = MenuItem::new(popup, "Copy to Other Pane");
280    let ctx_new = MenuItem::new(popup, "New Folder...");
281    for t in &tables {
282        t.set_context_menu(popup);
283    }
284
285    let ui = Ui {
286        win,
287        body,
288        right,
289        panes,
290        tree,
291        tables: [tables[0], tables[1]],
292        pane_labels: [pane_labels[0], pane_labels[1]],
293        path,
294        up,
295        refresh,
296        copy_btn,
297        move_btn,
298        preview_title,
299        preview,
300        image,
301        status,
302        tag,
303        popup,
304        items: Items {
305            new_folder,
306            rename,
307            copy,
308            mv,
309            delete,
310            quit,
311            hidden,
312            refresh: refresh_item,
313            up: up_item,
314            home: home_item,
315            switch,
316            about,
317            ctx_open,
318            ctx_rename,
319            ctx_delete,
320            ctx_copy,
321            ctx_new,
322        },
323    };
324    let fm = Rc::new(Fm {
325        ui,
326        st: RefCell::new(State::default()),
327        quiet: Cell::new(0),
328        typing: Cell::new(false),
329        dialog_ui: Cell::new(None),
330    });
331    fm.wire();
332    fm.init_tree();
333    {
334        let mut st = fm.st.borrow_mut();
335        for p in &opts.dirs {
336            st.panes.push(Pane {
337                path: p.clone(),
338                entries: vec![],
339                sort: (SortKey::Name, true),
340                mtime: None,
341                truncated: false,
342            });
343        }
344    }
345    for (i, p) in opts.dirs.iter().enumerate() {
346        if !fm.navigate(i, p.clone(), None, true, false) {
347            // an unreadable start directory falls back to the home folder, then to "/"
348            let fallback = home_dir().unwrap_or_else(|| PathBuf::from("/"));
349            fm.navigate(i, fallback, None, true, false);
350        }
351    }
352    fm.set_active(0);
353    let first = fm.path_of(0);
354    fm.tree_reveal(&first);
355    fm.ui.win.show();
356    fm
357}
358
359impl Fm {
360    fn wire(self: &Rc<Self>) {
361        let u = &self.ui;
362        let it = u.items;
363        macro_rules! click {
364            ($btn:expr, $f:ident) => {{
365                let fm = self.clone();
366                $btn.on_click(move || fm.$f());
367            }};
368        }
369        click!(it.new_folder, op_new_folder);
370        click!(it.ctx_new, op_new_folder);
371        click!(it.rename, op_rename);
372        click!(it.ctx_rename, op_rename);
373        click!(it.delete, op_delete);
374        click!(it.ctx_delete, op_delete);
375        click!(it.copy, op_copy);
376        click!(it.ctx_copy, op_copy);
377        click!(u.copy_btn, op_copy);
378        click!(it.mv, op_move);
379        click!(u.move_btn, op_move);
380        click!(it.ctx_open, op_open);
381        click!(it.refresh, refresh_all);
382        click!(u.refresh, refresh_all);
383        click!(it.up, go_up);
384        click!(u.up, go_up);
385        click!(it.home, go_home);
386        click!(it.switch, switch_pane);
387        click!(it.about, about);
388        it.quit.on_click(App::quit);
389        {
390            let fm = self.clone();
391            it.hidden.on_toggle(move |on| fm.set_show_hidden(on));
392        }
393        for i in 0..2 {
394            let t = u.tables[i];
395            let fm = self.clone();
396            t.on_select(move |r| fm.on_row_selected(i, r));
397            let fm = self.clone();
398            t.on_activate(move |r| fm.on_row_activated(i, r));
399            let fm = self.clone();
400            t.on_column_click(move |c| fm.sort_by_column(i, c));
401            let fm = self.clone();
402            t.on_context_menu(move |_, _| fm.prepare_context_menu(i));
403        }
404        {
405            let fm = self.clone();
406            u.path.on_change(move |text| fm.on_path_typed(text));
407        }
408        {
409            let fm = self.clone();
410            u.tree.on_select(move |n| fm.on_tree_selected(n));
411            let fm = self.clone();
412            u.tree.on_expand(move |n, open| {
413                if open {
414                    fm.tree_load(n);
415                }
416            });
417        }
418        {
419            let fm = self.clone();
420            u.win.on_resize(move |w, h| {
421                trace!("RESIZE {w} {h}");
422                fm.relabel_soon();
423            });
424            for sp in [u.body, u.right, u.panes] {
425                let fm = self.clone();
426                sp.on_move(move |_| fm.relabel_soon());
427            }
428        }
429        // pick up changes made by other programs
430        let fm = self.clone();
431        Timer::every(1500, move || fm.poll());
432        // report geometry once the first layout has happened
433        let fm = self.clone();
434        Timer::once(500, move || {
435            fm.print_bounds();
436            trace!("READY");
437        });
438    }
439
440    // ---------------------------------------------------------------- state helpers
441
442    pub fn path_of(&self, pane: usize) -> PathBuf {
443        self.st
444            .borrow()
445            .panes
446            .get(pane)
447            .map(|p| p.path.clone())
448            .unwrap_or_default()
449    }
450
451    pub fn active(&self) -> usize {
452        self.st.borrow().active
453    }
454
455    fn entry_at(&self, pane: usize, row: usize) -> Option<Entry> {
456        self.st.borrow().panes.get(pane)?.entries.get(row).cloned()
457    }
458
459    /// The selected entry of `pane`, or None (nothing selected). The ".." row counts.
460    pub fn selected(&self, pane: usize) -> Option<Entry> {
461        let row = self.ui.tables[pane].selected()?;
462        self.entry_at(pane, row)
463    }
464
465    /// The selected real item (not "..") of the active pane.
466    fn target(&self) -> Option<Entry> {
467        self.selected(self.active()).filter(|e| !e.is_parent)
468    }
469
470    pub fn say(&self, msg: &str) {
471        self.ui.status.set_text(msg);
472        trace!("STATUS {msg}");
473    }
474
475    fn quietly<R>(&self, f: impl FnOnce() -> R) -> R {
476        self.quiet.set(self.quiet.get() + 1);
477        let r = f();
478        self.quiet.set(self.quiet.get() - 1);
479        r
480    }
481
482    // ---------------------------------------------------------------- navigation
483
484    /// Show `path` in `pane`. `select` picks a row afterwards (e.g. the folder we came from).
485    /// `reveal` also selects the folder in the tree. Returns false (and says why) on failure.
486    pub fn navigate(
487        self: &Rc<Self>,
488        pane: usize,
489        path: PathBuf,
490        select: Option<PathBuf>,
491        reveal: bool,
492        from_box: bool,
493    ) -> bool {
494        let hidden = self.st.borrow().show_hidden;
495        let listing = match fsm::read_dir(&path, hidden) {
496            Ok(l) => l,
497            Err(e) => {
498                self.say(&format!("Cannot open {}: {}", path.display(), e));
499                trace!("ERROR NAV {} {}", PANE_NAMES[pane], path.display());
500                return false;
501            }
502        };
503        let n = listing.entries.len();
504        let truncated = listing.truncated;
505        {
506            let mut st = self.st.borrow_mut();
507            let Some(p) = st.panes.get_mut(pane) else {
508                return false;
509            };
510            let mut entries = listing.entries;
511            fsm::sort_entries(&mut entries, p.sort.0, p.sort.1);
512            if let Some(parent) = Entry::parent_of(&path) {
513                entries.insert(0, parent);
514            }
515            p.mtime = std::fs::metadata(&path).and_then(|m| m.modified()).ok();
516            p.entries = entries;
517            p.path = path.clone();
518            p.truncated = truncated;
519        }
520        self.populate(pane, select.as_deref());
521        self.typing.set(from_box);
522        self.set_active(pane);
523        self.refresh_labels();
524        self.typing.set(false);
525        if reveal {
526            self.tree_reveal(&path);
527        }
528        // select + preview the requested row, else preview the directory itself
529        let row = select.and_then(|s| {
530            self.st.borrow().panes[pane]
531                .entries
532                .iter()
533                .position(|e| e.path == s)
534        });
535        match row {
536            Some(r) => self.on_row_selected(pane, Some(r)),
537            None => {
538                self.show_preview(Entry::from_path(&path));
539                self.update_status();
540            }
541        }
542        trace!("NAV {} {} {}", PANE_NAMES[pane], path.display(), n);
543        if truncated {
544            self.say(&format!(
545                "Showing only the first {} entries of {}",
546                fsm::MAX_ENTRIES,
547                path.display()
548            ));
549        }
550        true
551    }
552
553    /// Re-read `pane`, keeping the selected item selected when it still exists.
554    fn reload(self: &Rc<Self>, pane: usize, keep: Option<PathBuf>) {
555        let path = self.path_of(pane);
556        let keep = keep.or_else(|| self.selected(pane).map(|e| e.path));
557        if self.navigate_quiet(pane, &path, keep.clone()) {
558            return;
559        }
560        // the directory vanished: climb to the nearest one that exists
561        let mut p = path.clone();
562        while let Some(parent) = p.parent().map(Path::to_path_buf) {
563            if parent.is_dir() && self.navigate(pane, parent.clone(), Some(p.clone()), true, false)
564            {
565                return;
566            }
567            p = parent;
568        }
569    }
570
571    /// Like `navigate` for the same directory but without the active-pane, tree and preview churn
572    /// unless the selection changed. Returns false if the directory cannot be read.
573    fn navigate_quiet(self: &Rc<Self>, pane: usize, path: &Path, keep: Option<PathBuf>) -> bool {
574        let hidden = self.st.borrow().show_hidden;
575        let Ok(listing) = fsm::read_dir(path, hidden) else {
576            return false;
577        };
578        {
579            let mut st = self.st.borrow_mut();
580            let p = &mut st.panes[pane];
581            let mut entries = listing.entries;
582            fsm::sort_entries(&mut entries, p.sort.0, p.sort.1);
583            if let Some(parent) = Entry::parent_of(path) {
584                entries.insert(0, parent);
585            }
586            p.mtime = std::fs::metadata(path).and_then(|m| m.modified()).ok();
587            p.entries = entries;
588            p.truncated = listing.truncated;
589        }
590        self.populate(pane, keep.as_deref());
591        if pane == self.active() {
592            let row = keep.and_then(|s| {
593                self.st.borrow().panes[pane]
594                    .entries
595                    .iter()
596                    .position(|e| e.path == s)
597            });
598            self.show_preview(
599                row.and_then(|r| self.entry_at(pane, r))
600                    .or_else(|| Entry::from_path(path)),
601            );
602        }
603        self.update_status();
604        true
605    }
606
607    #[allow(dead_code)] // used by tests/file_manager_mock.rs
608    /// Test helper: navigate without touching the tree.
609    pub fn navigate_for_test(self: &Rc<Self>, pane: usize, path: PathBuf) -> bool {
610        self.navigate(pane, path, None, false, false)
611    }
612
613    pub fn refresh_all(self: &Rc<Self>) {
614        for i in 0..2 {
615            self.reload(i, None);
616        }
617        self.say("Refreshed");
618        trace!("REFRESH");
619    }
620
621    /// Timer: reload panes whose directory changed on disk.
622    fn poll(self: &Rc<Self>) {
623        #[allow(clippy::needless_range_loop)]
624        for i in 0..2 {
625            let (path, old) = {
626                let st = self.st.borrow();
627                match st.panes.get(i) {
628                    Some(p) => (p.path.clone(), p.mtime),
629                    None => return,
630                }
631            };
632            let now = std::fs::metadata(&path).and_then(|m| m.modified()).ok();
633            if now != old {
634                trace!("CHANGED {}", PANE_NAMES[i]);
635                self.reload(i, None);
636            }
637        }
638    }
639
640    pub fn go_up(self: &Rc<Self>) {
641        let a = self.active();
642        let cur = self.path_of(a);
643        if let Some(parent) = cur.parent() {
644            self.navigate(a, parent.to_path_buf(), Some(cur.clone()), true, false);
645        }
646    }
647
648    fn go_home(self: &Rc<Self>) {
649        if let Some(h) = home_dir() {
650            let a = self.active();
651            self.navigate(a, h, None, true, false);
652        }
653    }
654
655    fn switch_pane(self: &Rc<Self>) {
656        let other = 1 - self.active();
657        self.set_active(other);
658        self.ui.tables[other].focus();
659    }
660
661    fn set_show_hidden(self: &Rc<Self>, on: bool) {
662        self.st.borrow_mut().show_hidden = on;
663        trace!("HIDDEN {on}");
664        for i in 0..2 {
665            self.reload(i, None);
666        }
667        // rebuild the folder tree so hidden folders appear or vanish too
668        self.init_tree();
669        let a = self.active();
670        let p = self.path_of(a);
671        self.tree_reveal(&p);
672    }
673
674    fn on_path_typed(self: &Rc<Self>, text: &str) {
675        if self.typing.get() {
676            return;
677        }
678        let a = self.active();
679        let t = text.trim();
680        if t.is_empty() || Path::new(t) == self.path_of(a) {
681            return;
682        }
683        let p = PathBuf::from(t);
684        if p.is_dir() {
685            self.navigate(a, p, None, true, true);
686        }
687    }
688
689    pub fn set_active(&self, pane: usize) {
690        let changed = {
691            let mut st = self.st.borrow_mut();
692            let c = st.active != pane;
693            st.active = pane;
694            c
695        };
696        self.refresh_labels();
697        if changed {
698            trace!("ACTIVE {}", PANE_NAMES[pane]);
699        }
700    }
701
702    /// The pane captions depend on the pane widths, which are known only after layout.
703    fn relabel_soon(self: &Rc<Self>) {
704        let fm = self.clone();
705        Timer::once(10, move || fm.refresh_labels());
706    }
707
708    /// Pane captions, path box, window title and the active-pane tag.
709    fn refresh_labels(&self) {
710        let (active, paths) = {
711            let st = self.st.borrow();
712            (
713                st.active,
714                st.panes.iter().map(|p| p.path.clone()).collect::<Vec<_>>(),
715            )
716        };
717        for (i, p) in paths.iter().enumerate() {
718            let mark = if i == active { "\u{25B6}" } else { " " };
719            // labels do not clip, so fit the path to the pane (about 7 px per character)
720            let room = (self.ui.tables[i].bounds().w / 7).max(12) as usize;
721            let head = format!("{mark} {}  ", PANE_NAMES[i]);
722            let path = fsm::ellipsize_path(
723                &p.display().to_string(),
724                room.saturating_sub(head.chars().count()),
725            );
726            self.ui.pane_labels[i].set_text(&format!("{head}{path}"));
727        }
728        let cur = paths.get(active).cloned().unwrap_or_default();
729        let text = cur.display().to_string();
730        if self.ui.path.text() != text && !self.typing.get() {
731            self.ui.path.set_text(&text);
732        }
733        let name = cur
734            .file_name()
735            .map(|n| n.to_string_lossy().into_owned())
736            .unwrap_or_else(|| text.clone());
737        self.ui
738            .win
739            .set_title(&format!("{name} [{}] - File Manager", PANE_NAMES[active]));
740        self.ui
741            .tag
742            .set_text(&format!("  Active pane: {}", PANE_NAMES[active]));
743        self.ui.up.set_enabled(cur.parent().is_some());
744    }
745
746    // ---------------------------------------------------------------- table
747
748    /// Fill a pane's table from its entries. Uses one `batch` so huge directories send one update.
749    fn populate(&self, pane: usize, select: Option<&Path>) {
750        let (rows, sort, sel) = {
751            let st = self.st.borrow();
752            let p = &st.panes[pane];
753            let rows: Vec<Vec<String>> = p.entries.iter().map(row_of).collect();
754            (
755                rows,
756                p.sort,
757                select.and_then(|s| p.entries.iter().position(|e| e.path == s)),
758            )
759        };
760        let t = self.ui.tables[pane];
761        self.quietly(|| {
762            t.batch(|t| t.set_rows(&rows));
763            t.set_sort_indicator(Some((sort.0.column(), sort.1)));
764            t.set_selected(sel);
765        });
766    }
767
768    fn sort_by_column(self: &Rc<Self>, pane: usize, col: usize) {
769        let key = SortKey::from_column(col);
770        let keep = self.selected(pane).map(|e| e.path);
771        {
772            let mut st = self.st.borrow_mut();
773            let Some(p) = st.panes.get_mut(pane) else {
774                return;
775            };
776            let asc = if p.sort.0 == key { !p.sort.1 } else { true };
777            p.sort = (key, asc);
778            let has_parent = p.entries.first().is_some_and(|e| e.is_parent);
779            fsm::sort_entries(&mut p.entries[has_parent as usize..], key, asc);
780        }
781        self.populate(pane, keep.as_deref());
782        let (k, asc) = self.st.borrow().panes[pane].sort;
783        trace!(
784            "SORT {} {} {}",
785            PANE_NAMES[pane],
786            k.column(),
787            if asc { "asc" } else { "desc" }
788        );
789    }
790
791    fn on_row_selected(self: &Rc<Self>, pane: usize, row: Option<usize>) {
792        if self.quiet.get() > 0 {
793            return;
794        }
795        self.set_active(pane);
796        let e = row.and_then(|r| self.entry_at(pane, r));
797        if let Some(e) = &e {
798            trace!("SELECT {} {}", PANE_NAMES[pane], e.name);
799        }
800        self.show_preview(e);
801        self.update_status();
802    }
803
804    fn on_row_activated(self: &Rc<Self>, pane: usize, row: usize) {
805        self.set_active(pane);
806        let Some(e) = self.entry_at(pane, row) else {
807            return;
808        };
809        self.open_entry(pane, e);
810    }
811
812    fn open_entry(self: &Rc<Self>, pane: usize, e: Entry) {
813        if e.is_dir {
814            let from = self.path_of(pane);
815            let select = e.is_parent.then_some(from);
816            self.navigate(pane, e.path, select, true, false);
817        } else {
818            trace!("OPEN {} {}", PANE_NAMES[pane], e.name);
819            self.show_preview(Some(e));
820        }
821    }
822
823    fn op_open(self: &Rc<Self>) {
824        if let Some(e) = self.selected(self.active()) {
825            self.open_entry(self.active(), e);
826        }
827    }
828
829    /// Runs just before the popup is shown: right-clicking a pane makes it the active one.
830    fn prepare_context_menu(&self, pane: usize) {
831        self.set_active(pane);
832        let sel = self.selected(pane);
833        let real = sel.as_ref().is_some_and(|e| !e.is_parent);
834        let it = self.ui.items;
835        it.ctx_open.set_enabled(sel.is_some());
836        it.ctx_rename.set_enabled(real);
837        it.ctx_delete.set_enabled(real);
838        it.ctx_copy.set_enabled(real);
839    }
840
841    // ---------------------------------------------------------------- preview and status
842
843    fn show_preview(&self, e: Option<Entry>) {
844        let u = &self.ui;
845        let Some(e) = e else {
846            u.preview_title.set_text("Preview");
847            u.preview.set_text("");
848            u.image.set_image(None);
849            u.image.set_visible(false);
850            return;
851        };
852        let p = fsm::preview(&e);
853        let (what, extra) = match &p {
854            Preview::Text { truncated, .. } => (
855                "text",
856                if *truncated {
857                    format!(" (first {} KB)", fsm::PREVIEW_LIMIT / 1024)
858                } else {
859                    String::new()
860                },
861            ),
862            Preview::Hex { .. } => (
863                "binary",
864                format!(" (hex dump of the first {} bytes)", fsm::HEX_LIMIT),
865            ),
866            Preview::Dir(_) => ("folder", String::new()),
867            Preview::Image { img, .. } => ("image", format!(" ({} x {})", img.w, img.h)),
868            Preview::Error(_) => ("error", String::new()),
869        };
870        u.preview_title.set_text(&format!(
871            "Preview: {}{extra}",
872            if e.is_parent { ".." } else { &e.name }
873        ));
874        u.preview.set_text(p.body());
875        match &p {
876            Preview::Image { img, .. } => {
877                u.image.set_image(Some(&scaled(img)));
878                u.image.set_visible(true);
879            }
880            _ => {
881                u.image.set_image(None);
882                u.image.set_visible(false);
883            }
884        }
885        trace!("PREVIEW {what} {} {}", p.shown_bytes(), e.name);
886    }
887
888    fn update_status(&self) {
889        let a = self.active();
890        let (n, dirs, total, trunc, sel) = {
891            let st = self.st.borrow();
892            let p = &st.panes[a];
893            let real: Vec<&Entry> = p.entries.iter().filter(|e| !e.is_parent).collect();
894            let dirs = real.iter().filter(|e| e.is_dir).count();
895            let total: u64 = real.iter().filter(|e| !e.is_dir).map(|e| e.size).sum();
896            (real.len(), dirs, total, p.truncated, p.entries.len())
897        };
898        let _ = sel;
899        let mut s = format!(
900            "{n} items ({dirs} folders, {} files), {} in files",
901            n - dirs,
902            fsm::human_size(total)
903        );
904        if trunc {
905            s.push_str(" (truncated)");
906        }
907        if let Some(e) = self.selected(a) {
908            s.push_str(&format!("   |   {}", fsm::describe(&e)));
909        }
910        self.ui.status.set_text(&s);
911        trace!("STATUS {s}");
912    }
913
914    fn print_bounds(&self) {
915        if !tracing() {
916            return;
917        }
918        let u = &self.ui;
919        let (b, ids): (Rect, Vec<(&str, Widget)>) = (
920            u.win.bounds(),
921            vec![
922                ("tree", *u.tree),
923                ("tableA", *u.tables[0]),
924                ("tableB", *u.tables[1]),
925                ("labelA", *u.pane_labels[0]),
926                ("labelB", *u.pane_labels[1]),
927                ("preview", *u.preview),
928                ("image", *u.image),
929                ("path", *u.path),
930                ("up", *u.up),
931                ("refresh", *u.refresh),
932                ("copy", *u.copy_btn),
933                ("move", *u.move_btn),
934                ("status", *u.status),
935                ("body", *u.body),
936                ("right", *u.right),
937                ("panes", *u.panes),
938            ],
939        );
940        let _ = b;
941        for (n, w) in ids {
942            let r = w.bounds();
943            println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
944        }
945    }
946
947    // ---------------------------------------------------------------- tree
948
949    fn init_tree(self: &Rc<Self>) {
950        let t = self.ui.tree;
951        t.clear();
952        let mut roots: Vec<(String, PathBuf)> = Vec::new();
953        if let Some(h) = home_dir() {
954            roots.push(("Home".into(), h));
955        }
956        #[cfg(windows)]
957        for d in b'A'..=b'Z' {
958            let p = PathBuf::from(format!("{}:\\", d as char));
959            if p.is_dir() {
960                roots.push((format!("{}:\\", d as char), p));
961            }
962        }
963        #[cfg(not(windows))]
964        roots.push(("File System (/)".into(), PathBuf::from("/")));
965        let mut st = self.st.borrow_mut();
966        st.node_paths.clear();
967        st.loaded.clear();
968        for (name, p) in roots {
969            let n = t.add(None, &name);
970            t.set_has_children(n, true);
971            st.node_paths.insert(n, p);
972        }
973    }
974
975    pub fn node_path(&self, n: TreeNodeId) -> Option<PathBuf> {
976        self.st.borrow().node_paths.get(&n).cloned()
977    }
978
979    /// Add the sub-folders of `node` the first time it is needed.
980    pub fn tree_load(&self, node: TreeNodeId) {
981        let Some(path) = self.node_path(node) else {
982            return;
983        };
984        if !self.st.borrow_mut().loaded.insert(node) {
985            return;
986        }
987        let hidden = self.st.borrow().show_hidden;
988        let dirs = fsm::subdirs(&path, hidden);
989        let t = self.ui.tree;
990        let mut new = Vec::new();
991        t.batch(|t| {
992            for d in &dirs {
993                let c = t.add(Some(node), &d.name);
994                t.set_has_children(c, true);
995                new.push((c, d.path.clone()));
996            }
997            t.set_has_children(node, !dirs.is_empty());
998        });
999        self.st.borrow_mut().node_paths.extend(new);
1000    }
1001
1002    /// Expand the tree down to `path` and select it (no callbacks fire).
1003    fn tree_reveal(&self, path: &Path) {
1004        let t = self.ui.tree;
1005        let mut best: Option<(TreeNodeId, usize)> = None;
1006        for r in t.children(None) {
1007            if let Some(rp) = self.node_path(r) {
1008                let depth = rp.components().count();
1009                if path.starts_with(&rp) && best.is_none_or(|(_, d)| depth > d) {
1010                    best = Some((r, depth));
1011                }
1012            }
1013        }
1014        let Some((mut node, _)) = best else { return };
1015        let Some(root_path) = self.node_path(node) else {
1016            return;
1017        };
1018        let Ok(rest) = path.strip_prefix(&root_path) else {
1019            return;
1020        };
1021        let mut cur = root_path;
1022        for comp in rest.components() {
1023            self.tree_load(node);
1024            cur.push(comp);
1025            match t
1026                .children(Some(node))
1027                .into_iter()
1028                .find(|c| self.node_path(*c).as_deref() == Some(cur.as_path()))
1029            {
1030                Some(c) => node = c,
1031                None => break,
1032            }
1033        }
1034        self.tree_load(node); // set_selected expands its ancestors; the node itself must not show a placeholder
1035        t.set_selected(Some(node));
1036    }
1037
1038    fn on_tree_selected(self: &Rc<Self>, n: Option<TreeNodeId>) {
1039        let Some(path) = n.and_then(|n| self.node_path(n)) else {
1040            return;
1041        };
1042        let a = self.active();
1043        if path != self.path_of(a) {
1044            trace!("TREE {}", path.display());
1045            self.navigate(a, path, None, false, false);
1046        }
1047    }
1048
1049    // ---------------------------------------------------------------- operations
1050
1051    fn confirm(&self, title: &str, text: &str) -> bool {
1052        message_box(
1053            Some(self.ui.win),
1054            MessageKind::Question,
1055            Buttons::YesNo,
1056            title,
1057            text,
1058        ) == Answer::Yes
1059    }
1060
1061    /// Reload every pane showing `dir` (or all, if `dir` is None) and select `select` in the active one.
1062    fn refresh_after(self: &Rc<Self>, select: Option<PathBuf>) {
1063        let a = self.active();
1064        for i in 0..2 {
1065            let keep = if i == a { select.clone() } else { None };
1066            self.reload(i, keep);
1067        }
1068    }
1069
1070    fn op_new_folder(self: &Rc<Self>) {
1071        let a = self.active();
1072        let dir = self.path_of(a);
1073        self.dialog(
1074            "New Folder",
1075            "Name of the new folder:",
1076            "New Folder",
1077            move |fm, name| {
1078                let p = fsm::make_dir(&dir, name)?;
1079                trace!("MKDIR {}", p.display());
1080                fm.refresh_after(Some(p));
1081                fm.say(&format!("Created folder \"{name}\""));
1082                Ok(())
1083            },
1084        );
1085    }
1086
1087    fn op_rename(self: &Rc<Self>) {
1088        let Some(e) = self.target() else {
1089            self.say("Select an item to rename first");
1090            return;
1091        };
1092        let old = e
1093            .path
1094            .file_name()
1095            .map(|n| n.to_string_lossy().into_owned())
1096            .unwrap_or_default();
1097        let (prompt, initial) = (format!("New name for \"{old}\":"), old.clone());
1098        self.dialog("Rename", &prompt, &initial, move |fm, name| {
1099            let p = fsm::rename_path(&e.path, name)?;
1100            trace!("RENAME {} {}", e.name, name);
1101            fm.refresh_after(Some(p));
1102            fm.say(&format!("Renamed \"{old}\" to \"{name}\""));
1103            Ok(())
1104        });
1105    }
1106
1107    fn op_delete(self: &Rc<Self>) {
1108        let Some(e) = self.target() else {
1109            self.say("Select an item to delete first");
1110            return;
1111        };
1112        let what = if e.is_dir && !e.is_link {
1113            "folder and everything in it"
1114        } else {
1115            "item"
1116        };
1117        if !self.confirm(
1118            "Delete",
1119            &format!(
1120                "Delete the {what} \"{}\"?\n\nThis cannot be undone.",
1121                e.name
1122            ),
1123        ) {
1124            self.say("Delete cancelled");
1125            return;
1126        }
1127        match fsm::remove_path(&e.path) {
1128            Ok(()) => {
1129                trace!("DELETE {}", e.name);
1130                self.refresh_after(None);
1131                self.say(&format!("Deleted \"{}\"", e.name));
1132            }
1133            Err(err) => {
1134                trace!("ERROR DELETE {}", e.name);
1135                self.say(&format!("Cannot delete \"{}\": {err}", e.name));
1136            }
1137        }
1138    }
1139
1140    fn op_copy(self: &Rc<Self>) {
1141        self.transfer(false)
1142    }
1143
1144    fn op_move(self: &Rc<Self>) {
1145        self.transfer(true)
1146    }
1147
1148    fn transfer(self: &Rc<Self>, mv: bool) {
1149        let verb = if mv { "Move" } else { "Copy" };
1150        let Some(e) = self.target() else {
1151            self.say(&format!("Select an item to {} first", verb.to_lowercase()));
1152            return;
1153        };
1154        let a = self.active();
1155        let dst_dir = self.path_of(1 - a);
1156        let dest = match fsm::check_transfer(&e.path, &dst_dir) {
1157            Ok(d) => d,
1158            Err(err) => {
1159                self.say(&err);
1160                return;
1161            }
1162        };
1163        if std::fs::symlink_metadata(&dest).is_ok() {
1164            if !self.confirm(
1165                "Overwrite",
1166                &format!(
1167                    "\"{}\" already exists in {}.\n\nReplace it?",
1168                    e.name,
1169                    dst_dir.display()
1170                ),
1171            ) {
1172                self.say(&format!("{verb} cancelled"));
1173                return;
1174            }
1175            if let Err(err) = fsm::remove_path(&dest) {
1176                self.say(&format!("Cannot replace \"{}\": {err}", e.name));
1177                return;
1178            }
1179        }
1180        let r = if mv {
1181            fsm::move_into(&e.path, &dst_dir)
1182        } else {
1183            fsm::copy_into(&e.path, &dst_dir)
1184        };
1185        match r {
1186            Ok(new) => {
1187                trace!("{} {} {}", verb.to_uppercase(), e.name, dst_dir.display());
1188                // both panes re-read; the other pane shows the new item selected
1189                self.reload(a, None);
1190                self.reload(1 - a, Some(new));
1191                self.say(&format!(
1192                    "{} \"{}\" to {}",
1193                    if mv { "Moved" } else { "Copied" },
1194                    e.name,
1195                    dst_dir.display()
1196                ));
1197            }
1198            Err(err) => {
1199                trace!("ERROR {} {}", verb.to_uppercase(), e.name);
1200                self.say(&err);
1201            }
1202        }
1203    }
1204
1205    fn about(&self) {
1206        message_box(
1207            Some(self.ui.win),
1208            MessageKind::Info,
1209            Buttons::Ok,
1210            "About File Manager",
1211            "A dual-pane file manager written with rungui's public API only.\n\nF2 rename, F5 copy, F6 move, F7 new folder, F8 delete,\nF9 switch pane, Ctrl+H hidden files, Ctrl+R refresh.\nTimes are shown in UTC.",
1212        );
1213    }
1214
1215    // ---------------------------------------------------------------- the rename / new folder dialog
1216
1217    /// A small window with a text field and OK / Cancel (rungui has no input-dialog API).
1218    /// `action` returns an error message to keep the dialog open.
1219    fn dialog(
1220        self: &Rc<Self>,
1221        title: &str,
1222        prompt: &str,
1223        initial: &str,
1224        action: impl Fn(&Rc<Fm>, &str) -> std::result::Result<(), String> + 'static,
1225    ) {
1226        if let Some(old) = self.st.borrow_mut().dialog.take() {
1227            old.destroy();
1228        }
1229        let w = Window::new(title);
1230        w.set_size(380, 150);
1231        w.set_resizable(false);
1232        let col = VBox::new(w);
1233        col.set_spacing(8);
1234        Label::new(col, prompt);
1235        let input = TextInput::new(col);
1236        input.set_text(initial);
1237        input.set_a11y_name(title);
1238        let err = Label::new(col, "");
1239        let row = HBox::new(col);
1240        row.set_spacing(8);
1241        Spacer::new(row);
1242        let cancel = Button::new(row, "Cancel");
1243        let ok = Button::new(row, "OK");
1244        self.st.borrow_mut().dialog = Some(w);
1245        self.dialog_ui.set(Some((w, input, ok, cancel)));
1246        trace!("DIALOG open {title}");
1247        {
1248            let fm = self.clone();
1249            ok.on_click(move || {
1250                let text = input.text();
1251                match action(&fm, text.trim()) {
1252                    Ok(()) => {
1253                        trace!("DIALOG done");
1254                        fm.st.borrow_mut().dialog = None;
1255                        w.destroy();
1256                    }
1257                    Err(e) => {
1258                        trace!("DIALOG error {e}");
1259                        err.set_text(&e);
1260                    }
1261                }
1262            });
1263            let fm = self.clone();
1264            cancel.on_click(move || {
1265                trace!("DIALOG cancel");
1266                fm.st.borrow_mut().dialog = None;
1267                w.destroy();
1268            });
1269            let fm = self.clone();
1270            w.on_close(move || {
1271                fm.st.borrow_mut().dialog = None;
1272                true
1273            });
1274        }
1275        w.show();
1276        input.focus();
1277        if tracing() {
1278            Timer::once(300, move || {
1279                for (n, wd) in [
1280                    ("dlg_input", *input),
1281                    ("dlg_ok", *ok),
1282                    ("dlg_cancel", *cancel),
1283                ] {
1284                    let r = wd.bounds();
1285                    println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
1286                }
1287            });
1288        }
1289    }
examples/kitchen_sink.rs (line 197)
4fn main() {
5    let app = App::new("kitchen-sink").expect("init");
6    let win = Window::new("rungui kitchen sink");
7
8    // Menus
9    let bar = MenuBar::new(win);
10    let file = Menu::new(bar, "File");
11    let open = MenuItem::new(file, "Open...");
12    open.set_accel("Ctrl+O");
13    let wrap = CheckMenuItem::new(file, "Word wrap");
14    wrap.set_checked(true);
15    let mono = CheckMenuItem::new(file, "Monospace notes");
16    MenuSeparator::new(file);
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(App::quit);
20
21    let root = VBox::new(win);
22    let status = Label::new(root, "Ready");
23    let tabs = Tabs::new(root);
24    tabs.set_expand(1.0);
25
26    // Page 1: form in a grid
27    let form = tabs.add_page("Form");
28    let grid = Grid::new(form, 2);
29    Label::new(grid, "Name");
30    let name = TextInput::new(grid);
31    name.set_expand(1.0);
32    Label::new(grid, "Password");
33    TextInput::password(grid);
34    Label::new(grid, "Colour");
35    let combo = ComboBox::new(grid);
36    combo.set_items(&["Red", "Green", "Blue"]);
37    combo.set_selected(Some(0));
38    Label::new(grid, "Count");
39    let spin = SpinBox::new(grid, 0.0, 10.0, 1.0);
40    Label::new(grid, "Level");
41    let slider = Slider::new(grid, 0.0, 100.0);
42    let progress = ProgressBar::new(form);
43    slider.on_change(move |v| progress.set_fraction(v / 100.0));
44    spin.on_change(move |v| status.set_text(&format!("count = {v}")));
45    combo.on_select(move |i| status.set_text(&format!("colour index {i:?}")));
46
47    // Page 2: choices
48    let choices = tabs.add_page("Choices");
49    let boxed = GroupBox::new(choices, "Options");
50    let group = RadioGroup::new();
51    let a = RadioButton::new(boxed, &group, "Option A");
52    RadioButton::new(boxed, &group, "Option B");
53    a.set_checked(true);
54    let check = CheckBox::new(boxed, "Enabled");
55    check.set_checked(true);
56    let list = ListBox::new(choices);
57    list.set_items(&["alpha", "beta", "gamma", "delta"]);
58    list.set_expand(1.0);
59    list.on_activate(move |i| status.set_text(&format!("activated {i}")));
60
61    // Page 3: text; a vertical splitter with notes on top and a fixed-pitch, unwrapped view below
62    let notes = tabs.add_page("Notes");
63    let vsplit = Splitter::new(notes, Orientation::Vertical);
64    let area = TextArea::new(vsplit);
65    let code = TextArea::new(vsplit);
66    code.set_monospace(true);
67    code.set_wrap(false);
68    code.set_read_only(true);
69    code.set_text(
70        "fn main() {\n    println!(\"a long line that does not wrap: {}\", \"-\".repeat(60));\n}\n",
71    );
72    vsplit.set_position(120);
73    vsplit.set_min_pane_sizes(40, 40);
74    vsplit.on_move(move |p| status.set_text(&format!("notes split at {p}px")));
75    wrap.on_toggle(move |on| area.set_wrap(on));
76    mono.on_toggle(move |on| area.set_monospace(on));
77
78    // Page 4: table, tree and a context menu
79    let data = tabs.add_page("Data");
80    let split = Splitter::new(data, Orientation::Horizontal);
81    split.on_move(move |p| status.set_text(&format!("data split at {p}px")));
82    let table = Table::new(split);
83    table.set_columns(&[
84        Column::new("Name").width(140).sortable(true),
85        Column::new("Size")
86            .width(70)
87            .align(ColumnAlign::Right)
88            .sortable(true),
89    ]);
90    table.set_rows(&[
91        vec!["kernel", "9120"],
92        vec!["README", "312"],
93        vec!["Cargo.toml", "1024"],
94    ]);
95    table.on_select(move |r| status.set_text(&format!("row {r:?}")));
96    table.on_activate(move |r| status.set_text(&format!("row {r} activated")));
97    table.on_column_click(move |c| {
98        // sorting is the app's job: reorder the rows, then show the arrow
99        let ascending = table.sort_indicator() != Some((c, true));
100        let mut rows = table.rows();
101        rows.sort_by(|a, b| match c {
102            1 => a[1]
103                .parse::<u64>()
104                .unwrap_or(0)
105                .cmp(&b[1].parse::<u64>().unwrap_or(0)),
106            _ => a[c].cmp(&b[c]),
107        });
108        if !ascending {
109            rows.reverse();
110        }
111        table.set_rows(&rows);
112        table.set_sort_indicator(Some((c, ascending)));
113    });
114
115    let tree = Tree::new(split);
116    let src = tree.add(None, "src");
117    tree.add(Some(src), "lib.rs");
118    tree.add(Some(src), "core.rs");
119    let docs = tree.add(None, "doc");
120    tree.set_has_children(docs, true); // lazily filled when first expanded
121    tree.set_expanded(src, true);
122    tree.on_select(move |n| status.set_text(&format!("node {:?}", n.map(|n| tree.text(n)))));
123    tree.on_expand(move |n, open| {
124        if open && tree.children(Some(n)).is_empty() {
125            tree.add(Some(n), "DESIGN.md");
126            tree.add(Some(n), "BUILDING.md");
127        }
128    });
129
130    // Page 5: a calendar, a multi-select list and a prompt
131    let dates = tabs.add_page("Dates");
132    let cal = Calendar::new(dates);
133    cal.on_change(move |d| status.set_text(&format!("{}-{:02}-{:02}", d.year, d.month, d.day)));
134    let many = ListBox::new(dates);
135    many.set_items(&["one", "two", "three", "four"]);
136    many.set_multi_select(true);
137    many.set_expand(1.0);
138    many.on_selection(move |rows| status.set_text(&format!("selected {rows:?}")));
139    let ask = Button::new(dates, "Ask...");
140    ask.on_click(move || {
141        let r = prompt(Some(win), "Name", "What is your name?", "");
142        status.set_text(&format!("name: {r:?}"));
143    });
144
145    // Right-click the table for a context menu; its items are rebuilt/enabled just before display.
146    let popup = PopupMenu::new();
147    let del = MenuItem::new(popup, "Delete row");
148    MenuSeparator::new(popup);
149    let hdr = CheckMenuItem::new(popup, "Show sizes");
150    hdr.set_checked(true);
151    table.set_context_menu(popup);
152    table.on_context_menu(move |_, _| del.set_enabled(table.selected().is_some()));
153    del.on_click(move || {
154        if let Some(r) = table.selected() {
155            table.remove_row(r);
156        }
157    });
158    hdr.on_toggle(move |on| status.set_text(&format!("show sizes: {on}")));
159    tree.set_context_menu(popup);
160
161    open.on_click(move || {
162        if let Some(p) = FileDialog::new()
163            .title("Open")
164            .filter("Text", &["txt", "md"])
165            .open(Some(win))
166        {
167            if let Ok(s) = std::fs::read_to_string(&p) {
168                area.set_text(&s);
169            }
170            status.set_text(&format!("opened {}", p.display()));
171        }
172    });
173
174    // Buttons row
175    let row = HBox::new(root);
176    Spacer::new(row);
177    let about = Button::new(row, "About");
178    about.on_click(move || {
179        message_box(
180            Some(win),
181            MessageKind::Info,
182            Buttons::Ok,
183            "About",
184            "rungui kitchen sink",
185        );
186    });
187    let ok = Button::new(row, "Close");
188    ok.on_click(move || win.close());
189    ok.set_a11y_description("Closes the window");
190
191    let n = std::cell::Cell::new(0);
192    Timer::every(1000, move || {
193        n.set(n.get() + 1);
194        status.set_text(&format!("uptime {}s", n.get()));
195    });
196
197    win.set_size(480, 400);
198    win.show();
199    app.run();
200}
Source

pub fn size(&self) -> (i32, i32)

The client-area size: the last size set or reported by the user, else the size layout chose.

Source

pub fn set_resizable(&self, v: bool)

Allow or forbid resizing by the user.

Examples found in repository?
examples/file_manager/app.rs (line 1231)
1219    fn dialog(
1220        self: &Rc<Self>,
1221        title: &str,
1222        prompt: &str,
1223        initial: &str,
1224        action: impl Fn(&Rc<Fm>, &str) -> std::result::Result<(), String> + 'static,
1225    ) {
1226        if let Some(old) = self.st.borrow_mut().dialog.take() {
1227            old.destroy();
1228        }
1229        let w = Window::new(title);
1230        w.set_size(380, 150);
1231        w.set_resizable(false);
1232        let col = VBox::new(w);
1233        col.set_spacing(8);
1234        Label::new(col, prompt);
1235        let input = TextInput::new(col);
1236        input.set_text(initial);
1237        input.set_a11y_name(title);
1238        let err = Label::new(col, "");
1239        let row = HBox::new(col);
1240        row.set_spacing(8);
1241        Spacer::new(row);
1242        let cancel = Button::new(row, "Cancel");
1243        let ok = Button::new(row, "OK");
1244        self.st.borrow_mut().dialog = Some(w);
1245        self.dialog_ui.set(Some((w, input, ok, cancel)));
1246        trace!("DIALOG open {title}");
1247        {
1248            let fm = self.clone();
1249            ok.on_click(move || {
1250                let text = input.text();
1251                match action(&fm, text.trim()) {
1252                    Ok(()) => {
1253                        trace!("DIALOG done");
1254                        fm.st.borrow_mut().dialog = None;
1255                        w.destroy();
1256                    }
1257                    Err(e) => {
1258                        trace!("DIALOG error {e}");
1259                        err.set_text(&e);
1260                    }
1261                }
1262            });
1263            let fm = self.clone();
1264            cancel.on_click(move || {
1265                trace!("DIALOG cancel");
1266                fm.st.borrow_mut().dialog = None;
1267                w.destroy();
1268            });
1269            let fm = self.clone();
1270            w.on_close(move || {
1271                fm.st.borrow_mut().dialog = None;
1272                true
1273            });
1274        }
1275        w.show();
1276        input.focus();
1277        if tracing() {
1278            Timer::once(300, move || {
1279                for (n, wd) in [
1280                    ("dlg_input", *input),
1281                    ("dlg_ok", *ok),
1282                    ("dlg_cancel", *cancel),
1283                ] {
1284                    let r = wd.bounds();
1285                    println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
1286                }
1287            });
1288        }
1289    }
Source

pub fn show(&self)

Show the window (and lay it out).

Examples found in repository?
examples/hello.rs (line 12)
3fn main() {
4    let app = App::new("hello").expect("init");
5    let win = Window::new("Hello, rungui");
6    let col = VBox::new(win);
7    let label = Label::new(col, "Hello, wörld! こんにちは");
8    let name = TextInput::new(col);
9    name.set_placeholder("Your name");
10    let button = Button::new(col, "Greet");
11    button.on_click(move || label.set_text(&format!("Hello, {}!", name.text())));
12    win.show();
13    app.run();
14}
More examples
Hide additional examples
examples/smoke_layout.rs (line 41)
6fn main() {
7    let app = App::new("smoke-layout").expect("init");
8    let w = Window::new("smoke-layout");
9    w.set_position(120, 90);
10    let col = VBox::new(w);
11    let mono = TextInput::new(col);
12    mono.set_monospace(true);
13    mono.set_text("monospace entry");
14    let hs = Splitter::new(col, Orientation::Horizontal);
15    hs.set_position(200);
16    hs.set_min_pane_sizes(60, 60);
17    let area = TextArea::new(hs);
18    area.set_monospace(true);
19    area.set_wrap(false);
20    area.set_text("a long line that does not wrap: 0123456789 0123456789 0123456789 0123456789\n");
21    let table = Table::new(hs);
22    table.set_columns(&[Column::new("Name").width(80), Column::new("Size")]);
23    table.set_rows(&[vec!["a", "1"], vec!["b", "2"]]);
24    let vs = Splitter::new(col, Orientation::Vertical);
25    let tree = Tree::new(vs);
26    let r = tree.add(None, "root");
27    tree.add(Some(r), "kid");
28    let list = ListBox::new(vs);
29    list.set_items(&["one", "two"]);
30    table.on_select(|i| println!("TABLE_SEL {i:?}"));
31    tree.on_select(|n| println!("TREE_SEL {}", n.is_some()));
32    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
33    hs.on_move(|p| println!("HSPLIT {p}"));
34    vs.on_move(|p| println!("VSPLIT {p}"));
35    w.on_move(|x, y| println!("MOVED {x} {y}"));
36    w.on_resize(|w, h| println!("RESIZED {w} {h}"));
37    w.on_close(|| {
38        App::quit();
39        true
40    });
41    w.show();
42    let _t = Timer::once(600, move || {
43        println!("POS {:?}", w.position());
44        for (n, b) in [
45            ("hs", hs.bounds()),
46            ("vs", vs.bounds()),
47            ("table", table.bounds()),
48            ("tree", tree.bounds()),
49            ("area", area.bounds()),
50        ] {
51            println!("BOUNDS {n} {} {} {} {}", b.x, b.y, b.w, b.h);
52        }
53        println!("HPOS {} VPOS {}", hs.position(), vs.position());
54        println!(
55            "MONO {} {} WRAP {}",
56            mono.monospace(),
57            area.monospace(),
58            area.wrap()
59        );
60        println!("READY");
61    });
62    app.run();
63    println!("BYE");
64}
examples/smoke_dialogs.rs (line 47)
5fn main() {
6    let app = App::new("smoke-dialogs").expect("init");
7    let win = Window::new("smoke-dialogs");
8    let col = VBox::new(win);
9    let field = TextInput::new(col);
10    field.on_activate(|| println!("ACTIVATE"));
11    let ask = Button::new(col, "Ask");
12    ask.on_click(move || {
13        let r = Prompt::new("Rename").message("New name?").initial("old").run(Some(win));
14        println!("PROMPT {r:?}");
15    });
16    let modal = Button::new(col, "Modal");
17    modal.on_click(move || {
18        let d = Window::new("smoke-modal");
19        Label::new(d, "modal window");
20        let close = Button::new(d, "Close");
21        close.on_click(move || d.hide());
22        d.on_cancel(move || {
23            println!("MODAL_CANCEL");
24            d.hide();
25        });
26        println!("MODAL_OPEN");
27        d.run_modal(Some(win));
28        println!("MODAL_DONE");
29        d.destroy();
30    });
31    let list = ListBox::new(col);
32    list.set_items(&["one", "two", "three", "four", "five"]);
33    list.set_multi_select(true);
34    list.on_selection(|s| println!("LIST_SEL {s:?}"));
35    let table = Table::new(col);
36    table.set_columns(&[Column::new("Name").width(100)]);
37    table.set_rows(&[vec!["a"], vec!["b"], vec!["c"], vec!["d"]]);
38    table.set_multi_select(true);
39    table.on_selection(|s| println!("TABLE_SEL {s:?}"));
40    let cal = Calendar::new(col);
41    cal.set_date(Date::new(2031, 7, 4).unwrap());
42    cal.on_change(|d| println!("DATE {}-{:02}-{:02}", d.year, d.month, d.day));
43    win.on_close(|| {
44        App::quit();
45        true
46    });
47    win.show();
48    println!("TODAY {:?}", Date::today().is_valid());
49    let _t = Timer::once(600, move || {
50        for (n, w) in [
51            ("field", field.bounds()),
52            ("ask", ask.bounds()),
53            ("modal", modal.bounds()),
54            ("list", list.bounds()),
55            ("table", table.bounds()),
56            ("cal", cal.bounds()),
57        ] {
58            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
59        }
60        println!("READY");
61    });
62    let _exit = std::env::var("RUNGUI_EXIT_AFTER_MS")
63        .ok()
64        .and_then(|v| v.parse::<u32>().ok())
65        .map(|ms| Timer::once(ms, App::quit));
66    app.run();
67    println!("BYE");
68}
examples/smoke_controls.rs (line 80)
5fn main() {
6    let app = App::new("smoke").expect("init");
7    let a = Window::new("smoke-a");
8    let col = VBox::new(a);
9    let btn = Button::new(col, "Press ünï");
10    let txt = TextInput::new(col);
11    let chk = CheckBox::new(col, "Check");
12    let list = ListBox::new(col);
13    list.set_items(&["one", "two", "three"]);
14    let slider = Slider::new(col, 0.0, 100.0);
15    let combo = ComboBox::new(col);
16    combo.set_items(&["x", "y"]);
17    let dlg = Button::new(col, "Dialog");
18    dlg.on_click(move || {
19        let r = message_box(
20            Some(a),
21            MessageKind::Question,
22            Buttons::YesNo,
23            "Title ü",
24            "Really?",
25        );
26        println!("DIALOG {r:?}");
27    });
28    let g = RadioGroup::new();
29    let ra = RadioButton::new(col, &g, "Ra");
30    let rb = RadioButton::new(col, &g, "Rb");
31    ra.set_checked(true);
32    ra.on_toggle(|v| println!("RA {v}"));
33    rb.on_toggle(|v| println!("RB {v}"));
34    let table = Table::new(col);
35    table.set_columns(&[
36        Column::new("Name").width(80).sortable(true),
37        Column::new("Size").align(ColumnAlign::Right),
38    ]);
39    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
40    table.on_select(|i| println!("TABLE_SEL {i:?}"));
41    table.on_column_click(|c| println!("TABLE_COL {c}"));
42    let tree = Tree::new(col);
43    let root = tree.add(None, "root");
44    let kid = tree.add(Some(root), "kid");
45    let lazy = tree.add(None, "lazy");
46    tree.set_has_children(lazy, true);
47    let _ = kid;
48    tree.on_select(|n| println!("TREE_SEL {}", n.is_some()));
49    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
50    a.set_context_menu({
51        let p = PopupMenu::new();
52        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
53        p
54    });
55    btn.on_click(|| println!("CLICK"));
56    txt.on_change(|t| println!("TEXT {t}"));
57    chk.on_toggle(|b| println!("TOGGLE {b}"));
58    list.on_select(|i| println!("SELECT {i:?}"));
59    slider.on_change(|v| println!("VALUE {v:.0}"));
60    combo.on_select(|i| println!("COMBO {i:?}"));
61    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
62    a.on_close(|| {
63        println!("CLOSE_REQUESTED");
64        true
65    });
66
67    let b = Window::new("smoke-b");
68    let bar = MenuBar::new(b);
69    let file = Menu::new(bar, "File");
70    let item = MenuItem::new(file, "Quit");
71    item.set_accel("Ctrl+Q");
72    item.on_click(|| {
73        println!("MENU_QUIT");
74        App::quit();
75    });
76    let ck = CheckMenuItem::new(file, "Flag");
77    ck.on_toggle(|v| println!("MENUTOGGLE {v}"));
78    Label::new(b, "second window");
79
80    a.show();
81    b.show();
82    println!(
83        "HANDLE {}",
84        a.native_handle().is_some() && btn.native_handle().is_some()
85    );
86    let _t = Timer::once(600, move || {
87        for (n, w) in [
88            ("btn", btn.bounds()),
89            ("txt", txt.bounds()),
90            ("chk", chk.bounds()),
91            ("list", list.bounds()),
92            ("slider", slider.bounds()),
93            ("combo", combo.bounds()),
94            ("dlg", dlg.bounds()),
95            ("rb", rb.bounds()),
96            ("table", table.bounds()),
97            ("tree", tree.bounds()),
98        ] {
99            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
100        }
101        println!("READY");
102    });
103    // CI: RUNGUI_EXIT_AFTER_MS=n quits the loop after n ms so a startup crash shows up as a failure.
104    let _exit = std::env::var("RUNGUI_EXIT_AFTER_MS")
105        .ok()
106        .and_then(|v| v.parse::<u32>().ok())
107        .map(|ms| Timer::once(ms, App::quit));
108    app.run();
109    println!("BYE");
110}
examples/smoke_cocoa.rs (line 108)
6fn main() {
7    let app = App::new("smoke-cocoa").expect("init");
8    let a = Window::new("cc-a");
9    let bar = MenuBar::new(a);
10    let file = Menu::new(bar, "File");
11    let flag = CheckMenuItem::new(file, "Flag");
12    flag.set_accel("Ctrl+K");
13    flag.on_toggle(|v| println!("MENUTOGGLE {v}"));
14    let go = MenuItem::new(file, "Go");
15    go.set_accel("Ctrl+Shift+G");
16    go.on_click(|| println!("MENU_GO"));
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(|| {
20        println!("MENU_QUIT");
21        App::quit();
22    });
23
24    let col = VBox::new(a);
25    let row = HBox::new(col);
26    let btn = Button::new(row, "Press ünï");
27    let spin = SpinBox::new(row, 0.0, 10.0, 1.0);
28    let txt = TextInput::new(col);
29    let chk = CheckBox::new(col, "Monospace");
30    let hs = Splitter::new(col, Orientation::Horizontal);
31    let ta1 = TextArea::new(hs);
32    let ta2 = TextArea::new(hs);
33    ta2.set_text(
34        "long line without wrapping: 0123456789 0123456789 0123456789 0123456789 0123456789",
35    );
36    ta2.set_wrap(false);
37    hs.set_position(200);
38    hs.set_min_pane_sizes(60, 60);
39    let slider = Slider::new(col, 0.0, 100.0);
40    let combo = ComboBox::new(col);
41    combo.set_items(&["x", "y", "z"]);
42    let tabs = Tabs::new(col);
43    let p1 = tabs.add_page("First");
44    let p2 = tabs.add_page("Second");
45    Label::new(p1, "page one");
46    Label::new(p2, "page two");
47    let vs = Splitter::new(col, Orientation::Vertical);
48    let table = Table::new(vs);
49    table.set_columns(&[
50        Column::new("Name").width(80).sortable(true),
51        Column::new("Size").align(ColumnAlign::Right),
52    ]);
53    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
54    let tree = Tree::new(vs);
55    let root = tree.add(None, "root");
56    tree.add(Some(root), "kid");
57    let lazy = tree.add(None, "lazy");
58    tree.set_has_children(lazy, true);
59    vs.set_position(100);
60    vs.set_min_pane_sizes(40, 40);
61
62    btn.on_click(|| println!("CLICK"));
63    spin.on_change(|v| println!("SPIN {v}"));
64    txt.on_change(|t| println!("TEXT {t}"));
65    ta1.on_change(|t| println!("AREA {}", t.replace('\n', "|")));
66    chk.on_toggle(move |on| {
67        println!("MONO {on}");
68        txt.set_monospace(on);
69        ta1.set_monospace(on);
70    });
71    hs.on_move(|p| println!("HSPLIT {p}"));
72    vs.on_move(|p| println!("VSPLIT {p}"));
73    slider.on_change(|v| println!("VALUE {v:.0}"));
74    combo.on_select(|i| println!("COMBO {i:?}"));
75    tabs.on_select(|i| println!("TAB {i:?}"));
76    table.on_select(|i| println!("TABLE_SEL {i:?}"));
77    table.on_column_click(move |c| {
78        let ascending = table.sort_indicator() != Some((c, true));
79        let mut rows = table.rows();
80        rows.sort_by(|x, y| x[c].cmp(&y[c]));
81        if !ascending {
82            rows.reverse();
83        }
84        table.set_rows(&rows);
85        table.set_sort_indicator(Some((c, ascending)));
86        println!(
87            "TABLE_COL {c} {} {}",
88            if ascending { "asc" } else { "desc" },
89            rows[0][0]
90        );
91    });
92    tree.on_select(move |n| println!("TREE_SEL {}", n.is_some()));
93    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
94    a.set_context_menu({
95        let p = PopupMenu::new();
96        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
97        p
98    });
99    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
100    a.on_move(|x, y| println!("MOVED {x} {y}"));
101    a.set_min_size(300, 400);
102    a.set_position(220, 100);
103    a.set_size(560, 700);
104    a.on_close(|| {
105        println!("CLOSE_REQUESTED");
106        true
107    });
108    a.show();
109    println!(
110        "HANDLE {}",
111        a.native_handle().is_some() && btn.native_handle().is_some()
112    );
113    let _t = Timer::once(700, move || {
114        for (n, w) in [
115            ("btn", btn.bounds()),
116            ("spin", spin.bounds()),
117            ("txt", txt.bounds()),
118            ("chk", chk.bounds()),
119            ("hs", hs.bounds()),
120            ("slider", slider.bounds()),
121            ("combo", combo.bounds()),
122            ("tabs", tabs.bounds()),
123            ("vs", vs.bounds()),
124            ("table", table.bounds()),
125            ("tree", tree.bounds()),
126        ] {
127            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
128        }
129        println!("SPLITPOS h {} v {}", hs.position(), vs.position());
130        println!("READY");
131    });
132    app.run();
133    println!("BYE");
134}
examples/file_manager/app.rs (line 355)
162pub fn build(opts: Options) -> Rc<Fm> {
163    let win = Window::new("File Manager");
164    win.set_size(1000, 700);
165    win.set_min_size(640, 420);
166
167    // ---- menus (accelerators are the keyboard interface; there is no key-event API)
168    let bar = MenuBar::new(win);
169    let file = Menu::new(bar, "File");
170    let new_folder = MenuItem::new(file, "New Folder");
171    new_folder.set_accel("F7");
172    let rename = MenuItem::new(file, "Rename");
173    rename.set_accel("F2");
174    MenuSeparator::new(file);
175    let copy = MenuItem::new(file, "Copy to Other Pane");
176    copy.set_accel("F5");
177    let mv = MenuItem::new(file, "Move to Other Pane");
178    mv.set_accel("F6");
179    let delete = MenuItem::new(file, "Delete");
180    delete.set_accel("F8");
181    MenuSeparator::new(file);
182    let quit = MenuItem::new(file, "Quit");
183    quit.set_accel("Ctrl+Q");
184    let view = Menu::new(bar, "View");
185    let hidden = CheckMenuItem::new(view, "Show Hidden Files");
186    hidden.set_accel("Ctrl+H");
187    let refresh_item = MenuItem::new(view, "Refresh");
188    refresh_item.set_accel("Ctrl+R");
189    let go = Menu::new(bar, "Go");
190    let up_item = MenuItem::new(go, "Up One Level");
191    up_item.set_accel("Alt+Up");
192    let home_item = MenuItem::new(go, "Home Folder");
193    home_item.set_accel("Alt+Home");
194    let switch = MenuItem::new(go, "Switch Active Pane");
195    switch.set_accel("F9");
196    let helpm = Menu::new(bar, "Help");
197    let about = MenuItem::new(helpm, "About");
198
199    // ---- layout
200    let root = VBox::new(win);
201    root.set_spacing(6);
202    root.set_expand(1.0); // a window stacks its children vertically; give the whole area to this one
203
204    let tools = HBox::new(root);
205    tools.set_spacing(6);
206    let up = Button::new(tools, "\u{2191} Up");
207    up.set_tooltip("Go to the parent folder (Alt+Up)");
208    let refresh = Button::new(tools, "Refresh");
209    refresh.set_tooltip("Reload both panes (Ctrl+R)");
210    let path = TextInput::new(tools);
211    path.set_expand(1.0);
212    path.set_monospace(true);
213    path.set_tooltip("Type a folder path to open it in the active pane");
214    path.set_a11y_name("Path of the active pane");
215    let copy_btn = Button::new(tools, "Copy \u{2192}");
216    copy_btn.set_tooltip("Copy the selected item to the other pane (F5)");
217    let move_btn = Button::new(tools, "Move \u{2192}");
218    move_btn.set_tooltip("Move the selected item to the other pane (F6)");
219
220    let body = Splitter::new(root, Orientation::Horizontal);
221    body.set_expand(1.0);
222    let tree = Tree::new(body);
223    tree.set_a11y_name("Folders");
224    let right = Splitter::new(body, Orientation::Vertical);
225    let panes = Splitter::new(right, Orientation::Horizontal);
226    let mut tables = Vec::new();
227    let mut pane_labels = Vec::new();
228    for (i, n) in PANE_NAMES.iter().enumerate() {
229        let col = VBox::new(panes);
230        col.set_spacing(2);
231        pane_labels.push(Label::new(col, ""));
232        let t = Table::new(col);
233        t.set_expand(1.0);
234        t.set_a11y_name(&format!("Files, pane {n}"));
235        t.set_columns(&[
236            Column::new("Name").width(125).sortable(true),
237            Column::new("Size")
238                .width(62)
239                .align(ColumnAlign::Right)
240                .sortable(true),
241            Column::new("Modified").width(128).sortable(true),
242            Column::new("Kind").width(90).sortable(true),
243        ]);
244        let _ = i;
245        tables.push(t);
246    }
247    let pv = VBox::new(right);
248    pv.set_spacing(2);
249    let preview_title = Label::new(pv, "Preview");
250    let pv_row = HBox::new(pv);
251    pv_row.set_expand(1.0);
252    let image = Image::new(pv_row);
253    image.set_visible(false);
254    image.set_align(Align::Start);
255    let preview = TextArea::new(pv_row);
256    preview.set_expand(1.0);
257    preview.set_read_only(true);
258    preview.set_monospace(true);
259    preview.set_wrap(false);
260    preview.set_a11y_name("Preview");
261
262    let sbar = HBox::new(root);
263    let status = Label::new(sbar, "");
264    status.set_expand(1.0);
265    let tag = Label::new(sbar, "");
266
267    body.set_position(170);
268    body.set_min_pane_sizes(100, 300);
269    right.set_position(400);
270    right.set_min_pane_sizes(120, 80);
271    panes.set_min_pane_sizes(180, 180);
272
273    // ---- context menu shared by both tables
274    let popup = PopupMenu::new();
275    let ctx_open = MenuItem::new(popup, "Open");
276    let ctx_rename = MenuItem::new(popup, "Rename...");
277    let ctx_delete = MenuItem::new(popup, "Delete...");
278    MenuSeparator::new(popup);
279    let ctx_copy = MenuItem::new(popup, "Copy to Other Pane");
280    let ctx_new = MenuItem::new(popup, "New Folder...");
281    for t in &tables {
282        t.set_context_menu(popup);
283    }
284
285    let ui = Ui {
286        win,
287        body,
288        right,
289        panes,
290        tree,
291        tables: [tables[0], tables[1]],
292        pane_labels: [pane_labels[0], pane_labels[1]],
293        path,
294        up,
295        refresh,
296        copy_btn,
297        move_btn,
298        preview_title,
299        preview,
300        image,
301        status,
302        tag,
303        popup,
304        items: Items {
305            new_folder,
306            rename,
307            copy,
308            mv,
309            delete,
310            quit,
311            hidden,
312            refresh: refresh_item,
313            up: up_item,
314            home: home_item,
315            switch,
316            about,
317            ctx_open,
318            ctx_rename,
319            ctx_delete,
320            ctx_copy,
321            ctx_new,
322        },
323    };
324    let fm = Rc::new(Fm {
325        ui,
326        st: RefCell::new(State::default()),
327        quiet: Cell::new(0),
328        typing: Cell::new(false),
329        dialog_ui: Cell::new(None),
330    });
331    fm.wire();
332    fm.init_tree();
333    {
334        let mut st = fm.st.borrow_mut();
335        for p in &opts.dirs {
336            st.panes.push(Pane {
337                path: p.clone(),
338                entries: vec![],
339                sort: (SortKey::Name, true),
340                mtime: None,
341                truncated: false,
342            });
343        }
344    }
345    for (i, p) in opts.dirs.iter().enumerate() {
346        if !fm.navigate(i, p.clone(), None, true, false) {
347            // an unreadable start directory falls back to the home folder, then to "/"
348            let fallback = home_dir().unwrap_or_else(|| PathBuf::from("/"));
349            fm.navigate(i, fallback, None, true, false);
350        }
351    }
352    fm.set_active(0);
353    let first = fm.path_of(0);
354    fm.tree_reveal(&first);
355    fm.ui.win.show();
356    fm
357}
358
359impl Fm {
360    fn wire(self: &Rc<Self>) {
361        let u = &self.ui;
362        let it = u.items;
363        macro_rules! click {
364            ($btn:expr, $f:ident) => {{
365                let fm = self.clone();
366                $btn.on_click(move || fm.$f());
367            }};
368        }
369        click!(it.new_folder, op_new_folder);
370        click!(it.ctx_new, op_new_folder);
371        click!(it.rename, op_rename);
372        click!(it.ctx_rename, op_rename);
373        click!(it.delete, op_delete);
374        click!(it.ctx_delete, op_delete);
375        click!(it.copy, op_copy);
376        click!(it.ctx_copy, op_copy);
377        click!(u.copy_btn, op_copy);
378        click!(it.mv, op_move);
379        click!(u.move_btn, op_move);
380        click!(it.ctx_open, op_open);
381        click!(it.refresh, refresh_all);
382        click!(u.refresh, refresh_all);
383        click!(it.up, go_up);
384        click!(u.up, go_up);
385        click!(it.home, go_home);
386        click!(it.switch, switch_pane);
387        click!(it.about, about);
388        it.quit.on_click(App::quit);
389        {
390            let fm = self.clone();
391            it.hidden.on_toggle(move |on| fm.set_show_hidden(on));
392        }
393        for i in 0..2 {
394            let t = u.tables[i];
395            let fm = self.clone();
396            t.on_select(move |r| fm.on_row_selected(i, r));
397            let fm = self.clone();
398            t.on_activate(move |r| fm.on_row_activated(i, r));
399            let fm = self.clone();
400            t.on_column_click(move |c| fm.sort_by_column(i, c));
401            let fm = self.clone();
402            t.on_context_menu(move |_, _| fm.prepare_context_menu(i));
403        }
404        {
405            let fm = self.clone();
406            u.path.on_change(move |text| fm.on_path_typed(text));
407        }
408        {
409            let fm = self.clone();
410            u.tree.on_select(move |n| fm.on_tree_selected(n));
411            let fm = self.clone();
412            u.tree.on_expand(move |n, open| {
413                if open {
414                    fm.tree_load(n);
415                }
416            });
417        }
418        {
419            let fm = self.clone();
420            u.win.on_resize(move |w, h| {
421                trace!("RESIZE {w} {h}");
422                fm.relabel_soon();
423            });
424            for sp in [u.body, u.right, u.panes] {
425                let fm = self.clone();
426                sp.on_move(move |_| fm.relabel_soon());
427            }
428        }
429        // pick up changes made by other programs
430        let fm = self.clone();
431        Timer::every(1500, move || fm.poll());
432        // report geometry once the first layout has happened
433        let fm = self.clone();
434        Timer::once(500, move || {
435            fm.print_bounds();
436            trace!("READY");
437        });
438    }
439
440    // ---------------------------------------------------------------- state helpers
441
442    pub fn path_of(&self, pane: usize) -> PathBuf {
443        self.st
444            .borrow()
445            .panes
446            .get(pane)
447            .map(|p| p.path.clone())
448            .unwrap_or_default()
449    }
450
451    pub fn active(&self) -> usize {
452        self.st.borrow().active
453    }
454
455    fn entry_at(&self, pane: usize, row: usize) -> Option<Entry> {
456        self.st.borrow().panes.get(pane)?.entries.get(row).cloned()
457    }
458
459    /// The selected entry of `pane`, or None (nothing selected). The ".." row counts.
460    pub fn selected(&self, pane: usize) -> Option<Entry> {
461        let row = self.ui.tables[pane].selected()?;
462        self.entry_at(pane, row)
463    }
464
465    /// The selected real item (not "..") of the active pane.
466    fn target(&self) -> Option<Entry> {
467        self.selected(self.active()).filter(|e| !e.is_parent)
468    }
469
470    pub fn say(&self, msg: &str) {
471        self.ui.status.set_text(msg);
472        trace!("STATUS {msg}");
473    }
474
475    fn quietly<R>(&self, f: impl FnOnce() -> R) -> R {
476        self.quiet.set(self.quiet.get() + 1);
477        let r = f();
478        self.quiet.set(self.quiet.get() - 1);
479        r
480    }
481
482    // ---------------------------------------------------------------- navigation
483
484    /// Show `path` in `pane`. `select` picks a row afterwards (e.g. the folder we came from).
485    /// `reveal` also selects the folder in the tree. Returns false (and says why) on failure.
486    pub fn navigate(
487        self: &Rc<Self>,
488        pane: usize,
489        path: PathBuf,
490        select: Option<PathBuf>,
491        reveal: bool,
492        from_box: bool,
493    ) -> bool {
494        let hidden = self.st.borrow().show_hidden;
495        let listing = match fsm::read_dir(&path, hidden) {
496            Ok(l) => l,
497            Err(e) => {
498                self.say(&format!("Cannot open {}: {}", path.display(), e));
499                trace!("ERROR NAV {} {}", PANE_NAMES[pane], path.display());
500                return false;
501            }
502        };
503        let n = listing.entries.len();
504        let truncated = listing.truncated;
505        {
506            let mut st = self.st.borrow_mut();
507            let Some(p) = st.panes.get_mut(pane) else {
508                return false;
509            };
510            let mut entries = listing.entries;
511            fsm::sort_entries(&mut entries, p.sort.0, p.sort.1);
512            if let Some(parent) = Entry::parent_of(&path) {
513                entries.insert(0, parent);
514            }
515            p.mtime = std::fs::metadata(&path).and_then(|m| m.modified()).ok();
516            p.entries = entries;
517            p.path = path.clone();
518            p.truncated = truncated;
519        }
520        self.populate(pane, select.as_deref());
521        self.typing.set(from_box);
522        self.set_active(pane);
523        self.refresh_labels();
524        self.typing.set(false);
525        if reveal {
526            self.tree_reveal(&path);
527        }
528        // select + preview the requested row, else preview the directory itself
529        let row = select.and_then(|s| {
530            self.st.borrow().panes[pane]
531                .entries
532                .iter()
533                .position(|e| e.path == s)
534        });
535        match row {
536            Some(r) => self.on_row_selected(pane, Some(r)),
537            None => {
538                self.show_preview(Entry::from_path(&path));
539                self.update_status();
540            }
541        }
542        trace!("NAV {} {} {}", PANE_NAMES[pane], path.display(), n);
543        if truncated {
544            self.say(&format!(
545                "Showing only the first {} entries of {}",
546                fsm::MAX_ENTRIES,
547                path.display()
548            ));
549        }
550        true
551    }
552
553    /// Re-read `pane`, keeping the selected item selected when it still exists.
554    fn reload(self: &Rc<Self>, pane: usize, keep: Option<PathBuf>) {
555        let path = self.path_of(pane);
556        let keep = keep.or_else(|| self.selected(pane).map(|e| e.path));
557        if self.navigate_quiet(pane, &path, keep.clone()) {
558            return;
559        }
560        // the directory vanished: climb to the nearest one that exists
561        let mut p = path.clone();
562        while let Some(parent) = p.parent().map(Path::to_path_buf) {
563            if parent.is_dir() && self.navigate(pane, parent.clone(), Some(p.clone()), true, false)
564            {
565                return;
566            }
567            p = parent;
568        }
569    }
570
571    /// Like `navigate` for the same directory but without the active-pane, tree and preview churn
572    /// unless the selection changed. Returns false if the directory cannot be read.
573    fn navigate_quiet(self: &Rc<Self>, pane: usize, path: &Path, keep: Option<PathBuf>) -> bool {
574        let hidden = self.st.borrow().show_hidden;
575        let Ok(listing) = fsm::read_dir(path, hidden) else {
576            return false;
577        };
578        {
579            let mut st = self.st.borrow_mut();
580            let p = &mut st.panes[pane];
581            let mut entries = listing.entries;
582            fsm::sort_entries(&mut entries, p.sort.0, p.sort.1);
583            if let Some(parent) = Entry::parent_of(path) {
584                entries.insert(0, parent);
585            }
586            p.mtime = std::fs::metadata(path).and_then(|m| m.modified()).ok();
587            p.entries = entries;
588            p.truncated = listing.truncated;
589        }
590        self.populate(pane, keep.as_deref());
591        if pane == self.active() {
592            let row = keep.and_then(|s| {
593                self.st.borrow().panes[pane]
594                    .entries
595                    .iter()
596                    .position(|e| e.path == s)
597            });
598            self.show_preview(
599                row.and_then(|r| self.entry_at(pane, r))
600                    .or_else(|| Entry::from_path(path)),
601            );
602        }
603        self.update_status();
604        true
605    }
606
607    #[allow(dead_code)] // used by tests/file_manager_mock.rs
608    /// Test helper: navigate without touching the tree.
609    pub fn navigate_for_test(self: &Rc<Self>, pane: usize, path: PathBuf) -> bool {
610        self.navigate(pane, path, None, false, false)
611    }
612
613    pub fn refresh_all(self: &Rc<Self>) {
614        for i in 0..2 {
615            self.reload(i, None);
616        }
617        self.say("Refreshed");
618        trace!("REFRESH");
619    }
620
621    /// Timer: reload panes whose directory changed on disk.
622    fn poll(self: &Rc<Self>) {
623        #[allow(clippy::needless_range_loop)]
624        for i in 0..2 {
625            let (path, old) = {
626                let st = self.st.borrow();
627                match st.panes.get(i) {
628                    Some(p) => (p.path.clone(), p.mtime),
629                    None => return,
630                }
631            };
632            let now = std::fs::metadata(&path).and_then(|m| m.modified()).ok();
633            if now != old {
634                trace!("CHANGED {}", PANE_NAMES[i]);
635                self.reload(i, None);
636            }
637        }
638    }
639
640    pub fn go_up(self: &Rc<Self>) {
641        let a = self.active();
642        let cur = self.path_of(a);
643        if let Some(parent) = cur.parent() {
644            self.navigate(a, parent.to_path_buf(), Some(cur.clone()), true, false);
645        }
646    }
647
648    fn go_home(self: &Rc<Self>) {
649        if let Some(h) = home_dir() {
650            let a = self.active();
651            self.navigate(a, h, None, true, false);
652        }
653    }
654
655    fn switch_pane(self: &Rc<Self>) {
656        let other = 1 - self.active();
657        self.set_active(other);
658        self.ui.tables[other].focus();
659    }
660
661    fn set_show_hidden(self: &Rc<Self>, on: bool) {
662        self.st.borrow_mut().show_hidden = on;
663        trace!("HIDDEN {on}");
664        for i in 0..2 {
665            self.reload(i, None);
666        }
667        // rebuild the folder tree so hidden folders appear or vanish too
668        self.init_tree();
669        let a = self.active();
670        let p = self.path_of(a);
671        self.tree_reveal(&p);
672    }
673
674    fn on_path_typed(self: &Rc<Self>, text: &str) {
675        if self.typing.get() {
676            return;
677        }
678        let a = self.active();
679        let t = text.trim();
680        if t.is_empty() || Path::new(t) == self.path_of(a) {
681            return;
682        }
683        let p = PathBuf::from(t);
684        if p.is_dir() {
685            self.navigate(a, p, None, true, true);
686        }
687    }
688
689    pub fn set_active(&self, pane: usize) {
690        let changed = {
691            let mut st = self.st.borrow_mut();
692            let c = st.active != pane;
693            st.active = pane;
694            c
695        };
696        self.refresh_labels();
697        if changed {
698            trace!("ACTIVE {}", PANE_NAMES[pane]);
699        }
700    }
701
702    /// The pane captions depend on the pane widths, which are known only after layout.
703    fn relabel_soon(self: &Rc<Self>) {
704        let fm = self.clone();
705        Timer::once(10, move || fm.refresh_labels());
706    }
707
708    /// Pane captions, path box, window title and the active-pane tag.
709    fn refresh_labels(&self) {
710        let (active, paths) = {
711            let st = self.st.borrow();
712            (
713                st.active,
714                st.panes.iter().map(|p| p.path.clone()).collect::<Vec<_>>(),
715            )
716        };
717        for (i, p) in paths.iter().enumerate() {
718            let mark = if i == active { "\u{25B6}" } else { " " };
719            // labels do not clip, so fit the path to the pane (about 7 px per character)
720            let room = (self.ui.tables[i].bounds().w / 7).max(12) as usize;
721            let head = format!("{mark} {}  ", PANE_NAMES[i]);
722            let path = fsm::ellipsize_path(
723                &p.display().to_string(),
724                room.saturating_sub(head.chars().count()),
725            );
726            self.ui.pane_labels[i].set_text(&format!("{head}{path}"));
727        }
728        let cur = paths.get(active).cloned().unwrap_or_default();
729        let text = cur.display().to_string();
730        if self.ui.path.text() != text && !self.typing.get() {
731            self.ui.path.set_text(&text);
732        }
733        let name = cur
734            .file_name()
735            .map(|n| n.to_string_lossy().into_owned())
736            .unwrap_or_else(|| text.clone());
737        self.ui
738            .win
739            .set_title(&format!("{name} [{}] - File Manager", PANE_NAMES[active]));
740        self.ui
741            .tag
742            .set_text(&format!("  Active pane: {}", PANE_NAMES[active]));
743        self.ui.up.set_enabled(cur.parent().is_some());
744    }
745
746    // ---------------------------------------------------------------- table
747
748    /// Fill a pane's table from its entries. Uses one `batch` so huge directories send one update.
749    fn populate(&self, pane: usize, select: Option<&Path>) {
750        let (rows, sort, sel) = {
751            let st = self.st.borrow();
752            let p = &st.panes[pane];
753            let rows: Vec<Vec<String>> = p.entries.iter().map(row_of).collect();
754            (
755                rows,
756                p.sort,
757                select.and_then(|s| p.entries.iter().position(|e| e.path == s)),
758            )
759        };
760        let t = self.ui.tables[pane];
761        self.quietly(|| {
762            t.batch(|t| t.set_rows(&rows));
763            t.set_sort_indicator(Some((sort.0.column(), sort.1)));
764            t.set_selected(sel);
765        });
766    }
767
768    fn sort_by_column(self: &Rc<Self>, pane: usize, col: usize) {
769        let key = SortKey::from_column(col);
770        let keep = self.selected(pane).map(|e| e.path);
771        {
772            let mut st = self.st.borrow_mut();
773            let Some(p) = st.panes.get_mut(pane) else {
774                return;
775            };
776            let asc = if p.sort.0 == key { !p.sort.1 } else { true };
777            p.sort = (key, asc);
778            let has_parent = p.entries.first().is_some_and(|e| e.is_parent);
779            fsm::sort_entries(&mut p.entries[has_parent as usize..], key, asc);
780        }
781        self.populate(pane, keep.as_deref());
782        let (k, asc) = self.st.borrow().panes[pane].sort;
783        trace!(
784            "SORT {} {} {}",
785            PANE_NAMES[pane],
786            k.column(),
787            if asc { "asc" } else { "desc" }
788        );
789    }
790
791    fn on_row_selected(self: &Rc<Self>, pane: usize, row: Option<usize>) {
792        if self.quiet.get() > 0 {
793            return;
794        }
795        self.set_active(pane);
796        let e = row.and_then(|r| self.entry_at(pane, r));
797        if let Some(e) = &e {
798            trace!("SELECT {} {}", PANE_NAMES[pane], e.name);
799        }
800        self.show_preview(e);
801        self.update_status();
802    }
803
804    fn on_row_activated(self: &Rc<Self>, pane: usize, row: usize) {
805        self.set_active(pane);
806        let Some(e) = self.entry_at(pane, row) else {
807            return;
808        };
809        self.open_entry(pane, e);
810    }
811
812    fn open_entry(self: &Rc<Self>, pane: usize, e: Entry) {
813        if e.is_dir {
814            let from = self.path_of(pane);
815            let select = e.is_parent.then_some(from);
816            self.navigate(pane, e.path, select, true, false);
817        } else {
818            trace!("OPEN {} {}", PANE_NAMES[pane], e.name);
819            self.show_preview(Some(e));
820        }
821    }
822
823    fn op_open(self: &Rc<Self>) {
824        if let Some(e) = self.selected(self.active()) {
825            self.open_entry(self.active(), e);
826        }
827    }
828
829    /// Runs just before the popup is shown: right-clicking a pane makes it the active one.
830    fn prepare_context_menu(&self, pane: usize) {
831        self.set_active(pane);
832        let sel = self.selected(pane);
833        let real = sel.as_ref().is_some_and(|e| !e.is_parent);
834        let it = self.ui.items;
835        it.ctx_open.set_enabled(sel.is_some());
836        it.ctx_rename.set_enabled(real);
837        it.ctx_delete.set_enabled(real);
838        it.ctx_copy.set_enabled(real);
839    }
840
841    // ---------------------------------------------------------------- preview and status
842
843    fn show_preview(&self, e: Option<Entry>) {
844        let u = &self.ui;
845        let Some(e) = e else {
846            u.preview_title.set_text("Preview");
847            u.preview.set_text("");
848            u.image.set_image(None);
849            u.image.set_visible(false);
850            return;
851        };
852        let p = fsm::preview(&e);
853        let (what, extra) = match &p {
854            Preview::Text { truncated, .. } => (
855                "text",
856                if *truncated {
857                    format!(" (first {} KB)", fsm::PREVIEW_LIMIT / 1024)
858                } else {
859                    String::new()
860                },
861            ),
862            Preview::Hex { .. } => (
863                "binary",
864                format!(" (hex dump of the first {} bytes)", fsm::HEX_LIMIT),
865            ),
866            Preview::Dir(_) => ("folder", String::new()),
867            Preview::Image { img, .. } => ("image", format!(" ({} x {})", img.w, img.h)),
868            Preview::Error(_) => ("error", String::new()),
869        };
870        u.preview_title.set_text(&format!(
871            "Preview: {}{extra}",
872            if e.is_parent { ".." } else { &e.name }
873        ));
874        u.preview.set_text(p.body());
875        match &p {
876            Preview::Image { img, .. } => {
877                u.image.set_image(Some(&scaled(img)));
878                u.image.set_visible(true);
879            }
880            _ => {
881                u.image.set_image(None);
882                u.image.set_visible(false);
883            }
884        }
885        trace!("PREVIEW {what} {} {}", p.shown_bytes(), e.name);
886    }
887
888    fn update_status(&self) {
889        let a = self.active();
890        let (n, dirs, total, trunc, sel) = {
891            let st = self.st.borrow();
892            let p = &st.panes[a];
893            let real: Vec<&Entry> = p.entries.iter().filter(|e| !e.is_parent).collect();
894            let dirs = real.iter().filter(|e| e.is_dir).count();
895            let total: u64 = real.iter().filter(|e| !e.is_dir).map(|e| e.size).sum();
896            (real.len(), dirs, total, p.truncated, p.entries.len())
897        };
898        let _ = sel;
899        let mut s = format!(
900            "{n} items ({dirs} folders, {} files), {} in files",
901            n - dirs,
902            fsm::human_size(total)
903        );
904        if trunc {
905            s.push_str(" (truncated)");
906        }
907        if let Some(e) = self.selected(a) {
908            s.push_str(&format!("   |   {}", fsm::describe(&e)));
909        }
910        self.ui.status.set_text(&s);
911        trace!("STATUS {s}");
912    }
913
914    fn print_bounds(&self) {
915        if !tracing() {
916            return;
917        }
918        let u = &self.ui;
919        let (b, ids): (Rect, Vec<(&str, Widget)>) = (
920            u.win.bounds(),
921            vec![
922                ("tree", *u.tree),
923                ("tableA", *u.tables[0]),
924                ("tableB", *u.tables[1]),
925                ("labelA", *u.pane_labels[0]),
926                ("labelB", *u.pane_labels[1]),
927                ("preview", *u.preview),
928                ("image", *u.image),
929                ("path", *u.path),
930                ("up", *u.up),
931                ("refresh", *u.refresh),
932                ("copy", *u.copy_btn),
933                ("move", *u.move_btn),
934                ("status", *u.status),
935                ("body", *u.body),
936                ("right", *u.right),
937                ("panes", *u.panes),
938            ],
939        );
940        let _ = b;
941        for (n, w) in ids {
942            let r = w.bounds();
943            println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
944        }
945    }
946
947    // ---------------------------------------------------------------- tree
948
949    fn init_tree(self: &Rc<Self>) {
950        let t = self.ui.tree;
951        t.clear();
952        let mut roots: Vec<(String, PathBuf)> = Vec::new();
953        if let Some(h) = home_dir() {
954            roots.push(("Home".into(), h));
955        }
956        #[cfg(windows)]
957        for d in b'A'..=b'Z' {
958            let p = PathBuf::from(format!("{}:\\", d as char));
959            if p.is_dir() {
960                roots.push((format!("{}:\\", d as char), p));
961            }
962        }
963        #[cfg(not(windows))]
964        roots.push(("File System (/)".into(), PathBuf::from("/")));
965        let mut st = self.st.borrow_mut();
966        st.node_paths.clear();
967        st.loaded.clear();
968        for (name, p) in roots {
969            let n = t.add(None, &name);
970            t.set_has_children(n, true);
971            st.node_paths.insert(n, p);
972        }
973    }
974
975    pub fn node_path(&self, n: TreeNodeId) -> Option<PathBuf> {
976        self.st.borrow().node_paths.get(&n).cloned()
977    }
978
979    /// Add the sub-folders of `node` the first time it is needed.
980    pub fn tree_load(&self, node: TreeNodeId) {
981        let Some(path) = self.node_path(node) else {
982            return;
983        };
984        if !self.st.borrow_mut().loaded.insert(node) {
985            return;
986        }
987        let hidden = self.st.borrow().show_hidden;
988        let dirs = fsm::subdirs(&path, hidden);
989        let t = self.ui.tree;
990        let mut new = Vec::new();
991        t.batch(|t| {
992            for d in &dirs {
993                let c = t.add(Some(node), &d.name);
994                t.set_has_children(c, true);
995                new.push((c, d.path.clone()));
996            }
997            t.set_has_children(node, !dirs.is_empty());
998        });
999        self.st.borrow_mut().node_paths.extend(new);
1000    }
1001
1002    /// Expand the tree down to `path` and select it (no callbacks fire).
1003    fn tree_reveal(&self, path: &Path) {
1004        let t = self.ui.tree;
1005        let mut best: Option<(TreeNodeId, usize)> = None;
1006        for r in t.children(None) {
1007            if let Some(rp) = self.node_path(r) {
1008                let depth = rp.components().count();
1009                if path.starts_with(&rp) && best.is_none_or(|(_, d)| depth > d) {
1010                    best = Some((r, depth));
1011                }
1012            }
1013        }
1014        let Some((mut node, _)) = best else { return };
1015        let Some(root_path) = self.node_path(node) else {
1016            return;
1017        };
1018        let Ok(rest) = path.strip_prefix(&root_path) else {
1019            return;
1020        };
1021        let mut cur = root_path;
1022        for comp in rest.components() {
1023            self.tree_load(node);
1024            cur.push(comp);
1025            match t
1026                .children(Some(node))
1027                .into_iter()
1028                .find(|c| self.node_path(*c).as_deref() == Some(cur.as_path()))
1029            {
1030                Some(c) => node = c,
1031                None => break,
1032            }
1033        }
1034        self.tree_load(node); // set_selected expands its ancestors; the node itself must not show a placeholder
1035        t.set_selected(Some(node));
1036    }
1037
1038    fn on_tree_selected(self: &Rc<Self>, n: Option<TreeNodeId>) {
1039        let Some(path) = n.and_then(|n| self.node_path(n)) else {
1040            return;
1041        };
1042        let a = self.active();
1043        if path != self.path_of(a) {
1044            trace!("TREE {}", path.display());
1045            self.navigate(a, path, None, false, false);
1046        }
1047    }
1048
1049    // ---------------------------------------------------------------- operations
1050
1051    fn confirm(&self, title: &str, text: &str) -> bool {
1052        message_box(
1053            Some(self.ui.win),
1054            MessageKind::Question,
1055            Buttons::YesNo,
1056            title,
1057            text,
1058        ) == Answer::Yes
1059    }
1060
1061    /// Reload every pane showing `dir` (or all, if `dir` is None) and select `select` in the active one.
1062    fn refresh_after(self: &Rc<Self>, select: Option<PathBuf>) {
1063        let a = self.active();
1064        for i in 0..2 {
1065            let keep = if i == a { select.clone() } else { None };
1066            self.reload(i, keep);
1067        }
1068    }
1069
1070    fn op_new_folder(self: &Rc<Self>) {
1071        let a = self.active();
1072        let dir = self.path_of(a);
1073        self.dialog(
1074            "New Folder",
1075            "Name of the new folder:",
1076            "New Folder",
1077            move |fm, name| {
1078                let p = fsm::make_dir(&dir, name)?;
1079                trace!("MKDIR {}", p.display());
1080                fm.refresh_after(Some(p));
1081                fm.say(&format!("Created folder \"{name}\""));
1082                Ok(())
1083            },
1084        );
1085    }
1086
1087    fn op_rename(self: &Rc<Self>) {
1088        let Some(e) = self.target() else {
1089            self.say("Select an item to rename first");
1090            return;
1091        };
1092        let old = e
1093            .path
1094            .file_name()
1095            .map(|n| n.to_string_lossy().into_owned())
1096            .unwrap_or_default();
1097        let (prompt, initial) = (format!("New name for \"{old}\":"), old.clone());
1098        self.dialog("Rename", &prompt, &initial, move |fm, name| {
1099            let p = fsm::rename_path(&e.path, name)?;
1100            trace!("RENAME {} {}", e.name, name);
1101            fm.refresh_after(Some(p));
1102            fm.say(&format!("Renamed \"{old}\" to \"{name}\""));
1103            Ok(())
1104        });
1105    }
1106
1107    fn op_delete(self: &Rc<Self>) {
1108        let Some(e) = self.target() else {
1109            self.say("Select an item to delete first");
1110            return;
1111        };
1112        let what = if e.is_dir && !e.is_link {
1113            "folder and everything in it"
1114        } else {
1115            "item"
1116        };
1117        if !self.confirm(
1118            "Delete",
1119            &format!(
1120                "Delete the {what} \"{}\"?\n\nThis cannot be undone.",
1121                e.name
1122            ),
1123        ) {
1124            self.say("Delete cancelled");
1125            return;
1126        }
1127        match fsm::remove_path(&e.path) {
1128            Ok(()) => {
1129                trace!("DELETE {}", e.name);
1130                self.refresh_after(None);
1131                self.say(&format!("Deleted \"{}\"", e.name));
1132            }
1133            Err(err) => {
1134                trace!("ERROR DELETE {}", e.name);
1135                self.say(&format!("Cannot delete \"{}\": {err}", e.name));
1136            }
1137        }
1138    }
1139
1140    fn op_copy(self: &Rc<Self>) {
1141        self.transfer(false)
1142    }
1143
1144    fn op_move(self: &Rc<Self>) {
1145        self.transfer(true)
1146    }
1147
1148    fn transfer(self: &Rc<Self>, mv: bool) {
1149        let verb = if mv { "Move" } else { "Copy" };
1150        let Some(e) = self.target() else {
1151            self.say(&format!("Select an item to {} first", verb.to_lowercase()));
1152            return;
1153        };
1154        let a = self.active();
1155        let dst_dir = self.path_of(1 - a);
1156        let dest = match fsm::check_transfer(&e.path, &dst_dir) {
1157            Ok(d) => d,
1158            Err(err) => {
1159                self.say(&err);
1160                return;
1161            }
1162        };
1163        if std::fs::symlink_metadata(&dest).is_ok() {
1164            if !self.confirm(
1165                "Overwrite",
1166                &format!(
1167                    "\"{}\" already exists in {}.\n\nReplace it?",
1168                    e.name,
1169                    dst_dir.display()
1170                ),
1171            ) {
1172                self.say(&format!("{verb} cancelled"));
1173                return;
1174            }
1175            if let Err(err) = fsm::remove_path(&dest) {
1176                self.say(&format!("Cannot replace \"{}\": {err}", e.name));
1177                return;
1178            }
1179        }
1180        let r = if mv {
1181            fsm::move_into(&e.path, &dst_dir)
1182        } else {
1183            fsm::copy_into(&e.path, &dst_dir)
1184        };
1185        match r {
1186            Ok(new) => {
1187                trace!("{} {} {}", verb.to_uppercase(), e.name, dst_dir.display());
1188                // both panes re-read; the other pane shows the new item selected
1189                self.reload(a, None);
1190                self.reload(1 - a, Some(new));
1191                self.say(&format!(
1192                    "{} \"{}\" to {}",
1193                    if mv { "Moved" } else { "Copied" },
1194                    e.name,
1195                    dst_dir.display()
1196                ));
1197            }
1198            Err(err) => {
1199                trace!("ERROR {} {}", verb.to_uppercase(), e.name);
1200                self.say(&err);
1201            }
1202        }
1203    }
1204
1205    fn about(&self) {
1206        message_box(
1207            Some(self.ui.win),
1208            MessageKind::Info,
1209            Buttons::Ok,
1210            "About File Manager",
1211            "A dual-pane file manager written with rungui's public API only.\n\nF2 rename, F5 copy, F6 move, F7 new folder, F8 delete,\nF9 switch pane, Ctrl+H hidden files, Ctrl+R refresh.\nTimes are shown in UTC.",
1212        );
1213    }
1214
1215    // ---------------------------------------------------------------- the rename / new folder dialog
1216
1217    /// A small window with a text field and OK / Cancel (rungui has no input-dialog API).
1218    /// `action` returns an error message to keep the dialog open.
1219    fn dialog(
1220        self: &Rc<Self>,
1221        title: &str,
1222        prompt: &str,
1223        initial: &str,
1224        action: impl Fn(&Rc<Fm>, &str) -> std::result::Result<(), String> + 'static,
1225    ) {
1226        if let Some(old) = self.st.borrow_mut().dialog.take() {
1227            old.destroy();
1228        }
1229        let w = Window::new(title);
1230        w.set_size(380, 150);
1231        w.set_resizable(false);
1232        let col = VBox::new(w);
1233        col.set_spacing(8);
1234        Label::new(col, prompt);
1235        let input = TextInput::new(col);
1236        input.set_text(initial);
1237        input.set_a11y_name(title);
1238        let err = Label::new(col, "");
1239        let row = HBox::new(col);
1240        row.set_spacing(8);
1241        Spacer::new(row);
1242        let cancel = Button::new(row, "Cancel");
1243        let ok = Button::new(row, "OK");
1244        self.st.borrow_mut().dialog = Some(w);
1245        self.dialog_ui.set(Some((w, input, ok, cancel)));
1246        trace!("DIALOG open {title}");
1247        {
1248            let fm = self.clone();
1249            ok.on_click(move || {
1250                let text = input.text();
1251                match action(&fm, text.trim()) {
1252                    Ok(()) => {
1253                        trace!("DIALOG done");
1254                        fm.st.borrow_mut().dialog = None;
1255                        w.destroy();
1256                    }
1257                    Err(e) => {
1258                        trace!("DIALOG error {e}");
1259                        err.set_text(&e);
1260                    }
1261                }
1262            });
1263            let fm = self.clone();
1264            cancel.on_click(move || {
1265                trace!("DIALOG cancel");
1266                fm.st.borrow_mut().dialog = None;
1267                w.destroy();
1268            });
1269            let fm = self.clone();
1270            w.on_close(move || {
1271                fm.st.borrow_mut().dialog = None;
1272                true
1273            });
1274        }
1275        w.show();
1276        input.focus();
1277        if tracing() {
1278            Timer::once(300, move || {
1279                for (n, wd) in [
1280                    ("dlg_input", *input),
1281                    ("dlg_ok", *ok),
1282                    ("dlg_cancel", *cancel),
1283                ] {
1284                    let r = wd.bounds();
1285                    println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
1286                }
1287            });
1288        }
1289    }
Source

pub fn hide(&self)

Hide the window.

Examples found in repository?
examples/smoke_dialogs.rs (line 21)
5fn main() {
6    let app = App::new("smoke-dialogs").expect("init");
7    let win = Window::new("smoke-dialogs");
8    let col = VBox::new(win);
9    let field = TextInput::new(col);
10    field.on_activate(|| println!("ACTIVATE"));
11    let ask = Button::new(col, "Ask");
12    ask.on_click(move || {
13        let r = Prompt::new("Rename").message("New name?").initial("old").run(Some(win));
14        println!("PROMPT {r:?}");
15    });
16    let modal = Button::new(col, "Modal");
17    modal.on_click(move || {
18        let d = Window::new("smoke-modal");
19        Label::new(d, "modal window");
20        let close = Button::new(d, "Close");
21        close.on_click(move || d.hide());
22        d.on_cancel(move || {
23            println!("MODAL_CANCEL");
24            d.hide();
25        });
26        println!("MODAL_OPEN");
27        d.run_modal(Some(win));
28        println!("MODAL_DONE");
29        d.destroy();
30    });
31    let list = ListBox::new(col);
32    list.set_items(&["one", "two", "three", "four", "five"]);
33    list.set_multi_select(true);
34    list.on_selection(|s| println!("LIST_SEL {s:?}"));
35    let table = Table::new(col);
36    table.set_columns(&[Column::new("Name").width(100)]);
37    table.set_rows(&[vec!["a"], vec!["b"], vec!["c"], vec!["d"]]);
38    table.set_multi_select(true);
39    table.on_selection(|s| println!("TABLE_SEL {s:?}"));
40    let cal = Calendar::new(col);
41    cal.set_date(Date::new(2031, 7, 4).unwrap());
42    cal.on_change(|d| println!("DATE {}-{:02}-{:02}", d.year, d.month, d.day));
43    win.on_close(|| {
44        App::quit();
45        true
46    });
47    win.show();
48    println!("TODAY {:?}", Date::today().is_valid());
49    let _t = Timer::once(600, move || {
50        for (n, w) in [
51            ("field", field.bounds()),
52            ("ask", ask.bounds()),
53            ("modal", modal.bounds()),
54            ("list", list.bounds()),
55            ("table", table.bounds()),
56            ("cal", cal.bounds()),
57        ] {
58            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
59        }
60        println!("READY");
61    });
62    let _exit = std::env::var("RUNGUI_EXIT_AFTER_MS")
63        .ok()
64        .and_then(|v| v.parse::<u32>().ok())
65        .map(|ms| Timer::once(ms, App::quit));
66    app.run();
67    println!("BYE");
68}
Source

pub fn on_close(&self, f: impl FnMut() -> bool + 'static)

Close handler: return true to allow closing (default), false to veto.

Examples found in repository?
examples/smoke_layout.rs (lines 37-40)
6fn main() {
7    let app = App::new("smoke-layout").expect("init");
8    let w = Window::new("smoke-layout");
9    w.set_position(120, 90);
10    let col = VBox::new(w);
11    let mono = TextInput::new(col);
12    mono.set_monospace(true);
13    mono.set_text("monospace entry");
14    let hs = Splitter::new(col, Orientation::Horizontal);
15    hs.set_position(200);
16    hs.set_min_pane_sizes(60, 60);
17    let area = TextArea::new(hs);
18    area.set_monospace(true);
19    area.set_wrap(false);
20    area.set_text("a long line that does not wrap: 0123456789 0123456789 0123456789 0123456789\n");
21    let table = Table::new(hs);
22    table.set_columns(&[Column::new("Name").width(80), Column::new("Size")]);
23    table.set_rows(&[vec!["a", "1"], vec!["b", "2"]]);
24    let vs = Splitter::new(col, Orientation::Vertical);
25    let tree = Tree::new(vs);
26    let r = tree.add(None, "root");
27    tree.add(Some(r), "kid");
28    let list = ListBox::new(vs);
29    list.set_items(&["one", "two"]);
30    table.on_select(|i| println!("TABLE_SEL {i:?}"));
31    tree.on_select(|n| println!("TREE_SEL {}", n.is_some()));
32    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
33    hs.on_move(|p| println!("HSPLIT {p}"));
34    vs.on_move(|p| println!("VSPLIT {p}"));
35    w.on_move(|x, y| println!("MOVED {x} {y}"));
36    w.on_resize(|w, h| println!("RESIZED {w} {h}"));
37    w.on_close(|| {
38        App::quit();
39        true
40    });
41    w.show();
42    let _t = Timer::once(600, move || {
43        println!("POS {:?}", w.position());
44        for (n, b) in [
45            ("hs", hs.bounds()),
46            ("vs", vs.bounds()),
47            ("table", table.bounds()),
48            ("tree", tree.bounds()),
49            ("area", area.bounds()),
50        ] {
51            println!("BOUNDS {n} {} {} {} {}", b.x, b.y, b.w, b.h);
52        }
53        println!("HPOS {} VPOS {}", hs.position(), vs.position());
54        println!(
55            "MONO {} {} WRAP {}",
56            mono.monospace(),
57            area.monospace(),
58            area.wrap()
59        );
60        println!("READY");
61    });
62    app.run();
63    println!("BYE");
64}
More examples
Hide additional examples
examples/smoke_dialogs.rs (lines 43-46)
5fn main() {
6    let app = App::new("smoke-dialogs").expect("init");
7    let win = Window::new("smoke-dialogs");
8    let col = VBox::new(win);
9    let field = TextInput::new(col);
10    field.on_activate(|| println!("ACTIVATE"));
11    let ask = Button::new(col, "Ask");
12    ask.on_click(move || {
13        let r = Prompt::new("Rename").message("New name?").initial("old").run(Some(win));
14        println!("PROMPT {r:?}");
15    });
16    let modal = Button::new(col, "Modal");
17    modal.on_click(move || {
18        let d = Window::new("smoke-modal");
19        Label::new(d, "modal window");
20        let close = Button::new(d, "Close");
21        close.on_click(move || d.hide());
22        d.on_cancel(move || {
23            println!("MODAL_CANCEL");
24            d.hide();
25        });
26        println!("MODAL_OPEN");
27        d.run_modal(Some(win));
28        println!("MODAL_DONE");
29        d.destroy();
30    });
31    let list = ListBox::new(col);
32    list.set_items(&["one", "two", "three", "four", "five"]);
33    list.set_multi_select(true);
34    list.on_selection(|s| println!("LIST_SEL {s:?}"));
35    let table = Table::new(col);
36    table.set_columns(&[Column::new("Name").width(100)]);
37    table.set_rows(&[vec!["a"], vec!["b"], vec!["c"], vec!["d"]]);
38    table.set_multi_select(true);
39    table.on_selection(|s| println!("TABLE_SEL {s:?}"));
40    let cal = Calendar::new(col);
41    cal.set_date(Date::new(2031, 7, 4).unwrap());
42    cal.on_change(|d| println!("DATE {}-{:02}-{:02}", d.year, d.month, d.day));
43    win.on_close(|| {
44        App::quit();
45        true
46    });
47    win.show();
48    println!("TODAY {:?}", Date::today().is_valid());
49    let _t = Timer::once(600, move || {
50        for (n, w) in [
51            ("field", field.bounds()),
52            ("ask", ask.bounds()),
53            ("modal", modal.bounds()),
54            ("list", list.bounds()),
55            ("table", table.bounds()),
56            ("cal", cal.bounds()),
57        ] {
58            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
59        }
60        println!("READY");
61    });
62    let _exit = std::env::var("RUNGUI_EXIT_AFTER_MS")
63        .ok()
64        .and_then(|v| v.parse::<u32>().ok())
65        .map(|ms| Timer::once(ms, App::quit));
66    app.run();
67    println!("BYE");
68}
examples/file_manager/app.rs (lines 1270-1273)
1219    fn dialog(
1220        self: &Rc<Self>,
1221        title: &str,
1222        prompt: &str,
1223        initial: &str,
1224        action: impl Fn(&Rc<Fm>, &str) -> std::result::Result<(), String> + 'static,
1225    ) {
1226        if let Some(old) = self.st.borrow_mut().dialog.take() {
1227            old.destroy();
1228        }
1229        let w = Window::new(title);
1230        w.set_size(380, 150);
1231        w.set_resizable(false);
1232        let col = VBox::new(w);
1233        col.set_spacing(8);
1234        Label::new(col, prompt);
1235        let input = TextInput::new(col);
1236        input.set_text(initial);
1237        input.set_a11y_name(title);
1238        let err = Label::new(col, "");
1239        let row = HBox::new(col);
1240        row.set_spacing(8);
1241        Spacer::new(row);
1242        let cancel = Button::new(row, "Cancel");
1243        let ok = Button::new(row, "OK");
1244        self.st.borrow_mut().dialog = Some(w);
1245        self.dialog_ui.set(Some((w, input, ok, cancel)));
1246        trace!("DIALOG open {title}");
1247        {
1248            let fm = self.clone();
1249            ok.on_click(move || {
1250                let text = input.text();
1251                match action(&fm, text.trim()) {
1252                    Ok(()) => {
1253                        trace!("DIALOG done");
1254                        fm.st.borrow_mut().dialog = None;
1255                        w.destroy();
1256                    }
1257                    Err(e) => {
1258                        trace!("DIALOG error {e}");
1259                        err.set_text(&e);
1260                    }
1261                }
1262            });
1263            let fm = self.clone();
1264            cancel.on_click(move || {
1265                trace!("DIALOG cancel");
1266                fm.st.borrow_mut().dialog = None;
1267                w.destroy();
1268            });
1269            let fm = self.clone();
1270            w.on_close(move || {
1271                fm.st.borrow_mut().dialog = None;
1272                true
1273            });
1274        }
1275        w.show();
1276        input.focus();
1277        if tracing() {
1278            Timer::once(300, move || {
1279                for (n, wd) in [
1280                    ("dlg_input", *input),
1281                    ("dlg_ok", *ok),
1282                    ("dlg_cancel", *cancel),
1283                ] {
1284                    let r = wd.bounds();
1285                    println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
1286                }
1287            });
1288        }
1289    }
examples/smoke_controls.rs (lines 62-65)
5fn main() {
6    let app = App::new("smoke").expect("init");
7    let a = Window::new("smoke-a");
8    let col = VBox::new(a);
9    let btn = Button::new(col, "Press ünï");
10    let txt = TextInput::new(col);
11    let chk = CheckBox::new(col, "Check");
12    let list = ListBox::new(col);
13    list.set_items(&["one", "two", "three"]);
14    let slider = Slider::new(col, 0.0, 100.0);
15    let combo = ComboBox::new(col);
16    combo.set_items(&["x", "y"]);
17    let dlg = Button::new(col, "Dialog");
18    dlg.on_click(move || {
19        let r = message_box(
20            Some(a),
21            MessageKind::Question,
22            Buttons::YesNo,
23            "Title ü",
24            "Really?",
25        );
26        println!("DIALOG {r:?}");
27    });
28    let g = RadioGroup::new();
29    let ra = RadioButton::new(col, &g, "Ra");
30    let rb = RadioButton::new(col, &g, "Rb");
31    ra.set_checked(true);
32    ra.on_toggle(|v| println!("RA {v}"));
33    rb.on_toggle(|v| println!("RB {v}"));
34    let table = Table::new(col);
35    table.set_columns(&[
36        Column::new("Name").width(80).sortable(true),
37        Column::new("Size").align(ColumnAlign::Right),
38    ]);
39    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
40    table.on_select(|i| println!("TABLE_SEL {i:?}"));
41    table.on_column_click(|c| println!("TABLE_COL {c}"));
42    let tree = Tree::new(col);
43    let root = tree.add(None, "root");
44    let kid = tree.add(Some(root), "kid");
45    let lazy = tree.add(None, "lazy");
46    tree.set_has_children(lazy, true);
47    let _ = kid;
48    tree.on_select(|n| println!("TREE_SEL {}", n.is_some()));
49    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
50    a.set_context_menu({
51        let p = PopupMenu::new();
52        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
53        p
54    });
55    btn.on_click(|| println!("CLICK"));
56    txt.on_change(|t| println!("TEXT {t}"));
57    chk.on_toggle(|b| println!("TOGGLE {b}"));
58    list.on_select(|i| println!("SELECT {i:?}"));
59    slider.on_change(|v| println!("VALUE {v:.0}"));
60    combo.on_select(|i| println!("COMBO {i:?}"));
61    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
62    a.on_close(|| {
63        println!("CLOSE_REQUESTED");
64        true
65    });
66
67    let b = Window::new("smoke-b");
68    let bar = MenuBar::new(b);
69    let file = Menu::new(bar, "File");
70    let item = MenuItem::new(file, "Quit");
71    item.set_accel("Ctrl+Q");
72    item.on_click(|| {
73        println!("MENU_QUIT");
74        App::quit();
75    });
76    let ck = CheckMenuItem::new(file, "Flag");
77    ck.on_toggle(|v| println!("MENUTOGGLE {v}"));
78    Label::new(b, "second window");
79
80    a.show();
81    b.show();
82    println!(
83        "HANDLE {}",
84        a.native_handle().is_some() && btn.native_handle().is_some()
85    );
86    let _t = Timer::once(600, move || {
87        for (n, w) in [
88            ("btn", btn.bounds()),
89            ("txt", txt.bounds()),
90            ("chk", chk.bounds()),
91            ("list", list.bounds()),
92            ("slider", slider.bounds()),
93            ("combo", combo.bounds()),
94            ("dlg", dlg.bounds()),
95            ("rb", rb.bounds()),
96            ("table", table.bounds()),
97            ("tree", tree.bounds()),
98        ] {
99            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
100        }
101        println!("READY");
102    });
103    // CI: RUNGUI_EXIT_AFTER_MS=n quits the loop after n ms so a startup crash shows up as a failure.
104    let _exit = std::env::var("RUNGUI_EXIT_AFTER_MS")
105        .ok()
106        .and_then(|v| v.parse::<u32>().ok())
107        .map(|ms| Timer::once(ms, App::quit));
108    app.run();
109    println!("BYE");
110}
examples/smoke_cocoa.rs (lines 104-107)
6fn main() {
7    let app = App::new("smoke-cocoa").expect("init");
8    let a = Window::new("cc-a");
9    let bar = MenuBar::new(a);
10    let file = Menu::new(bar, "File");
11    let flag = CheckMenuItem::new(file, "Flag");
12    flag.set_accel("Ctrl+K");
13    flag.on_toggle(|v| println!("MENUTOGGLE {v}"));
14    let go = MenuItem::new(file, "Go");
15    go.set_accel("Ctrl+Shift+G");
16    go.on_click(|| println!("MENU_GO"));
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(|| {
20        println!("MENU_QUIT");
21        App::quit();
22    });
23
24    let col = VBox::new(a);
25    let row = HBox::new(col);
26    let btn = Button::new(row, "Press ünï");
27    let spin = SpinBox::new(row, 0.0, 10.0, 1.0);
28    let txt = TextInput::new(col);
29    let chk = CheckBox::new(col, "Monospace");
30    let hs = Splitter::new(col, Orientation::Horizontal);
31    let ta1 = TextArea::new(hs);
32    let ta2 = TextArea::new(hs);
33    ta2.set_text(
34        "long line without wrapping: 0123456789 0123456789 0123456789 0123456789 0123456789",
35    );
36    ta2.set_wrap(false);
37    hs.set_position(200);
38    hs.set_min_pane_sizes(60, 60);
39    let slider = Slider::new(col, 0.0, 100.0);
40    let combo = ComboBox::new(col);
41    combo.set_items(&["x", "y", "z"]);
42    let tabs = Tabs::new(col);
43    let p1 = tabs.add_page("First");
44    let p2 = tabs.add_page("Second");
45    Label::new(p1, "page one");
46    Label::new(p2, "page two");
47    let vs = Splitter::new(col, Orientation::Vertical);
48    let table = Table::new(vs);
49    table.set_columns(&[
50        Column::new("Name").width(80).sortable(true),
51        Column::new("Size").align(ColumnAlign::Right),
52    ]);
53    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
54    let tree = Tree::new(vs);
55    let root = tree.add(None, "root");
56    tree.add(Some(root), "kid");
57    let lazy = tree.add(None, "lazy");
58    tree.set_has_children(lazy, true);
59    vs.set_position(100);
60    vs.set_min_pane_sizes(40, 40);
61
62    btn.on_click(|| println!("CLICK"));
63    spin.on_change(|v| println!("SPIN {v}"));
64    txt.on_change(|t| println!("TEXT {t}"));
65    ta1.on_change(|t| println!("AREA {}", t.replace('\n', "|")));
66    chk.on_toggle(move |on| {
67        println!("MONO {on}");
68        txt.set_monospace(on);
69        ta1.set_monospace(on);
70    });
71    hs.on_move(|p| println!("HSPLIT {p}"));
72    vs.on_move(|p| println!("VSPLIT {p}"));
73    slider.on_change(|v| println!("VALUE {v:.0}"));
74    combo.on_select(|i| println!("COMBO {i:?}"));
75    tabs.on_select(|i| println!("TAB {i:?}"));
76    table.on_select(|i| println!("TABLE_SEL {i:?}"));
77    table.on_column_click(move |c| {
78        let ascending = table.sort_indicator() != Some((c, true));
79        let mut rows = table.rows();
80        rows.sort_by(|x, y| x[c].cmp(&y[c]));
81        if !ascending {
82            rows.reverse();
83        }
84        table.set_rows(&rows);
85        table.set_sort_indicator(Some((c, ascending)));
86        println!(
87            "TABLE_COL {c} {} {}",
88            if ascending { "asc" } else { "desc" },
89            rows[0][0]
90        );
91    });
92    tree.on_select(move |n| println!("TREE_SEL {}", n.is_some()));
93    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
94    a.set_context_menu({
95        let p = PopupMenu::new();
96        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
97        p
98    });
99    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
100    a.on_move(|x, y| println!("MOVED {x} {y}"));
101    a.set_min_size(300, 400);
102    a.set_position(220, 100);
103    a.set_size(560, 700);
104    a.on_close(|| {
105        println!("CLOSE_REQUESTED");
106        true
107    });
108    a.show();
109    println!(
110        "HANDLE {}",
111        a.native_handle().is_some() && btn.native_handle().is_some()
112    );
113    let _t = Timer::once(700, move || {
114        for (n, w) in [
115            ("btn", btn.bounds()),
116            ("spin", spin.bounds()),
117            ("txt", txt.bounds()),
118            ("chk", chk.bounds()),
119            ("hs", hs.bounds()),
120            ("slider", slider.bounds()),
121            ("combo", combo.bounds()),
122            ("tabs", tabs.bounds()),
123            ("vs", vs.bounds()),
124            ("table", table.bounds()),
125            ("tree", tree.bounds()),
126        ] {
127            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
128        }
129        println!("SPLITPOS h {} v {}", hs.position(), vs.position());
130        println!("READY");
131    });
132    app.run();
133    println!("BYE");
134}
Source

pub fn on_resize(&self, f: impl FnMut(i32, i32) + 'static)

Called with the new client size when the user resizes the window.

Examples found in repository?
examples/smoke_layout.rs (line 36)
6fn main() {
7    let app = App::new("smoke-layout").expect("init");
8    let w = Window::new("smoke-layout");
9    w.set_position(120, 90);
10    let col = VBox::new(w);
11    let mono = TextInput::new(col);
12    mono.set_monospace(true);
13    mono.set_text("monospace entry");
14    let hs = Splitter::new(col, Orientation::Horizontal);
15    hs.set_position(200);
16    hs.set_min_pane_sizes(60, 60);
17    let area = TextArea::new(hs);
18    area.set_monospace(true);
19    area.set_wrap(false);
20    area.set_text("a long line that does not wrap: 0123456789 0123456789 0123456789 0123456789\n");
21    let table = Table::new(hs);
22    table.set_columns(&[Column::new("Name").width(80), Column::new("Size")]);
23    table.set_rows(&[vec!["a", "1"], vec!["b", "2"]]);
24    let vs = Splitter::new(col, Orientation::Vertical);
25    let tree = Tree::new(vs);
26    let r = tree.add(None, "root");
27    tree.add(Some(r), "kid");
28    let list = ListBox::new(vs);
29    list.set_items(&["one", "two"]);
30    table.on_select(|i| println!("TABLE_SEL {i:?}"));
31    tree.on_select(|n| println!("TREE_SEL {}", n.is_some()));
32    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
33    hs.on_move(|p| println!("HSPLIT {p}"));
34    vs.on_move(|p| println!("VSPLIT {p}"));
35    w.on_move(|x, y| println!("MOVED {x} {y}"));
36    w.on_resize(|w, h| println!("RESIZED {w} {h}"));
37    w.on_close(|| {
38        App::quit();
39        true
40    });
41    w.show();
42    let _t = Timer::once(600, move || {
43        println!("POS {:?}", w.position());
44        for (n, b) in [
45            ("hs", hs.bounds()),
46            ("vs", vs.bounds()),
47            ("table", table.bounds()),
48            ("tree", tree.bounds()),
49            ("area", area.bounds()),
50        ] {
51            println!("BOUNDS {n} {} {} {} {}", b.x, b.y, b.w, b.h);
52        }
53        println!("HPOS {} VPOS {}", hs.position(), vs.position());
54        println!(
55            "MONO {} {} WRAP {}",
56            mono.monospace(),
57            area.monospace(),
58            area.wrap()
59        );
60        println!("READY");
61    });
62    app.run();
63    println!("BYE");
64}
More examples
Hide additional examples
examples/file_manager/app.rs (lines 420-423)
360    fn wire(self: &Rc<Self>) {
361        let u = &self.ui;
362        let it = u.items;
363        macro_rules! click {
364            ($btn:expr, $f:ident) => {{
365                let fm = self.clone();
366                $btn.on_click(move || fm.$f());
367            }};
368        }
369        click!(it.new_folder, op_new_folder);
370        click!(it.ctx_new, op_new_folder);
371        click!(it.rename, op_rename);
372        click!(it.ctx_rename, op_rename);
373        click!(it.delete, op_delete);
374        click!(it.ctx_delete, op_delete);
375        click!(it.copy, op_copy);
376        click!(it.ctx_copy, op_copy);
377        click!(u.copy_btn, op_copy);
378        click!(it.mv, op_move);
379        click!(u.move_btn, op_move);
380        click!(it.ctx_open, op_open);
381        click!(it.refresh, refresh_all);
382        click!(u.refresh, refresh_all);
383        click!(it.up, go_up);
384        click!(u.up, go_up);
385        click!(it.home, go_home);
386        click!(it.switch, switch_pane);
387        click!(it.about, about);
388        it.quit.on_click(App::quit);
389        {
390            let fm = self.clone();
391            it.hidden.on_toggle(move |on| fm.set_show_hidden(on));
392        }
393        for i in 0..2 {
394            let t = u.tables[i];
395            let fm = self.clone();
396            t.on_select(move |r| fm.on_row_selected(i, r));
397            let fm = self.clone();
398            t.on_activate(move |r| fm.on_row_activated(i, r));
399            let fm = self.clone();
400            t.on_column_click(move |c| fm.sort_by_column(i, c));
401            let fm = self.clone();
402            t.on_context_menu(move |_, _| fm.prepare_context_menu(i));
403        }
404        {
405            let fm = self.clone();
406            u.path.on_change(move |text| fm.on_path_typed(text));
407        }
408        {
409            let fm = self.clone();
410            u.tree.on_select(move |n| fm.on_tree_selected(n));
411            let fm = self.clone();
412            u.tree.on_expand(move |n, open| {
413                if open {
414                    fm.tree_load(n);
415                }
416            });
417        }
418        {
419            let fm = self.clone();
420            u.win.on_resize(move |w, h| {
421                trace!("RESIZE {w} {h}");
422                fm.relabel_soon();
423            });
424            for sp in [u.body, u.right, u.panes] {
425                let fm = self.clone();
426                sp.on_move(move |_| fm.relabel_soon());
427            }
428        }
429        // pick up changes made by other programs
430        let fm = self.clone();
431        Timer::every(1500, move || fm.poll());
432        // report geometry once the first layout has happened
433        let fm = self.clone();
434        Timer::once(500, move || {
435            fm.print_bounds();
436            trace!("READY");
437        });
438    }
examples/smoke_controls.rs (line 61)
5fn main() {
6    let app = App::new("smoke").expect("init");
7    let a = Window::new("smoke-a");
8    let col = VBox::new(a);
9    let btn = Button::new(col, "Press ünï");
10    let txt = TextInput::new(col);
11    let chk = CheckBox::new(col, "Check");
12    let list = ListBox::new(col);
13    list.set_items(&["one", "two", "three"]);
14    let slider = Slider::new(col, 0.0, 100.0);
15    let combo = ComboBox::new(col);
16    combo.set_items(&["x", "y"]);
17    let dlg = Button::new(col, "Dialog");
18    dlg.on_click(move || {
19        let r = message_box(
20            Some(a),
21            MessageKind::Question,
22            Buttons::YesNo,
23            "Title ü",
24            "Really?",
25        );
26        println!("DIALOG {r:?}");
27    });
28    let g = RadioGroup::new();
29    let ra = RadioButton::new(col, &g, "Ra");
30    let rb = RadioButton::new(col, &g, "Rb");
31    ra.set_checked(true);
32    ra.on_toggle(|v| println!("RA {v}"));
33    rb.on_toggle(|v| println!("RB {v}"));
34    let table = Table::new(col);
35    table.set_columns(&[
36        Column::new("Name").width(80).sortable(true),
37        Column::new("Size").align(ColumnAlign::Right),
38    ]);
39    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
40    table.on_select(|i| println!("TABLE_SEL {i:?}"));
41    table.on_column_click(|c| println!("TABLE_COL {c}"));
42    let tree = Tree::new(col);
43    let root = tree.add(None, "root");
44    let kid = tree.add(Some(root), "kid");
45    let lazy = tree.add(None, "lazy");
46    tree.set_has_children(lazy, true);
47    let _ = kid;
48    tree.on_select(|n| println!("TREE_SEL {}", n.is_some()));
49    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
50    a.set_context_menu({
51        let p = PopupMenu::new();
52        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
53        p
54    });
55    btn.on_click(|| println!("CLICK"));
56    txt.on_change(|t| println!("TEXT {t}"));
57    chk.on_toggle(|b| println!("TOGGLE {b}"));
58    list.on_select(|i| println!("SELECT {i:?}"));
59    slider.on_change(|v| println!("VALUE {v:.0}"));
60    combo.on_select(|i| println!("COMBO {i:?}"));
61    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
62    a.on_close(|| {
63        println!("CLOSE_REQUESTED");
64        true
65    });
66
67    let b = Window::new("smoke-b");
68    let bar = MenuBar::new(b);
69    let file = Menu::new(bar, "File");
70    let item = MenuItem::new(file, "Quit");
71    item.set_accel("Ctrl+Q");
72    item.on_click(|| {
73        println!("MENU_QUIT");
74        App::quit();
75    });
76    let ck = CheckMenuItem::new(file, "Flag");
77    ck.on_toggle(|v| println!("MENUTOGGLE {v}"));
78    Label::new(b, "second window");
79
80    a.show();
81    b.show();
82    println!(
83        "HANDLE {}",
84        a.native_handle().is_some() && btn.native_handle().is_some()
85    );
86    let _t = Timer::once(600, move || {
87        for (n, w) in [
88            ("btn", btn.bounds()),
89            ("txt", txt.bounds()),
90            ("chk", chk.bounds()),
91            ("list", list.bounds()),
92            ("slider", slider.bounds()),
93            ("combo", combo.bounds()),
94            ("dlg", dlg.bounds()),
95            ("rb", rb.bounds()),
96            ("table", table.bounds()),
97            ("tree", tree.bounds()),
98        ] {
99            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
100        }
101        println!("READY");
102    });
103    // CI: RUNGUI_EXIT_AFTER_MS=n quits the loop after n ms so a startup crash shows up as a failure.
104    let _exit = std::env::var("RUNGUI_EXIT_AFTER_MS")
105        .ok()
106        .and_then(|v| v.parse::<u32>().ok())
107        .map(|ms| Timer::once(ms, App::quit));
108    app.run();
109    println!("BYE");
110}
examples/smoke_cocoa.rs (line 99)
6fn main() {
7    let app = App::new("smoke-cocoa").expect("init");
8    let a = Window::new("cc-a");
9    let bar = MenuBar::new(a);
10    let file = Menu::new(bar, "File");
11    let flag = CheckMenuItem::new(file, "Flag");
12    flag.set_accel("Ctrl+K");
13    flag.on_toggle(|v| println!("MENUTOGGLE {v}"));
14    let go = MenuItem::new(file, "Go");
15    go.set_accel("Ctrl+Shift+G");
16    go.on_click(|| println!("MENU_GO"));
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(|| {
20        println!("MENU_QUIT");
21        App::quit();
22    });
23
24    let col = VBox::new(a);
25    let row = HBox::new(col);
26    let btn = Button::new(row, "Press ünï");
27    let spin = SpinBox::new(row, 0.0, 10.0, 1.0);
28    let txt = TextInput::new(col);
29    let chk = CheckBox::new(col, "Monospace");
30    let hs = Splitter::new(col, Orientation::Horizontal);
31    let ta1 = TextArea::new(hs);
32    let ta2 = TextArea::new(hs);
33    ta2.set_text(
34        "long line without wrapping: 0123456789 0123456789 0123456789 0123456789 0123456789",
35    );
36    ta2.set_wrap(false);
37    hs.set_position(200);
38    hs.set_min_pane_sizes(60, 60);
39    let slider = Slider::new(col, 0.0, 100.0);
40    let combo = ComboBox::new(col);
41    combo.set_items(&["x", "y", "z"]);
42    let tabs = Tabs::new(col);
43    let p1 = tabs.add_page("First");
44    let p2 = tabs.add_page("Second");
45    Label::new(p1, "page one");
46    Label::new(p2, "page two");
47    let vs = Splitter::new(col, Orientation::Vertical);
48    let table = Table::new(vs);
49    table.set_columns(&[
50        Column::new("Name").width(80).sortable(true),
51        Column::new("Size").align(ColumnAlign::Right),
52    ]);
53    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
54    let tree = Tree::new(vs);
55    let root = tree.add(None, "root");
56    tree.add(Some(root), "kid");
57    let lazy = tree.add(None, "lazy");
58    tree.set_has_children(lazy, true);
59    vs.set_position(100);
60    vs.set_min_pane_sizes(40, 40);
61
62    btn.on_click(|| println!("CLICK"));
63    spin.on_change(|v| println!("SPIN {v}"));
64    txt.on_change(|t| println!("TEXT {t}"));
65    ta1.on_change(|t| println!("AREA {}", t.replace('\n', "|")));
66    chk.on_toggle(move |on| {
67        println!("MONO {on}");
68        txt.set_monospace(on);
69        ta1.set_monospace(on);
70    });
71    hs.on_move(|p| println!("HSPLIT {p}"));
72    vs.on_move(|p| println!("VSPLIT {p}"));
73    slider.on_change(|v| println!("VALUE {v:.0}"));
74    combo.on_select(|i| println!("COMBO {i:?}"));
75    tabs.on_select(|i| println!("TAB {i:?}"));
76    table.on_select(|i| println!("TABLE_SEL {i:?}"));
77    table.on_column_click(move |c| {
78        let ascending = table.sort_indicator() != Some((c, true));
79        let mut rows = table.rows();
80        rows.sort_by(|x, y| x[c].cmp(&y[c]));
81        if !ascending {
82            rows.reverse();
83        }
84        table.set_rows(&rows);
85        table.set_sort_indicator(Some((c, ascending)));
86        println!(
87            "TABLE_COL {c} {} {}",
88            if ascending { "asc" } else { "desc" },
89            rows[0][0]
90        );
91    });
92    tree.on_select(move |n| println!("TREE_SEL {}", n.is_some()));
93    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
94    a.set_context_menu({
95        let p = PopupMenu::new();
96        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
97        p
98    });
99    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
100    a.on_move(|x, y| println!("MOVED {x} {y}"));
101    a.set_min_size(300, 400);
102    a.set_position(220, 100);
103    a.set_size(560, 700);
104    a.on_close(|| {
105        println!("CLOSE_REQUESTED");
106        true
107    });
108    a.show();
109    println!(
110        "HANDLE {}",
111        a.native_handle().is_some() && btn.native_handle().is_some()
112    );
113    let _t = Timer::once(700, move || {
114        for (n, w) in [
115            ("btn", btn.bounds()),
116            ("spin", spin.bounds()),
117            ("txt", txt.bounds()),
118            ("chk", chk.bounds()),
119            ("hs", hs.bounds()),
120            ("slider", slider.bounds()),
121            ("combo", combo.bounds()),
122            ("tabs", tabs.bounds()),
123            ("vs", vs.bounds()),
124            ("table", table.bounds()),
125            ("tree", tree.bounds()),
126        ] {
127            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
128        }
129        println!("SPLITPOS h {} v {}", hs.position(), vs.position());
130        println!("READY");
131    });
132    app.run();
133    println!("BYE");
134}
Source

pub fn set_position(&self, x: i32, y: i32)

Move the window’s outer frame to screen position (x, y) in logical pixels. Some platforms (Wayland, some window managers) ignore this.

Examples found in repository?
examples/smoke_layout.rs (line 9)
6fn main() {
7    let app = App::new("smoke-layout").expect("init");
8    let w = Window::new("smoke-layout");
9    w.set_position(120, 90);
10    let col = VBox::new(w);
11    let mono = TextInput::new(col);
12    mono.set_monospace(true);
13    mono.set_text("monospace entry");
14    let hs = Splitter::new(col, Orientation::Horizontal);
15    hs.set_position(200);
16    hs.set_min_pane_sizes(60, 60);
17    let area = TextArea::new(hs);
18    area.set_monospace(true);
19    area.set_wrap(false);
20    area.set_text("a long line that does not wrap: 0123456789 0123456789 0123456789 0123456789\n");
21    let table = Table::new(hs);
22    table.set_columns(&[Column::new("Name").width(80), Column::new("Size")]);
23    table.set_rows(&[vec!["a", "1"], vec!["b", "2"]]);
24    let vs = Splitter::new(col, Orientation::Vertical);
25    let tree = Tree::new(vs);
26    let r = tree.add(None, "root");
27    tree.add(Some(r), "kid");
28    let list = ListBox::new(vs);
29    list.set_items(&["one", "two"]);
30    table.on_select(|i| println!("TABLE_SEL {i:?}"));
31    tree.on_select(|n| println!("TREE_SEL {}", n.is_some()));
32    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
33    hs.on_move(|p| println!("HSPLIT {p}"));
34    vs.on_move(|p| println!("VSPLIT {p}"));
35    w.on_move(|x, y| println!("MOVED {x} {y}"));
36    w.on_resize(|w, h| println!("RESIZED {w} {h}"));
37    w.on_close(|| {
38        App::quit();
39        true
40    });
41    w.show();
42    let _t = Timer::once(600, move || {
43        println!("POS {:?}", w.position());
44        for (n, b) in [
45            ("hs", hs.bounds()),
46            ("vs", vs.bounds()),
47            ("table", table.bounds()),
48            ("tree", tree.bounds()),
49            ("area", area.bounds()),
50        ] {
51            println!("BOUNDS {n} {} {} {} {}", b.x, b.y, b.w, b.h);
52        }
53        println!("HPOS {} VPOS {}", hs.position(), vs.position());
54        println!(
55            "MONO {} {} WRAP {}",
56            mono.monospace(),
57            area.monospace(),
58            area.wrap()
59        );
60        println!("READY");
61    });
62    app.run();
63    println!("BYE");
64}
More examples
Hide additional examples
examples/smoke_cocoa.rs (line 102)
6fn main() {
7    let app = App::new("smoke-cocoa").expect("init");
8    let a = Window::new("cc-a");
9    let bar = MenuBar::new(a);
10    let file = Menu::new(bar, "File");
11    let flag = CheckMenuItem::new(file, "Flag");
12    flag.set_accel("Ctrl+K");
13    flag.on_toggle(|v| println!("MENUTOGGLE {v}"));
14    let go = MenuItem::new(file, "Go");
15    go.set_accel("Ctrl+Shift+G");
16    go.on_click(|| println!("MENU_GO"));
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(|| {
20        println!("MENU_QUIT");
21        App::quit();
22    });
23
24    let col = VBox::new(a);
25    let row = HBox::new(col);
26    let btn = Button::new(row, "Press ünï");
27    let spin = SpinBox::new(row, 0.0, 10.0, 1.0);
28    let txt = TextInput::new(col);
29    let chk = CheckBox::new(col, "Monospace");
30    let hs = Splitter::new(col, Orientation::Horizontal);
31    let ta1 = TextArea::new(hs);
32    let ta2 = TextArea::new(hs);
33    ta2.set_text(
34        "long line without wrapping: 0123456789 0123456789 0123456789 0123456789 0123456789",
35    );
36    ta2.set_wrap(false);
37    hs.set_position(200);
38    hs.set_min_pane_sizes(60, 60);
39    let slider = Slider::new(col, 0.0, 100.0);
40    let combo = ComboBox::new(col);
41    combo.set_items(&["x", "y", "z"]);
42    let tabs = Tabs::new(col);
43    let p1 = tabs.add_page("First");
44    let p2 = tabs.add_page("Second");
45    Label::new(p1, "page one");
46    Label::new(p2, "page two");
47    let vs = Splitter::new(col, Orientation::Vertical);
48    let table = Table::new(vs);
49    table.set_columns(&[
50        Column::new("Name").width(80).sortable(true),
51        Column::new("Size").align(ColumnAlign::Right),
52    ]);
53    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
54    let tree = Tree::new(vs);
55    let root = tree.add(None, "root");
56    tree.add(Some(root), "kid");
57    let lazy = tree.add(None, "lazy");
58    tree.set_has_children(lazy, true);
59    vs.set_position(100);
60    vs.set_min_pane_sizes(40, 40);
61
62    btn.on_click(|| println!("CLICK"));
63    spin.on_change(|v| println!("SPIN {v}"));
64    txt.on_change(|t| println!("TEXT {t}"));
65    ta1.on_change(|t| println!("AREA {}", t.replace('\n', "|")));
66    chk.on_toggle(move |on| {
67        println!("MONO {on}");
68        txt.set_monospace(on);
69        ta1.set_monospace(on);
70    });
71    hs.on_move(|p| println!("HSPLIT {p}"));
72    vs.on_move(|p| println!("VSPLIT {p}"));
73    slider.on_change(|v| println!("VALUE {v:.0}"));
74    combo.on_select(|i| println!("COMBO {i:?}"));
75    tabs.on_select(|i| println!("TAB {i:?}"));
76    table.on_select(|i| println!("TABLE_SEL {i:?}"));
77    table.on_column_click(move |c| {
78        let ascending = table.sort_indicator() != Some((c, true));
79        let mut rows = table.rows();
80        rows.sort_by(|x, y| x[c].cmp(&y[c]));
81        if !ascending {
82            rows.reverse();
83        }
84        table.set_rows(&rows);
85        table.set_sort_indicator(Some((c, ascending)));
86        println!(
87            "TABLE_COL {c} {} {}",
88            if ascending { "asc" } else { "desc" },
89            rows[0][0]
90        );
91    });
92    tree.on_select(move |n| println!("TREE_SEL {}", n.is_some()));
93    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
94    a.set_context_menu({
95        let p = PopupMenu::new();
96        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
97        p
98    });
99    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
100    a.on_move(|x, y| println!("MOVED {x} {y}"));
101    a.set_min_size(300, 400);
102    a.set_position(220, 100);
103    a.set_size(560, 700);
104    a.on_close(|| {
105        println!("CLOSE_REQUESTED");
106        true
107    });
108    a.show();
109    println!(
110        "HANDLE {}",
111        a.native_handle().is_some() && btn.native_handle().is_some()
112    );
113    let _t = Timer::once(700, move || {
114        for (n, w) in [
115            ("btn", btn.bounds()),
116            ("spin", spin.bounds()),
117            ("txt", txt.bounds()),
118            ("chk", chk.bounds()),
119            ("hs", hs.bounds()),
120            ("slider", slider.bounds()),
121            ("combo", combo.bounds()),
122            ("tabs", tabs.bounds()),
123            ("vs", vs.bounds()),
124            ("table", table.bounds()),
125            ("tree", tree.bounds()),
126        ] {
127            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
128        }
129        println!("SPLITPOS h {} v {}", hs.position(), vs.position());
130        println!("READY");
131    });
132    app.run();
133    println!("BYE");
134}
Source

pub fn position(&self) -> Option<(i32, i32)>

The last position set with Window::set_position or reported by the platform after the user moved the window; None if neither happened (the window manager placed it).

Examples found in repository?
examples/smoke_layout.rs (line 43)
6fn main() {
7    let app = App::new("smoke-layout").expect("init");
8    let w = Window::new("smoke-layout");
9    w.set_position(120, 90);
10    let col = VBox::new(w);
11    let mono = TextInput::new(col);
12    mono.set_monospace(true);
13    mono.set_text("monospace entry");
14    let hs = Splitter::new(col, Orientation::Horizontal);
15    hs.set_position(200);
16    hs.set_min_pane_sizes(60, 60);
17    let area = TextArea::new(hs);
18    area.set_monospace(true);
19    area.set_wrap(false);
20    area.set_text("a long line that does not wrap: 0123456789 0123456789 0123456789 0123456789\n");
21    let table = Table::new(hs);
22    table.set_columns(&[Column::new("Name").width(80), Column::new("Size")]);
23    table.set_rows(&[vec!["a", "1"], vec!["b", "2"]]);
24    let vs = Splitter::new(col, Orientation::Vertical);
25    let tree = Tree::new(vs);
26    let r = tree.add(None, "root");
27    tree.add(Some(r), "kid");
28    let list = ListBox::new(vs);
29    list.set_items(&["one", "two"]);
30    table.on_select(|i| println!("TABLE_SEL {i:?}"));
31    tree.on_select(|n| println!("TREE_SEL {}", n.is_some()));
32    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
33    hs.on_move(|p| println!("HSPLIT {p}"));
34    vs.on_move(|p| println!("VSPLIT {p}"));
35    w.on_move(|x, y| println!("MOVED {x} {y}"));
36    w.on_resize(|w, h| println!("RESIZED {w} {h}"));
37    w.on_close(|| {
38        App::quit();
39        true
40    });
41    w.show();
42    let _t = Timer::once(600, move || {
43        println!("POS {:?}", w.position());
44        for (n, b) in [
45            ("hs", hs.bounds()),
46            ("vs", vs.bounds()),
47            ("table", table.bounds()),
48            ("tree", tree.bounds()),
49            ("area", area.bounds()),
50        ] {
51            println!("BOUNDS {n} {} {} {} {}", b.x, b.y, b.w, b.h);
52        }
53        println!("HPOS {} VPOS {}", hs.position(), vs.position());
54        println!(
55            "MONO {} {} WRAP {}",
56            mono.monospace(),
57            area.monospace(),
58            area.wrap()
59        );
60        println!("READY");
61    });
62    app.run();
63    println!("BYE");
64}
Source

pub fn on_move(&self, f: impl FnMut(i32, i32) + 'static)

Called with the new screen position when the user moves the window (not on every platform; see Window::position).

Examples found in repository?
examples/smoke_layout.rs (line 35)
6fn main() {
7    let app = App::new("smoke-layout").expect("init");
8    let w = Window::new("smoke-layout");
9    w.set_position(120, 90);
10    let col = VBox::new(w);
11    let mono = TextInput::new(col);
12    mono.set_monospace(true);
13    mono.set_text("monospace entry");
14    let hs = Splitter::new(col, Orientation::Horizontal);
15    hs.set_position(200);
16    hs.set_min_pane_sizes(60, 60);
17    let area = TextArea::new(hs);
18    area.set_monospace(true);
19    area.set_wrap(false);
20    area.set_text("a long line that does not wrap: 0123456789 0123456789 0123456789 0123456789\n");
21    let table = Table::new(hs);
22    table.set_columns(&[Column::new("Name").width(80), Column::new("Size")]);
23    table.set_rows(&[vec!["a", "1"], vec!["b", "2"]]);
24    let vs = Splitter::new(col, Orientation::Vertical);
25    let tree = Tree::new(vs);
26    let r = tree.add(None, "root");
27    tree.add(Some(r), "kid");
28    let list = ListBox::new(vs);
29    list.set_items(&["one", "two"]);
30    table.on_select(|i| println!("TABLE_SEL {i:?}"));
31    tree.on_select(|n| println!("TREE_SEL {}", n.is_some()));
32    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
33    hs.on_move(|p| println!("HSPLIT {p}"));
34    vs.on_move(|p| println!("VSPLIT {p}"));
35    w.on_move(|x, y| println!("MOVED {x} {y}"));
36    w.on_resize(|w, h| println!("RESIZED {w} {h}"));
37    w.on_close(|| {
38        App::quit();
39        true
40    });
41    w.show();
42    let _t = Timer::once(600, move || {
43        println!("POS {:?}", w.position());
44        for (n, b) in [
45            ("hs", hs.bounds()),
46            ("vs", vs.bounds()),
47            ("table", table.bounds()),
48            ("tree", tree.bounds()),
49            ("area", area.bounds()),
50        ] {
51            println!("BOUNDS {n} {} {} {} {}", b.x, b.y, b.w, b.h);
52        }
53        println!("HPOS {} VPOS {}", hs.position(), vs.position());
54        println!(
55            "MONO {} {} WRAP {}",
56            mono.monospace(),
57            area.monospace(),
58            area.wrap()
59        );
60        println!("READY");
61    });
62    app.run();
63    println!("BYE");
64}
More examples
Hide additional examples
examples/smoke_cocoa.rs (line 100)
6fn main() {
7    let app = App::new("smoke-cocoa").expect("init");
8    let a = Window::new("cc-a");
9    let bar = MenuBar::new(a);
10    let file = Menu::new(bar, "File");
11    let flag = CheckMenuItem::new(file, "Flag");
12    flag.set_accel("Ctrl+K");
13    flag.on_toggle(|v| println!("MENUTOGGLE {v}"));
14    let go = MenuItem::new(file, "Go");
15    go.set_accel("Ctrl+Shift+G");
16    go.on_click(|| println!("MENU_GO"));
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(|| {
20        println!("MENU_QUIT");
21        App::quit();
22    });
23
24    let col = VBox::new(a);
25    let row = HBox::new(col);
26    let btn = Button::new(row, "Press ünï");
27    let spin = SpinBox::new(row, 0.0, 10.0, 1.0);
28    let txt = TextInput::new(col);
29    let chk = CheckBox::new(col, "Monospace");
30    let hs = Splitter::new(col, Orientation::Horizontal);
31    let ta1 = TextArea::new(hs);
32    let ta2 = TextArea::new(hs);
33    ta2.set_text(
34        "long line without wrapping: 0123456789 0123456789 0123456789 0123456789 0123456789",
35    );
36    ta2.set_wrap(false);
37    hs.set_position(200);
38    hs.set_min_pane_sizes(60, 60);
39    let slider = Slider::new(col, 0.0, 100.0);
40    let combo = ComboBox::new(col);
41    combo.set_items(&["x", "y", "z"]);
42    let tabs = Tabs::new(col);
43    let p1 = tabs.add_page("First");
44    let p2 = tabs.add_page("Second");
45    Label::new(p1, "page one");
46    Label::new(p2, "page two");
47    let vs = Splitter::new(col, Orientation::Vertical);
48    let table = Table::new(vs);
49    table.set_columns(&[
50        Column::new("Name").width(80).sortable(true),
51        Column::new("Size").align(ColumnAlign::Right),
52    ]);
53    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
54    let tree = Tree::new(vs);
55    let root = tree.add(None, "root");
56    tree.add(Some(root), "kid");
57    let lazy = tree.add(None, "lazy");
58    tree.set_has_children(lazy, true);
59    vs.set_position(100);
60    vs.set_min_pane_sizes(40, 40);
61
62    btn.on_click(|| println!("CLICK"));
63    spin.on_change(|v| println!("SPIN {v}"));
64    txt.on_change(|t| println!("TEXT {t}"));
65    ta1.on_change(|t| println!("AREA {}", t.replace('\n', "|")));
66    chk.on_toggle(move |on| {
67        println!("MONO {on}");
68        txt.set_monospace(on);
69        ta1.set_monospace(on);
70    });
71    hs.on_move(|p| println!("HSPLIT {p}"));
72    vs.on_move(|p| println!("VSPLIT {p}"));
73    slider.on_change(|v| println!("VALUE {v:.0}"));
74    combo.on_select(|i| println!("COMBO {i:?}"));
75    tabs.on_select(|i| println!("TAB {i:?}"));
76    table.on_select(|i| println!("TABLE_SEL {i:?}"));
77    table.on_column_click(move |c| {
78        let ascending = table.sort_indicator() != Some((c, true));
79        let mut rows = table.rows();
80        rows.sort_by(|x, y| x[c].cmp(&y[c]));
81        if !ascending {
82            rows.reverse();
83        }
84        table.set_rows(&rows);
85        table.set_sort_indicator(Some((c, ascending)));
86        println!(
87            "TABLE_COL {c} {} {}",
88            if ascending { "asc" } else { "desc" },
89            rows[0][0]
90        );
91    });
92    tree.on_select(move |n| println!("TREE_SEL {}", n.is_some()));
93    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
94    a.set_context_menu({
95        let p = PopupMenu::new();
96        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
97        p
98    });
99    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
100    a.on_move(|x, y| println!("MOVED {x} {y}"));
101    a.set_min_size(300, 400);
102    a.set_position(220, 100);
103    a.set_size(560, 700);
104    a.on_close(|| {
105        println!("CLOSE_REQUESTED");
106        true
107    });
108    a.show();
109    println!(
110        "HANDLE {}",
111        a.native_handle().is_some() && btn.native_handle().is_some()
112    );
113    let _t = Timer::once(700, move || {
114        for (n, w) in [
115            ("btn", btn.bounds()),
116            ("spin", spin.bounds()),
117            ("txt", txt.bounds()),
118            ("chk", chk.bounds()),
119            ("hs", hs.bounds()),
120            ("slider", slider.bounds()),
121            ("combo", combo.bounds()),
122            ("tabs", tabs.bounds()),
123            ("vs", vs.bounds()),
124            ("table", table.bounds()),
125            ("tree", tree.bounds()),
126        ] {
127            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
128        }
129        println!("SPLITPOS h {} v {}", hs.position(), vs.position());
130        println!("READY");
131    });
132    app.run();
133    println!("BYE");
134}
Source

pub fn on_cancel(&self, f: impl FnMut() + 'static)

Called when the user presses Escape while this window is active, whichever of its widgets has the focus (unless that widget used the key itself, as an open drop-down does).

Examples found in repository?
examples/smoke_dialogs.rs (lines 22-25)
5fn main() {
6    let app = App::new("smoke-dialogs").expect("init");
7    let win = Window::new("smoke-dialogs");
8    let col = VBox::new(win);
9    let field = TextInput::new(col);
10    field.on_activate(|| println!("ACTIVATE"));
11    let ask = Button::new(col, "Ask");
12    ask.on_click(move || {
13        let r = Prompt::new("Rename").message("New name?").initial("old").run(Some(win));
14        println!("PROMPT {r:?}");
15    });
16    let modal = Button::new(col, "Modal");
17    modal.on_click(move || {
18        let d = Window::new("smoke-modal");
19        Label::new(d, "modal window");
20        let close = Button::new(d, "Close");
21        close.on_click(move || d.hide());
22        d.on_cancel(move || {
23            println!("MODAL_CANCEL");
24            d.hide();
25        });
26        println!("MODAL_OPEN");
27        d.run_modal(Some(win));
28        println!("MODAL_DONE");
29        d.destroy();
30    });
31    let list = ListBox::new(col);
32    list.set_items(&["one", "two", "three", "four", "five"]);
33    list.set_multi_select(true);
34    list.on_selection(|s| println!("LIST_SEL {s:?}"));
35    let table = Table::new(col);
36    table.set_columns(&[Column::new("Name").width(100)]);
37    table.set_rows(&[vec!["a"], vec!["b"], vec!["c"], vec!["d"]]);
38    table.set_multi_select(true);
39    table.on_selection(|s| println!("TABLE_SEL {s:?}"));
40    let cal = Calendar::new(col);
41    cal.set_date(Date::new(2031, 7, 4).unwrap());
42    cal.on_change(|d| println!("DATE {}-{:02}-{:02}", d.year, d.month, d.day));
43    win.on_close(|| {
44        App::quit();
45        true
46    });
47    win.show();
48    println!("TODAY {:?}", Date::today().is_valid());
49    let _t = Timer::once(600, move || {
50        for (n, w) in [
51            ("field", field.bounds()),
52            ("ask", ask.bounds()),
53            ("modal", modal.bounds()),
54            ("list", list.bounds()),
55            ("table", table.bounds()),
56            ("cal", cal.bounds()),
57        ] {
58            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
59        }
60        println!("READY");
61    });
62    let _exit = std::env::var("RUNGUI_EXIT_AFTER_MS")
63        .ok()
64        .and_then(|v| v.parse::<u32>().ok())
65        .map(|ms| Timer::once(ms, App::quit));
66    app.run();
67    println!("BYE");
68}
Source

pub fn run_modal(&self, parent: Option<Window>)

Show the window as a modal dialog over parent and wait: the application’s other windows take no input, and this call returns only when the window is hidden (Window::hide), closed or destroyed, or the application quits. Events (including those of this window) are handled while it waits, so the window’s own callbacks end the dialog, typically with hide() from a button’s on_click. A closed window is destroyed; one that was only hidden can be run again. Called on a dead window, or on one that is already running modally, it does nothing.

Examples found in repository?
examples/smoke_dialogs.rs (line 27)
5fn main() {
6    let app = App::new("smoke-dialogs").expect("init");
7    let win = Window::new("smoke-dialogs");
8    let col = VBox::new(win);
9    let field = TextInput::new(col);
10    field.on_activate(|| println!("ACTIVATE"));
11    let ask = Button::new(col, "Ask");
12    ask.on_click(move || {
13        let r = Prompt::new("Rename").message("New name?").initial("old").run(Some(win));
14        println!("PROMPT {r:?}");
15    });
16    let modal = Button::new(col, "Modal");
17    modal.on_click(move || {
18        let d = Window::new("smoke-modal");
19        Label::new(d, "modal window");
20        let close = Button::new(d, "Close");
21        close.on_click(move || d.hide());
22        d.on_cancel(move || {
23            println!("MODAL_CANCEL");
24            d.hide();
25        });
26        println!("MODAL_OPEN");
27        d.run_modal(Some(win));
28        println!("MODAL_DONE");
29        d.destroy();
30    });
31    let list = ListBox::new(col);
32    list.set_items(&["one", "two", "three", "four", "five"]);
33    list.set_multi_select(true);
34    list.on_selection(|s| println!("LIST_SEL {s:?}"));
35    let table = Table::new(col);
36    table.set_columns(&[Column::new("Name").width(100)]);
37    table.set_rows(&[vec!["a"], vec!["b"], vec!["c"], vec!["d"]]);
38    table.set_multi_select(true);
39    table.on_selection(|s| println!("TABLE_SEL {s:?}"));
40    let cal = Calendar::new(col);
41    cal.set_date(Date::new(2031, 7, 4).unwrap());
42    cal.on_change(|d| println!("DATE {}-{:02}-{:02}", d.year, d.month, d.day));
43    win.on_close(|| {
44        App::quit();
45        true
46    });
47    win.show();
48    println!("TODAY {:?}", Date::today().is_valid());
49    let _t = Timer::once(600, move || {
50        for (n, w) in [
51            ("field", field.bounds()),
52            ("ask", ask.bounds()),
53            ("modal", modal.bounds()),
54            ("list", list.bounds()),
55            ("table", table.bounds()),
56            ("cal", cal.bounds()),
57        ] {
58            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
59        }
60        println!("READY");
61    });
62    let _exit = std::env::var("RUNGUI_EXIT_AFTER_MS")
63        .ok()
64        .and_then(|v| v.parse::<u32>().ok())
65        .map(|ms| Timer::once(ms, App::quit));
66    app.run();
67    println!("BYE");
68}
Source

pub fn close(&self)

Close now (no on_close check).

Examples found in repository?
examples/kitchen_sink.rs (line 188)
4fn main() {
5    let app = App::new("kitchen-sink").expect("init");
6    let win = Window::new("rungui kitchen sink");
7
8    // Menus
9    let bar = MenuBar::new(win);
10    let file = Menu::new(bar, "File");
11    let open = MenuItem::new(file, "Open...");
12    open.set_accel("Ctrl+O");
13    let wrap = CheckMenuItem::new(file, "Word wrap");
14    wrap.set_checked(true);
15    let mono = CheckMenuItem::new(file, "Monospace notes");
16    MenuSeparator::new(file);
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(App::quit);
20
21    let root = VBox::new(win);
22    let status = Label::new(root, "Ready");
23    let tabs = Tabs::new(root);
24    tabs.set_expand(1.0);
25
26    // Page 1: form in a grid
27    let form = tabs.add_page("Form");
28    let grid = Grid::new(form, 2);
29    Label::new(grid, "Name");
30    let name = TextInput::new(grid);
31    name.set_expand(1.0);
32    Label::new(grid, "Password");
33    TextInput::password(grid);
34    Label::new(grid, "Colour");
35    let combo = ComboBox::new(grid);
36    combo.set_items(&["Red", "Green", "Blue"]);
37    combo.set_selected(Some(0));
38    Label::new(grid, "Count");
39    let spin = SpinBox::new(grid, 0.0, 10.0, 1.0);
40    Label::new(grid, "Level");
41    let slider = Slider::new(grid, 0.0, 100.0);
42    let progress = ProgressBar::new(form);
43    slider.on_change(move |v| progress.set_fraction(v / 100.0));
44    spin.on_change(move |v| status.set_text(&format!("count = {v}")));
45    combo.on_select(move |i| status.set_text(&format!("colour index {i:?}")));
46
47    // Page 2: choices
48    let choices = tabs.add_page("Choices");
49    let boxed = GroupBox::new(choices, "Options");
50    let group = RadioGroup::new();
51    let a = RadioButton::new(boxed, &group, "Option A");
52    RadioButton::new(boxed, &group, "Option B");
53    a.set_checked(true);
54    let check = CheckBox::new(boxed, "Enabled");
55    check.set_checked(true);
56    let list = ListBox::new(choices);
57    list.set_items(&["alpha", "beta", "gamma", "delta"]);
58    list.set_expand(1.0);
59    list.on_activate(move |i| status.set_text(&format!("activated {i}")));
60
61    // Page 3: text; a vertical splitter with notes on top and a fixed-pitch, unwrapped view below
62    let notes = tabs.add_page("Notes");
63    let vsplit = Splitter::new(notes, Orientation::Vertical);
64    let area = TextArea::new(vsplit);
65    let code = TextArea::new(vsplit);
66    code.set_monospace(true);
67    code.set_wrap(false);
68    code.set_read_only(true);
69    code.set_text(
70        "fn main() {\n    println!(\"a long line that does not wrap: {}\", \"-\".repeat(60));\n}\n",
71    );
72    vsplit.set_position(120);
73    vsplit.set_min_pane_sizes(40, 40);
74    vsplit.on_move(move |p| status.set_text(&format!("notes split at {p}px")));
75    wrap.on_toggle(move |on| area.set_wrap(on));
76    mono.on_toggle(move |on| area.set_monospace(on));
77
78    // Page 4: table, tree and a context menu
79    let data = tabs.add_page("Data");
80    let split = Splitter::new(data, Orientation::Horizontal);
81    split.on_move(move |p| status.set_text(&format!("data split at {p}px")));
82    let table = Table::new(split);
83    table.set_columns(&[
84        Column::new("Name").width(140).sortable(true),
85        Column::new("Size")
86            .width(70)
87            .align(ColumnAlign::Right)
88            .sortable(true),
89    ]);
90    table.set_rows(&[
91        vec!["kernel", "9120"],
92        vec!["README", "312"],
93        vec!["Cargo.toml", "1024"],
94    ]);
95    table.on_select(move |r| status.set_text(&format!("row {r:?}")));
96    table.on_activate(move |r| status.set_text(&format!("row {r} activated")));
97    table.on_column_click(move |c| {
98        // sorting is the app's job: reorder the rows, then show the arrow
99        let ascending = table.sort_indicator() != Some((c, true));
100        let mut rows = table.rows();
101        rows.sort_by(|a, b| match c {
102            1 => a[1]
103                .parse::<u64>()
104                .unwrap_or(0)
105                .cmp(&b[1].parse::<u64>().unwrap_or(0)),
106            _ => a[c].cmp(&b[c]),
107        });
108        if !ascending {
109            rows.reverse();
110        }
111        table.set_rows(&rows);
112        table.set_sort_indicator(Some((c, ascending)));
113    });
114
115    let tree = Tree::new(split);
116    let src = tree.add(None, "src");
117    tree.add(Some(src), "lib.rs");
118    tree.add(Some(src), "core.rs");
119    let docs = tree.add(None, "doc");
120    tree.set_has_children(docs, true); // lazily filled when first expanded
121    tree.set_expanded(src, true);
122    tree.on_select(move |n| status.set_text(&format!("node {:?}", n.map(|n| tree.text(n)))));
123    tree.on_expand(move |n, open| {
124        if open && tree.children(Some(n)).is_empty() {
125            tree.add(Some(n), "DESIGN.md");
126            tree.add(Some(n), "BUILDING.md");
127        }
128    });
129
130    // Page 5: a calendar, a multi-select list and a prompt
131    let dates = tabs.add_page("Dates");
132    let cal = Calendar::new(dates);
133    cal.on_change(move |d| status.set_text(&format!("{}-{:02}-{:02}", d.year, d.month, d.day)));
134    let many = ListBox::new(dates);
135    many.set_items(&["one", "two", "three", "four"]);
136    many.set_multi_select(true);
137    many.set_expand(1.0);
138    many.on_selection(move |rows| status.set_text(&format!("selected {rows:?}")));
139    let ask = Button::new(dates, "Ask...");
140    ask.on_click(move || {
141        let r = prompt(Some(win), "Name", "What is your name?", "");
142        status.set_text(&format!("name: {r:?}"));
143    });
144
145    // Right-click the table for a context menu; its items are rebuilt/enabled just before display.
146    let popup = PopupMenu::new();
147    let del = MenuItem::new(popup, "Delete row");
148    MenuSeparator::new(popup);
149    let hdr = CheckMenuItem::new(popup, "Show sizes");
150    hdr.set_checked(true);
151    table.set_context_menu(popup);
152    table.on_context_menu(move |_, _| del.set_enabled(table.selected().is_some()));
153    del.on_click(move || {
154        if let Some(r) = table.selected() {
155            table.remove_row(r);
156        }
157    });
158    hdr.on_toggle(move |on| status.set_text(&format!("show sizes: {on}")));
159    tree.set_context_menu(popup);
160
161    open.on_click(move || {
162        if let Some(p) = FileDialog::new()
163            .title("Open")
164            .filter("Text", &["txt", "md"])
165            .open(Some(win))
166        {
167            if let Ok(s) = std::fs::read_to_string(&p) {
168                area.set_text(&s);
169            }
170            status.set_text(&format!("opened {}", p.display()));
171        }
172    });
173
174    // Buttons row
175    let row = HBox::new(root);
176    Spacer::new(row);
177    let about = Button::new(row, "About");
178    about.on_click(move || {
179        message_box(
180            Some(win),
181            MessageKind::Info,
182            Buttons::Ok,
183            "About",
184            "rungui kitchen sink",
185        );
186    });
187    let ok = Button::new(row, "Close");
188    ok.on_click(move || win.close());
189    ok.set_a11y_description("Closes the window");
190
191    let n = std::cell::Cell::new(0);
192    Timer::every(1000, move || {
193        n.set(n.get() + 1);
194        status.set_text(&format!("uptime {}s", n.get()));
195    });
196
197    win.set_size(480, 400);
198    win.show();
199    app.run();
200}
Source§

impl Window

Source

pub fn from_id(id: WidgetId) -> Self

Wrap a raw id (e.g. one carried across threads). No checks: stale ids are inert.

Methods from Deref<Target = Widget>§

Source

pub fn id(&self) -> WidgetId

The widget’s id.

Source

pub fn is_alive(&self) -> bool

False after destroy, or if creation failed (see crate::last_error).

Source

pub fn destroy(&self)

Destroy this widget and all its children. (Destroying many siblings one at a time costs time proportional to how many are left each; to clear a container, destroy the container.)

Examples found in repository?
examples/smoke_dialogs.rs (line 29)
5fn main() {
6    let app = App::new("smoke-dialogs").expect("init");
7    let win = Window::new("smoke-dialogs");
8    let col = VBox::new(win);
9    let field = TextInput::new(col);
10    field.on_activate(|| println!("ACTIVATE"));
11    let ask = Button::new(col, "Ask");
12    ask.on_click(move || {
13        let r = Prompt::new("Rename").message("New name?").initial("old").run(Some(win));
14        println!("PROMPT {r:?}");
15    });
16    let modal = Button::new(col, "Modal");
17    modal.on_click(move || {
18        let d = Window::new("smoke-modal");
19        Label::new(d, "modal window");
20        let close = Button::new(d, "Close");
21        close.on_click(move || d.hide());
22        d.on_cancel(move || {
23            println!("MODAL_CANCEL");
24            d.hide();
25        });
26        println!("MODAL_OPEN");
27        d.run_modal(Some(win));
28        println!("MODAL_DONE");
29        d.destroy();
30    });
31    let list = ListBox::new(col);
32    list.set_items(&["one", "two", "three", "four", "five"]);
33    list.set_multi_select(true);
34    list.on_selection(|s| println!("LIST_SEL {s:?}"));
35    let table = Table::new(col);
36    table.set_columns(&[Column::new("Name").width(100)]);
37    table.set_rows(&[vec!["a"], vec!["b"], vec!["c"], vec!["d"]]);
38    table.set_multi_select(true);
39    table.on_selection(|s| println!("TABLE_SEL {s:?}"));
40    let cal = Calendar::new(col);
41    cal.set_date(Date::new(2031, 7, 4).unwrap());
42    cal.on_change(|d| println!("DATE {}-{:02}-{:02}", d.year, d.month, d.day));
43    win.on_close(|| {
44        App::quit();
45        true
46    });
47    win.show();
48    println!("TODAY {:?}", Date::today().is_valid());
49    let _t = Timer::once(600, move || {
50        for (n, w) in [
51            ("field", field.bounds()),
52            ("ask", ask.bounds()),
53            ("modal", modal.bounds()),
54            ("list", list.bounds()),
55            ("table", table.bounds()),
56            ("cal", cal.bounds()),
57        ] {
58            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
59        }
60        println!("READY");
61    });
62    let _exit = std::env::var("RUNGUI_EXIT_AFTER_MS")
63        .ok()
64        .and_then(|v| v.parse::<u32>().ok())
65        .map(|ms| Timer::once(ms, App::quit));
66    app.run();
67    println!("BYE");
68}
More examples
Hide additional examples
examples/file_manager/app.rs (line 1227)
1219    fn dialog(
1220        self: &Rc<Self>,
1221        title: &str,
1222        prompt: &str,
1223        initial: &str,
1224        action: impl Fn(&Rc<Fm>, &str) -> std::result::Result<(), String> + 'static,
1225    ) {
1226        if let Some(old) = self.st.borrow_mut().dialog.take() {
1227            old.destroy();
1228        }
1229        let w = Window::new(title);
1230        w.set_size(380, 150);
1231        w.set_resizable(false);
1232        let col = VBox::new(w);
1233        col.set_spacing(8);
1234        Label::new(col, prompt);
1235        let input = TextInput::new(col);
1236        input.set_text(initial);
1237        input.set_a11y_name(title);
1238        let err = Label::new(col, "");
1239        let row = HBox::new(col);
1240        row.set_spacing(8);
1241        Spacer::new(row);
1242        let cancel = Button::new(row, "Cancel");
1243        let ok = Button::new(row, "OK");
1244        self.st.borrow_mut().dialog = Some(w);
1245        self.dialog_ui.set(Some((w, input, ok, cancel)));
1246        trace!("DIALOG open {title}");
1247        {
1248            let fm = self.clone();
1249            ok.on_click(move || {
1250                let text = input.text();
1251                match action(&fm, text.trim()) {
1252                    Ok(()) => {
1253                        trace!("DIALOG done");
1254                        fm.st.borrow_mut().dialog = None;
1255                        w.destroy();
1256                    }
1257                    Err(e) => {
1258                        trace!("DIALOG error {e}");
1259                        err.set_text(&e);
1260                    }
1261                }
1262            });
1263            let fm = self.clone();
1264            cancel.on_click(move || {
1265                trace!("DIALOG cancel");
1266                fm.st.borrow_mut().dialog = None;
1267                w.destroy();
1268            });
1269            let fm = self.clone();
1270            w.on_close(move || {
1271                fm.st.borrow_mut().dialog = None;
1272                true
1273            });
1274        }
1275        w.show();
1276        input.focus();
1277        if tracing() {
1278            Timer::once(300, move || {
1279                for (n, wd) in [
1280                    ("dlg_input", *input),
1281                    ("dlg_ok", *ok),
1282                    ("dlg_cancel", *cancel),
1283                ] {
1284                    let r = wd.bounds();
1285                    println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
1286                }
1287            });
1288        }
1289    }
Source

pub fn set_enabled(&self, v: bool)

Enable or disable the widget and everything inside it.

Examples found in repository?
examples/file_manager/app.rs (line 743)
709    fn refresh_labels(&self) {
710        let (active, paths) = {
711            let st = self.st.borrow();
712            (
713                st.active,
714                st.panes.iter().map(|p| p.path.clone()).collect::<Vec<_>>(),
715            )
716        };
717        for (i, p) in paths.iter().enumerate() {
718            let mark = if i == active { "\u{25B6}" } else { " " };
719            // labels do not clip, so fit the path to the pane (about 7 px per character)
720            let room = (self.ui.tables[i].bounds().w / 7).max(12) as usize;
721            let head = format!("{mark} {}  ", PANE_NAMES[i]);
722            let path = fsm::ellipsize_path(
723                &p.display().to_string(),
724                room.saturating_sub(head.chars().count()),
725            );
726            self.ui.pane_labels[i].set_text(&format!("{head}{path}"));
727        }
728        let cur = paths.get(active).cloned().unwrap_or_default();
729        let text = cur.display().to_string();
730        if self.ui.path.text() != text && !self.typing.get() {
731            self.ui.path.set_text(&text);
732        }
733        let name = cur
734            .file_name()
735            .map(|n| n.to_string_lossy().into_owned())
736            .unwrap_or_else(|| text.clone());
737        self.ui
738            .win
739            .set_title(&format!("{name} [{}] - File Manager", PANE_NAMES[active]));
740        self.ui
741            .tag
742            .set_text(&format!("  Active pane: {}", PANE_NAMES[active]));
743        self.ui.up.set_enabled(cur.parent().is_some());
744    }
745
746    // ---------------------------------------------------------------- table
747
748    /// Fill a pane's table from its entries. Uses one `batch` so huge directories send one update.
749    fn populate(&self, pane: usize, select: Option<&Path>) {
750        let (rows, sort, sel) = {
751            let st = self.st.borrow();
752            let p = &st.panes[pane];
753            let rows: Vec<Vec<String>> = p.entries.iter().map(row_of).collect();
754            (
755                rows,
756                p.sort,
757                select.and_then(|s| p.entries.iter().position(|e| e.path == s)),
758            )
759        };
760        let t = self.ui.tables[pane];
761        self.quietly(|| {
762            t.batch(|t| t.set_rows(&rows));
763            t.set_sort_indicator(Some((sort.0.column(), sort.1)));
764            t.set_selected(sel);
765        });
766    }
767
768    fn sort_by_column(self: &Rc<Self>, pane: usize, col: usize) {
769        let key = SortKey::from_column(col);
770        let keep = self.selected(pane).map(|e| e.path);
771        {
772            let mut st = self.st.borrow_mut();
773            let Some(p) = st.panes.get_mut(pane) else {
774                return;
775            };
776            let asc = if p.sort.0 == key { !p.sort.1 } else { true };
777            p.sort = (key, asc);
778            let has_parent = p.entries.first().is_some_and(|e| e.is_parent);
779            fsm::sort_entries(&mut p.entries[has_parent as usize..], key, asc);
780        }
781        self.populate(pane, keep.as_deref());
782        let (k, asc) = self.st.borrow().panes[pane].sort;
783        trace!(
784            "SORT {} {} {}",
785            PANE_NAMES[pane],
786            k.column(),
787            if asc { "asc" } else { "desc" }
788        );
789    }
790
791    fn on_row_selected(self: &Rc<Self>, pane: usize, row: Option<usize>) {
792        if self.quiet.get() > 0 {
793            return;
794        }
795        self.set_active(pane);
796        let e = row.and_then(|r| self.entry_at(pane, r));
797        if let Some(e) = &e {
798            trace!("SELECT {} {}", PANE_NAMES[pane], e.name);
799        }
800        self.show_preview(e);
801        self.update_status();
802    }
803
804    fn on_row_activated(self: &Rc<Self>, pane: usize, row: usize) {
805        self.set_active(pane);
806        let Some(e) = self.entry_at(pane, row) else {
807            return;
808        };
809        self.open_entry(pane, e);
810    }
811
812    fn open_entry(self: &Rc<Self>, pane: usize, e: Entry) {
813        if e.is_dir {
814            let from = self.path_of(pane);
815            let select = e.is_parent.then_some(from);
816            self.navigate(pane, e.path, select, true, false);
817        } else {
818            trace!("OPEN {} {}", PANE_NAMES[pane], e.name);
819            self.show_preview(Some(e));
820        }
821    }
822
823    fn op_open(self: &Rc<Self>) {
824        if let Some(e) = self.selected(self.active()) {
825            self.open_entry(self.active(), e);
826        }
827    }
828
829    /// Runs just before the popup is shown: right-clicking a pane makes it the active one.
830    fn prepare_context_menu(&self, pane: usize) {
831        self.set_active(pane);
832        let sel = self.selected(pane);
833        let real = sel.as_ref().is_some_and(|e| !e.is_parent);
834        let it = self.ui.items;
835        it.ctx_open.set_enabled(sel.is_some());
836        it.ctx_rename.set_enabled(real);
837        it.ctx_delete.set_enabled(real);
838        it.ctx_copy.set_enabled(real);
839    }
More examples
Hide additional examples
examples/kitchen_sink.rs (line 152)
4fn main() {
5    let app = App::new("kitchen-sink").expect("init");
6    let win = Window::new("rungui kitchen sink");
7
8    // Menus
9    let bar = MenuBar::new(win);
10    let file = Menu::new(bar, "File");
11    let open = MenuItem::new(file, "Open...");
12    open.set_accel("Ctrl+O");
13    let wrap = CheckMenuItem::new(file, "Word wrap");
14    wrap.set_checked(true);
15    let mono = CheckMenuItem::new(file, "Monospace notes");
16    MenuSeparator::new(file);
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(App::quit);
20
21    let root = VBox::new(win);
22    let status = Label::new(root, "Ready");
23    let tabs = Tabs::new(root);
24    tabs.set_expand(1.0);
25
26    // Page 1: form in a grid
27    let form = tabs.add_page("Form");
28    let grid = Grid::new(form, 2);
29    Label::new(grid, "Name");
30    let name = TextInput::new(grid);
31    name.set_expand(1.0);
32    Label::new(grid, "Password");
33    TextInput::password(grid);
34    Label::new(grid, "Colour");
35    let combo = ComboBox::new(grid);
36    combo.set_items(&["Red", "Green", "Blue"]);
37    combo.set_selected(Some(0));
38    Label::new(grid, "Count");
39    let spin = SpinBox::new(grid, 0.0, 10.0, 1.0);
40    Label::new(grid, "Level");
41    let slider = Slider::new(grid, 0.0, 100.0);
42    let progress = ProgressBar::new(form);
43    slider.on_change(move |v| progress.set_fraction(v / 100.0));
44    spin.on_change(move |v| status.set_text(&format!("count = {v}")));
45    combo.on_select(move |i| status.set_text(&format!("colour index {i:?}")));
46
47    // Page 2: choices
48    let choices = tabs.add_page("Choices");
49    let boxed = GroupBox::new(choices, "Options");
50    let group = RadioGroup::new();
51    let a = RadioButton::new(boxed, &group, "Option A");
52    RadioButton::new(boxed, &group, "Option B");
53    a.set_checked(true);
54    let check = CheckBox::new(boxed, "Enabled");
55    check.set_checked(true);
56    let list = ListBox::new(choices);
57    list.set_items(&["alpha", "beta", "gamma", "delta"]);
58    list.set_expand(1.0);
59    list.on_activate(move |i| status.set_text(&format!("activated {i}")));
60
61    // Page 3: text; a vertical splitter with notes on top and a fixed-pitch, unwrapped view below
62    let notes = tabs.add_page("Notes");
63    let vsplit = Splitter::new(notes, Orientation::Vertical);
64    let area = TextArea::new(vsplit);
65    let code = TextArea::new(vsplit);
66    code.set_monospace(true);
67    code.set_wrap(false);
68    code.set_read_only(true);
69    code.set_text(
70        "fn main() {\n    println!(\"a long line that does not wrap: {}\", \"-\".repeat(60));\n}\n",
71    );
72    vsplit.set_position(120);
73    vsplit.set_min_pane_sizes(40, 40);
74    vsplit.on_move(move |p| status.set_text(&format!("notes split at {p}px")));
75    wrap.on_toggle(move |on| area.set_wrap(on));
76    mono.on_toggle(move |on| area.set_monospace(on));
77
78    // Page 4: table, tree and a context menu
79    let data = tabs.add_page("Data");
80    let split = Splitter::new(data, Orientation::Horizontal);
81    split.on_move(move |p| status.set_text(&format!("data split at {p}px")));
82    let table = Table::new(split);
83    table.set_columns(&[
84        Column::new("Name").width(140).sortable(true),
85        Column::new("Size")
86            .width(70)
87            .align(ColumnAlign::Right)
88            .sortable(true),
89    ]);
90    table.set_rows(&[
91        vec!["kernel", "9120"],
92        vec!["README", "312"],
93        vec!["Cargo.toml", "1024"],
94    ]);
95    table.on_select(move |r| status.set_text(&format!("row {r:?}")));
96    table.on_activate(move |r| status.set_text(&format!("row {r} activated")));
97    table.on_column_click(move |c| {
98        // sorting is the app's job: reorder the rows, then show the arrow
99        let ascending = table.sort_indicator() != Some((c, true));
100        let mut rows = table.rows();
101        rows.sort_by(|a, b| match c {
102            1 => a[1]
103                .parse::<u64>()
104                .unwrap_or(0)
105                .cmp(&b[1].parse::<u64>().unwrap_or(0)),
106            _ => a[c].cmp(&b[c]),
107        });
108        if !ascending {
109            rows.reverse();
110        }
111        table.set_rows(&rows);
112        table.set_sort_indicator(Some((c, ascending)));
113    });
114
115    let tree = Tree::new(split);
116    let src = tree.add(None, "src");
117    tree.add(Some(src), "lib.rs");
118    tree.add(Some(src), "core.rs");
119    let docs = tree.add(None, "doc");
120    tree.set_has_children(docs, true); // lazily filled when first expanded
121    tree.set_expanded(src, true);
122    tree.on_select(move |n| status.set_text(&format!("node {:?}", n.map(|n| tree.text(n)))));
123    tree.on_expand(move |n, open| {
124        if open && tree.children(Some(n)).is_empty() {
125            tree.add(Some(n), "DESIGN.md");
126            tree.add(Some(n), "BUILDING.md");
127        }
128    });
129
130    // Page 5: a calendar, a multi-select list and a prompt
131    let dates = tabs.add_page("Dates");
132    let cal = Calendar::new(dates);
133    cal.on_change(move |d| status.set_text(&format!("{}-{:02}-{:02}", d.year, d.month, d.day)));
134    let many = ListBox::new(dates);
135    many.set_items(&["one", "two", "three", "four"]);
136    many.set_multi_select(true);
137    many.set_expand(1.0);
138    many.on_selection(move |rows| status.set_text(&format!("selected {rows:?}")));
139    let ask = Button::new(dates, "Ask...");
140    ask.on_click(move || {
141        let r = prompt(Some(win), "Name", "What is your name?", "");
142        status.set_text(&format!("name: {r:?}"));
143    });
144
145    // Right-click the table for a context menu; its items are rebuilt/enabled just before display.
146    let popup = PopupMenu::new();
147    let del = MenuItem::new(popup, "Delete row");
148    MenuSeparator::new(popup);
149    let hdr = CheckMenuItem::new(popup, "Show sizes");
150    hdr.set_checked(true);
151    table.set_context_menu(popup);
152    table.on_context_menu(move |_, _| del.set_enabled(table.selected().is_some()));
153    del.on_click(move || {
154        if let Some(r) = table.selected() {
155            table.remove_row(r);
156        }
157    });
158    hdr.on_toggle(move |on| status.set_text(&format!("show sizes: {on}")));
159    tree.set_context_menu(popup);
160
161    open.on_click(move || {
162        if let Some(p) = FileDialog::new()
163            .title("Open")
164            .filter("Text", &["txt", "md"])
165            .open(Some(win))
166        {
167            if let Ok(s) = std::fs::read_to_string(&p) {
168                area.set_text(&s);
169            }
170            status.set_text(&format!("opened {}", p.display()));
171        }
172    });
173
174    // Buttons row
175    let row = HBox::new(root);
176    Spacer::new(row);
177    let about = Button::new(row, "About");
178    about.on_click(move || {
179        message_box(
180            Some(win),
181            MessageKind::Info,
182            Buttons::Ok,
183            "About",
184            "rungui kitchen sink",
185        );
186    });
187    let ok = Button::new(row, "Close");
188    ok.on_click(move || win.close());
189    ok.set_a11y_description("Closes the window");
190
191    let n = std::cell::Cell::new(0);
192    Timer::every(1000, move || {
193        n.set(n.get() + 1);
194        status.set_text(&format!("uptime {}s", n.get()));
195    });
196
197    win.set_size(480, 400);
198    win.show();
199    app.run();
200}
Source

pub fn enabled(&self) -> bool

Whether the widget itself is enabled (a disabled ancestor still disables it on screen).

Source

pub fn set_visible(&self, v: bool)

Hidden widgets take no layout space. Hiding a box hides everything inside it.

Examples found in repository?
examples/file_manager/app.rs (line 253)
162pub fn build(opts: Options) -> Rc<Fm> {
163    let win = Window::new("File Manager");
164    win.set_size(1000, 700);
165    win.set_min_size(640, 420);
166
167    // ---- menus (accelerators are the keyboard interface; there is no key-event API)
168    let bar = MenuBar::new(win);
169    let file = Menu::new(bar, "File");
170    let new_folder = MenuItem::new(file, "New Folder");
171    new_folder.set_accel("F7");
172    let rename = MenuItem::new(file, "Rename");
173    rename.set_accel("F2");
174    MenuSeparator::new(file);
175    let copy = MenuItem::new(file, "Copy to Other Pane");
176    copy.set_accel("F5");
177    let mv = MenuItem::new(file, "Move to Other Pane");
178    mv.set_accel("F6");
179    let delete = MenuItem::new(file, "Delete");
180    delete.set_accel("F8");
181    MenuSeparator::new(file);
182    let quit = MenuItem::new(file, "Quit");
183    quit.set_accel("Ctrl+Q");
184    let view = Menu::new(bar, "View");
185    let hidden = CheckMenuItem::new(view, "Show Hidden Files");
186    hidden.set_accel("Ctrl+H");
187    let refresh_item = MenuItem::new(view, "Refresh");
188    refresh_item.set_accel("Ctrl+R");
189    let go = Menu::new(bar, "Go");
190    let up_item = MenuItem::new(go, "Up One Level");
191    up_item.set_accel("Alt+Up");
192    let home_item = MenuItem::new(go, "Home Folder");
193    home_item.set_accel("Alt+Home");
194    let switch = MenuItem::new(go, "Switch Active Pane");
195    switch.set_accel("F9");
196    let helpm = Menu::new(bar, "Help");
197    let about = MenuItem::new(helpm, "About");
198
199    // ---- layout
200    let root = VBox::new(win);
201    root.set_spacing(6);
202    root.set_expand(1.0); // a window stacks its children vertically; give the whole area to this one
203
204    let tools = HBox::new(root);
205    tools.set_spacing(6);
206    let up = Button::new(tools, "\u{2191} Up");
207    up.set_tooltip("Go to the parent folder (Alt+Up)");
208    let refresh = Button::new(tools, "Refresh");
209    refresh.set_tooltip("Reload both panes (Ctrl+R)");
210    let path = TextInput::new(tools);
211    path.set_expand(1.0);
212    path.set_monospace(true);
213    path.set_tooltip("Type a folder path to open it in the active pane");
214    path.set_a11y_name("Path of the active pane");
215    let copy_btn = Button::new(tools, "Copy \u{2192}");
216    copy_btn.set_tooltip("Copy the selected item to the other pane (F5)");
217    let move_btn = Button::new(tools, "Move \u{2192}");
218    move_btn.set_tooltip("Move the selected item to the other pane (F6)");
219
220    let body = Splitter::new(root, Orientation::Horizontal);
221    body.set_expand(1.0);
222    let tree = Tree::new(body);
223    tree.set_a11y_name("Folders");
224    let right = Splitter::new(body, Orientation::Vertical);
225    let panes = Splitter::new(right, Orientation::Horizontal);
226    let mut tables = Vec::new();
227    let mut pane_labels = Vec::new();
228    for (i, n) in PANE_NAMES.iter().enumerate() {
229        let col = VBox::new(panes);
230        col.set_spacing(2);
231        pane_labels.push(Label::new(col, ""));
232        let t = Table::new(col);
233        t.set_expand(1.0);
234        t.set_a11y_name(&format!("Files, pane {n}"));
235        t.set_columns(&[
236            Column::new("Name").width(125).sortable(true),
237            Column::new("Size")
238                .width(62)
239                .align(ColumnAlign::Right)
240                .sortable(true),
241            Column::new("Modified").width(128).sortable(true),
242            Column::new("Kind").width(90).sortable(true),
243        ]);
244        let _ = i;
245        tables.push(t);
246    }
247    let pv = VBox::new(right);
248    pv.set_spacing(2);
249    let preview_title = Label::new(pv, "Preview");
250    let pv_row = HBox::new(pv);
251    pv_row.set_expand(1.0);
252    let image = Image::new(pv_row);
253    image.set_visible(false);
254    image.set_align(Align::Start);
255    let preview = TextArea::new(pv_row);
256    preview.set_expand(1.0);
257    preview.set_read_only(true);
258    preview.set_monospace(true);
259    preview.set_wrap(false);
260    preview.set_a11y_name("Preview");
261
262    let sbar = HBox::new(root);
263    let status = Label::new(sbar, "");
264    status.set_expand(1.0);
265    let tag = Label::new(sbar, "");
266
267    body.set_position(170);
268    body.set_min_pane_sizes(100, 300);
269    right.set_position(400);
270    right.set_min_pane_sizes(120, 80);
271    panes.set_min_pane_sizes(180, 180);
272
273    // ---- context menu shared by both tables
274    let popup = PopupMenu::new();
275    let ctx_open = MenuItem::new(popup, "Open");
276    let ctx_rename = MenuItem::new(popup, "Rename...");
277    let ctx_delete = MenuItem::new(popup, "Delete...");
278    MenuSeparator::new(popup);
279    let ctx_copy = MenuItem::new(popup, "Copy to Other Pane");
280    let ctx_new = MenuItem::new(popup, "New Folder...");
281    for t in &tables {
282        t.set_context_menu(popup);
283    }
284
285    let ui = Ui {
286        win,
287        body,
288        right,
289        panes,
290        tree,
291        tables: [tables[0], tables[1]],
292        pane_labels: [pane_labels[0], pane_labels[1]],
293        path,
294        up,
295        refresh,
296        copy_btn,
297        move_btn,
298        preview_title,
299        preview,
300        image,
301        status,
302        tag,
303        popup,
304        items: Items {
305            new_folder,
306            rename,
307            copy,
308            mv,
309            delete,
310            quit,
311            hidden,
312            refresh: refresh_item,
313            up: up_item,
314            home: home_item,
315            switch,
316            about,
317            ctx_open,
318            ctx_rename,
319            ctx_delete,
320            ctx_copy,
321            ctx_new,
322        },
323    };
324    let fm = Rc::new(Fm {
325        ui,
326        st: RefCell::new(State::default()),
327        quiet: Cell::new(0),
328        typing: Cell::new(false),
329        dialog_ui: Cell::new(None),
330    });
331    fm.wire();
332    fm.init_tree();
333    {
334        let mut st = fm.st.borrow_mut();
335        for p in &opts.dirs {
336            st.panes.push(Pane {
337                path: p.clone(),
338                entries: vec![],
339                sort: (SortKey::Name, true),
340                mtime: None,
341                truncated: false,
342            });
343        }
344    }
345    for (i, p) in opts.dirs.iter().enumerate() {
346        if !fm.navigate(i, p.clone(), None, true, false) {
347            // an unreadable start directory falls back to the home folder, then to "/"
348            let fallback = home_dir().unwrap_or_else(|| PathBuf::from("/"));
349            fm.navigate(i, fallback, None, true, false);
350        }
351    }
352    fm.set_active(0);
353    let first = fm.path_of(0);
354    fm.tree_reveal(&first);
355    fm.ui.win.show();
356    fm
357}
358
359impl Fm {
360    fn wire(self: &Rc<Self>) {
361        let u = &self.ui;
362        let it = u.items;
363        macro_rules! click {
364            ($btn:expr, $f:ident) => {{
365                let fm = self.clone();
366                $btn.on_click(move || fm.$f());
367            }};
368        }
369        click!(it.new_folder, op_new_folder);
370        click!(it.ctx_new, op_new_folder);
371        click!(it.rename, op_rename);
372        click!(it.ctx_rename, op_rename);
373        click!(it.delete, op_delete);
374        click!(it.ctx_delete, op_delete);
375        click!(it.copy, op_copy);
376        click!(it.ctx_copy, op_copy);
377        click!(u.copy_btn, op_copy);
378        click!(it.mv, op_move);
379        click!(u.move_btn, op_move);
380        click!(it.ctx_open, op_open);
381        click!(it.refresh, refresh_all);
382        click!(u.refresh, refresh_all);
383        click!(it.up, go_up);
384        click!(u.up, go_up);
385        click!(it.home, go_home);
386        click!(it.switch, switch_pane);
387        click!(it.about, about);
388        it.quit.on_click(App::quit);
389        {
390            let fm = self.clone();
391            it.hidden.on_toggle(move |on| fm.set_show_hidden(on));
392        }
393        for i in 0..2 {
394            let t = u.tables[i];
395            let fm = self.clone();
396            t.on_select(move |r| fm.on_row_selected(i, r));
397            let fm = self.clone();
398            t.on_activate(move |r| fm.on_row_activated(i, r));
399            let fm = self.clone();
400            t.on_column_click(move |c| fm.sort_by_column(i, c));
401            let fm = self.clone();
402            t.on_context_menu(move |_, _| fm.prepare_context_menu(i));
403        }
404        {
405            let fm = self.clone();
406            u.path.on_change(move |text| fm.on_path_typed(text));
407        }
408        {
409            let fm = self.clone();
410            u.tree.on_select(move |n| fm.on_tree_selected(n));
411            let fm = self.clone();
412            u.tree.on_expand(move |n, open| {
413                if open {
414                    fm.tree_load(n);
415                }
416            });
417        }
418        {
419            let fm = self.clone();
420            u.win.on_resize(move |w, h| {
421                trace!("RESIZE {w} {h}");
422                fm.relabel_soon();
423            });
424            for sp in [u.body, u.right, u.panes] {
425                let fm = self.clone();
426                sp.on_move(move |_| fm.relabel_soon());
427            }
428        }
429        // pick up changes made by other programs
430        let fm = self.clone();
431        Timer::every(1500, move || fm.poll());
432        // report geometry once the first layout has happened
433        let fm = self.clone();
434        Timer::once(500, move || {
435            fm.print_bounds();
436            trace!("READY");
437        });
438    }
439
440    // ---------------------------------------------------------------- state helpers
441
442    pub fn path_of(&self, pane: usize) -> PathBuf {
443        self.st
444            .borrow()
445            .panes
446            .get(pane)
447            .map(|p| p.path.clone())
448            .unwrap_or_default()
449    }
450
451    pub fn active(&self) -> usize {
452        self.st.borrow().active
453    }
454
455    fn entry_at(&self, pane: usize, row: usize) -> Option<Entry> {
456        self.st.borrow().panes.get(pane)?.entries.get(row).cloned()
457    }
458
459    /// The selected entry of `pane`, or None (nothing selected). The ".." row counts.
460    pub fn selected(&self, pane: usize) -> Option<Entry> {
461        let row = self.ui.tables[pane].selected()?;
462        self.entry_at(pane, row)
463    }
464
465    /// The selected real item (not "..") of the active pane.
466    fn target(&self) -> Option<Entry> {
467        self.selected(self.active()).filter(|e| !e.is_parent)
468    }
469
470    pub fn say(&self, msg: &str) {
471        self.ui.status.set_text(msg);
472        trace!("STATUS {msg}");
473    }
474
475    fn quietly<R>(&self, f: impl FnOnce() -> R) -> R {
476        self.quiet.set(self.quiet.get() + 1);
477        let r = f();
478        self.quiet.set(self.quiet.get() - 1);
479        r
480    }
481
482    // ---------------------------------------------------------------- navigation
483
484    /// Show `path` in `pane`. `select` picks a row afterwards (e.g. the folder we came from).
485    /// `reveal` also selects the folder in the tree. Returns false (and says why) on failure.
486    pub fn navigate(
487        self: &Rc<Self>,
488        pane: usize,
489        path: PathBuf,
490        select: Option<PathBuf>,
491        reveal: bool,
492        from_box: bool,
493    ) -> bool {
494        let hidden = self.st.borrow().show_hidden;
495        let listing = match fsm::read_dir(&path, hidden) {
496            Ok(l) => l,
497            Err(e) => {
498                self.say(&format!("Cannot open {}: {}", path.display(), e));
499                trace!("ERROR NAV {} {}", PANE_NAMES[pane], path.display());
500                return false;
501            }
502        };
503        let n = listing.entries.len();
504        let truncated = listing.truncated;
505        {
506            let mut st = self.st.borrow_mut();
507            let Some(p) = st.panes.get_mut(pane) else {
508                return false;
509            };
510            let mut entries = listing.entries;
511            fsm::sort_entries(&mut entries, p.sort.0, p.sort.1);
512            if let Some(parent) = Entry::parent_of(&path) {
513                entries.insert(0, parent);
514            }
515            p.mtime = std::fs::metadata(&path).and_then(|m| m.modified()).ok();
516            p.entries = entries;
517            p.path = path.clone();
518            p.truncated = truncated;
519        }
520        self.populate(pane, select.as_deref());
521        self.typing.set(from_box);
522        self.set_active(pane);
523        self.refresh_labels();
524        self.typing.set(false);
525        if reveal {
526            self.tree_reveal(&path);
527        }
528        // select + preview the requested row, else preview the directory itself
529        let row = select.and_then(|s| {
530            self.st.borrow().panes[pane]
531                .entries
532                .iter()
533                .position(|e| e.path == s)
534        });
535        match row {
536            Some(r) => self.on_row_selected(pane, Some(r)),
537            None => {
538                self.show_preview(Entry::from_path(&path));
539                self.update_status();
540            }
541        }
542        trace!("NAV {} {} {}", PANE_NAMES[pane], path.display(), n);
543        if truncated {
544            self.say(&format!(
545                "Showing only the first {} entries of {}",
546                fsm::MAX_ENTRIES,
547                path.display()
548            ));
549        }
550        true
551    }
552
553    /// Re-read `pane`, keeping the selected item selected when it still exists.
554    fn reload(self: &Rc<Self>, pane: usize, keep: Option<PathBuf>) {
555        let path = self.path_of(pane);
556        let keep = keep.or_else(|| self.selected(pane).map(|e| e.path));
557        if self.navigate_quiet(pane, &path, keep.clone()) {
558            return;
559        }
560        // the directory vanished: climb to the nearest one that exists
561        let mut p = path.clone();
562        while let Some(parent) = p.parent().map(Path::to_path_buf) {
563            if parent.is_dir() && self.navigate(pane, parent.clone(), Some(p.clone()), true, false)
564            {
565                return;
566            }
567            p = parent;
568        }
569    }
570
571    /// Like `navigate` for the same directory but without the active-pane, tree and preview churn
572    /// unless the selection changed. Returns false if the directory cannot be read.
573    fn navigate_quiet(self: &Rc<Self>, pane: usize, path: &Path, keep: Option<PathBuf>) -> bool {
574        let hidden = self.st.borrow().show_hidden;
575        let Ok(listing) = fsm::read_dir(path, hidden) else {
576            return false;
577        };
578        {
579            let mut st = self.st.borrow_mut();
580            let p = &mut st.panes[pane];
581            let mut entries = listing.entries;
582            fsm::sort_entries(&mut entries, p.sort.0, p.sort.1);
583            if let Some(parent) = Entry::parent_of(path) {
584                entries.insert(0, parent);
585            }
586            p.mtime = std::fs::metadata(path).and_then(|m| m.modified()).ok();
587            p.entries = entries;
588            p.truncated = listing.truncated;
589        }
590        self.populate(pane, keep.as_deref());
591        if pane == self.active() {
592            let row = keep.and_then(|s| {
593                self.st.borrow().panes[pane]
594                    .entries
595                    .iter()
596                    .position(|e| e.path == s)
597            });
598            self.show_preview(
599                row.and_then(|r| self.entry_at(pane, r))
600                    .or_else(|| Entry::from_path(path)),
601            );
602        }
603        self.update_status();
604        true
605    }
606
607    #[allow(dead_code)] // used by tests/file_manager_mock.rs
608    /// Test helper: navigate without touching the tree.
609    pub fn navigate_for_test(self: &Rc<Self>, pane: usize, path: PathBuf) -> bool {
610        self.navigate(pane, path, None, false, false)
611    }
612
613    pub fn refresh_all(self: &Rc<Self>) {
614        for i in 0..2 {
615            self.reload(i, None);
616        }
617        self.say("Refreshed");
618        trace!("REFRESH");
619    }
620
621    /// Timer: reload panes whose directory changed on disk.
622    fn poll(self: &Rc<Self>) {
623        #[allow(clippy::needless_range_loop)]
624        for i in 0..2 {
625            let (path, old) = {
626                let st = self.st.borrow();
627                match st.panes.get(i) {
628                    Some(p) => (p.path.clone(), p.mtime),
629                    None => return,
630                }
631            };
632            let now = std::fs::metadata(&path).and_then(|m| m.modified()).ok();
633            if now != old {
634                trace!("CHANGED {}", PANE_NAMES[i]);
635                self.reload(i, None);
636            }
637        }
638    }
639
640    pub fn go_up(self: &Rc<Self>) {
641        let a = self.active();
642        let cur = self.path_of(a);
643        if let Some(parent) = cur.parent() {
644            self.navigate(a, parent.to_path_buf(), Some(cur.clone()), true, false);
645        }
646    }
647
648    fn go_home(self: &Rc<Self>) {
649        if let Some(h) = home_dir() {
650            let a = self.active();
651            self.navigate(a, h, None, true, false);
652        }
653    }
654
655    fn switch_pane(self: &Rc<Self>) {
656        let other = 1 - self.active();
657        self.set_active(other);
658        self.ui.tables[other].focus();
659    }
660
661    fn set_show_hidden(self: &Rc<Self>, on: bool) {
662        self.st.borrow_mut().show_hidden = on;
663        trace!("HIDDEN {on}");
664        for i in 0..2 {
665            self.reload(i, None);
666        }
667        // rebuild the folder tree so hidden folders appear or vanish too
668        self.init_tree();
669        let a = self.active();
670        let p = self.path_of(a);
671        self.tree_reveal(&p);
672    }
673
674    fn on_path_typed(self: &Rc<Self>, text: &str) {
675        if self.typing.get() {
676            return;
677        }
678        let a = self.active();
679        let t = text.trim();
680        if t.is_empty() || Path::new(t) == self.path_of(a) {
681            return;
682        }
683        let p = PathBuf::from(t);
684        if p.is_dir() {
685            self.navigate(a, p, None, true, true);
686        }
687    }
688
689    pub fn set_active(&self, pane: usize) {
690        let changed = {
691            let mut st = self.st.borrow_mut();
692            let c = st.active != pane;
693            st.active = pane;
694            c
695        };
696        self.refresh_labels();
697        if changed {
698            trace!("ACTIVE {}", PANE_NAMES[pane]);
699        }
700    }
701
702    /// The pane captions depend on the pane widths, which are known only after layout.
703    fn relabel_soon(self: &Rc<Self>) {
704        let fm = self.clone();
705        Timer::once(10, move || fm.refresh_labels());
706    }
707
708    /// Pane captions, path box, window title and the active-pane tag.
709    fn refresh_labels(&self) {
710        let (active, paths) = {
711            let st = self.st.borrow();
712            (
713                st.active,
714                st.panes.iter().map(|p| p.path.clone()).collect::<Vec<_>>(),
715            )
716        };
717        for (i, p) in paths.iter().enumerate() {
718            let mark = if i == active { "\u{25B6}" } else { " " };
719            // labels do not clip, so fit the path to the pane (about 7 px per character)
720            let room = (self.ui.tables[i].bounds().w / 7).max(12) as usize;
721            let head = format!("{mark} {}  ", PANE_NAMES[i]);
722            let path = fsm::ellipsize_path(
723                &p.display().to_string(),
724                room.saturating_sub(head.chars().count()),
725            );
726            self.ui.pane_labels[i].set_text(&format!("{head}{path}"));
727        }
728        let cur = paths.get(active).cloned().unwrap_or_default();
729        let text = cur.display().to_string();
730        if self.ui.path.text() != text && !self.typing.get() {
731            self.ui.path.set_text(&text);
732        }
733        let name = cur
734            .file_name()
735            .map(|n| n.to_string_lossy().into_owned())
736            .unwrap_or_else(|| text.clone());
737        self.ui
738            .win
739            .set_title(&format!("{name} [{}] - File Manager", PANE_NAMES[active]));
740        self.ui
741            .tag
742            .set_text(&format!("  Active pane: {}", PANE_NAMES[active]));
743        self.ui.up.set_enabled(cur.parent().is_some());
744    }
745
746    // ---------------------------------------------------------------- table
747
748    /// Fill a pane's table from its entries. Uses one `batch` so huge directories send one update.
749    fn populate(&self, pane: usize, select: Option<&Path>) {
750        let (rows, sort, sel) = {
751            let st = self.st.borrow();
752            let p = &st.panes[pane];
753            let rows: Vec<Vec<String>> = p.entries.iter().map(row_of).collect();
754            (
755                rows,
756                p.sort,
757                select.and_then(|s| p.entries.iter().position(|e| e.path == s)),
758            )
759        };
760        let t = self.ui.tables[pane];
761        self.quietly(|| {
762            t.batch(|t| t.set_rows(&rows));
763            t.set_sort_indicator(Some((sort.0.column(), sort.1)));
764            t.set_selected(sel);
765        });
766    }
767
768    fn sort_by_column(self: &Rc<Self>, pane: usize, col: usize) {
769        let key = SortKey::from_column(col);
770        let keep = self.selected(pane).map(|e| e.path);
771        {
772            let mut st = self.st.borrow_mut();
773            let Some(p) = st.panes.get_mut(pane) else {
774                return;
775            };
776            let asc = if p.sort.0 == key { !p.sort.1 } else { true };
777            p.sort = (key, asc);
778            let has_parent = p.entries.first().is_some_and(|e| e.is_parent);
779            fsm::sort_entries(&mut p.entries[has_parent as usize..], key, asc);
780        }
781        self.populate(pane, keep.as_deref());
782        let (k, asc) = self.st.borrow().panes[pane].sort;
783        trace!(
784            "SORT {} {} {}",
785            PANE_NAMES[pane],
786            k.column(),
787            if asc { "asc" } else { "desc" }
788        );
789    }
790
791    fn on_row_selected(self: &Rc<Self>, pane: usize, row: Option<usize>) {
792        if self.quiet.get() > 0 {
793            return;
794        }
795        self.set_active(pane);
796        let e = row.and_then(|r| self.entry_at(pane, r));
797        if let Some(e) = &e {
798            trace!("SELECT {} {}", PANE_NAMES[pane], e.name);
799        }
800        self.show_preview(e);
801        self.update_status();
802    }
803
804    fn on_row_activated(self: &Rc<Self>, pane: usize, row: usize) {
805        self.set_active(pane);
806        let Some(e) = self.entry_at(pane, row) else {
807            return;
808        };
809        self.open_entry(pane, e);
810    }
811
812    fn open_entry(self: &Rc<Self>, pane: usize, e: Entry) {
813        if e.is_dir {
814            let from = self.path_of(pane);
815            let select = e.is_parent.then_some(from);
816            self.navigate(pane, e.path, select, true, false);
817        } else {
818            trace!("OPEN {} {}", PANE_NAMES[pane], e.name);
819            self.show_preview(Some(e));
820        }
821    }
822
823    fn op_open(self: &Rc<Self>) {
824        if let Some(e) = self.selected(self.active()) {
825            self.open_entry(self.active(), e);
826        }
827    }
828
829    /// Runs just before the popup is shown: right-clicking a pane makes it the active one.
830    fn prepare_context_menu(&self, pane: usize) {
831        self.set_active(pane);
832        let sel = self.selected(pane);
833        let real = sel.as_ref().is_some_and(|e| !e.is_parent);
834        let it = self.ui.items;
835        it.ctx_open.set_enabled(sel.is_some());
836        it.ctx_rename.set_enabled(real);
837        it.ctx_delete.set_enabled(real);
838        it.ctx_copy.set_enabled(real);
839    }
840
841    // ---------------------------------------------------------------- preview and status
842
843    fn show_preview(&self, e: Option<Entry>) {
844        let u = &self.ui;
845        let Some(e) = e else {
846            u.preview_title.set_text("Preview");
847            u.preview.set_text("");
848            u.image.set_image(None);
849            u.image.set_visible(false);
850            return;
851        };
852        let p = fsm::preview(&e);
853        let (what, extra) = match &p {
854            Preview::Text { truncated, .. } => (
855                "text",
856                if *truncated {
857                    format!(" (first {} KB)", fsm::PREVIEW_LIMIT / 1024)
858                } else {
859                    String::new()
860                },
861            ),
862            Preview::Hex { .. } => (
863                "binary",
864                format!(" (hex dump of the first {} bytes)", fsm::HEX_LIMIT),
865            ),
866            Preview::Dir(_) => ("folder", String::new()),
867            Preview::Image { img, .. } => ("image", format!(" ({} x {})", img.w, img.h)),
868            Preview::Error(_) => ("error", String::new()),
869        };
870        u.preview_title.set_text(&format!(
871            "Preview: {}{extra}",
872            if e.is_parent { ".." } else { &e.name }
873        ));
874        u.preview.set_text(p.body());
875        match &p {
876            Preview::Image { img, .. } => {
877                u.image.set_image(Some(&scaled(img)));
878                u.image.set_visible(true);
879            }
880            _ => {
881                u.image.set_image(None);
882                u.image.set_visible(false);
883            }
884        }
885        trace!("PREVIEW {what} {} {}", p.shown_bytes(), e.name);
886    }
Source

pub fn visible(&self) -> bool

Whether the widget itself is shown (a hidden ancestor still hides it).

Source

pub fn set_tooltip(&self, t: &str)

Set the tooltip text (empty removes it); also the default accessible description.

Examples found in repository?
examples/file_manager/app.rs (line 207)
162pub fn build(opts: Options) -> Rc<Fm> {
163    let win = Window::new("File Manager");
164    win.set_size(1000, 700);
165    win.set_min_size(640, 420);
166
167    // ---- menus (accelerators are the keyboard interface; there is no key-event API)
168    let bar = MenuBar::new(win);
169    let file = Menu::new(bar, "File");
170    let new_folder = MenuItem::new(file, "New Folder");
171    new_folder.set_accel("F7");
172    let rename = MenuItem::new(file, "Rename");
173    rename.set_accel("F2");
174    MenuSeparator::new(file);
175    let copy = MenuItem::new(file, "Copy to Other Pane");
176    copy.set_accel("F5");
177    let mv = MenuItem::new(file, "Move to Other Pane");
178    mv.set_accel("F6");
179    let delete = MenuItem::new(file, "Delete");
180    delete.set_accel("F8");
181    MenuSeparator::new(file);
182    let quit = MenuItem::new(file, "Quit");
183    quit.set_accel("Ctrl+Q");
184    let view = Menu::new(bar, "View");
185    let hidden = CheckMenuItem::new(view, "Show Hidden Files");
186    hidden.set_accel("Ctrl+H");
187    let refresh_item = MenuItem::new(view, "Refresh");
188    refresh_item.set_accel("Ctrl+R");
189    let go = Menu::new(bar, "Go");
190    let up_item = MenuItem::new(go, "Up One Level");
191    up_item.set_accel("Alt+Up");
192    let home_item = MenuItem::new(go, "Home Folder");
193    home_item.set_accel("Alt+Home");
194    let switch = MenuItem::new(go, "Switch Active Pane");
195    switch.set_accel("F9");
196    let helpm = Menu::new(bar, "Help");
197    let about = MenuItem::new(helpm, "About");
198
199    // ---- layout
200    let root = VBox::new(win);
201    root.set_spacing(6);
202    root.set_expand(1.0); // a window stacks its children vertically; give the whole area to this one
203
204    let tools = HBox::new(root);
205    tools.set_spacing(6);
206    let up = Button::new(tools, "\u{2191} Up");
207    up.set_tooltip("Go to the parent folder (Alt+Up)");
208    let refresh = Button::new(tools, "Refresh");
209    refresh.set_tooltip("Reload both panes (Ctrl+R)");
210    let path = TextInput::new(tools);
211    path.set_expand(1.0);
212    path.set_monospace(true);
213    path.set_tooltip("Type a folder path to open it in the active pane");
214    path.set_a11y_name("Path of the active pane");
215    let copy_btn = Button::new(tools, "Copy \u{2192}");
216    copy_btn.set_tooltip("Copy the selected item to the other pane (F5)");
217    let move_btn = Button::new(tools, "Move \u{2192}");
218    move_btn.set_tooltip("Move the selected item to the other pane (F6)");
219
220    let body = Splitter::new(root, Orientation::Horizontal);
221    body.set_expand(1.0);
222    let tree = Tree::new(body);
223    tree.set_a11y_name("Folders");
224    let right = Splitter::new(body, Orientation::Vertical);
225    let panes = Splitter::new(right, Orientation::Horizontal);
226    let mut tables = Vec::new();
227    let mut pane_labels = Vec::new();
228    for (i, n) in PANE_NAMES.iter().enumerate() {
229        let col = VBox::new(panes);
230        col.set_spacing(2);
231        pane_labels.push(Label::new(col, ""));
232        let t = Table::new(col);
233        t.set_expand(1.0);
234        t.set_a11y_name(&format!("Files, pane {n}"));
235        t.set_columns(&[
236            Column::new("Name").width(125).sortable(true),
237            Column::new("Size")
238                .width(62)
239                .align(ColumnAlign::Right)
240                .sortable(true),
241            Column::new("Modified").width(128).sortable(true),
242            Column::new("Kind").width(90).sortable(true),
243        ]);
244        let _ = i;
245        tables.push(t);
246    }
247    let pv = VBox::new(right);
248    pv.set_spacing(2);
249    let preview_title = Label::new(pv, "Preview");
250    let pv_row = HBox::new(pv);
251    pv_row.set_expand(1.0);
252    let image = Image::new(pv_row);
253    image.set_visible(false);
254    image.set_align(Align::Start);
255    let preview = TextArea::new(pv_row);
256    preview.set_expand(1.0);
257    preview.set_read_only(true);
258    preview.set_monospace(true);
259    preview.set_wrap(false);
260    preview.set_a11y_name("Preview");
261
262    let sbar = HBox::new(root);
263    let status = Label::new(sbar, "");
264    status.set_expand(1.0);
265    let tag = Label::new(sbar, "");
266
267    body.set_position(170);
268    body.set_min_pane_sizes(100, 300);
269    right.set_position(400);
270    right.set_min_pane_sizes(120, 80);
271    panes.set_min_pane_sizes(180, 180);
272
273    // ---- context menu shared by both tables
274    let popup = PopupMenu::new();
275    let ctx_open = MenuItem::new(popup, "Open");
276    let ctx_rename = MenuItem::new(popup, "Rename...");
277    let ctx_delete = MenuItem::new(popup, "Delete...");
278    MenuSeparator::new(popup);
279    let ctx_copy = MenuItem::new(popup, "Copy to Other Pane");
280    let ctx_new = MenuItem::new(popup, "New Folder...");
281    for t in &tables {
282        t.set_context_menu(popup);
283    }
284
285    let ui = Ui {
286        win,
287        body,
288        right,
289        panes,
290        tree,
291        tables: [tables[0], tables[1]],
292        pane_labels: [pane_labels[0], pane_labels[1]],
293        path,
294        up,
295        refresh,
296        copy_btn,
297        move_btn,
298        preview_title,
299        preview,
300        image,
301        status,
302        tag,
303        popup,
304        items: Items {
305            new_folder,
306            rename,
307            copy,
308            mv,
309            delete,
310            quit,
311            hidden,
312            refresh: refresh_item,
313            up: up_item,
314            home: home_item,
315            switch,
316            about,
317            ctx_open,
318            ctx_rename,
319            ctx_delete,
320            ctx_copy,
321            ctx_new,
322        },
323    };
324    let fm = Rc::new(Fm {
325        ui,
326        st: RefCell::new(State::default()),
327        quiet: Cell::new(0),
328        typing: Cell::new(false),
329        dialog_ui: Cell::new(None),
330    });
331    fm.wire();
332    fm.init_tree();
333    {
334        let mut st = fm.st.borrow_mut();
335        for p in &opts.dirs {
336            st.panes.push(Pane {
337                path: p.clone(),
338                entries: vec![],
339                sort: (SortKey::Name, true),
340                mtime: None,
341                truncated: false,
342            });
343        }
344    }
345    for (i, p) in opts.dirs.iter().enumerate() {
346        if !fm.navigate(i, p.clone(), None, true, false) {
347            // an unreadable start directory falls back to the home folder, then to "/"
348            let fallback = home_dir().unwrap_or_else(|| PathBuf::from("/"));
349            fm.navigate(i, fallback, None, true, false);
350        }
351    }
352    fm.set_active(0);
353    let first = fm.path_of(0);
354    fm.tree_reveal(&first);
355    fm.ui.win.show();
356    fm
357}
Source

pub fn focus(&self)

Move keyboard focus to the widget.

Examples found in repository?
examples/file_manager/app.rs (line 658)
655    fn switch_pane(self: &Rc<Self>) {
656        let other = 1 - self.active();
657        self.set_active(other);
658        self.ui.tables[other].focus();
659    }
660
661    fn set_show_hidden(self: &Rc<Self>, on: bool) {
662        self.st.borrow_mut().show_hidden = on;
663        trace!("HIDDEN {on}");
664        for i in 0..2 {
665            self.reload(i, None);
666        }
667        // rebuild the folder tree so hidden folders appear or vanish too
668        self.init_tree();
669        let a = self.active();
670        let p = self.path_of(a);
671        self.tree_reveal(&p);
672    }
673
674    fn on_path_typed(self: &Rc<Self>, text: &str) {
675        if self.typing.get() {
676            return;
677        }
678        let a = self.active();
679        let t = text.trim();
680        if t.is_empty() || Path::new(t) == self.path_of(a) {
681            return;
682        }
683        let p = PathBuf::from(t);
684        if p.is_dir() {
685            self.navigate(a, p, None, true, true);
686        }
687    }
688
689    pub fn set_active(&self, pane: usize) {
690        let changed = {
691            let mut st = self.st.borrow_mut();
692            let c = st.active != pane;
693            st.active = pane;
694            c
695        };
696        self.refresh_labels();
697        if changed {
698            trace!("ACTIVE {}", PANE_NAMES[pane]);
699        }
700    }
701
702    /// The pane captions depend on the pane widths, which are known only after layout.
703    fn relabel_soon(self: &Rc<Self>) {
704        let fm = self.clone();
705        Timer::once(10, move || fm.refresh_labels());
706    }
707
708    /// Pane captions, path box, window title and the active-pane tag.
709    fn refresh_labels(&self) {
710        let (active, paths) = {
711            let st = self.st.borrow();
712            (
713                st.active,
714                st.panes.iter().map(|p| p.path.clone()).collect::<Vec<_>>(),
715            )
716        };
717        for (i, p) in paths.iter().enumerate() {
718            let mark = if i == active { "\u{25B6}" } else { " " };
719            // labels do not clip, so fit the path to the pane (about 7 px per character)
720            let room = (self.ui.tables[i].bounds().w / 7).max(12) as usize;
721            let head = format!("{mark} {}  ", PANE_NAMES[i]);
722            let path = fsm::ellipsize_path(
723                &p.display().to_string(),
724                room.saturating_sub(head.chars().count()),
725            );
726            self.ui.pane_labels[i].set_text(&format!("{head}{path}"));
727        }
728        let cur = paths.get(active).cloned().unwrap_or_default();
729        let text = cur.display().to_string();
730        if self.ui.path.text() != text && !self.typing.get() {
731            self.ui.path.set_text(&text);
732        }
733        let name = cur
734            .file_name()
735            .map(|n| n.to_string_lossy().into_owned())
736            .unwrap_or_else(|| text.clone());
737        self.ui
738            .win
739            .set_title(&format!("{name} [{}] - File Manager", PANE_NAMES[active]));
740        self.ui
741            .tag
742            .set_text(&format!("  Active pane: {}", PANE_NAMES[active]));
743        self.ui.up.set_enabled(cur.parent().is_some());
744    }
745
746    // ---------------------------------------------------------------- table
747
748    /// Fill a pane's table from its entries. Uses one `batch` so huge directories send one update.
749    fn populate(&self, pane: usize, select: Option<&Path>) {
750        let (rows, sort, sel) = {
751            let st = self.st.borrow();
752            let p = &st.panes[pane];
753            let rows: Vec<Vec<String>> = p.entries.iter().map(row_of).collect();
754            (
755                rows,
756                p.sort,
757                select.and_then(|s| p.entries.iter().position(|e| e.path == s)),
758            )
759        };
760        let t = self.ui.tables[pane];
761        self.quietly(|| {
762            t.batch(|t| t.set_rows(&rows));
763            t.set_sort_indicator(Some((sort.0.column(), sort.1)));
764            t.set_selected(sel);
765        });
766    }
767
768    fn sort_by_column(self: &Rc<Self>, pane: usize, col: usize) {
769        let key = SortKey::from_column(col);
770        let keep = self.selected(pane).map(|e| e.path);
771        {
772            let mut st = self.st.borrow_mut();
773            let Some(p) = st.panes.get_mut(pane) else {
774                return;
775            };
776            let asc = if p.sort.0 == key { !p.sort.1 } else { true };
777            p.sort = (key, asc);
778            let has_parent = p.entries.first().is_some_and(|e| e.is_parent);
779            fsm::sort_entries(&mut p.entries[has_parent as usize..], key, asc);
780        }
781        self.populate(pane, keep.as_deref());
782        let (k, asc) = self.st.borrow().panes[pane].sort;
783        trace!(
784            "SORT {} {} {}",
785            PANE_NAMES[pane],
786            k.column(),
787            if asc { "asc" } else { "desc" }
788        );
789    }
790
791    fn on_row_selected(self: &Rc<Self>, pane: usize, row: Option<usize>) {
792        if self.quiet.get() > 0 {
793            return;
794        }
795        self.set_active(pane);
796        let e = row.and_then(|r| self.entry_at(pane, r));
797        if let Some(e) = &e {
798            trace!("SELECT {} {}", PANE_NAMES[pane], e.name);
799        }
800        self.show_preview(e);
801        self.update_status();
802    }
803
804    fn on_row_activated(self: &Rc<Self>, pane: usize, row: usize) {
805        self.set_active(pane);
806        let Some(e) = self.entry_at(pane, row) else {
807            return;
808        };
809        self.open_entry(pane, e);
810    }
811
812    fn open_entry(self: &Rc<Self>, pane: usize, e: Entry) {
813        if e.is_dir {
814            let from = self.path_of(pane);
815            let select = e.is_parent.then_some(from);
816            self.navigate(pane, e.path, select, true, false);
817        } else {
818            trace!("OPEN {} {}", PANE_NAMES[pane], e.name);
819            self.show_preview(Some(e));
820        }
821    }
822
823    fn op_open(self: &Rc<Self>) {
824        if let Some(e) = self.selected(self.active()) {
825            self.open_entry(self.active(), e);
826        }
827    }
828
829    /// Runs just before the popup is shown: right-clicking a pane makes it the active one.
830    fn prepare_context_menu(&self, pane: usize) {
831        self.set_active(pane);
832        let sel = self.selected(pane);
833        let real = sel.as_ref().is_some_and(|e| !e.is_parent);
834        let it = self.ui.items;
835        it.ctx_open.set_enabled(sel.is_some());
836        it.ctx_rename.set_enabled(real);
837        it.ctx_delete.set_enabled(real);
838        it.ctx_copy.set_enabled(real);
839    }
840
841    // ---------------------------------------------------------------- preview and status
842
843    fn show_preview(&self, e: Option<Entry>) {
844        let u = &self.ui;
845        let Some(e) = e else {
846            u.preview_title.set_text("Preview");
847            u.preview.set_text("");
848            u.image.set_image(None);
849            u.image.set_visible(false);
850            return;
851        };
852        let p = fsm::preview(&e);
853        let (what, extra) = match &p {
854            Preview::Text { truncated, .. } => (
855                "text",
856                if *truncated {
857                    format!(" (first {} KB)", fsm::PREVIEW_LIMIT / 1024)
858                } else {
859                    String::new()
860                },
861            ),
862            Preview::Hex { .. } => (
863                "binary",
864                format!(" (hex dump of the first {} bytes)", fsm::HEX_LIMIT),
865            ),
866            Preview::Dir(_) => ("folder", String::new()),
867            Preview::Image { img, .. } => ("image", format!(" ({} x {})", img.w, img.h)),
868            Preview::Error(_) => ("error", String::new()),
869        };
870        u.preview_title.set_text(&format!(
871            "Preview: {}{extra}",
872            if e.is_parent { ".." } else { &e.name }
873        ));
874        u.preview.set_text(p.body());
875        match &p {
876            Preview::Image { img, .. } => {
877                u.image.set_image(Some(&scaled(img)));
878                u.image.set_visible(true);
879            }
880            _ => {
881                u.image.set_image(None);
882                u.image.set_visible(false);
883            }
884        }
885        trace!("PREVIEW {what} {} {}", p.shown_bytes(), e.name);
886    }
887
888    fn update_status(&self) {
889        let a = self.active();
890        let (n, dirs, total, trunc, sel) = {
891            let st = self.st.borrow();
892            let p = &st.panes[a];
893            let real: Vec<&Entry> = p.entries.iter().filter(|e| !e.is_parent).collect();
894            let dirs = real.iter().filter(|e| e.is_dir).count();
895            let total: u64 = real.iter().filter(|e| !e.is_dir).map(|e| e.size).sum();
896            (real.len(), dirs, total, p.truncated, p.entries.len())
897        };
898        let _ = sel;
899        let mut s = format!(
900            "{n} items ({dirs} folders, {} files), {} in files",
901            n - dirs,
902            fsm::human_size(total)
903        );
904        if trunc {
905            s.push_str(" (truncated)");
906        }
907        if let Some(e) = self.selected(a) {
908            s.push_str(&format!("   |   {}", fsm::describe(&e)));
909        }
910        self.ui.status.set_text(&s);
911        trace!("STATUS {s}");
912    }
913
914    fn print_bounds(&self) {
915        if !tracing() {
916            return;
917        }
918        let u = &self.ui;
919        let (b, ids): (Rect, Vec<(&str, Widget)>) = (
920            u.win.bounds(),
921            vec![
922                ("tree", *u.tree),
923                ("tableA", *u.tables[0]),
924                ("tableB", *u.tables[1]),
925                ("labelA", *u.pane_labels[0]),
926                ("labelB", *u.pane_labels[1]),
927                ("preview", *u.preview),
928                ("image", *u.image),
929                ("path", *u.path),
930                ("up", *u.up),
931                ("refresh", *u.refresh),
932                ("copy", *u.copy_btn),
933                ("move", *u.move_btn),
934                ("status", *u.status),
935                ("body", *u.body),
936                ("right", *u.right),
937                ("panes", *u.panes),
938            ],
939        );
940        let _ = b;
941        for (n, w) in ids {
942            let r = w.bounds();
943            println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
944        }
945    }
946
947    // ---------------------------------------------------------------- tree
948
949    fn init_tree(self: &Rc<Self>) {
950        let t = self.ui.tree;
951        t.clear();
952        let mut roots: Vec<(String, PathBuf)> = Vec::new();
953        if let Some(h) = home_dir() {
954            roots.push(("Home".into(), h));
955        }
956        #[cfg(windows)]
957        for d in b'A'..=b'Z' {
958            let p = PathBuf::from(format!("{}:\\", d as char));
959            if p.is_dir() {
960                roots.push((format!("{}:\\", d as char), p));
961            }
962        }
963        #[cfg(not(windows))]
964        roots.push(("File System (/)".into(), PathBuf::from("/")));
965        let mut st = self.st.borrow_mut();
966        st.node_paths.clear();
967        st.loaded.clear();
968        for (name, p) in roots {
969            let n = t.add(None, &name);
970            t.set_has_children(n, true);
971            st.node_paths.insert(n, p);
972        }
973    }
974
975    pub fn node_path(&self, n: TreeNodeId) -> Option<PathBuf> {
976        self.st.borrow().node_paths.get(&n).cloned()
977    }
978
979    /// Add the sub-folders of `node` the first time it is needed.
980    pub fn tree_load(&self, node: TreeNodeId) {
981        let Some(path) = self.node_path(node) else {
982            return;
983        };
984        if !self.st.borrow_mut().loaded.insert(node) {
985            return;
986        }
987        let hidden = self.st.borrow().show_hidden;
988        let dirs = fsm::subdirs(&path, hidden);
989        let t = self.ui.tree;
990        let mut new = Vec::new();
991        t.batch(|t| {
992            for d in &dirs {
993                let c = t.add(Some(node), &d.name);
994                t.set_has_children(c, true);
995                new.push((c, d.path.clone()));
996            }
997            t.set_has_children(node, !dirs.is_empty());
998        });
999        self.st.borrow_mut().node_paths.extend(new);
1000    }
1001
1002    /// Expand the tree down to `path` and select it (no callbacks fire).
1003    fn tree_reveal(&self, path: &Path) {
1004        let t = self.ui.tree;
1005        let mut best: Option<(TreeNodeId, usize)> = None;
1006        for r in t.children(None) {
1007            if let Some(rp) = self.node_path(r) {
1008                let depth = rp.components().count();
1009                if path.starts_with(&rp) && best.is_none_or(|(_, d)| depth > d) {
1010                    best = Some((r, depth));
1011                }
1012            }
1013        }
1014        let Some((mut node, _)) = best else { return };
1015        let Some(root_path) = self.node_path(node) else {
1016            return;
1017        };
1018        let Ok(rest) = path.strip_prefix(&root_path) else {
1019            return;
1020        };
1021        let mut cur = root_path;
1022        for comp in rest.components() {
1023            self.tree_load(node);
1024            cur.push(comp);
1025            match t
1026                .children(Some(node))
1027                .into_iter()
1028                .find(|c| self.node_path(*c).as_deref() == Some(cur.as_path()))
1029            {
1030                Some(c) => node = c,
1031                None => break,
1032            }
1033        }
1034        self.tree_load(node); // set_selected expands its ancestors; the node itself must not show a placeholder
1035        t.set_selected(Some(node));
1036    }
1037
1038    fn on_tree_selected(self: &Rc<Self>, n: Option<TreeNodeId>) {
1039        let Some(path) = n.and_then(|n| self.node_path(n)) else {
1040            return;
1041        };
1042        let a = self.active();
1043        if path != self.path_of(a) {
1044            trace!("TREE {}", path.display());
1045            self.navigate(a, path, None, false, false);
1046        }
1047    }
1048
1049    // ---------------------------------------------------------------- operations
1050
1051    fn confirm(&self, title: &str, text: &str) -> bool {
1052        message_box(
1053            Some(self.ui.win),
1054            MessageKind::Question,
1055            Buttons::YesNo,
1056            title,
1057            text,
1058        ) == Answer::Yes
1059    }
1060
1061    /// Reload every pane showing `dir` (or all, if `dir` is None) and select `select` in the active one.
1062    fn refresh_after(self: &Rc<Self>, select: Option<PathBuf>) {
1063        let a = self.active();
1064        for i in 0..2 {
1065            let keep = if i == a { select.clone() } else { None };
1066            self.reload(i, keep);
1067        }
1068    }
1069
1070    fn op_new_folder(self: &Rc<Self>) {
1071        let a = self.active();
1072        let dir = self.path_of(a);
1073        self.dialog(
1074            "New Folder",
1075            "Name of the new folder:",
1076            "New Folder",
1077            move |fm, name| {
1078                let p = fsm::make_dir(&dir, name)?;
1079                trace!("MKDIR {}", p.display());
1080                fm.refresh_after(Some(p));
1081                fm.say(&format!("Created folder \"{name}\""));
1082                Ok(())
1083            },
1084        );
1085    }
1086
1087    fn op_rename(self: &Rc<Self>) {
1088        let Some(e) = self.target() else {
1089            self.say("Select an item to rename first");
1090            return;
1091        };
1092        let old = e
1093            .path
1094            .file_name()
1095            .map(|n| n.to_string_lossy().into_owned())
1096            .unwrap_or_default();
1097        let (prompt, initial) = (format!("New name for \"{old}\":"), old.clone());
1098        self.dialog("Rename", &prompt, &initial, move |fm, name| {
1099            let p = fsm::rename_path(&e.path, name)?;
1100            trace!("RENAME {} {}", e.name, name);
1101            fm.refresh_after(Some(p));
1102            fm.say(&format!("Renamed \"{old}\" to \"{name}\""));
1103            Ok(())
1104        });
1105    }
1106
1107    fn op_delete(self: &Rc<Self>) {
1108        let Some(e) = self.target() else {
1109            self.say("Select an item to delete first");
1110            return;
1111        };
1112        let what = if e.is_dir && !e.is_link {
1113            "folder and everything in it"
1114        } else {
1115            "item"
1116        };
1117        if !self.confirm(
1118            "Delete",
1119            &format!(
1120                "Delete the {what} \"{}\"?\n\nThis cannot be undone.",
1121                e.name
1122            ),
1123        ) {
1124            self.say("Delete cancelled");
1125            return;
1126        }
1127        match fsm::remove_path(&e.path) {
1128            Ok(()) => {
1129                trace!("DELETE {}", e.name);
1130                self.refresh_after(None);
1131                self.say(&format!("Deleted \"{}\"", e.name));
1132            }
1133            Err(err) => {
1134                trace!("ERROR DELETE {}", e.name);
1135                self.say(&format!("Cannot delete \"{}\": {err}", e.name));
1136            }
1137        }
1138    }
1139
1140    fn op_copy(self: &Rc<Self>) {
1141        self.transfer(false)
1142    }
1143
1144    fn op_move(self: &Rc<Self>) {
1145        self.transfer(true)
1146    }
1147
1148    fn transfer(self: &Rc<Self>, mv: bool) {
1149        let verb = if mv { "Move" } else { "Copy" };
1150        let Some(e) = self.target() else {
1151            self.say(&format!("Select an item to {} first", verb.to_lowercase()));
1152            return;
1153        };
1154        let a = self.active();
1155        let dst_dir = self.path_of(1 - a);
1156        let dest = match fsm::check_transfer(&e.path, &dst_dir) {
1157            Ok(d) => d,
1158            Err(err) => {
1159                self.say(&err);
1160                return;
1161            }
1162        };
1163        if std::fs::symlink_metadata(&dest).is_ok() {
1164            if !self.confirm(
1165                "Overwrite",
1166                &format!(
1167                    "\"{}\" already exists in {}.\n\nReplace it?",
1168                    e.name,
1169                    dst_dir.display()
1170                ),
1171            ) {
1172                self.say(&format!("{verb} cancelled"));
1173                return;
1174            }
1175            if let Err(err) = fsm::remove_path(&dest) {
1176                self.say(&format!("Cannot replace \"{}\": {err}", e.name));
1177                return;
1178            }
1179        }
1180        let r = if mv {
1181            fsm::move_into(&e.path, &dst_dir)
1182        } else {
1183            fsm::copy_into(&e.path, &dst_dir)
1184        };
1185        match r {
1186            Ok(new) => {
1187                trace!("{} {} {}", verb.to_uppercase(), e.name, dst_dir.display());
1188                // both panes re-read; the other pane shows the new item selected
1189                self.reload(a, None);
1190                self.reload(1 - a, Some(new));
1191                self.say(&format!(
1192                    "{} \"{}\" to {}",
1193                    if mv { "Moved" } else { "Copied" },
1194                    e.name,
1195                    dst_dir.display()
1196                ));
1197            }
1198            Err(err) => {
1199                trace!("ERROR {} {}", verb.to_uppercase(), e.name);
1200                self.say(&err);
1201            }
1202        }
1203    }
1204
1205    fn about(&self) {
1206        message_box(
1207            Some(self.ui.win),
1208            MessageKind::Info,
1209            Buttons::Ok,
1210            "About File Manager",
1211            "A dual-pane file manager written with rungui's public API only.\n\nF2 rename, F5 copy, F6 move, F7 new folder, F8 delete,\nF9 switch pane, Ctrl+H hidden files, Ctrl+R refresh.\nTimes are shown in UTC.",
1212        );
1213    }
1214
1215    // ---------------------------------------------------------------- the rename / new folder dialog
1216
1217    /// A small window with a text field and OK / Cancel (rungui has no input-dialog API).
1218    /// `action` returns an error message to keep the dialog open.
1219    fn dialog(
1220        self: &Rc<Self>,
1221        title: &str,
1222        prompt: &str,
1223        initial: &str,
1224        action: impl Fn(&Rc<Fm>, &str) -> std::result::Result<(), String> + 'static,
1225    ) {
1226        if let Some(old) = self.st.borrow_mut().dialog.take() {
1227            old.destroy();
1228        }
1229        let w = Window::new(title);
1230        w.set_size(380, 150);
1231        w.set_resizable(false);
1232        let col = VBox::new(w);
1233        col.set_spacing(8);
1234        Label::new(col, prompt);
1235        let input = TextInput::new(col);
1236        input.set_text(initial);
1237        input.set_a11y_name(title);
1238        let err = Label::new(col, "");
1239        let row = HBox::new(col);
1240        row.set_spacing(8);
1241        Spacer::new(row);
1242        let cancel = Button::new(row, "Cancel");
1243        let ok = Button::new(row, "OK");
1244        self.st.borrow_mut().dialog = Some(w);
1245        self.dialog_ui.set(Some((w, input, ok, cancel)));
1246        trace!("DIALOG open {title}");
1247        {
1248            let fm = self.clone();
1249            ok.on_click(move || {
1250                let text = input.text();
1251                match action(&fm, text.trim()) {
1252                    Ok(()) => {
1253                        trace!("DIALOG done");
1254                        fm.st.borrow_mut().dialog = None;
1255                        w.destroy();
1256                    }
1257                    Err(e) => {
1258                        trace!("DIALOG error {e}");
1259                        err.set_text(&e);
1260                    }
1261                }
1262            });
1263            let fm = self.clone();
1264            cancel.on_click(move || {
1265                trace!("DIALOG cancel");
1266                fm.st.borrow_mut().dialog = None;
1267                w.destroy();
1268            });
1269            let fm = self.clone();
1270            w.on_close(move || {
1271                fm.st.borrow_mut().dialog = None;
1272                true
1273            });
1274        }
1275        w.show();
1276        input.focus();
1277        if tracing() {
1278            Timer::once(300, move || {
1279                for (n, wd) in [
1280                    ("dlg_input", *input),
1281                    ("dlg_ok", *ok),
1282                    ("dlg_cancel", *cancel),
1283                ] {
1284                    let r = wd.bounds();
1285                    println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
1286                }
1287            });
1288        }
1289    }
Source

pub fn set_expand(&self, weight: f32)

Share of spare space along the parent stack’s axis (0 = natural size, 1 = take a share).

Examples found in repository?
examples/file_manager/app.rs (line 202)
162pub fn build(opts: Options) -> Rc<Fm> {
163    let win = Window::new("File Manager");
164    win.set_size(1000, 700);
165    win.set_min_size(640, 420);
166
167    // ---- menus (accelerators are the keyboard interface; there is no key-event API)
168    let bar = MenuBar::new(win);
169    let file = Menu::new(bar, "File");
170    let new_folder = MenuItem::new(file, "New Folder");
171    new_folder.set_accel("F7");
172    let rename = MenuItem::new(file, "Rename");
173    rename.set_accel("F2");
174    MenuSeparator::new(file);
175    let copy = MenuItem::new(file, "Copy to Other Pane");
176    copy.set_accel("F5");
177    let mv = MenuItem::new(file, "Move to Other Pane");
178    mv.set_accel("F6");
179    let delete = MenuItem::new(file, "Delete");
180    delete.set_accel("F8");
181    MenuSeparator::new(file);
182    let quit = MenuItem::new(file, "Quit");
183    quit.set_accel("Ctrl+Q");
184    let view = Menu::new(bar, "View");
185    let hidden = CheckMenuItem::new(view, "Show Hidden Files");
186    hidden.set_accel("Ctrl+H");
187    let refresh_item = MenuItem::new(view, "Refresh");
188    refresh_item.set_accel("Ctrl+R");
189    let go = Menu::new(bar, "Go");
190    let up_item = MenuItem::new(go, "Up One Level");
191    up_item.set_accel("Alt+Up");
192    let home_item = MenuItem::new(go, "Home Folder");
193    home_item.set_accel("Alt+Home");
194    let switch = MenuItem::new(go, "Switch Active Pane");
195    switch.set_accel("F9");
196    let helpm = Menu::new(bar, "Help");
197    let about = MenuItem::new(helpm, "About");
198
199    // ---- layout
200    let root = VBox::new(win);
201    root.set_spacing(6);
202    root.set_expand(1.0); // a window stacks its children vertically; give the whole area to this one
203
204    let tools = HBox::new(root);
205    tools.set_spacing(6);
206    let up = Button::new(tools, "\u{2191} Up");
207    up.set_tooltip("Go to the parent folder (Alt+Up)");
208    let refresh = Button::new(tools, "Refresh");
209    refresh.set_tooltip("Reload both panes (Ctrl+R)");
210    let path = TextInput::new(tools);
211    path.set_expand(1.0);
212    path.set_monospace(true);
213    path.set_tooltip("Type a folder path to open it in the active pane");
214    path.set_a11y_name("Path of the active pane");
215    let copy_btn = Button::new(tools, "Copy \u{2192}");
216    copy_btn.set_tooltip("Copy the selected item to the other pane (F5)");
217    let move_btn = Button::new(tools, "Move \u{2192}");
218    move_btn.set_tooltip("Move the selected item to the other pane (F6)");
219
220    let body = Splitter::new(root, Orientation::Horizontal);
221    body.set_expand(1.0);
222    let tree = Tree::new(body);
223    tree.set_a11y_name("Folders");
224    let right = Splitter::new(body, Orientation::Vertical);
225    let panes = Splitter::new(right, Orientation::Horizontal);
226    let mut tables = Vec::new();
227    let mut pane_labels = Vec::new();
228    for (i, n) in PANE_NAMES.iter().enumerate() {
229        let col = VBox::new(panes);
230        col.set_spacing(2);
231        pane_labels.push(Label::new(col, ""));
232        let t = Table::new(col);
233        t.set_expand(1.0);
234        t.set_a11y_name(&format!("Files, pane {n}"));
235        t.set_columns(&[
236            Column::new("Name").width(125).sortable(true),
237            Column::new("Size")
238                .width(62)
239                .align(ColumnAlign::Right)
240                .sortable(true),
241            Column::new("Modified").width(128).sortable(true),
242            Column::new("Kind").width(90).sortable(true),
243        ]);
244        let _ = i;
245        tables.push(t);
246    }
247    let pv = VBox::new(right);
248    pv.set_spacing(2);
249    let preview_title = Label::new(pv, "Preview");
250    let pv_row = HBox::new(pv);
251    pv_row.set_expand(1.0);
252    let image = Image::new(pv_row);
253    image.set_visible(false);
254    image.set_align(Align::Start);
255    let preview = TextArea::new(pv_row);
256    preview.set_expand(1.0);
257    preview.set_read_only(true);
258    preview.set_monospace(true);
259    preview.set_wrap(false);
260    preview.set_a11y_name("Preview");
261
262    let sbar = HBox::new(root);
263    let status = Label::new(sbar, "");
264    status.set_expand(1.0);
265    let tag = Label::new(sbar, "");
266
267    body.set_position(170);
268    body.set_min_pane_sizes(100, 300);
269    right.set_position(400);
270    right.set_min_pane_sizes(120, 80);
271    panes.set_min_pane_sizes(180, 180);
272
273    // ---- context menu shared by both tables
274    let popup = PopupMenu::new();
275    let ctx_open = MenuItem::new(popup, "Open");
276    let ctx_rename = MenuItem::new(popup, "Rename...");
277    let ctx_delete = MenuItem::new(popup, "Delete...");
278    MenuSeparator::new(popup);
279    let ctx_copy = MenuItem::new(popup, "Copy to Other Pane");
280    let ctx_new = MenuItem::new(popup, "New Folder...");
281    for t in &tables {
282        t.set_context_menu(popup);
283    }
284
285    let ui = Ui {
286        win,
287        body,
288        right,
289        panes,
290        tree,
291        tables: [tables[0], tables[1]],
292        pane_labels: [pane_labels[0], pane_labels[1]],
293        path,
294        up,
295        refresh,
296        copy_btn,
297        move_btn,
298        preview_title,
299        preview,
300        image,
301        status,
302        tag,
303        popup,
304        items: Items {
305            new_folder,
306            rename,
307            copy,
308            mv,
309            delete,
310            quit,
311            hidden,
312            refresh: refresh_item,
313            up: up_item,
314            home: home_item,
315            switch,
316            about,
317            ctx_open,
318            ctx_rename,
319            ctx_delete,
320            ctx_copy,
321            ctx_new,
322        },
323    };
324    let fm = Rc::new(Fm {
325        ui,
326        st: RefCell::new(State::default()),
327        quiet: Cell::new(0),
328        typing: Cell::new(false),
329        dialog_ui: Cell::new(None),
330    });
331    fm.wire();
332    fm.init_tree();
333    {
334        let mut st = fm.st.borrow_mut();
335        for p in &opts.dirs {
336            st.panes.push(Pane {
337                path: p.clone(),
338                entries: vec![],
339                sort: (SortKey::Name, true),
340                mtime: None,
341                truncated: false,
342            });
343        }
344    }
345    for (i, p) in opts.dirs.iter().enumerate() {
346        if !fm.navigate(i, p.clone(), None, true, false) {
347            // an unreadable start directory falls back to the home folder, then to "/"
348            let fallback = home_dir().unwrap_or_else(|| PathBuf::from("/"));
349            fm.navigate(i, fallback, None, true, false);
350        }
351    }
352    fm.set_active(0);
353    let first = fm.path_of(0);
354    fm.tree_reveal(&first);
355    fm.ui.win.show();
356    fm
357}
More examples
Hide additional examples
examples/kitchen_sink.rs (line 24)
4fn main() {
5    let app = App::new("kitchen-sink").expect("init");
6    let win = Window::new("rungui kitchen sink");
7
8    // Menus
9    let bar = MenuBar::new(win);
10    let file = Menu::new(bar, "File");
11    let open = MenuItem::new(file, "Open...");
12    open.set_accel("Ctrl+O");
13    let wrap = CheckMenuItem::new(file, "Word wrap");
14    wrap.set_checked(true);
15    let mono = CheckMenuItem::new(file, "Monospace notes");
16    MenuSeparator::new(file);
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(App::quit);
20
21    let root = VBox::new(win);
22    let status = Label::new(root, "Ready");
23    let tabs = Tabs::new(root);
24    tabs.set_expand(1.0);
25
26    // Page 1: form in a grid
27    let form = tabs.add_page("Form");
28    let grid = Grid::new(form, 2);
29    Label::new(grid, "Name");
30    let name = TextInput::new(grid);
31    name.set_expand(1.0);
32    Label::new(grid, "Password");
33    TextInput::password(grid);
34    Label::new(grid, "Colour");
35    let combo = ComboBox::new(grid);
36    combo.set_items(&["Red", "Green", "Blue"]);
37    combo.set_selected(Some(0));
38    Label::new(grid, "Count");
39    let spin = SpinBox::new(grid, 0.0, 10.0, 1.0);
40    Label::new(grid, "Level");
41    let slider = Slider::new(grid, 0.0, 100.0);
42    let progress = ProgressBar::new(form);
43    slider.on_change(move |v| progress.set_fraction(v / 100.0));
44    spin.on_change(move |v| status.set_text(&format!("count = {v}")));
45    combo.on_select(move |i| status.set_text(&format!("colour index {i:?}")));
46
47    // Page 2: choices
48    let choices = tabs.add_page("Choices");
49    let boxed = GroupBox::new(choices, "Options");
50    let group = RadioGroup::new();
51    let a = RadioButton::new(boxed, &group, "Option A");
52    RadioButton::new(boxed, &group, "Option B");
53    a.set_checked(true);
54    let check = CheckBox::new(boxed, "Enabled");
55    check.set_checked(true);
56    let list = ListBox::new(choices);
57    list.set_items(&["alpha", "beta", "gamma", "delta"]);
58    list.set_expand(1.0);
59    list.on_activate(move |i| status.set_text(&format!("activated {i}")));
60
61    // Page 3: text; a vertical splitter with notes on top and a fixed-pitch, unwrapped view below
62    let notes = tabs.add_page("Notes");
63    let vsplit = Splitter::new(notes, Orientation::Vertical);
64    let area = TextArea::new(vsplit);
65    let code = TextArea::new(vsplit);
66    code.set_monospace(true);
67    code.set_wrap(false);
68    code.set_read_only(true);
69    code.set_text(
70        "fn main() {\n    println!(\"a long line that does not wrap: {}\", \"-\".repeat(60));\n}\n",
71    );
72    vsplit.set_position(120);
73    vsplit.set_min_pane_sizes(40, 40);
74    vsplit.on_move(move |p| status.set_text(&format!("notes split at {p}px")));
75    wrap.on_toggle(move |on| area.set_wrap(on));
76    mono.on_toggle(move |on| area.set_monospace(on));
77
78    // Page 4: table, tree and a context menu
79    let data = tabs.add_page("Data");
80    let split = Splitter::new(data, Orientation::Horizontal);
81    split.on_move(move |p| status.set_text(&format!("data split at {p}px")));
82    let table = Table::new(split);
83    table.set_columns(&[
84        Column::new("Name").width(140).sortable(true),
85        Column::new("Size")
86            .width(70)
87            .align(ColumnAlign::Right)
88            .sortable(true),
89    ]);
90    table.set_rows(&[
91        vec!["kernel", "9120"],
92        vec!["README", "312"],
93        vec!["Cargo.toml", "1024"],
94    ]);
95    table.on_select(move |r| status.set_text(&format!("row {r:?}")));
96    table.on_activate(move |r| status.set_text(&format!("row {r} activated")));
97    table.on_column_click(move |c| {
98        // sorting is the app's job: reorder the rows, then show the arrow
99        let ascending = table.sort_indicator() != Some((c, true));
100        let mut rows = table.rows();
101        rows.sort_by(|a, b| match c {
102            1 => a[1]
103                .parse::<u64>()
104                .unwrap_or(0)
105                .cmp(&b[1].parse::<u64>().unwrap_or(0)),
106            _ => a[c].cmp(&b[c]),
107        });
108        if !ascending {
109            rows.reverse();
110        }
111        table.set_rows(&rows);
112        table.set_sort_indicator(Some((c, ascending)));
113    });
114
115    let tree = Tree::new(split);
116    let src = tree.add(None, "src");
117    tree.add(Some(src), "lib.rs");
118    tree.add(Some(src), "core.rs");
119    let docs = tree.add(None, "doc");
120    tree.set_has_children(docs, true); // lazily filled when first expanded
121    tree.set_expanded(src, true);
122    tree.on_select(move |n| status.set_text(&format!("node {:?}", n.map(|n| tree.text(n)))));
123    tree.on_expand(move |n, open| {
124        if open && tree.children(Some(n)).is_empty() {
125            tree.add(Some(n), "DESIGN.md");
126            tree.add(Some(n), "BUILDING.md");
127        }
128    });
129
130    // Page 5: a calendar, a multi-select list and a prompt
131    let dates = tabs.add_page("Dates");
132    let cal = Calendar::new(dates);
133    cal.on_change(move |d| status.set_text(&format!("{}-{:02}-{:02}", d.year, d.month, d.day)));
134    let many = ListBox::new(dates);
135    many.set_items(&["one", "two", "three", "four"]);
136    many.set_multi_select(true);
137    many.set_expand(1.0);
138    many.on_selection(move |rows| status.set_text(&format!("selected {rows:?}")));
139    let ask = Button::new(dates, "Ask...");
140    ask.on_click(move || {
141        let r = prompt(Some(win), "Name", "What is your name?", "");
142        status.set_text(&format!("name: {r:?}"));
143    });
144
145    // Right-click the table for a context menu; its items are rebuilt/enabled just before display.
146    let popup = PopupMenu::new();
147    let del = MenuItem::new(popup, "Delete row");
148    MenuSeparator::new(popup);
149    let hdr = CheckMenuItem::new(popup, "Show sizes");
150    hdr.set_checked(true);
151    table.set_context_menu(popup);
152    table.on_context_menu(move |_, _| del.set_enabled(table.selected().is_some()));
153    del.on_click(move || {
154        if let Some(r) = table.selected() {
155            table.remove_row(r);
156        }
157    });
158    hdr.on_toggle(move |on| status.set_text(&format!("show sizes: {on}")));
159    tree.set_context_menu(popup);
160
161    open.on_click(move || {
162        if let Some(p) = FileDialog::new()
163            .title("Open")
164            .filter("Text", &["txt", "md"])
165            .open(Some(win))
166        {
167            if let Ok(s) = std::fs::read_to_string(&p) {
168                area.set_text(&s);
169            }
170            status.set_text(&format!("opened {}", p.display()));
171        }
172    });
173
174    // Buttons row
175    let row = HBox::new(root);
176    Spacer::new(row);
177    let about = Button::new(row, "About");
178    about.on_click(move || {
179        message_box(
180            Some(win),
181            MessageKind::Info,
182            Buttons::Ok,
183            "About",
184            "rungui kitchen sink",
185        );
186    });
187    let ok = Button::new(row, "Close");
188    ok.on_click(move || win.close());
189    ok.set_a11y_description("Closes the window");
190
191    let n = std::cell::Cell::new(0);
192    Timer::every(1000, move || {
193        n.set(n.get() + 1);
194        status.set_text(&format!("uptime {}s", n.get()));
195    });
196
197    win.set_size(480, 400);
198    win.show();
199    app.run();
200}
Source

pub fn set_align(&self, a: Align)

Alignment inside the parent’s cell/cross axis (default Fill).

Examples found in repository?
examples/file_manager/app.rs (line 254)
162pub fn build(opts: Options) -> Rc<Fm> {
163    let win = Window::new("File Manager");
164    win.set_size(1000, 700);
165    win.set_min_size(640, 420);
166
167    // ---- menus (accelerators are the keyboard interface; there is no key-event API)
168    let bar = MenuBar::new(win);
169    let file = Menu::new(bar, "File");
170    let new_folder = MenuItem::new(file, "New Folder");
171    new_folder.set_accel("F7");
172    let rename = MenuItem::new(file, "Rename");
173    rename.set_accel("F2");
174    MenuSeparator::new(file);
175    let copy = MenuItem::new(file, "Copy to Other Pane");
176    copy.set_accel("F5");
177    let mv = MenuItem::new(file, "Move to Other Pane");
178    mv.set_accel("F6");
179    let delete = MenuItem::new(file, "Delete");
180    delete.set_accel("F8");
181    MenuSeparator::new(file);
182    let quit = MenuItem::new(file, "Quit");
183    quit.set_accel("Ctrl+Q");
184    let view = Menu::new(bar, "View");
185    let hidden = CheckMenuItem::new(view, "Show Hidden Files");
186    hidden.set_accel("Ctrl+H");
187    let refresh_item = MenuItem::new(view, "Refresh");
188    refresh_item.set_accel("Ctrl+R");
189    let go = Menu::new(bar, "Go");
190    let up_item = MenuItem::new(go, "Up One Level");
191    up_item.set_accel("Alt+Up");
192    let home_item = MenuItem::new(go, "Home Folder");
193    home_item.set_accel("Alt+Home");
194    let switch = MenuItem::new(go, "Switch Active Pane");
195    switch.set_accel("F9");
196    let helpm = Menu::new(bar, "Help");
197    let about = MenuItem::new(helpm, "About");
198
199    // ---- layout
200    let root = VBox::new(win);
201    root.set_spacing(6);
202    root.set_expand(1.0); // a window stacks its children vertically; give the whole area to this one
203
204    let tools = HBox::new(root);
205    tools.set_spacing(6);
206    let up = Button::new(tools, "\u{2191} Up");
207    up.set_tooltip("Go to the parent folder (Alt+Up)");
208    let refresh = Button::new(tools, "Refresh");
209    refresh.set_tooltip("Reload both panes (Ctrl+R)");
210    let path = TextInput::new(tools);
211    path.set_expand(1.0);
212    path.set_monospace(true);
213    path.set_tooltip("Type a folder path to open it in the active pane");
214    path.set_a11y_name("Path of the active pane");
215    let copy_btn = Button::new(tools, "Copy \u{2192}");
216    copy_btn.set_tooltip("Copy the selected item to the other pane (F5)");
217    let move_btn = Button::new(tools, "Move \u{2192}");
218    move_btn.set_tooltip("Move the selected item to the other pane (F6)");
219
220    let body = Splitter::new(root, Orientation::Horizontal);
221    body.set_expand(1.0);
222    let tree = Tree::new(body);
223    tree.set_a11y_name("Folders");
224    let right = Splitter::new(body, Orientation::Vertical);
225    let panes = Splitter::new(right, Orientation::Horizontal);
226    let mut tables = Vec::new();
227    let mut pane_labels = Vec::new();
228    for (i, n) in PANE_NAMES.iter().enumerate() {
229        let col = VBox::new(panes);
230        col.set_spacing(2);
231        pane_labels.push(Label::new(col, ""));
232        let t = Table::new(col);
233        t.set_expand(1.0);
234        t.set_a11y_name(&format!("Files, pane {n}"));
235        t.set_columns(&[
236            Column::new("Name").width(125).sortable(true),
237            Column::new("Size")
238                .width(62)
239                .align(ColumnAlign::Right)
240                .sortable(true),
241            Column::new("Modified").width(128).sortable(true),
242            Column::new("Kind").width(90).sortable(true),
243        ]);
244        let _ = i;
245        tables.push(t);
246    }
247    let pv = VBox::new(right);
248    pv.set_spacing(2);
249    let preview_title = Label::new(pv, "Preview");
250    let pv_row = HBox::new(pv);
251    pv_row.set_expand(1.0);
252    let image = Image::new(pv_row);
253    image.set_visible(false);
254    image.set_align(Align::Start);
255    let preview = TextArea::new(pv_row);
256    preview.set_expand(1.0);
257    preview.set_read_only(true);
258    preview.set_monospace(true);
259    preview.set_wrap(false);
260    preview.set_a11y_name("Preview");
261
262    let sbar = HBox::new(root);
263    let status = Label::new(sbar, "");
264    status.set_expand(1.0);
265    let tag = Label::new(sbar, "");
266
267    body.set_position(170);
268    body.set_min_pane_sizes(100, 300);
269    right.set_position(400);
270    right.set_min_pane_sizes(120, 80);
271    panes.set_min_pane_sizes(180, 180);
272
273    // ---- context menu shared by both tables
274    let popup = PopupMenu::new();
275    let ctx_open = MenuItem::new(popup, "Open");
276    let ctx_rename = MenuItem::new(popup, "Rename...");
277    let ctx_delete = MenuItem::new(popup, "Delete...");
278    MenuSeparator::new(popup);
279    let ctx_copy = MenuItem::new(popup, "Copy to Other Pane");
280    let ctx_new = MenuItem::new(popup, "New Folder...");
281    for t in &tables {
282        t.set_context_menu(popup);
283    }
284
285    let ui = Ui {
286        win,
287        body,
288        right,
289        panes,
290        tree,
291        tables: [tables[0], tables[1]],
292        pane_labels: [pane_labels[0], pane_labels[1]],
293        path,
294        up,
295        refresh,
296        copy_btn,
297        move_btn,
298        preview_title,
299        preview,
300        image,
301        status,
302        tag,
303        popup,
304        items: Items {
305            new_folder,
306            rename,
307            copy,
308            mv,
309            delete,
310            quit,
311            hidden,
312            refresh: refresh_item,
313            up: up_item,
314            home: home_item,
315            switch,
316            about,
317            ctx_open,
318            ctx_rename,
319            ctx_delete,
320            ctx_copy,
321            ctx_new,
322        },
323    };
324    let fm = Rc::new(Fm {
325        ui,
326        st: RefCell::new(State::default()),
327        quiet: Cell::new(0),
328        typing: Cell::new(false),
329        dialog_ui: Cell::new(None),
330    });
331    fm.wire();
332    fm.init_tree();
333    {
334        let mut st = fm.st.borrow_mut();
335        for p in &opts.dirs {
336            st.panes.push(Pane {
337                path: p.clone(),
338                entries: vec![],
339                sort: (SortKey::Name, true),
340                mtime: None,
341                truncated: false,
342            });
343        }
344    }
345    for (i, p) in opts.dirs.iter().enumerate() {
346        if !fm.navigate(i, p.clone(), None, true, false) {
347            // an unreadable start directory falls back to the home folder, then to "/"
348            let fallback = home_dir().unwrap_or_else(|| PathBuf::from("/"));
349            fm.navigate(i, fallback, None, true, false);
350        }
351    }
352    fm.set_active(0);
353    let first = fm.path_of(0);
354    fm.tree_reveal(&first);
355    fm.ui.win.show();
356    fm
357}
Source

pub fn set_min_size(&self, w: i32, h: i32)

Minimum laid-out size. On a Window this is the minimum CLIENT size: the user cannot resize below it (where the platform allows) and layout never goes below it.

Examples found in repository?
examples/smoke_cocoa.rs (line 101)
6fn main() {
7    let app = App::new("smoke-cocoa").expect("init");
8    let a = Window::new("cc-a");
9    let bar = MenuBar::new(a);
10    let file = Menu::new(bar, "File");
11    let flag = CheckMenuItem::new(file, "Flag");
12    flag.set_accel("Ctrl+K");
13    flag.on_toggle(|v| println!("MENUTOGGLE {v}"));
14    let go = MenuItem::new(file, "Go");
15    go.set_accel("Ctrl+Shift+G");
16    go.on_click(|| println!("MENU_GO"));
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(|| {
20        println!("MENU_QUIT");
21        App::quit();
22    });
23
24    let col = VBox::new(a);
25    let row = HBox::new(col);
26    let btn = Button::new(row, "Press ünï");
27    let spin = SpinBox::new(row, 0.0, 10.0, 1.0);
28    let txt = TextInput::new(col);
29    let chk = CheckBox::new(col, "Monospace");
30    let hs = Splitter::new(col, Orientation::Horizontal);
31    let ta1 = TextArea::new(hs);
32    let ta2 = TextArea::new(hs);
33    ta2.set_text(
34        "long line without wrapping: 0123456789 0123456789 0123456789 0123456789 0123456789",
35    );
36    ta2.set_wrap(false);
37    hs.set_position(200);
38    hs.set_min_pane_sizes(60, 60);
39    let slider = Slider::new(col, 0.0, 100.0);
40    let combo = ComboBox::new(col);
41    combo.set_items(&["x", "y", "z"]);
42    let tabs = Tabs::new(col);
43    let p1 = tabs.add_page("First");
44    let p2 = tabs.add_page("Second");
45    Label::new(p1, "page one");
46    Label::new(p2, "page two");
47    let vs = Splitter::new(col, Orientation::Vertical);
48    let table = Table::new(vs);
49    table.set_columns(&[
50        Column::new("Name").width(80).sortable(true),
51        Column::new("Size").align(ColumnAlign::Right),
52    ]);
53    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
54    let tree = Tree::new(vs);
55    let root = tree.add(None, "root");
56    tree.add(Some(root), "kid");
57    let lazy = tree.add(None, "lazy");
58    tree.set_has_children(lazy, true);
59    vs.set_position(100);
60    vs.set_min_pane_sizes(40, 40);
61
62    btn.on_click(|| println!("CLICK"));
63    spin.on_change(|v| println!("SPIN {v}"));
64    txt.on_change(|t| println!("TEXT {t}"));
65    ta1.on_change(|t| println!("AREA {}", t.replace('\n', "|")));
66    chk.on_toggle(move |on| {
67        println!("MONO {on}");
68        txt.set_monospace(on);
69        ta1.set_monospace(on);
70    });
71    hs.on_move(|p| println!("HSPLIT {p}"));
72    vs.on_move(|p| println!("VSPLIT {p}"));
73    slider.on_change(|v| println!("VALUE {v:.0}"));
74    combo.on_select(|i| println!("COMBO {i:?}"));
75    tabs.on_select(|i| println!("TAB {i:?}"));
76    table.on_select(|i| println!("TABLE_SEL {i:?}"));
77    table.on_column_click(move |c| {
78        let ascending = table.sort_indicator() != Some((c, true));
79        let mut rows = table.rows();
80        rows.sort_by(|x, y| x[c].cmp(&y[c]));
81        if !ascending {
82            rows.reverse();
83        }
84        table.set_rows(&rows);
85        table.set_sort_indicator(Some((c, ascending)));
86        println!(
87            "TABLE_COL {c} {} {}",
88            if ascending { "asc" } else { "desc" },
89            rows[0][0]
90        );
91    });
92    tree.on_select(move |n| println!("TREE_SEL {}", n.is_some()));
93    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
94    a.set_context_menu({
95        let p = PopupMenu::new();
96        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
97        p
98    });
99    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
100    a.on_move(|x, y| println!("MOVED {x} {y}"));
101    a.set_min_size(300, 400);
102    a.set_position(220, 100);
103    a.set_size(560, 700);
104    a.on_close(|| {
105        println!("CLOSE_REQUESTED");
106        true
107    });
108    a.show();
109    println!(
110        "HANDLE {}",
111        a.native_handle().is_some() && btn.native_handle().is_some()
112    );
113    let _t = Timer::once(700, move || {
114        for (n, w) in [
115            ("btn", btn.bounds()),
116            ("spin", spin.bounds()),
117            ("txt", txt.bounds()),
118            ("chk", chk.bounds()),
119            ("hs", hs.bounds()),
120            ("slider", slider.bounds()),
121            ("combo", combo.bounds()),
122            ("tabs", tabs.bounds()),
123            ("vs", vs.bounds()),
124            ("table", table.bounds()),
125            ("tree", tree.bounds()),
126        ] {
127            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
128        }
129        println!("SPLITPOS h {} v {}", hs.position(), vs.position());
130        println!("READY");
131    });
132    app.run();
133    println!("BYE");
134}
More examples
Hide additional examples
examples/file_manager/app.rs (line 165)
162pub fn build(opts: Options) -> Rc<Fm> {
163    let win = Window::new("File Manager");
164    win.set_size(1000, 700);
165    win.set_min_size(640, 420);
166
167    // ---- menus (accelerators are the keyboard interface; there is no key-event API)
168    let bar = MenuBar::new(win);
169    let file = Menu::new(bar, "File");
170    let new_folder = MenuItem::new(file, "New Folder");
171    new_folder.set_accel("F7");
172    let rename = MenuItem::new(file, "Rename");
173    rename.set_accel("F2");
174    MenuSeparator::new(file);
175    let copy = MenuItem::new(file, "Copy to Other Pane");
176    copy.set_accel("F5");
177    let mv = MenuItem::new(file, "Move to Other Pane");
178    mv.set_accel("F6");
179    let delete = MenuItem::new(file, "Delete");
180    delete.set_accel("F8");
181    MenuSeparator::new(file);
182    let quit = MenuItem::new(file, "Quit");
183    quit.set_accel("Ctrl+Q");
184    let view = Menu::new(bar, "View");
185    let hidden = CheckMenuItem::new(view, "Show Hidden Files");
186    hidden.set_accel("Ctrl+H");
187    let refresh_item = MenuItem::new(view, "Refresh");
188    refresh_item.set_accel("Ctrl+R");
189    let go = Menu::new(bar, "Go");
190    let up_item = MenuItem::new(go, "Up One Level");
191    up_item.set_accel("Alt+Up");
192    let home_item = MenuItem::new(go, "Home Folder");
193    home_item.set_accel("Alt+Home");
194    let switch = MenuItem::new(go, "Switch Active Pane");
195    switch.set_accel("F9");
196    let helpm = Menu::new(bar, "Help");
197    let about = MenuItem::new(helpm, "About");
198
199    // ---- layout
200    let root = VBox::new(win);
201    root.set_spacing(6);
202    root.set_expand(1.0); // a window stacks its children vertically; give the whole area to this one
203
204    let tools = HBox::new(root);
205    tools.set_spacing(6);
206    let up = Button::new(tools, "\u{2191} Up");
207    up.set_tooltip("Go to the parent folder (Alt+Up)");
208    let refresh = Button::new(tools, "Refresh");
209    refresh.set_tooltip("Reload both panes (Ctrl+R)");
210    let path = TextInput::new(tools);
211    path.set_expand(1.0);
212    path.set_monospace(true);
213    path.set_tooltip("Type a folder path to open it in the active pane");
214    path.set_a11y_name("Path of the active pane");
215    let copy_btn = Button::new(tools, "Copy \u{2192}");
216    copy_btn.set_tooltip("Copy the selected item to the other pane (F5)");
217    let move_btn = Button::new(tools, "Move \u{2192}");
218    move_btn.set_tooltip("Move the selected item to the other pane (F6)");
219
220    let body = Splitter::new(root, Orientation::Horizontal);
221    body.set_expand(1.0);
222    let tree = Tree::new(body);
223    tree.set_a11y_name("Folders");
224    let right = Splitter::new(body, Orientation::Vertical);
225    let panes = Splitter::new(right, Orientation::Horizontal);
226    let mut tables = Vec::new();
227    let mut pane_labels = Vec::new();
228    for (i, n) in PANE_NAMES.iter().enumerate() {
229        let col = VBox::new(panes);
230        col.set_spacing(2);
231        pane_labels.push(Label::new(col, ""));
232        let t = Table::new(col);
233        t.set_expand(1.0);
234        t.set_a11y_name(&format!("Files, pane {n}"));
235        t.set_columns(&[
236            Column::new("Name").width(125).sortable(true),
237            Column::new("Size")
238                .width(62)
239                .align(ColumnAlign::Right)
240                .sortable(true),
241            Column::new("Modified").width(128).sortable(true),
242            Column::new("Kind").width(90).sortable(true),
243        ]);
244        let _ = i;
245        tables.push(t);
246    }
247    let pv = VBox::new(right);
248    pv.set_spacing(2);
249    let preview_title = Label::new(pv, "Preview");
250    let pv_row = HBox::new(pv);
251    pv_row.set_expand(1.0);
252    let image = Image::new(pv_row);
253    image.set_visible(false);
254    image.set_align(Align::Start);
255    let preview = TextArea::new(pv_row);
256    preview.set_expand(1.0);
257    preview.set_read_only(true);
258    preview.set_monospace(true);
259    preview.set_wrap(false);
260    preview.set_a11y_name("Preview");
261
262    let sbar = HBox::new(root);
263    let status = Label::new(sbar, "");
264    status.set_expand(1.0);
265    let tag = Label::new(sbar, "");
266
267    body.set_position(170);
268    body.set_min_pane_sizes(100, 300);
269    right.set_position(400);
270    right.set_min_pane_sizes(120, 80);
271    panes.set_min_pane_sizes(180, 180);
272
273    // ---- context menu shared by both tables
274    let popup = PopupMenu::new();
275    let ctx_open = MenuItem::new(popup, "Open");
276    let ctx_rename = MenuItem::new(popup, "Rename...");
277    let ctx_delete = MenuItem::new(popup, "Delete...");
278    MenuSeparator::new(popup);
279    let ctx_copy = MenuItem::new(popup, "Copy to Other Pane");
280    let ctx_new = MenuItem::new(popup, "New Folder...");
281    for t in &tables {
282        t.set_context_menu(popup);
283    }
284
285    let ui = Ui {
286        win,
287        body,
288        right,
289        panes,
290        tree,
291        tables: [tables[0], tables[1]],
292        pane_labels: [pane_labels[0], pane_labels[1]],
293        path,
294        up,
295        refresh,
296        copy_btn,
297        move_btn,
298        preview_title,
299        preview,
300        image,
301        status,
302        tag,
303        popup,
304        items: Items {
305            new_folder,
306            rename,
307            copy,
308            mv,
309            delete,
310            quit,
311            hidden,
312            refresh: refresh_item,
313            up: up_item,
314            home: home_item,
315            switch,
316            about,
317            ctx_open,
318            ctx_rename,
319            ctx_delete,
320            ctx_copy,
321            ctx_new,
322        },
323    };
324    let fm = Rc::new(Fm {
325        ui,
326        st: RefCell::new(State::default()),
327        quiet: Cell::new(0),
328        typing: Cell::new(false),
329        dialog_ui: Cell::new(None),
330    });
331    fm.wire();
332    fm.init_tree();
333    {
334        let mut st = fm.st.borrow_mut();
335        for p in &opts.dirs {
336            st.panes.push(Pane {
337                path: p.clone(),
338                entries: vec![],
339                sort: (SortKey::Name, true),
340                mtime: None,
341                truncated: false,
342            });
343        }
344    }
345    for (i, p) in opts.dirs.iter().enumerate() {
346        if !fm.navigate(i, p.clone(), None, true, false) {
347            // an unreadable start directory falls back to the home folder, then to "/"
348            let fallback = home_dir().unwrap_or_else(|| PathBuf::from("/"));
349            fm.navigate(i, fallback, None, true, false);
350        }
351    }
352    fm.set_active(0);
353    let first = fm.path_of(0);
354    fm.tree_reveal(&first);
355    fm.ui.win.show();
356    fm
357}
Source

pub fn set_fixed_size(&self, w: i32, h: i32)

Force the natural size (overrides the toolkit’s preferred size).

Source

pub fn set_spacing(&self, px: i32)

Space between children (stacks/grids/containers).

Examples found in repository?
examples/file_manager/app.rs (line 201)
162pub fn build(opts: Options) -> Rc<Fm> {
163    let win = Window::new("File Manager");
164    win.set_size(1000, 700);
165    win.set_min_size(640, 420);
166
167    // ---- menus (accelerators are the keyboard interface; there is no key-event API)
168    let bar = MenuBar::new(win);
169    let file = Menu::new(bar, "File");
170    let new_folder = MenuItem::new(file, "New Folder");
171    new_folder.set_accel("F7");
172    let rename = MenuItem::new(file, "Rename");
173    rename.set_accel("F2");
174    MenuSeparator::new(file);
175    let copy = MenuItem::new(file, "Copy to Other Pane");
176    copy.set_accel("F5");
177    let mv = MenuItem::new(file, "Move to Other Pane");
178    mv.set_accel("F6");
179    let delete = MenuItem::new(file, "Delete");
180    delete.set_accel("F8");
181    MenuSeparator::new(file);
182    let quit = MenuItem::new(file, "Quit");
183    quit.set_accel("Ctrl+Q");
184    let view = Menu::new(bar, "View");
185    let hidden = CheckMenuItem::new(view, "Show Hidden Files");
186    hidden.set_accel("Ctrl+H");
187    let refresh_item = MenuItem::new(view, "Refresh");
188    refresh_item.set_accel("Ctrl+R");
189    let go = Menu::new(bar, "Go");
190    let up_item = MenuItem::new(go, "Up One Level");
191    up_item.set_accel("Alt+Up");
192    let home_item = MenuItem::new(go, "Home Folder");
193    home_item.set_accel("Alt+Home");
194    let switch = MenuItem::new(go, "Switch Active Pane");
195    switch.set_accel("F9");
196    let helpm = Menu::new(bar, "Help");
197    let about = MenuItem::new(helpm, "About");
198
199    // ---- layout
200    let root = VBox::new(win);
201    root.set_spacing(6);
202    root.set_expand(1.0); // a window stacks its children vertically; give the whole area to this one
203
204    let tools = HBox::new(root);
205    tools.set_spacing(6);
206    let up = Button::new(tools, "\u{2191} Up");
207    up.set_tooltip("Go to the parent folder (Alt+Up)");
208    let refresh = Button::new(tools, "Refresh");
209    refresh.set_tooltip("Reload both panes (Ctrl+R)");
210    let path = TextInput::new(tools);
211    path.set_expand(1.0);
212    path.set_monospace(true);
213    path.set_tooltip("Type a folder path to open it in the active pane");
214    path.set_a11y_name("Path of the active pane");
215    let copy_btn = Button::new(tools, "Copy \u{2192}");
216    copy_btn.set_tooltip("Copy the selected item to the other pane (F5)");
217    let move_btn = Button::new(tools, "Move \u{2192}");
218    move_btn.set_tooltip("Move the selected item to the other pane (F6)");
219
220    let body = Splitter::new(root, Orientation::Horizontal);
221    body.set_expand(1.0);
222    let tree = Tree::new(body);
223    tree.set_a11y_name("Folders");
224    let right = Splitter::new(body, Orientation::Vertical);
225    let panes = Splitter::new(right, Orientation::Horizontal);
226    let mut tables = Vec::new();
227    let mut pane_labels = Vec::new();
228    for (i, n) in PANE_NAMES.iter().enumerate() {
229        let col = VBox::new(panes);
230        col.set_spacing(2);
231        pane_labels.push(Label::new(col, ""));
232        let t = Table::new(col);
233        t.set_expand(1.0);
234        t.set_a11y_name(&format!("Files, pane {n}"));
235        t.set_columns(&[
236            Column::new("Name").width(125).sortable(true),
237            Column::new("Size")
238                .width(62)
239                .align(ColumnAlign::Right)
240                .sortable(true),
241            Column::new("Modified").width(128).sortable(true),
242            Column::new("Kind").width(90).sortable(true),
243        ]);
244        let _ = i;
245        tables.push(t);
246    }
247    let pv = VBox::new(right);
248    pv.set_spacing(2);
249    let preview_title = Label::new(pv, "Preview");
250    let pv_row = HBox::new(pv);
251    pv_row.set_expand(1.0);
252    let image = Image::new(pv_row);
253    image.set_visible(false);
254    image.set_align(Align::Start);
255    let preview = TextArea::new(pv_row);
256    preview.set_expand(1.0);
257    preview.set_read_only(true);
258    preview.set_monospace(true);
259    preview.set_wrap(false);
260    preview.set_a11y_name("Preview");
261
262    let sbar = HBox::new(root);
263    let status = Label::new(sbar, "");
264    status.set_expand(1.0);
265    let tag = Label::new(sbar, "");
266
267    body.set_position(170);
268    body.set_min_pane_sizes(100, 300);
269    right.set_position(400);
270    right.set_min_pane_sizes(120, 80);
271    panes.set_min_pane_sizes(180, 180);
272
273    // ---- context menu shared by both tables
274    let popup = PopupMenu::new();
275    let ctx_open = MenuItem::new(popup, "Open");
276    let ctx_rename = MenuItem::new(popup, "Rename...");
277    let ctx_delete = MenuItem::new(popup, "Delete...");
278    MenuSeparator::new(popup);
279    let ctx_copy = MenuItem::new(popup, "Copy to Other Pane");
280    let ctx_new = MenuItem::new(popup, "New Folder...");
281    for t in &tables {
282        t.set_context_menu(popup);
283    }
284
285    let ui = Ui {
286        win,
287        body,
288        right,
289        panes,
290        tree,
291        tables: [tables[0], tables[1]],
292        pane_labels: [pane_labels[0], pane_labels[1]],
293        path,
294        up,
295        refresh,
296        copy_btn,
297        move_btn,
298        preview_title,
299        preview,
300        image,
301        status,
302        tag,
303        popup,
304        items: Items {
305            new_folder,
306            rename,
307            copy,
308            mv,
309            delete,
310            quit,
311            hidden,
312            refresh: refresh_item,
313            up: up_item,
314            home: home_item,
315            switch,
316            about,
317            ctx_open,
318            ctx_rename,
319            ctx_delete,
320            ctx_copy,
321            ctx_new,
322        },
323    };
324    let fm = Rc::new(Fm {
325        ui,
326        st: RefCell::new(State::default()),
327        quiet: Cell::new(0),
328        typing: Cell::new(false),
329        dialog_ui: Cell::new(None),
330    });
331    fm.wire();
332    fm.init_tree();
333    {
334        let mut st = fm.st.borrow_mut();
335        for p in &opts.dirs {
336            st.panes.push(Pane {
337                path: p.clone(),
338                entries: vec![],
339                sort: (SortKey::Name, true),
340                mtime: None,
341                truncated: false,
342            });
343        }
344    }
345    for (i, p) in opts.dirs.iter().enumerate() {
346        if !fm.navigate(i, p.clone(), None, true, false) {
347            // an unreadable start directory falls back to the home folder, then to "/"
348            let fallback = home_dir().unwrap_or_else(|| PathBuf::from("/"));
349            fm.navigate(i, fallback, None, true, false);
350        }
351    }
352    fm.set_active(0);
353    let first = fm.path_of(0);
354    fm.tree_reveal(&first);
355    fm.ui.win.show();
356    fm
357}
358
359impl Fm {
360    fn wire(self: &Rc<Self>) {
361        let u = &self.ui;
362        let it = u.items;
363        macro_rules! click {
364            ($btn:expr, $f:ident) => {{
365                let fm = self.clone();
366                $btn.on_click(move || fm.$f());
367            }};
368        }
369        click!(it.new_folder, op_new_folder);
370        click!(it.ctx_new, op_new_folder);
371        click!(it.rename, op_rename);
372        click!(it.ctx_rename, op_rename);
373        click!(it.delete, op_delete);
374        click!(it.ctx_delete, op_delete);
375        click!(it.copy, op_copy);
376        click!(it.ctx_copy, op_copy);
377        click!(u.copy_btn, op_copy);
378        click!(it.mv, op_move);
379        click!(u.move_btn, op_move);
380        click!(it.ctx_open, op_open);
381        click!(it.refresh, refresh_all);
382        click!(u.refresh, refresh_all);
383        click!(it.up, go_up);
384        click!(u.up, go_up);
385        click!(it.home, go_home);
386        click!(it.switch, switch_pane);
387        click!(it.about, about);
388        it.quit.on_click(App::quit);
389        {
390            let fm = self.clone();
391            it.hidden.on_toggle(move |on| fm.set_show_hidden(on));
392        }
393        for i in 0..2 {
394            let t = u.tables[i];
395            let fm = self.clone();
396            t.on_select(move |r| fm.on_row_selected(i, r));
397            let fm = self.clone();
398            t.on_activate(move |r| fm.on_row_activated(i, r));
399            let fm = self.clone();
400            t.on_column_click(move |c| fm.sort_by_column(i, c));
401            let fm = self.clone();
402            t.on_context_menu(move |_, _| fm.prepare_context_menu(i));
403        }
404        {
405            let fm = self.clone();
406            u.path.on_change(move |text| fm.on_path_typed(text));
407        }
408        {
409            let fm = self.clone();
410            u.tree.on_select(move |n| fm.on_tree_selected(n));
411            let fm = self.clone();
412            u.tree.on_expand(move |n, open| {
413                if open {
414                    fm.tree_load(n);
415                }
416            });
417        }
418        {
419            let fm = self.clone();
420            u.win.on_resize(move |w, h| {
421                trace!("RESIZE {w} {h}");
422                fm.relabel_soon();
423            });
424            for sp in [u.body, u.right, u.panes] {
425                let fm = self.clone();
426                sp.on_move(move |_| fm.relabel_soon());
427            }
428        }
429        // pick up changes made by other programs
430        let fm = self.clone();
431        Timer::every(1500, move || fm.poll());
432        // report geometry once the first layout has happened
433        let fm = self.clone();
434        Timer::once(500, move || {
435            fm.print_bounds();
436            trace!("READY");
437        });
438    }
439
440    // ---------------------------------------------------------------- state helpers
441
442    pub fn path_of(&self, pane: usize) -> PathBuf {
443        self.st
444            .borrow()
445            .panes
446            .get(pane)
447            .map(|p| p.path.clone())
448            .unwrap_or_default()
449    }
450
451    pub fn active(&self) -> usize {
452        self.st.borrow().active
453    }
454
455    fn entry_at(&self, pane: usize, row: usize) -> Option<Entry> {
456        self.st.borrow().panes.get(pane)?.entries.get(row).cloned()
457    }
458
459    /// The selected entry of `pane`, or None (nothing selected). The ".." row counts.
460    pub fn selected(&self, pane: usize) -> Option<Entry> {
461        let row = self.ui.tables[pane].selected()?;
462        self.entry_at(pane, row)
463    }
464
465    /// The selected real item (not "..") of the active pane.
466    fn target(&self) -> Option<Entry> {
467        self.selected(self.active()).filter(|e| !e.is_parent)
468    }
469
470    pub fn say(&self, msg: &str) {
471        self.ui.status.set_text(msg);
472        trace!("STATUS {msg}");
473    }
474
475    fn quietly<R>(&self, f: impl FnOnce() -> R) -> R {
476        self.quiet.set(self.quiet.get() + 1);
477        let r = f();
478        self.quiet.set(self.quiet.get() - 1);
479        r
480    }
481
482    // ---------------------------------------------------------------- navigation
483
484    /// Show `path` in `pane`. `select` picks a row afterwards (e.g. the folder we came from).
485    /// `reveal` also selects the folder in the tree. Returns false (and says why) on failure.
486    pub fn navigate(
487        self: &Rc<Self>,
488        pane: usize,
489        path: PathBuf,
490        select: Option<PathBuf>,
491        reveal: bool,
492        from_box: bool,
493    ) -> bool {
494        let hidden = self.st.borrow().show_hidden;
495        let listing = match fsm::read_dir(&path, hidden) {
496            Ok(l) => l,
497            Err(e) => {
498                self.say(&format!("Cannot open {}: {}", path.display(), e));
499                trace!("ERROR NAV {} {}", PANE_NAMES[pane], path.display());
500                return false;
501            }
502        };
503        let n = listing.entries.len();
504        let truncated = listing.truncated;
505        {
506            let mut st = self.st.borrow_mut();
507            let Some(p) = st.panes.get_mut(pane) else {
508                return false;
509            };
510            let mut entries = listing.entries;
511            fsm::sort_entries(&mut entries, p.sort.0, p.sort.1);
512            if let Some(parent) = Entry::parent_of(&path) {
513                entries.insert(0, parent);
514            }
515            p.mtime = std::fs::metadata(&path).and_then(|m| m.modified()).ok();
516            p.entries = entries;
517            p.path = path.clone();
518            p.truncated = truncated;
519        }
520        self.populate(pane, select.as_deref());
521        self.typing.set(from_box);
522        self.set_active(pane);
523        self.refresh_labels();
524        self.typing.set(false);
525        if reveal {
526            self.tree_reveal(&path);
527        }
528        // select + preview the requested row, else preview the directory itself
529        let row = select.and_then(|s| {
530            self.st.borrow().panes[pane]
531                .entries
532                .iter()
533                .position(|e| e.path == s)
534        });
535        match row {
536            Some(r) => self.on_row_selected(pane, Some(r)),
537            None => {
538                self.show_preview(Entry::from_path(&path));
539                self.update_status();
540            }
541        }
542        trace!("NAV {} {} {}", PANE_NAMES[pane], path.display(), n);
543        if truncated {
544            self.say(&format!(
545                "Showing only the first {} entries of {}",
546                fsm::MAX_ENTRIES,
547                path.display()
548            ));
549        }
550        true
551    }
552
553    /// Re-read `pane`, keeping the selected item selected when it still exists.
554    fn reload(self: &Rc<Self>, pane: usize, keep: Option<PathBuf>) {
555        let path = self.path_of(pane);
556        let keep = keep.or_else(|| self.selected(pane).map(|e| e.path));
557        if self.navigate_quiet(pane, &path, keep.clone()) {
558            return;
559        }
560        // the directory vanished: climb to the nearest one that exists
561        let mut p = path.clone();
562        while let Some(parent) = p.parent().map(Path::to_path_buf) {
563            if parent.is_dir() && self.navigate(pane, parent.clone(), Some(p.clone()), true, false)
564            {
565                return;
566            }
567            p = parent;
568        }
569    }
570
571    /// Like `navigate` for the same directory but without the active-pane, tree and preview churn
572    /// unless the selection changed. Returns false if the directory cannot be read.
573    fn navigate_quiet(self: &Rc<Self>, pane: usize, path: &Path, keep: Option<PathBuf>) -> bool {
574        let hidden = self.st.borrow().show_hidden;
575        let Ok(listing) = fsm::read_dir(path, hidden) else {
576            return false;
577        };
578        {
579            let mut st = self.st.borrow_mut();
580            let p = &mut st.panes[pane];
581            let mut entries = listing.entries;
582            fsm::sort_entries(&mut entries, p.sort.0, p.sort.1);
583            if let Some(parent) = Entry::parent_of(path) {
584                entries.insert(0, parent);
585            }
586            p.mtime = std::fs::metadata(path).and_then(|m| m.modified()).ok();
587            p.entries = entries;
588            p.truncated = listing.truncated;
589        }
590        self.populate(pane, keep.as_deref());
591        if pane == self.active() {
592            let row = keep.and_then(|s| {
593                self.st.borrow().panes[pane]
594                    .entries
595                    .iter()
596                    .position(|e| e.path == s)
597            });
598            self.show_preview(
599                row.and_then(|r| self.entry_at(pane, r))
600                    .or_else(|| Entry::from_path(path)),
601            );
602        }
603        self.update_status();
604        true
605    }
606
607    #[allow(dead_code)] // used by tests/file_manager_mock.rs
608    /// Test helper: navigate without touching the tree.
609    pub fn navigate_for_test(self: &Rc<Self>, pane: usize, path: PathBuf) -> bool {
610        self.navigate(pane, path, None, false, false)
611    }
612
613    pub fn refresh_all(self: &Rc<Self>) {
614        for i in 0..2 {
615            self.reload(i, None);
616        }
617        self.say("Refreshed");
618        trace!("REFRESH");
619    }
620
621    /// Timer: reload panes whose directory changed on disk.
622    fn poll(self: &Rc<Self>) {
623        #[allow(clippy::needless_range_loop)]
624        for i in 0..2 {
625            let (path, old) = {
626                let st = self.st.borrow();
627                match st.panes.get(i) {
628                    Some(p) => (p.path.clone(), p.mtime),
629                    None => return,
630                }
631            };
632            let now = std::fs::metadata(&path).and_then(|m| m.modified()).ok();
633            if now != old {
634                trace!("CHANGED {}", PANE_NAMES[i]);
635                self.reload(i, None);
636            }
637        }
638    }
639
640    pub fn go_up(self: &Rc<Self>) {
641        let a = self.active();
642        let cur = self.path_of(a);
643        if let Some(parent) = cur.parent() {
644            self.navigate(a, parent.to_path_buf(), Some(cur.clone()), true, false);
645        }
646    }
647
648    fn go_home(self: &Rc<Self>) {
649        if let Some(h) = home_dir() {
650            let a = self.active();
651            self.navigate(a, h, None, true, false);
652        }
653    }
654
655    fn switch_pane(self: &Rc<Self>) {
656        let other = 1 - self.active();
657        self.set_active(other);
658        self.ui.tables[other].focus();
659    }
660
661    fn set_show_hidden(self: &Rc<Self>, on: bool) {
662        self.st.borrow_mut().show_hidden = on;
663        trace!("HIDDEN {on}");
664        for i in 0..2 {
665            self.reload(i, None);
666        }
667        // rebuild the folder tree so hidden folders appear or vanish too
668        self.init_tree();
669        let a = self.active();
670        let p = self.path_of(a);
671        self.tree_reveal(&p);
672    }
673
674    fn on_path_typed(self: &Rc<Self>, text: &str) {
675        if self.typing.get() {
676            return;
677        }
678        let a = self.active();
679        let t = text.trim();
680        if t.is_empty() || Path::new(t) == self.path_of(a) {
681            return;
682        }
683        let p = PathBuf::from(t);
684        if p.is_dir() {
685            self.navigate(a, p, None, true, true);
686        }
687    }
688
689    pub fn set_active(&self, pane: usize) {
690        let changed = {
691            let mut st = self.st.borrow_mut();
692            let c = st.active != pane;
693            st.active = pane;
694            c
695        };
696        self.refresh_labels();
697        if changed {
698            trace!("ACTIVE {}", PANE_NAMES[pane]);
699        }
700    }
701
702    /// The pane captions depend on the pane widths, which are known only after layout.
703    fn relabel_soon(self: &Rc<Self>) {
704        let fm = self.clone();
705        Timer::once(10, move || fm.refresh_labels());
706    }
707
708    /// Pane captions, path box, window title and the active-pane tag.
709    fn refresh_labels(&self) {
710        let (active, paths) = {
711            let st = self.st.borrow();
712            (
713                st.active,
714                st.panes.iter().map(|p| p.path.clone()).collect::<Vec<_>>(),
715            )
716        };
717        for (i, p) in paths.iter().enumerate() {
718            let mark = if i == active { "\u{25B6}" } else { " " };
719            // labels do not clip, so fit the path to the pane (about 7 px per character)
720            let room = (self.ui.tables[i].bounds().w / 7).max(12) as usize;
721            let head = format!("{mark} {}  ", PANE_NAMES[i]);
722            let path = fsm::ellipsize_path(
723                &p.display().to_string(),
724                room.saturating_sub(head.chars().count()),
725            );
726            self.ui.pane_labels[i].set_text(&format!("{head}{path}"));
727        }
728        let cur = paths.get(active).cloned().unwrap_or_default();
729        let text = cur.display().to_string();
730        if self.ui.path.text() != text && !self.typing.get() {
731            self.ui.path.set_text(&text);
732        }
733        let name = cur
734            .file_name()
735            .map(|n| n.to_string_lossy().into_owned())
736            .unwrap_or_else(|| text.clone());
737        self.ui
738            .win
739            .set_title(&format!("{name} [{}] - File Manager", PANE_NAMES[active]));
740        self.ui
741            .tag
742            .set_text(&format!("  Active pane: {}", PANE_NAMES[active]));
743        self.ui.up.set_enabled(cur.parent().is_some());
744    }
745
746    // ---------------------------------------------------------------- table
747
748    /// Fill a pane's table from its entries. Uses one `batch` so huge directories send one update.
749    fn populate(&self, pane: usize, select: Option<&Path>) {
750        let (rows, sort, sel) = {
751            let st = self.st.borrow();
752            let p = &st.panes[pane];
753            let rows: Vec<Vec<String>> = p.entries.iter().map(row_of).collect();
754            (
755                rows,
756                p.sort,
757                select.and_then(|s| p.entries.iter().position(|e| e.path == s)),
758            )
759        };
760        let t = self.ui.tables[pane];
761        self.quietly(|| {
762            t.batch(|t| t.set_rows(&rows));
763            t.set_sort_indicator(Some((sort.0.column(), sort.1)));
764            t.set_selected(sel);
765        });
766    }
767
768    fn sort_by_column(self: &Rc<Self>, pane: usize, col: usize) {
769        let key = SortKey::from_column(col);
770        let keep = self.selected(pane).map(|e| e.path);
771        {
772            let mut st = self.st.borrow_mut();
773            let Some(p) = st.panes.get_mut(pane) else {
774                return;
775            };
776            let asc = if p.sort.0 == key { !p.sort.1 } else { true };
777            p.sort = (key, asc);
778            let has_parent = p.entries.first().is_some_and(|e| e.is_parent);
779            fsm::sort_entries(&mut p.entries[has_parent as usize..], key, asc);
780        }
781        self.populate(pane, keep.as_deref());
782        let (k, asc) = self.st.borrow().panes[pane].sort;
783        trace!(
784            "SORT {} {} {}",
785            PANE_NAMES[pane],
786            k.column(),
787            if asc { "asc" } else { "desc" }
788        );
789    }
790
791    fn on_row_selected(self: &Rc<Self>, pane: usize, row: Option<usize>) {
792        if self.quiet.get() > 0 {
793            return;
794        }
795        self.set_active(pane);
796        let e = row.and_then(|r| self.entry_at(pane, r));
797        if let Some(e) = &e {
798            trace!("SELECT {} {}", PANE_NAMES[pane], e.name);
799        }
800        self.show_preview(e);
801        self.update_status();
802    }
803
804    fn on_row_activated(self: &Rc<Self>, pane: usize, row: usize) {
805        self.set_active(pane);
806        let Some(e) = self.entry_at(pane, row) else {
807            return;
808        };
809        self.open_entry(pane, e);
810    }
811
812    fn open_entry(self: &Rc<Self>, pane: usize, e: Entry) {
813        if e.is_dir {
814            let from = self.path_of(pane);
815            let select = e.is_parent.then_some(from);
816            self.navigate(pane, e.path, select, true, false);
817        } else {
818            trace!("OPEN {} {}", PANE_NAMES[pane], e.name);
819            self.show_preview(Some(e));
820        }
821    }
822
823    fn op_open(self: &Rc<Self>) {
824        if let Some(e) = self.selected(self.active()) {
825            self.open_entry(self.active(), e);
826        }
827    }
828
829    /// Runs just before the popup is shown: right-clicking a pane makes it the active one.
830    fn prepare_context_menu(&self, pane: usize) {
831        self.set_active(pane);
832        let sel = self.selected(pane);
833        let real = sel.as_ref().is_some_and(|e| !e.is_parent);
834        let it = self.ui.items;
835        it.ctx_open.set_enabled(sel.is_some());
836        it.ctx_rename.set_enabled(real);
837        it.ctx_delete.set_enabled(real);
838        it.ctx_copy.set_enabled(real);
839    }
840
841    // ---------------------------------------------------------------- preview and status
842
843    fn show_preview(&self, e: Option<Entry>) {
844        let u = &self.ui;
845        let Some(e) = e else {
846            u.preview_title.set_text("Preview");
847            u.preview.set_text("");
848            u.image.set_image(None);
849            u.image.set_visible(false);
850            return;
851        };
852        let p = fsm::preview(&e);
853        let (what, extra) = match &p {
854            Preview::Text { truncated, .. } => (
855                "text",
856                if *truncated {
857                    format!(" (first {} KB)", fsm::PREVIEW_LIMIT / 1024)
858                } else {
859                    String::new()
860                },
861            ),
862            Preview::Hex { .. } => (
863                "binary",
864                format!(" (hex dump of the first {} bytes)", fsm::HEX_LIMIT),
865            ),
866            Preview::Dir(_) => ("folder", String::new()),
867            Preview::Image { img, .. } => ("image", format!(" ({} x {})", img.w, img.h)),
868            Preview::Error(_) => ("error", String::new()),
869        };
870        u.preview_title.set_text(&format!(
871            "Preview: {}{extra}",
872            if e.is_parent { ".." } else { &e.name }
873        ));
874        u.preview.set_text(p.body());
875        match &p {
876            Preview::Image { img, .. } => {
877                u.image.set_image(Some(&scaled(img)));
878                u.image.set_visible(true);
879            }
880            _ => {
881                u.image.set_image(None);
882                u.image.set_visible(false);
883            }
884        }
885        trace!("PREVIEW {what} {} {}", p.shown_bytes(), e.name);
886    }
887
888    fn update_status(&self) {
889        let a = self.active();
890        let (n, dirs, total, trunc, sel) = {
891            let st = self.st.borrow();
892            let p = &st.panes[a];
893            let real: Vec<&Entry> = p.entries.iter().filter(|e| !e.is_parent).collect();
894            let dirs = real.iter().filter(|e| e.is_dir).count();
895            let total: u64 = real.iter().filter(|e| !e.is_dir).map(|e| e.size).sum();
896            (real.len(), dirs, total, p.truncated, p.entries.len())
897        };
898        let _ = sel;
899        let mut s = format!(
900            "{n} items ({dirs} folders, {} files), {} in files",
901            n - dirs,
902            fsm::human_size(total)
903        );
904        if trunc {
905            s.push_str(" (truncated)");
906        }
907        if let Some(e) = self.selected(a) {
908            s.push_str(&format!("   |   {}", fsm::describe(&e)));
909        }
910        self.ui.status.set_text(&s);
911        trace!("STATUS {s}");
912    }
913
914    fn print_bounds(&self) {
915        if !tracing() {
916            return;
917        }
918        let u = &self.ui;
919        let (b, ids): (Rect, Vec<(&str, Widget)>) = (
920            u.win.bounds(),
921            vec![
922                ("tree", *u.tree),
923                ("tableA", *u.tables[0]),
924                ("tableB", *u.tables[1]),
925                ("labelA", *u.pane_labels[0]),
926                ("labelB", *u.pane_labels[1]),
927                ("preview", *u.preview),
928                ("image", *u.image),
929                ("path", *u.path),
930                ("up", *u.up),
931                ("refresh", *u.refresh),
932                ("copy", *u.copy_btn),
933                ("move", *u.move_btn),
934                ("status", *u.status),
935                ("body", *u.body),
936                ("right", *u.right),
937                ("panes", *u.panes),
938            ],
939        );
940        let _ = b;
941        for (n, w) in ids {
942            let r = w.bounds();
943            println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
944        }
945    }
946
947    // ---------------------------------------------------------------- tree
948
949    fn init_tree(self: &Rc<Self>) {
950        let t = self.ui.tree;
951        t.clear();
952        let mut roots: Vec<(String, PathBuf)> = Vec::new();
953        if let Some(h) = home_dir() {
954            roots.push(("Home".into(), h));
955        }
956        #[cfg(windows)]
957        for d in b'A'..=b'Z' {
958            let p = PathBuf::from(format!("{}:\\", d as char));
959            if p.is_dir() {
960                roots.push((format!("{}:\\", d as char), p));
961            }
962        }
963        #[cfg(not(windows))]
964        roots.push(("File System (/)".into(), PathBuf::from("/")));
965        let mut st = self.st.borrow_mut();
966        st.node_paths.clear();
967        st.loaded.clear();
968        for (name, p) in roots {
969            let n = t.add(None, &name);
970            t.set_has_children(n, true);
971            st.node_paths.insert(n, p);
972        }
973    }
974
975    pub fn node_path(&self, n: TreeNodeId) -> Option<PathBuf> {
976        self.st.borrow().node_paths.get(&n).cloned()
977    }
978
979    /// Add the sub-folders of `node` the first time it is needed.
980    pub fn tree_load(&self, node: TreeNodeId) {
981        let Some(path) = self.node_path(node) else {
982            return;
983        };
984        if !self.st.borrow_mut().loaded.insert(node) {
985            return;
986        }
987        let hidden = self.st.borrow().show_hidden;
988        let dirs = fsm::subdirs(&path, hidden);
989        let t = self.ui.tree;
990        let mut new = Vec::new();
991        t.batch(|t| {
992            for d in &dirs {
993                let c = t.add(Some(node), &d.name);
994                t.set_has_children(c, true);
995                new.push((c, d.path.clone()));
996            }
997            t.set_has_children(node, !dirs.is_empty());
998        });
999        self.st.borrow_mut().node_paths.extend(new);
1000    }
1001
1002    /// Expand the tree down to `path` and select it (no callbacks fire).
1003    fn tree_reveal(&self, path: &Path) {
1004        let t = self.ui.tree;
1005        let mut best: Option<(TreeNodeId, usize)> = None;
1006        for r in t.children(None) {
1007            if let Some(rp) = self.node_path(r) {
1008                let depth = rp.components().count();
1009                if path.starts_with(&rp) && best.is_none_or(|(_, d)| depth > d) {
1010                    best = Some((r, depth));
1011                }
1012            }
1013        }
1014        let Some((mut node, _)) = best else { return };
1015        let Some(root_path) = self.node_path(node) else {
1016            return;
1017        };
1018        let Ok(rest) = path.strip_prefix(&root_path) else {
1019            return;
1020        };
1021        let mut cur = root_path;
1022        for comp in rest.components() {
1023            self.tree_load(node);
1024            cur.push(comp);
1025            match t
1026                .children(Some(node))
1027                .into_iter()
1028                .find(|c| self.node_path(*c).as_deref() == Some(cur.as_path()))
1029            {
1030                Some(c) => node = c,
1031                None => break,
1032            }
1033        }
1034        self.tree_load(node); // set_selected expands its ancestors; the node itself must not show a placeholder
1035        t.set_selected(Some(node));
1036    }
1037
1038    fn on_tree_selected(self: &Rc<Self>, n: Option<TreeNodeId>) {
1039        let Some(path) = n.and_then(|n| self.node_path(n)) else {
1040            return;
1041        };
1042        let a = self.active();
1043        if path != self.path_of(a) {
1044            trace!("TREE {}", path.display());
1045            self.navigate(a, path, None, false, false);
1046        }
1047    }
1048
1049    // ---------------------------------------------------------------- operations
1050
1051    fn confirm(&self, title: &str, text: &str) -> bool {
1052        message_box(
1053            Some(self.ui.win),
1054            MessageKind::Question,
1055            Buttons::YesNo,
1056            title,
1057            text,
1058        ) == Answer::Yes
1059    }
1060
1061    /// Reload every pane showing `dir` (or all, if `dir` is None) and select `select` in the active one.
1062    fn refresh_after(self: &Rc<Self>, select: Option<PathBuf>) {
1063        let a = self.active();
1064        for i in 0..2 {
1065            let keep = if i == a { select.clone() } else { None };
1066            self.reload(i, keep);
1067        }
1068    }
1069
1070    fn op_new_folder(self: &Rc<Self>) {
1071        let a = self.active();
1072        let dir = self.path_of(a);
1073        self.dialog(
1074            "New Folder",
1075            "Name of the new folder:",
1076            "New Folder",
1077            move |fm, name| {
1078                let p = fsm::make_dir(&dir, name)?;
1079                trace!("MKDIR {}", p.display());
1080                fm.refresh_after(Some(p));
1081                fm.say(&format!("Created folder \"{name}\""));
1082                Ok(())
1083            },
1084        );
1085    }
1086
1087    fn op_rename(self: &Rc<Self>) {
1088        let Some(e) = self.target() else {
1089            self.say("Select an item to rename first");
1090            return;
1091        };
1092        let old = e
1093            .path
1094            .file_name()
1095            .map(|n| n.to_string_lossy().into_owned())
1096            .unwrap_or_default();
1097        let (prompt, initial) = (format!("New name for \"{old}\":"), old.clone());
1098        self.dialog("Rename", &prompt, &initial, move |fm, name| {
1099            let p = fsm::rename_path(&e.path, name)?;
1100            trace!("RENAME {} {}", e.name, name);
1101            fm.refresh_after(Some(p));
1102            fm.say(&format!("Renamed \"{old}\" to \"{name}\""));
1103            Ok(())
1104        });
1105    }
1106
1107    fn op_delete(self: &Rc<Self>) {
1108        let Some(e) = self.target() else {
1109            self.say("Select an item to delete first");
1110            return;
1111        };
1112        let what = if e.is_dir && !e.is_link {
1113            "folder and everything in it"
1114        } else {
1115            "item"
1116        };
1117        if !self.confirm(
1118            "Delete",
1119            &format!(
1120                "Delete the {what} \"{}\"?\n\nThis cannot be undone.",
1121                e.name
1122            ),
1123        ) {
1124            self.say("Delete cancelled");
1125            return;
1126        }
1127        match fsm::remove_path(&e.path) {
1128            Ok(()) => {
1129                trace!("DELETE {}", e.name);
1130                self.refresh_after(None);
1131                self.say(&format!("Deleted \"{}\"", e.name));
1132            }
1133            Err(err) => {
1134                trace!("ERROR DELETE {}", e.name);
1135                self.say(&format!("Cannot delete \"{}\": {err}", e.name));
1136            }
1137        }
1138    }
1139
1140    fn op_copy(self: &Rc<Self>) {
1141        self.transfer(false)
1142    }
1143
1144    fn op_move(self: &Rc<Self>) {
1145        self.transfer(true)
1146    }
1147
1148    fn transfer(self: &Rc<Self>, mv: bool) {
1149        let verb = if mv { "Move" } else { "Copy" };
1150        let Some(e) = self.target() else {
1151            self.say(&format!("Select an item to {} first", verb.to_lowercase()));
1152            return;
1153        };
1154        let a = self.active();
1155        let dst_dir = self.path_of(1 - a);
1156        let dest = match fsm::check_transfer(&e.path, &dst_dir) {
1157            Ok(d) => d,
1158            Err(err) => {
1159                self.say(&err);
1160                return;
1161            }
1162        };
1163        if std::fs::symlink_metadata(&dest).is_ok() {
1164            if !self.confirm(
1165                "Overwrite",
1166                &format!(
1167                    "\"{}\" already exists in {}.\n\nReplace it?",
1168                    e.name,
1169                    dst_dir.display()
1170                ),
1171            ) {
1172                self.say(&format!("{verb} cancelled"));
1173                return;
1174            }
1175            if let Err(err) = fsm::remove_path(&dest) {
1176                self.say(&format!("Cannot replace \"{}\": {err}", e.name));
1177                return;
1178            }
1179        }
1180        let r = if mv {
1181            fsm::move_into(&e.path, &dst_dir)
1182        } else {
1183            fsm::copy_into(&e.path, &dst_dir)
1184        };
1185        match r {
1186            Ok(new) => {
1187                trace!("{} {} {}", verb.to_uppercase(), e.name, dst_dir.display());
1188                // both panes re-read; the other pane shows the new item selected
1189                self.reload(a, None);
1190                self.reload(1 - a, Some(new));
1191                self.say(&format!(
1192                    "{} \"{}\" to {}",
1193                    if mv { "Moved" } else { "Copied" },
1194                    e.name,
1195                    dst_dir.display()
1196                ));
1197            }
1198            Err(err) => {
1199                trace!("ERROR {} {}", verb.to_uppercase(), e.name);
1200                self.say(&err);
1201            }
1202        }
1203    }
1204
1205    fn about(&self) {
1206        message_box(
1207            Some(self.ui.win),
1208            MessageKind::Info,
1209            Buttons::Ok,
1210            "About File Manager",
1211            "A dual-pane file manager written with rungui's public API only.\n\nF2 rename, F5 copy, F6 move, F7 new folder, F8 delete,\nF9 switch pane, Ctrl+H hidden files, Ctrl+R refresh.\nTimes are shown in UTC.",
1212        );
1213    }
1214
1215    // ---------------------------------------------------------------- the rename / new folder dialog
1216
1217    /// A small window with a text field and OK / Cancel (rungui has no input-dialog API).
1218    /// `action` returns an error message to keep the dialog open.
1219    fn dialog(
1220        self: &Rc<Self>,
1221        title: &str,
1222        prompt: &str,
1223        initial: &str,
1224        action: impl Fn(&Rc<Fm>, &str) -> std::result::Result<(), String> + 'static,
1225    ) {
1226        if let Some(old) = self.st.borrow_mut().dialog.take() {
1227            old.destroy();
1228        }
1229        let w = Window::new(title);
1230        w.set_size(380, 150);
1231        w.set_resizable(false);
1232        let col = VBox::new(w);
1233        col.set_spacing(8);
1234        Label::new(col, prompt);
1235        let input = TextInput::new(col);
1236        input.set_text(initial);
1237        input.set_a11y_name(title);
1238        let err = Label::new(col, "");
1239        let row = HBox::new(col);
1240        row.set_spacing(8);
1241        Spacer::new(row);
1242        let cancel = Button::new(row, "Cancel");
1243        let ok = Button::new(row, "OK");
1244        self.st.borrow_mut().dialog = Some(w);
1245        self.dialog_ui.set(Some((w, input, ok, cancel)));
1246        trace!("DIALOG open {title}");
1247        {
1248            let fm = self.clone();
1249            ok.on_click(move || {
1250                let text = input.text();
1251                match action(&fm, text.trim()) {
1252                    Ok(()) => {
1253                        trace!("DIALOG done");
1254                        fm.st.borrow_mut().dialog = None;
1255                        w.destroy();
1256                    }
1257                    Err(e) => {
1258                        trace!("DIALOG error {e}");
1259                        err.set_text(&e);
1260                    }
1261                }
1262            });
1263            let fm = self.clone();
1264            cancel.on_click(move || {
1265                trace!("DIALOG cancel");
1266                fm.st.borrow_mut().dialog = None;
1267                w.destroy();
1268            });
1269            let fm = self.clone();
1270            w.on_close(move || {
1271                fm.st.borrow_mut().dialog = None;
1272                true
1273            });
1274        }
1275        w.show();
1276        input.focus();
1277        if tracing() {
1278            Timer::once(300, move || {
1279                for (n, wd) in [
1280                    ("dlg_input", *input),
1281                    ("dlg_ok", *ok),
1282                    ("dlg_cancel", *cancel),
1283                ] {
1284                    let r = wd.bounds();
1285                    println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
1286                }
1287            });
1288        }
1289    }
Source

pub fn set_padding(&self, px: i32)

Inner margin of a container.

Source

pub fn set_cell(&self, col: usize, row: usize, colspan: usize, rowspan: usize)

Explicit grid cell in the parent Grid (otherwise children auto-flow).

Source

pub fn bounds(&self) -> Rect

Last laid-out bounds, relative to the nearest native parent (logical pixels).

Examples found in repository?
examples/file_manager/app.rs (line 720)
709    fn refresh_labels(&self) {
710        let (active, paths) = {
711            let st = self.st.borrow();
712            (
713                st.active,
714                st.panes.iter().map(|p| p.path.clone()).collect::<Vec<_>>(),
715            )
716        };
717        for (i, p) in paths.iter().enumerate() {
718            let mark = if i == active { "\u{25B6}" } else { " " };
719            // labels do not clip, so fit the path to the pane (about 7 px per character)
720            let room = (self.ui.tables[i].bounds().w / 7).max(12) as usize;
721            let head = format!("{mark} {}  ", PANE_NAMES[i]);
722            let path = fsm::ellipsize_path(
723                &p.display().to_string(),
724                room.saturating_sub(head.chars().count()),
725            );
726            self.ui.pane_labels[i].set_text(&format!("{head}{path}"));
727        }
728        let cur = paths.get(active).cloned().unwrap_or_default();
729        let text = cur.display().to_string();
730        if self.ui.path.text() != text && !self.typing.get() {
731            self.ui.path.set_text(&text);
732        }
733        let name = cur
734            .file_name()
735            .map(|n| n.to_string_lossy().into_owned())
736            .unwrap_or_else(|| text.clone());
737        self.ui
738            .win
739            .set_title(&format!("{name} [{}] - File Manager", PANE_NAMES[active]));
740        self.ui
741            .tag
742            .set_text(&format!("  Active pane: {}", PANE_NAMES[active]));
743        self.ui.up.set_enabled(cur.parent().is_some());
744    }
745
746    // ---------------------------------------------------------------- table
747
748    /// Fill a pane's table from its entries. Uses one `batch` so huge directories send one update.
749    fn populate(&self, pane: usize, select: Option<&Path>) {
750        let (rows, sort, sel) = {
751            let st = self.st.borrow();
752            let p = &st.panes[pane];
753            let rows: Vec<Vec<String>> = p.entries.iter().map(row_of).collect();
754            (
755                rows,
756                p.sort,
757                select.and_then(|s| p.entries.iter().position(|e| e.path == s)),
758            )
759        };
760        let t = self.ui.tables[pane];
761        self.quietly(|| {
762            t.batch(|t| t.set_rows(&rows));
763            t.set_sort_indicator(Some((sort.0.column(), sort.1)));
764            t.set_selected(sel);
765        });
766    }
767
768    fn sort_by_column(self: &Rc<Self>, pane: usize, col: usize) {
769        let key = SortKey::from_column(col);
770        let keep = self.selected(pane).map(|e| e.path);
771        {
772            let mut st = self.st.borrow_mut();
773            let Some(p) = st.panes.get_mut(pane) else {
774                return;
775            };
776            let asc = if p.sort.0 == key { !p.sort.1 } else { true };
777            p.sort = (key, asc);
778            let has_parent = p.entries.first().is_some_and(|e| e.is_parent);
779            fsm::sort_entries(&mut p.entries[has_parent as usize..], key, asc);
780        }
781        self.populate(pane, keep.as_deref());
782        let (k, asc) = self.st.borrow().panes[pane].sort;
783        trace!(
784            "SORT {} {} {}",
785            PANE_NAMES[pane],
786            k.column(),
787            if asc { "asc" } else { "desc" }
788        );
789    }
790
791    fn on_row_selected(self: &Rc<Self>, pane: usize, row: Option<usize>) {
792        if self.quiet.get() > 0 {
793            return;
794        }
795        self.set_active(pane);
796        let e = row.and_then(|r| self.entry_at(pane, r));
797        if let Some(e) = &e {
798            trace!("SELECT {} {}", PANE_NAMES[pane], e.name);
799        }
800        self.show_preview(e);
801        self.update_status();
802    }
803
804    fn on_row_activated(self: &Rc<Self>, pane: usize, row: usize) {
805        self.set_active(pane);
806        let Some(e) = self.entry_at(pane, row) else {
807            return;
808        };
809        self.open_entry(pane, e);
810    }
811
812    fn open_entry(self: &Rc<Self>, pane: usize, e: Entry) {
813        if e.is_dir {
814            let from = self.path_of(pane);
815            let select = e.is_parent.then_some(from);
816            self.navigate(pane, e.path, select, true, false);
817        } else {
818            trace!("OPEN {} {}", PANE_NAMES[pane], e.name);
819            self.show_preview(Some(e));
820        }
821    }
822
823    fn op_open(self: &Rc<Self>) {
824        if let Some(e) = self.selected(self.active()) {
825            self.open_entry(self.active(), e);
826        }
827    }
828
829    /// Runs just before the popup is shown: right-clicking a pane makes it the active one.
830    fn prepare_context_menu(&self, pane: usize) {
831        self.set_active(pane);
832        let sel = self.selected(pane);
833        let real = sel.as_ref().is_some_and(|e| !e.is_parent);
834        let it = self.ui.items;
835        it.ctx_open.set_enabled(sel.is_some());
836        it.ctx_rename.set_enabled(real);
837        it.ctx_delete.set_enabled(real);
838        it.ctx_copy.set_enabled(real);
839    }
840
841    // ---------------------------------------------------------------- preview and status
842
843    fn show_preview(&self, e: Option<Entry>) {
844        let u = &self.ui;
845        let Some(e) = e else {
846            u.preview_title.set_text("Preview");
847            u.preview.set_text("");
848            u.image.set_image(None);
849            u.image.set_visible(false);
850            return;
851        };
852        let p = fsm::preview(&e);
853        let (what, extra) = match &p {
854            Preview::Text { truncated, .. } => (
855                "text",
856                if *truncated {
857                    format!(" (first {} KB)", fsm::PREVIEW_LIMIT / 1024)
858                } else {
859                    String::new()
860                },
861            ),
862            Preview::Hex { .. } => (
863                "binary",
864                format!(" (hex dump of the first {} bytes)", fsm::HEX_LIMIT),
865            ),
866            Preview::Dir(_) => ("folder", String::new()),
867            Preview::Image { img, .. } => ("image", format!(" ({} x {})", img.w, img.h)),
868            Preview::Error(_) => ("error", String::new()),
869        };
870        u.preview_title.set_text(&format!(
871            "Preview: {}{extra}",
872            if e.is_parent { ".." } else { &e.name }
873        ));
874        u.preview.set_text(p.body());
875        match &p {
876            Preview::Image { img, .. } => {
877                u.image.set_image(Some(&scaled(img)));
878                u.image.set_visible(true);
879            }
880            _ => {
881                u.image.set_image(None);
882                u.image.set_visible(false);
883            }
884        }
885        trace!("PREVIEW {what} {} {}", p.shown_bytes(), e.name);
886    }
887
888    fn update_status(&self) {
889        let a = self.active();
890        let (n, dirs, total, trunc, sel) = {
891            let st = self.st.borrow();
892            let p = &st.panes[a];
893            let real: Vec<&Entry> = p.entries.iter().filter(|e| !e.is_parent).collect();
894            let dirs = real.iter().filter(|e| e.is_dir).count();
895            let total: u64 = real.iter().filter(|e| !e.is_dir).map(|e| e.size).sum();
896            (real.len(), dirs, total, p.truncated, p.entries.len())
897        };
898        let _ = sel;
899        let mut s = format!(
900            "{n} items ({dirs} folders, {} files), {} in files",
901            n - dirs,
902            fsm::human_size(total)
903        );
904        if trunc {
905            s.push_str(" (truncated)");
906        }
907        if let Some(e) = self.selected(a) {
908            s.push_str(&format!("   |   {}", fsm::describe(&e)));
909        }
910        self.ui.status.set_text(&s);
911        trace!("STATUS {s}");
912    }
913
914    fn print_bounds(&self) {
915        if !tracing() {
916            return;
917        }
918        let u = &self.ui;
919        let (b, ids): (Rect, Vec<(&str, Widget)>) = (
920            u.win.bounds(),
921            vec![
922                ("tree", *u.tree),
923                ("tableA", *u.tables[0]),
924                ("tableB", *u.tables[1]),
925                ("labelA", *u.pane_labels[0]),
926                ("labelB", *u.pane_labels[1]),
927                ("preview", *u.preview),
928                ("image", *u.image),
929                ("path", *u.path),
930                ("up", *u.up),
931                ("refresh", *u.refresh),
932                ("copy", *u.copy_btn),
933                ("move", *u.move_btn),
934                ("status", *u.status),
935                ("body", *u.body),
936                ("right", *u.right),
937                ("panes", *u.panes),
938            ],
939        );
940        let _ = b;
941        for (n, w) in ids {
942            let r = w.bounds();
943            println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
944        }
945    }
946
947    // ---------------------------------------------------------------- tree
948
949    fn init_tree(self: &Rc<Self>) {
950        let t = self.ui.tree;
951        t.clear();
952        let mut roots: Vec<(String, PathBuf)> = Vec::new();
953        if let Some(h) = home_dir() {
954            roots.push(("Home".into(), h));
955        }
956        #[cfg(windows)]
957        for d in b'A'..=b'Z' {
958            let p = PathBuf::from(format!("{}:\\", d as char));
959            if p.is_dir() {
960                roots.push((format!("{}:\\", d as char), p));
961            }
962        }
963        #[cfg(not(windows))]
964        roots.push(("File System (/)".into(), PathBuf::from("/")));
965        let mut st = self.st.borrow_mut();
966        st.node_paths.clear();
967        st.loaded.clear();
968        for (name, p) in roots {
969            let n = t.add(None, &name);
970            t.set_has_children(n, true);
971            st.node_paths.insert(n, p);
972        }
973    }
974
975    pub fn node_path(&self, n: TreeNodeId) -> Option<PathBuf> {
976        self.st.borrow().node_paths.get(&n).cloned()
977    }
978
979    /// Add the sub-folders of `node` the first time it is needed.
980    pub fn tree_load(&self, node: TreeNodeId) {
981        let Some(path) = self.node_path(node) else {
982            return;
983        };
984        if !self.st.borrow_mut().loaded.insert(node) {
985            return;
986        }
987        let hidden = self.st.borrow().show_hidden;
988        let dirs = fsm::subdirs(&path, hidden);
989        let t = self.ui.tree;
990        let mut new = Vec::new();
991        t.batch(|t| {
992            for d in &dirs {
993                let c = t.add(Some(node), &d.name);
994                t.set_has_children(c, true);
995                new.push((c, d.path.clone()));
996            }
997            t.set_has_children(node, !dirs.is_empty());
998        });
999        self.st.borrow_mut().node_paths.extend(new);
1000    }
1001
1002    /// Expand the tree down to `path` and select it (no callbacks fire).
1003    fn tree_reveal(&self, path: &Path) {
1004        let t = self.ui.tree;
1005        let mut best: Option<(TreeNodeId, usize)> = None;
1006        for r in t.children(None) {
1007            if let Some(rp) = self.node_path(r) {
1008                let depth = rp.components().count();
1009                if path.starts_with(&rp) && best.is_none_or(|(_, d)| depth > d) {
1010                    best = Some((r, depth));
1011                }
1012            }
1013        }
1014        let Some((mut node, _)) = best else { return };
1015        let Some(root_path) = self.node_path(node) else {
1016            return;
1017        };
1018        let Ok(rest) = path.strip_prefix(&root_path) else {
1019            return;
1020        };
1021        let mut cur = root_path;
1022        for comp in rest.components() {
1023            self.tree_load(node);
1024            cur.push(comp);
1025            match t
1026                .children(Some(node))
1027                .into_iter()
1028                .find(|c| self.node_path(*c).as_deref() == Some(cur.as_path()))
1029            {
1030                Some(c) => node = c,
1031                None => break,
1032            }
1033        }
1034        self.tree_load(node); // set_selected expands its ancestors; the node itself must not show a placeholder
1035        t.set_selected(Some(node));
1036    }
1037
1038    fn on_tree_selected(self: &Rc<Self>, n: Option<TreeNodeId>) {
1039        let Some(path) = n.and_then(|n| self.node_path(n)) else {
1040            return;
1041        };
1042        let a = self.active();
1043        if path != self.path_of(a) {
1044            trace!("TREE {}", path.display());
1045            self.navigate(a, path, None, false, false);
1046        }
1047    }
1048
1049    // ---------------------------------------------------------------- operations
1050
1051    fn confirm(&self, title: &str, text: &str) -> bool {
1052        message_box(
1053            Some(self.ui.win),
1054            MessageKind::Question,
1055            Buttons::YesNo,
1056            title,
1057            text,
1058        ) == Answer::Yes
1059    }
1060
1061    /// Reload every pane showing `dir` (or all, if `dir` is None) and select `select` in the active one.
1062    fn refresh_after(self: &Rc<Self>, select: Option<PathBuf>) {
1063        let a = self.active();
1064        for i in 0..2 {
1065            let keep = if i == a { select.clone() } else { None };
1066            self.reload(i, keep);
1067        }
1068    }
1069
1070    fn op_new_folder(self: &Rc<Self>) {
1071        let a = self.active();
1072        let dir = self.path_of(a);
1073        self.dialog(
1074            "New Folder",
1075            "Name of the new folder:",
1076            "New Folder",
1077            move |fm, name| {
1078                let p = fsm::make_dir(&dir, name)?;
1079                trace!("MKDIR {}", p.display());
1080                fm.refresh_after(Some(p));
1081                fm.say(&format!("Created folder \"{name}\""));
1082                Ok(())
1083            },
1084        );
1085    }
1086
1087    fn op_rename(self: &Rc<Self>) {
1088        let Some(e) = self.target() else {
1089            self.say("Select an item to rename first");
1090            return;
1091        };
1092        let old = e
1093            .path
1094            .file_name()
1095            .map(|n| n.to_string_lossy().into_owned())
1096            .unwrap_or_default();
1097        let (prompt, initial) = (format!("New name for \"{old}\":"), old.clone());
1098        self.dialog("Rename", &prompt, &initial, move |fm, name| {
1099            let p = fsm::rename_path(&e.path, name)?;
1100            trace!("RENAME {} {}", e.name, name);
1101            fm.refresh_after(Some(p));
1102            fm.say(&format!("Renamed \"{old}\" to \"{name}\""));
1103            Ok(())
1104        });
1105    }
1106
1107    fn op_delete(self: &Rc<Self>) {
1108        let Some(e) = self.target() else {
1109            self.say("Select an item to delete first");
1110            return;
1111        };
1112        let what = if e.is_dir && !e.is_link {
1113            "folder and everything in it"
1114        } else {
1115            "item"
1116        };
1117        if !self.confirm(
1118            "Delete",
1119            &format!(
1120                "Delete the {what} \"{}\"?\n\nThis cannot be undone.",
1121                e.name
1122            ),
1123        ) {
1124            self.say("Delete cancelled");
1125            return;
1126        }
1127        match fsm::remove_path(&e.path) {
1128            Ok(()) => {
1129                trace!("DELETE {}", e.name);
1130                self.refresh_after(None);
1131                self.say(&format!("Deleted \"{}\"", e.name));
1132            }
1133            Err(err) => {
1134                trace!("ERROR DELETE {}", e.name);
1135                self.say(&format!("Cannot delete \"{}\": {err}", e.name));
1136            }
1137        }
1138    }
1139
1140    fn op_copy(self: &Rc<Self>) {
1141        self.transfer(false)
1142    }
1143
1144    fn op_move(self: &Rc<Self>) {
1145        self.transfer(true)
1146    }
1147
1148    fn transfer(self: &Rc<Self>, mv: bool) {
1149        let verb = if mv { "Move" } else { "Copy" };
1150        let Some(e) = self.target() else {
1151            self.say(&format!("Select an item to {} first", verb.to_lowercase()));
1152            return;
1153        };
1154        let a = self.active();
1155        let dst_dir = self.path_of(1 - a);
1156        let dest = match fsm::check_transfer(&e.path, &dst_dir) {
1157            Ok(d) => d,
1158            Err(err) => {
1159                self.say(&err);
1160                return;
1161            }
1162        };
1163        if std::fs::symlink_metadata(&dest).is_ok() {
1164            if !self.confirm(
1165                "Overwrite",
1166                &format!(
1167                    "\"{}\" already exists in {}.\n\nReplace it?",
1168                    e.name,
1169                    dst_dir.display()
1170                ),
1171            ) {
1172                self.say(&format!("{verb} cancelled"));
1173                return;
1174            }
1175            if let Err(err) = fsm::remove_path(&dest) {
1176                self.say(&format!("Cannot replace \"{}\": {err}", e.name));
1177                return;
1178            }
1179        }
1180        let r = if mv {
1181            fsm::move_into(&e.path, &dst_dir)
1182        } else {
1183            fsm::copy_into(&e.path, &dst_dir)
1184        };
1185        match r {
1186            Ok(new) => {
1187                trace!("{} {} {}", verb.to_uppercase(), e.name, dst_dir.display());
1188                // both panes re-read; the other pane shows the new item selected
1189                self.reload(a, None);
1190                self.reload(1 - a, Some(new));
1191                self.say(&format!(
1192                    "{} \"{}\" to {}",
1193                    if mv { "Moved" } else { "Copied" },
1194                    e.name,
1195                    dst_dir.display()
1196                ));
1197            }
1198            Err(err) => {
1199                trace!("ERROR {} {}", verb.to_uppercase(), e.name);
1200                self.say(&err);
1201            }
1202        }
1203    }
1204
1205    fn about(&self) {
1206        message_box(
1207            Some(self.ui.win),
1208            MessageKind::Info,
1209            Buttons::Ok,
1210            "About File Manager",
1211            "A dual-pane file manager written with rungui's public API only.\n\nF2 rename, F5 copy, F6 move, F7 new folder, F8 delete,\nF9 switch pane, Ctrl+H hidden files, Ctrl+R refresh.\nTimes are shown in UTC.",
1212        );
1213    }
1214
1215    // ---------------------------------------------------------------- the rename / new folder dialog
1216
1217    /// A small window with a text field and OK / Cancel (rungui has no input-dialog API).
1218    /// `action` returns an error message to keep the dialog open.
1219    fn dialog(
1220        self: &Rc<Self>,
1221        title: &str,
1222        prompt: &str,
1223        initial: &str,
1224        action: impl Fn(&Rc<Fm>, &str) -> std::result::Result<(), String> + 'static,
1225    ) {
1226        if let Some(old) = self.st.borrow_mut().dialog.take() {
1227            old.destroy();
1228        }
1229        let w = Window::new(title);
1230        w.set_size(380, 150);
1231        w.set_resizable(false);
1232        let col = VBox::new(w);
1233        col.set_spacing(8);
1234        Label::new(col, prompt);
1235        let input = TextInput::new(col);
1236        input.set_text(initial);
1237        input.set_a11y_name(title);
1238        let err = Label::new(col, "");
1239        let row = HBox::new(col);
1240        row.set_spacing(8);
1241        Spacer::new(row);
1242        let cancel = Button::new(row, "Cancel");
1243        let ok = Button::new(row, "OK");
1244        self.st.borrow_mut().dialog = Some(w);
1245        self.dialog_ui.set(Some((w, input, ok, cancel)));
1246        trace!("DIALOG open {title}");
1247        {
1248            let fm = self.clone();
1249            ok.on_click(move || {
1250                let text = input.text();
1251                match action(&fm, text.trim()) {
1252                    Ok(()) => {
1253                        trace!("DIALOG done");
1254                        fm.st.borrow_mut().dialog = None;
1255                        w.destroy();
1256                    }
1257                    Err(e) => {
1258                        trace!("DIALOG error {e}");
1259                        err.set_text(&e);
1260                    }
1261                }
1262            });
1263            let fm = self.clone();
1264            cancel.on_click(move || {
1265                trace!("DIALOG cancel");
1266                fm.st.borrow_mut().dialog = None;
1267                w.destroy();
1268            });
1269            let fm = self.clone();
1270            w.on_close(move || {
1271                fm.st.borrow_mut().dialog = None;
1272                true
1273            });
1274        }
1275        w.show();
1276        input.focus();
1277        if tracing() {
1278            Timer::once(300, move || {
1279                for (n, wd) in [
1280                    ("dlg_input", *input),
1281                    ("dlg_ok", *ok),
1282                    ("dlg_cancel", *cancel),
1283                ] {
1284                    let r = wd.bounds();
1285                    println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
1286                }
1287            });
1288        }
1289    }
More examples
Hide additional examples
examples/smoke_layout.rs (line 45)
6fn main() {
7    let app = App::new("smoke-layout").expect("init");
8    let w = Window::new("smoke-layout");
9    w.set_position(120, 90);
10    let col = VBox::new(w);
11    let mono = TextInput::new(col);
12    mono.set_monospace(true);
13    mono.set_text("monospace entry");
14    let hs = Splitter::new(col, Orientation::Horizontal);
15    hs.set_position(200);
16    hs.set_min_pane_sizes(60, 60);
17    let area = TextArea::new(hs);
18    area.set_monospace(true);
19    area.set_wrap(false);
20    area.set_text("a long line that does not wrap: 0123456789 0123456789 0123456789 0123456789\n");
21    let table = Table::new(hs);
22    table.set_columns(&[Column::new("Name").width(80), Column::new("Size")]);
23    table.set_rows(&[vec!["a", "1"], vec!["b", "2"]]);
24    let vs = Splitter::new(col, Orientation::Vertical);
25    let tree = Tree::new(vs);
26    let r = tree.add(None, "root");
27    tree.add(Some(r), "kid");
28    let list = ListBox::new(vs);
29    list.set_items(&["one", "two"]);
30    table.on_select(|i| println!("TABLE_SEL {i:?}"));
31    tree.on_select(|n| println!("TREE_SEL {}", n.is_some()));
32    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
33    hs.on_move(|p| println!("HSPLIT {p}"));
34    vs.on_move(|p| println!("VSPLIT {p}"));
35    w.on_move(|x, y| println!("MOVED {x} {y}"));
36    w.on_resize(|w, h| println!("RESIZED {w} {h}"));
37    w.on_close(|| {
38        App::quit();
39        true
40    });
41    w.show();
42    let _t = Timer::once(600, move || {
43        println!("POS {:?}", w.position());
44        for (n, b) in [
45            ("hs", hs.bounds()),
46            ("vs", vs.bounds()),
47            ("table", table.bounds()),
48            ("tree", tree.bounds()),
49            ("area", area.bounds()),
50        ] {
51            println!("BOUNDS {n} {} {} {} {}", b.x, b.y, b.w, b.h);
52        }
53        println!("HPOS {} VPOS {}", hs.position(), vs.position());
54        println!(
55            "MONO {} {} WRAP {}",
56            mono.monospace(),
57            area.monospace(),
58            area.wrap()
59        );
60        println!("READY");
61    });
62    app.run();
63    println!("BYE");
64}
examples/smoke_dialogs.rs (line 51)
5fn main() {
6    let app = App::new("smoke-dialogs").expect("init");
7    let win = Window::new("smoke-dialogs");
8    let col = VBox::new(win);
9    let field = TextInput::new(col);
10    field.on_activate(|| println!("ACTIVATE"));
11    let ask = Button::new(col, "Ask");
12    ask.on_click(move || {
13        let r = Prompt::new("Rename").message("New name?").initial("old").run(Some(win));
14        println!("PROMPT {r:?}");
15    });
16    let modal = Button::new(col, "Modal");
17    modal.on_click(move || {
18        let d = Window::new("smoke-modal");
19        Label::new(d, "modal window");
20        let close = Button::new(d, "Close");
21        close.on_click(move || d.hide());
22        d.on_cancel(move || {
23            println!("MODAL_CANCEL");
24            d.hide();
25        });
26        println!("MODAL_OPEN");
27        d.run_modal(Some(win));
28        println!("MODAL_DONE");
29        d.destroy();
30    });
31    let list = ListBox::new(col);
32    list.set_items(&["one", "two", "three", "four", "five"]);
33    list.set_multi_select(true);
34    list.on_selection(|s| println!("LIST_SEL {s:?}"));
35    let table = Table::new(col);
36    table.set_columns(&[Column::new("Name").width(100)]);
37    table.set_rows(&[vec!["a"], vec!["b"], vec!["c"], vec!["d"]]);
38    table.set_multi_select(true);
39    table.on_selection(|s| println!("TABLE_SEL {s:?}"));
40    let cal = Calendar::new(col);
41    cal.set_date(Date::new(2031, 7, 4).unwrap());
42    cal.on_change(|d| println!("DATE {}-{:02}-{:02}", d.year, d.month, d.day));
43    win.on_close(|| {
44        App::quit();
45        true
46    });
47    win.show();
48    println!("TODAY {:?}", Date::today().is_valid());
49    let _t = Timer::once(600, move || {
50        for (n, w) in [
51            ("field", field.bounds()),
52            ("ask", ask.bounds()),
53            ("modal", modal.bounds()),
54            ("list", list.bounds()),
55            ("table", table.bounds()),
56            ("cal", cal.bounds()),
57        ] {
58            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
59        }
60        println!("READY");
61    });
62    let _exit = std::env::var("RUNGUI_EXIT_AFTER_MS")
63        .ok()
64        .and_then(|v| v.parse::<u32>().ok())
65        .map(|ms| Timer::once(ms, App::quit));
66    app.run();
67    println!("BYE");
68}
examples/smoke_controls.rs (line 88)
5fn main() {
6    let app = App::new("smoke").expect("init");
7    let a = Window::new("smoke-a");
8    let col = VBox::new(a);
9    let btn = Button::new(col, "Press ünï");
10    let txt = TextInput::new(col);
11    let chk = CheckBox::new(col, "Check");
12    let list = ListBox::new(col);
13    list.set_items(&["one", "two", "three"]);
14    let slider = Slider::new(col, 0.0, 100.0);
15    let combo = ComboBox::new(col);
16    combo.set_items(&["x", "y"]);
17    let dlg = Button::new(col, "Dialog");
18    dlg.on_click(move || {
19        let r = message_box(
20            Some(a),
21            MessageKind::Question,
22            Buttons::YesNo,
23            "Title ü",
24            "Really?",
25        );
26        println!("DIALOG {r:?}");
27    });
28    let g = RadioGroup::new();
29    let ra = RadioButton::new(col, &g, "Ra");
30    let rb = RadioButton::new(col, &g, "Rb");
31    ra.set_checked(true);
32    ra.on_toggle(|v| println!("RA {v}"));
33    rb.on_toggle(|v| println!("RB {v}"));
34    let table = Table::new(col);
35    table.set_columns(&[
36        Column::new("Name").width(80).sortable(true),
37        Column::new("Size").align(ColumnAlign::Right),
38    ]);
39    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
40    table.on_select(|i| println!("TABLE_SEL {i:?}"));
41    table.on_column_click(|c| println!("TABLE_COL {c}"));
42    let tree = Tree::new(col);
43    let root = tree.add(None, "root");
44    let kid = tree.add(Some(root), "kid");
45    let lazy = tree.add(None, "lazy");
46    tree.set_has_children(lazy, true);
47    let _ = kid;
48    tree.on_select(|n| println!("TREE_SEL {}", n.is_some()));
49    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
50    a.set_context_menu({
51        let p = PopupMenu::new();
52        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
53        p
54    });
55    btn.on_click(|| println!("CLICK"));
56    txt.on_change(|t| println!("TEXT {t}"));
57    chk.on_toggle(|b| println!("TOGGLE {b}"));
58    list.on_select(|i| println!("SELECT {i:?}"));
59    slider.on_change(|v| println!("VALUE {v:.0}"));
60    combo.on_select(|i| println!("COMBO {i:?}"));
61    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
62    a.on_close(|| {
63        println!("CLOSE_REQUESTED");
64        true
65    });
66
67    let b = Window::new("smoke-b");
68    let bar = MenuBar::new(b);
69    let file = Menu::new(bar, "File");
70    let item = MenuItem::new(file, "Quit");
71    item.set_accel("Ctrl+Q");
72    item.on_click(|| {
73        println!("MENU_QUIT");
74        App::quit();
75    });
76    let ck = CheckMenuItem::new(file, "Flag");
77    ck.on_toggle(|v| println!("MENUTOGGLE {v}"));
78    Label::new(b, "second window");
79
80    a.show();
81    b.show();
82    println!(
83        "HANDLE {}",
84        a.native_handle().is_some() && btn.native_handle().is_some()
85    );
86    let _t = Timer::once(600, move || {
87        for (n, w) in [
88            ("btn", btn.bounds()),
89            ("txt", txt.bounds()),
90            ("chk", chk.bounds()),
91            ("list", list.bounds()),
92            ("slider", slider.bounds()),
93            ("combo", combo.bounds()),
94            ("dlg", dlg.bounds()),
95            ("rb", rb.bounds()),
96            ("table", table.bounds()),
97            ("tree", tree.bounds()),
98        ] {
99            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
100        }
101        println!("READY");
102    });
103    // CI: RUNGUI_EXIT_AFTER_MS=n quits the loop after n ms so a startup crash shows up as a failure.
104    let _exit = std::env::var("RUNGUI_EXIT_AFTER_MS")
105        .ok()
106        .and_then(|v| v.parse::<u32>().ok())
107        .map(|ms| Timer::once(ms, App::quit));
108    app.run();
109    println!("BYE");
110}
examples/smoke_cocoa.rs (line 115)
6fn main() {
7    let app = App::new("smoke-cocoa").expect("init");
8    let a = Window::new("cc-a");
9    let bar = MenuBar::new(a);
10    let file = Menu::new(bar, "File");
11    let flag = CheckMenuItem::new(file, "Flag");
12    flag.set_accel("Ctrl+K");
13    flag.on_toggle(|v| println!("MENUTOGGLE {v}"));
14    let go = MenuItem::new(file, "Go");
15    go.set_accel("Ctrl+Shift+G");
16    go.on_click(|| println!("MENU_GO"));
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(|| {
20        println!("MENU_QUIT");
21        App::quit();
22    });
23
24    let col = VBox::new(a);
25    let row = HBox::new(col);
26    let btn = Button::new(row, "Press ünï");
27    let spin = SpinBox::new(row, 0.0, 10.0, 1.0);
28    let txt = TextInput::new(col);
29    let chk = CheckBox::new(col, "Monospace");
30    let hs = Splitter::new(col, Orientation::Horizontal);
31    let ta1 = TextArea::new(hs);
32    let ta2 = TextArea::new(hs);
33    ta2.set_text(
34        "long line without wrapping: 0123456789 0123456789 0123456789 0123456789 0123456789",
35    );
36    ta2.set_wrap(false);
37    hs.set_position(200);
38    hs.set_min_pane_sizes(60, 60);
39    let slider = Slider::new(col, 0.0, 100.0);
40    let combo = ComboBox::new(col);
41    combo.set_items(&["x", "y", "z"]);
42    let tabs = Tabs::new(col);
43    let p1 = tabs.add_page("First");
44    let p2 = tabs.add_page("Second");
45    Label::new(p1, "page one");
46    Label::new(p2, "page two");
47    let vs = Splitter::new(col, Orientation::Vertical);
48    let table = Table::new(vs);
49    table.set_columns(&[
50        Column::new("Name").width(80).sortable(true),
51        Column::new("Size").align(ColumnAlign::Right),
52    ]);
53    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
54    let tree = Tree::new(vs);
55    let root = tree.add(None, "root");
56    tree.add(Some(root), "kid");
57    let lazy = tree.add(None, "lazy");
58    tree.set_has_children(lazy, true);
59    vs.set_position(100);
60    vs.set_min_pane_sizes(40, 40);
61
62    btn.on_click(|| println!("CLICK"));
63    spin.on_change(|v| println!("SPIN {v}"));
64    txt.on_change(|t| println!("TEXT {t}"));
65    ta1.on_change(|t| println!("AREA {}", t.replace('\n', "|")));
66    chk.on_toggle(move |on| {
67        println!("MONO {on}");
68        txt.set_monospace(on);
69        ta1.set_monospace(on);
70    });
71    hs.on_move(|p| println!("HSPLIT {p}"));
72    vs.on_move(|p| println!("VSPLIT {p}"));
73    slider.on_change(|v| println!("VALUE {v:.0}"));
74    combo.on_select(|i| println!("COMBO {i:?}"));
75    tabs.on_select(|i| println!("TAB {i:?}"));
76    table.on_select(|i| println!("TABLE_SEL {i:?}"));
77    table.on_column_click(move |c| {
78        let ascending = table.sort_indicator() != Some((c, true));
79        let mut rows = table.rows();
80        rows.sort_by(|x, y| x[c].cmp(&y[c]));
81        if !ascending {
82            rows.reverse();
83        }
84        table.set_rows(&rows);
85        table.set_sort_indicator(Some((c, ascending)));
86        println!(
87            "TABLE_COL {c} {} {}",
88            if ascending { "asc" } else { "desc" },
89            rows[0][0]
90        );
91    });
92    tree.on_select(move |n| println!("TREE_SEL {}", n.is_some()));
93    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
94    a.set_context_menu({
95        let p = PopupMenu::new();
96        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
97        p
98    });
99    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
100    a.on_move(|x, y| println!("MOVED {x} {y}"));
101    a.set_min_size(300, 400);
102    a.set_position(220, 100);
103    a.set_size(560, 700);
104    a.on_close(|| {
105        println!("CLOSE_REQUESTED");
106        true
107    });
108    a.show();
109    println!(
110        "HANDLE {}",
111        a.native_handle().is_some() && btn.native_handle().is_some()
112    );
113    let _t = Timer::once(700, move || {
114        for (n, w) in [
115            ("btn", btn.bounds()),
116            ("spin", spin.bounds()),
117            ("txt", txt.bounds()),
118            ("chk", chk.bounds()),
119            ("hs", hs.bounds()),
120            ("slider", slider.bounds()),
121            ("combo", combo.bounds()),
122            ("tabs", tabs.bounds()),
123            ("vs", vs.bounds()),
124            ("table", table.bounds()),
125            ("tree", tree.bounds()),
126        ] {
127            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
128        }
129        println!("SPLITPOS h {} v {}", hs.position(), vs.position());
130        println!("READY");
131    });
132    app.run();
133    println!("BYE");
134}
Source

pub fn set_a11y_name(&self, s: &str)

Accessible name override (otherwise derived from the widget text / preceding label).

Examples found in repository?
examples/file_manager/app.rs (line 214)
162pub fn build(opts: Options) -> Rc<Fm> {
163    let win = Window::new("File Manager");
164    win.set_size(1000, 700);
165    win.set_min_size(640, 420);
166
167    // ---- menus (accelerators are the keyboard interface; there is no key-event API)
168    let bar = MenuBar::new(win);
169    let file = Menu::new(bar, "File");
170    let new_folder = MenuItem::new(file, "New Folder");
171    new_folder.set_accel("F7");
172    let rename = MenuItem::new(file, "Rename");
173    rename.set_accel("F2");
174    MenuSeparator::new(file);
175    let copy = MenuItem::new(file, "Copy to Other Pane");
176    copy.set_accel("F5");
177    let mv = MenuItem::new(file, "Move to Other Pane");
178    mv.set_accel("F6");
179    let delete = MenuItem::new(file, "Delete");
180    delete.set_accel("F8");
181    MenuSeparator::new(file);
182    let quit = MenuItem::new(file, "Quit");
183    quit.set_accel("Ctrl+Q");
184    let view = Menu::new(bar, "View");
185    let hidden = CheckMenuItem::new(view, "Show Hidden Files");
186    hidden.set_accel("Ctrl+H");
187    let refresh_item = MenuItem::new(view, "Refresh");
188    refresh_item.set_accel("Ctrl+R");
189    let go = Menu::new(bar, "Go");
190    let up_item = MenuItem::new(go, "Up One Level");
191    up_item.set_accel("Alt+Up");
192    let home_item = MenuItem::new(go, "Home Folder");
193    home_item.set_accel("Alt+Home");
194    let switch = MenuItem::new(go, "Switch Active Pane");
195    switch.set_accel("F9");
196    let helpm = Menu::new(bar, "Help");
197    let about = MenuItem::new(helpm, "About");
198
199    // ---- layout
200    let root = VBox::new(win);
201    root.set_spacing(6);
202    root.set_expand(1.0); // a window stacks its children vertically; give the whole area to this one
203
204    let tools = HBox::new(root);
205    tools.set_spacing(6);
206    let up = Button::new(tools, "\u{2191} Up");
207    up.set_tooltip("Go to the parent folder (Alt+Up)");
208    let refresh = Button::new(tools, "Refresh");
209    refresh.set_tooltip("Reload both panes (Ctrl+R)");
210    let path = TextInput::new(tools);
211    path.set_expand(1.0);
212    path.set_monospace(true);
213    path.set_tooltip("Type a folder path to open it in the active pane");
214    path.set_a11y_name("Path of the active pane");
215    let copy_btn = Button::new(tools, "Copy \u{2192}");
216    copy_btn.set_tooltip("Copy the selected item to the other pane (F5)");
217    let move_btn = Button::new(tools, "Move \u{2192}");
218    move_btn.set_tooltip("Move the selected item to the other pane (F6)");
219
220    let body = Splitter::new(root, Orientation::Horizontal);
221    body.set_expand(1.0);
222    let tree = Tree::new(body);
223    tree.set_a11y_name("Folders");
224    let right = Splitter::new(body, Orientation::Vertical);
225    let panes = Splitter::new(right, Orientation::Horizontal);
226    let mut tables = Vec::new();
227    let mut pane_labels = Vec::new();
228    for (i, n) in PANE_NAMES.iter().enumerate() {
229        let col = VBox::new(panes);
230        col.set_spacing(2);
231        pane_labels.push(Label::new(col, ""));
232        let t = Table::new(col);
233        t.set_expand(1.0);
234        t.set_a11y_name(&format!("Files, pane {n}"));
235        t.set_columns(&[
236            Column::new("Name").width(125).sortable(true),
237            Column::new("Size")
238                .width(62)
239                .align(ColumnAlign::Right)
240                .sortable(true),
241            Column::new("Modified").width(128).sortable(true),
242            Column::new("Kind").width(90).sortable(true),
243        ]);
244        let _ = i;
245        tables.push(t);
246    }
247    let pv = VBox::new(right);
248    pv.set_spacing(2);
249    let preview_title = Label::new(pv, "Preview");
250    let pv_row = HBox::new(pv);
251    pv_row.set_expand(1.0);
252    let image = Image::new(pv_row);
253    image.set_visible(false);
254    image.set_align(Align::Start);
255    let preview = TextArea::new(pv_row);
256    preview.set_expand(1.0);
257    preview.set_read_only(true);
258    preview.set_monospace(true);
259    preview.set_wrap(false);
260    preview.set_a11y_name("Preview");
261
262    let sbar = HBox::new(root);
263    let status = Label::new(sbar, "");
264    status.set_expand(1.0);
265    let tag = Label::new(sbar, "");
266
267    body.set_position(170);
268    body.set_min_pane_sizes(100, 300);
269    right.set_position(400);
270    right.set_min_pane_sizes(120, 80);
271    panes.set_min_pane_sizes(180, 180);
272
273    // ---- context menu shared by both tables
274    let popup = PopupMenu::new();
275    let ctx_open = MenuItem::new(popup, "Open");
276    let ctx_rename = MenuItem::new(popup, "Rename...");
277    let ctx_delete = MenuItem::new(popup, "Delete...");
278    MenuSeparator::new(popup);
279    let ctx_copy = MenuItem::new(popup, "Copy to Other Pane");
280    let ctx_new = MenuItem::new(popup, "New Folder...");
281    for t in &tables {
282        t.set_context_menu(popup);
283    }
284
285    let ui = Ui {
286        win,
287        body,
288        right,
289        panes,
290        tree,
291        tables: [tables[0], tables[1]],
292        pane_labels: [pane_labels[0], pane_labels[1]],
293        path,
294        up,
295        refresh,
296        copy_btn,
297        move_btn,
298        preview_title,
299        preview,
300        image,
301        status,
302        tag,
303        popup,
304        items: Items {
305            new_folder,
306            rename,
307            copy,
308            mv,
309            delete,
310            quit,
311            hidden,
312            refresh: refresh_item,
313            up: up_item,
314            home: home_item,
315            switch,
316            about,
317            ctx_open,
318            ctx_rename,
319            ctx_delete,
320            ctx_copy,
321            ctx_new,
322        },
323    };
324    let fm = Rc::new(Fm {
325        ui,
326        st: RefCell::new(State::default()),
327        quiet: Cell::new(0),
328        typing: Cell::new(false),
329        dialog_ui: Cell::new(None),
330    });
331    fm.wire();
332    fm.init_tree();
333    {
334        let mut st = fm.st.borrow_mut();
335        for p in &opts.dirs {
336            st.panes.push(Pane {
337                path: p.clone(),
338                entries: vec![],
339                sort: (SortKey::Name, true),
340                mtime: None,
341                truncated: false,
342            });
343        }
344    }
345    for (i, p) in opts.dirs.iter().enumerate() {
346        if !fm.navigate(i, p.clone(), None, true, false) {
347            // an unreadable start directory falls back to the home folder, then to "/"
348            let fallback = home_dir().unwrap_or_else(|| PathBuf::from("/"));
349            fm.navigate(i, fallback, None, true, false);
350        }
351    }
352    fm.set_active(0);
353    let first = fm.path_of(0);
354    fm.tree_reveal(&first);
355    fm.ui.win.show();
356    fm
357}
358
359impl Fm {
360    fn wire(self: &Rc<Self>) {
361        let u = &self.ui;
362        let it = u.items;
363        macro_rules! click {
364            ($btn:expr, $f:ident) => {{
365                let fm = self.clone();
366                $btn.on_click(move || fm.$f());
367            }};
368        }
369        click!(it.new_folder, op_new_folder);
370        click!(it.ctx_new, op_new_folder);
371        click!(it.rename, op_rename);
372        click!(it.ctx_rename, op_rename);
373        click!(it.delete, op_delete);
374        click!(it.ctx_delete, op_delete);
375        click!(it.copy, op_copy);
376        click!(it.ctx_copy, op_copy);
377        click!(u.copy_btn, op_copy);
378        click!(it.mv, op_move);
379        click!(u.move_btn, op_move);
380        click!(it.ctx_open, op_open);
381        click!(it.refresh, refresh_all);
382        click!(u.refresh, refresh_all);
383        click!(it.up, go_up);
384        click!(u.up, go_up);
385        click!(it.home, go_home);
386        click!(it.switch, switch_pane);
387        click!(it.about, about);
388        it.quit.on_click(App::quit);
389        {
390            let fm = self.clone();
391            it.hidden.on_toggle(move |on| fm.set_show_hidden(on));
392        }
393        for i in 0..2 {
394            let t = u.tables[i];
395            let fm = self.clone();
396            t.on_select(move |r| fm.on_row_selected(i, r));
397            let fm = self.clone();
398            t.on_activate(move |r| fm.on_row_activated(i, r));
399            let fm = self.clone();
400            t.on_column_click(move |c| fm.sort_by_column(i, c));
401            let fm = self.clone();
402            t.on_context_menu(move |_, _| fm.prepare_context_menu(i));
403        }
404        {
405            let fm = self.clone();
406            u.path.on_change(move |text| fm.on_path_typed(text));
407        }
408        {
409            let fm = self.clone();
410            u.tree.on_select(move |n| fm.on_tree_selected(n));
411            let fm = self.clone();
412            u.tree.on_expand(move |n, open| {
413                if open {
414                    fm.tree_load(n);
415                }
416            });
417        }
418        {
419            let fm = self.clone();
420            u.win.on_resize(move |w, h| {
421                trace!("RESIZE {w} {h}");
422                fm.relabel_soon();
423            });
424            for sp in [u.body, u.right, u.panes] {
425                let fm = self.clone();
426                sp.on_move(move |_| fm.relabel_soon());
427            }
428        }
429        // pick up changes made by other programs
430        let fm = self.clone();
431        Timer::every(1500, move || fm.poll());
432        // report geometry once the first layout has happened
433        let fm = self.clone();
434        Timer::once(500, move || {
435            fm.print_bounds();
436            trace!("READY");
437        });
438    }
439
440    // ---------------------------------------------------------------- state helpers
441
442    pub fn path_of(&self, pane: usize) -> PathBuf {
443        self.st
444            .borrow()
445            .panes
446            .get(pane)
447            .map(|p| p.path.clone())
448            .unwrap_or_default()
449    }
450
451    pub fn active(&self) -> usize {
452        self.st.borrow().active
453    }
454
455    fn entry_at(&self, pane: usize, row: usize) -> Option<Entry> {
456        self.st.borrow().panes.get(pane)?.entries.get(row).cloned()
457    }
458
459    /// The selected entry of `pane`, or None (nothing selected). The ".." row counts.
460    pub fn selected(&self, pane: usize) -> Option<Entry> {
461        let row = self.ui.tables[pane].selected()?;
462        self.entry_at(pane, row)
463    }
464
465    /// The selected real item (not "..") of the active pane.
466    fn target(&self) -> Option<Entry> {
467        self.selected(self.active()).filter(|e| !e.is_parent)
468    }
469
470    pub fn say(&self, msg: &str) {
471        self.ui.status.set_text(msg);
472        trace!("STATUS {msg}");
473    }
474
475    fn quietly<R>(&self, f: impl FnOnce() -> R) -> R {
476        self.quiet.set(self.quiet.get() + 1);
477        let r = f();
478        self.quiet.set(self.quiet.get() - 1);
479        r
480    }
481
482    // ---------------------------------------------------------------- navigation
483
484    /// Show `path` in `pane`. `select` picks a row afterwards (e.g. the folder we came from).
485    /// `reveal` also selects the folder in the tree. Returns false (and says why) on failure.
486    pub fn navigate(
487        self: &Rc<Self>,
488        pane: usize,
489        path: PathBuf,
490        select: Option<PathBuf>,
491        reveal: bool,
492        from_box: bool,
493    ) -> bool {
494        let hidden = self.st.borrow().show_hidden;
495        let listing = match fsm::read_dir(&path, hidden) {
496            Ok(l) => l,
497            Err(e) => {
498                self.say(&format!("Cannot open {}: {}", path.display(), e));
499                trace!("ERROR NAV {} {}", PANE_NAMES[pane], path.display());
500                return false;
501            }
502        };
503        let n = listing.entries.len();
504        let truncated = listing.truncated;
505        {
506            let mut st = self.st.borrow_mut();
507            let Some(p) = st.panes.get_mut(pane) else {
508                return false;
509            };
510            let mut entries = listing.entries;
511            fsm::sort_entries(&mut entries, p.sort.0, p.sort.1);
512            if let Some(parent) = Entry::parent_of(&path) {
513                entries.insert(0, parent);
514            }
515            p.mtime = std::fs::metadata(&path).and_then(|m| m.modified()).ok();
516            p.entries = entries;
517            p.path = path.clone();
518            p.truncated = truncated;
519        }
520        self.populate(pane, select.as_deref());
521        self.typing.set(from_box);
522        self.set_active(pane);
523        self.refresh_labels();
524        self.typing.set(false);
525        if reveal {
526            self.tree_reveal(&path);
527        }
528        // select + preview the requested row, else preview the directory itself
529        let row = select.and_then(|s| {
530            self.st.borrow().panes[pane]
531                .entries
532                .iter()
533                .position(|e| e.path == s)
534        });
535        match row {
536            Some(r) => self.on_row_selected(pane, Some(r)),
537            None => {
538                self.show_preview(Entry::from_path(&path));
539                self.update_status();
540            }
541        }
542        trace!("NAV {} {} {}", PANE_NAMES[pane], path.display(), n);
543        if truncated {
544            self.say(&format!(
545                "Showing only the first {} entries of {}",
546                fsm::MAX_ENTRIES,
547                path.display()
548            ));
549        }
550        true
551    }
552
553    /// Re-read `pane`, keeping the selected item selected when it still exists.
554    fn reload(self: &Rc<Self>, pane: usize, keep: Option<PathBuf>) {
555        let path = self.path_of(pane);
556        let keep = keep.or_else(|| self.selected(pane).map(|e| e.path));
557        if self.navigate_quiet(pane, &path, keep.clone()) {
558            return;
559        }
560        // the directory vanished: climb to the nearest one that exists
561        let mut p = path.clone();
562        while let Some(parent) = p.parent().map(Path::to_path_buf) {
563            if parent.is_dir() && self.navigate(pane, parent.clone(), Some(p.clone()), true, false)
564            {
565                return;
566            }
567            p = parent;
568        }
569    }
570
571    /// Like `navigate` for the same directory but without the active-pane, tree and preview churn
572    /// unless the selection changed. Returns false if the directory cannot be read.
573    fn navigate_quiet(self: &Rc<Self>, pane: usize, path: &Path, keep: Option<PathBuf>) -> bool {
574        let hidden = self.st.borrow().show_hidden;
575        let Ok(listing) = fsm::read_dir(path, hidden) else {
576            return false;
577        };
578        {
579            let mut st = self.st.borrow_mut();
580            let p = &mut st.panes[pane];
581            let mut entries = listing.entries;
582            fsm::sort_entries(&mut entries, p.sort.0, p.sort.1);
583            if let Some(parent) = Entry::parent_of(path) {
584                entries.insert(0, parent);
585            }
586            p.mtime = std::fs::metadata(path).and_then(|m| m.modified()).ok();
587            p.entries = entries;
588            p.truncated = listing.truncated;
589        }
590        self.populate(pane, keep.as_deref());
591        if pane == self.active() {
592            let row = keep.and_then(|s| {
593                self.st.borrow().panes[pane]
594                    .entries
595                    .iter()
596                    .position(|e| e.path == s)
597            });
598            self.show_preview(
599                row.and_then(|r| self.entry_at(pane, r))
600                    .or_else(|| Entry::from_path(path)),
601            );
602        }
603        self.update_status();
604        true
605    }
606
607    #[allow(dead_code)] // used by tests/file_manager_mock.rs
608    /// Test helper: navigate without touching the tree.
609    pub fn navigate_for_test(self: &Rc<Self>, pane: usize, path: PathBuf) -> bool {
610        self.navigate(pane, path, None, false, false)
611    }
612
613    pub fn refresh_all(self: &Rc<Self>) {
614        for i in 0..2 {
615            self.reload(i, None);
616        }
617        self.say("Refreshed");
618        trace!("REFRESH");
619    }
620
621    /// Timer: reload panes whose directory changed on disk.
622    fn poll(self: &Rc<Self>) {
623        #[allow(clippy::needless_range_loop)]
624        for i in 0..2 {
625            let (path, old) = {
626                let st = self.st.borrow();
627                match st.panes.get(i) {
628                    Some(p) => (p.path.clone(), p.mtime),
629                    None => return,
630                }
631            };
632            let now = std::fs::metadata(&path).and_then(|m| m.modified()).ok();
633            if now != old {
634                trace!("CHANGED {}", PANE_NAMES[i]);
635                self.reload(i, None);
636            }
637        }
638    }
639
640    pub fn go_up(self: &Rc<Self>) {
641        let a = self.active();
642        let cur = self.path_of(a);
643        if let Some(parent) = cur.parent() {
644            self.navigate(a, parent.to_path_buf(), Some(cur.clone()), true, false);
645        }
646    }
647
648    fn go_home(self: &Rc<Self>) {
649        if let Some(h) = home_dir() {
650            let a = self.active();
651            self.navigate(a, h, None, true, false);
652        }
653    }
654
655    fn switch_pane(self: &Rc<Self>) {
656        let other = 1 - self.active();
657        self.set_active(other);
658        self.ui.tables[other].focus();
659    }
660
661    fn set_show_hidden(self: &Rc<Self>, on: bool) {
662        self.st.borrow_mut().show_hidden = on;
663        trace!("HIDDEN {on}");
664        for i in 0..2 {
665            self.reload(i, None);
666        }
667        // rebuild the folder tree so hidden folders appear or vanish too
668        self.init_tree();
669        let a = self.active();
670        let p = self.path_of(a);
671        self.tree_reveal(&p);
672    }
673
674    fn on_path_typed(self: &Rc<Self>, text: &str) {
675        if self.typing.get() {
676            return;
677        }
678        let a = self.active();
679        let t = text.trim();
680        if t.is_empty() || Path::new(t) == self.path_of(a) {
681            return;
682        }
683        let p = PathBuf::from(t);
684        if p.is_dir() {
685            self.navigate(a, p, None, true, true);
686        }
687    }
688
689    pub fn set_active(&self, pane: usize) {
690        let changed = {
691            let mut st = self.st.borrow_mut();
692            let c = st.active != pane;
693            st.active = pane;
694            c
695        };
696        self.refresh_labels();
697        if changed {
698            trace!("ACTIVE {}", PANE_NAMES[pane]);
699        }
700    }
701
702    /// The pane captions depend on the pane widths, which are known only after layout.
703    fn relabel_soon(self: &Rc<Self>) {
704        let fm = self.clone();
705        Timer::once(10, move || fm.refresh_labels());
706    }
707
708    /// Pane captions, path box, window title and the active-pane tag.
709    fn refresh_labels(&self) {
710        let (active, paths) = {
711            let st = self.st.borrow();
712            (
713                st.active,
714                st.panes.iter().map(|p| p.path.clone()).collect::<Vec<_>>(),
715            )
716        };
717        for (i, p) in paths.iter().enumerate() {
718            let mark = if i == active { "\u{25B6}" } else { " " };
719            // labels do not clip, so fit the path to the pane (about 7 px per character)
720            let room = (self.ui.tables[i].bounds().w / 7).max(12) as usize;
721            let head = format!("{mark} {}  ", PANE_NAMES[i]);
722            let path = fsm::ellipsize_path(
723                &p.display().to_string(),
724                room.saturating_sub(head.chars().count()),
725            );
726            self.ui.pane_labels[i].set_text(&format!("{head}{path}"));
727        }
728        let cur = paths.get(active).cloned().unwrap_or_default();
729        let text = cur.display().to_string();
730        if self.ui.path.text() != text && !self.typing.get() {
731            self.ui.path.set_text(&text);
732        }
733        let name = cur
734            .file_name()
735            .map(|n| n.to_string_lossy().into_owned())
736            .unwrap_or_else(|| text.clone());
737        self.ui
738            .win
739            .set_title(&format!("{name} [{}] - File Manager", PANE_NAMES[active]));
740        self.ui
741            .tag
742            .set_text(&format!("  Active pane: {}", PANE_NAMES[active]));
743        self.ui.up.set_enabled(cur.parent().is_some());
744    }
745
746    // ---------------------------------------------------------------- table
747
748    /// Fill a pane's table from its entries. Uses one `batch` so huge directories send one update.
749    fn populate(&self, pane: usize, select: Option<&Path>) {
750        let (rows, sort, sel) = {
751            let st = self.st.borrow();
752            let p = &st.panes[pane];
753            let rows: Vec<Vec<String>> = p.entries.iter().map(row_of).collect();
754            (
755                rows,
756                p.sort,
757                select.and_then(|s| p.entries.iter().position(|e| e.path == s)),
758            )
759        };
760        let t = self.ui.tables[pane];
761        self.quietly(|| {
762            t.batch(|t| t.set_rows(&rows));
763            t.set_sort_indicator(Some((sort.0.column(), sort.1)));
764            t.set_selected(sel);
765        });
766    }
767
768    fn sort_by_column(self: &Rc<Self>, pane: usize, col: usize) {
769        let key = SortKey::from_column(col);
770        let keep = self.selected(pane).map(|e| e.path);
771        {
772            let mut st = self.st.borrow_mut();
773            let Some(p) = st.panes.get_mut(pane) else {
774                return;
775            };
776            let asc = if p.sort.0 == key { !p.sort.1 } else { true };
777            p.sort = (key, asc);
778            let has_parent = p.entries.first().is_some_and(|e| e.is_parent);
779            fsm::sort_entries(&mut p.entries[has_parent as usize..], key, asc);
780        }
781        self.populate(pane, keep.as_deref());
782        let (k, asc) = self.st.borrow().panes[pane].sort;
783        trace!(
784            "SORT {} {} {}",
785            PANE_NAMES[pane],
786            k.column(),
787            if asc { "asc" } else { "desc" }
788        );
789    }
790
791    fn on_row_selected(self: &Rc<Self>, pane: usize, row: Option<usize>) {
792        if self.quiet.get() > 0 {
793            return;
794        }
795        self.set_active(pane);
796        let e = row.and_then(|r| self.entry_at(pane, r));
797        if let Some(e) = &e {
798            trace!("SELECT {} {}", PANE_NAMES[pane], e.name);
799        }
800        self.show_preview(e);
801        self.update_status();
802    }
803
804    fn on_row_activated(self: &Rc<Self>, pane: usize, row: usize) {
805        self.set_active(pane);
806        let Some(e) = self.entry_at(pane, row) else {
807            return;
808        };
809        self.open_entry(pane, e);
810    }
811
812    fn open_entry(self: &Rc<Self>, pane: usize, e: Entry) {
813        if e.is_dir {
814            let from = self.path_of(pane);
815            let select = e.is_parent.then_some(from);
816            self.navigate(pane, e.path, select, true, false);
817        } else {
818            trace!("OPEN {} {}", PANE_NAMES[pane], e.name);
819            self.show_preview(Some(e));
820        }
821    }
822
823    fn op_open(self: &Rc<Self>) {
824        if let Some(e) = self.selected(self.active()) {
825            self.open_entry(self.active(), e);
826        }
827    }
828
829    /// Runs just before the popup is shown: right-clicking a pane makes it the active one.
830    fn prepare_context_menu(&self, pane: usize) {
831        self.set_active(pane);
832        let sel = self.selected(pane);
833        let real = sel.as_ref().is_some_and(|e| !e.is_parent);
834        let it = self.ui.items;
835        it.ctx_open.set_enabled(sel.is_some());
836        it.ctx_rename.set_enabled(real);
837        it.ctx_delete.set_enabled(real);
838        it.ctx_copy.set_enabled(real);
839    }
840
841    // ---------------------------------------------------------------- preview and status
842
843    fn show_preview(&self, e: Option<Entry>) {
844        let u = &self.ui;
845        let Some(e) = e else {
846            u.preview_title.set_text("Preview");
847            u.preview.set_text("");
848            u.image.set_image(None);
849            u.image.set_visible(false);
850            return;
851        };
852        let p = fsm::preview(&e);
853        let (what, extra) = match &p {
854            Preview::Text { truncated, .. } => (
855                "text",
856                if *truncated {
857                    format!(" (first {} KB)", fsm::PREVIEW_LIMIT / 1024)
858                } else {
859                    String::new()
860                },
861            ),
862            Preview::Hex { .. } => (
863                "binary",
864                format!(" (hex dump of the first {} bytes)", fsm::HEX_LIMIT),
865            ),
866            Preview::Dir(_) => ("folder", String::new()),
867            Preview::Image { img, .. } => ("image", format!(" ({} x {})", img.w, img.h)),
868            Preview::Error(_) => ("error", String::new()),
869        };
870        u.preview_title.set_text(&format!(
871            "Preview: {}{extra}",
872            if e.is_parent { ".." } else { &e.name }
873        ));
874        u.preview.set_text(p.body());
875        match &p {
876            Preview::Image { img, .. } => {
877                u.image.set_image(Some(&scaled(img)));
878                u.image.set_visible(true);
879            }
880            _ => {
881                u.image.set_image(None);
882                u.image.set_visible(false);
883            }
884        }
885        trace!("PREVIEW {what} {} {}", p.shown_bytes(), e.name);
886    }
887
888    fn update_status(&self) {
889        let a = self.active();
890        let (n, dirs, total, trunc, sel) = {
891            let st = self.st.borrow();
892            let p = &st.panes[a];
893            let real: Vec<&Entry> = p.entries.iter().filter(|e| !e.is_parent).collect();
894            let dirs = real.iter().filter(|e| e.is_dir).count();
895            let total: u64 = real.iter().filter(|e| !e.is_dir).map(|e| e.size).sum();
896            (real.len(), dirs, total, p.truncated, p.entries.len())
897        };
898        let _ = sel;
899        let mut s = format!(
900            "{n} items ({dirs} folders, {} files), {} in files",
901            n - dirs,
902            fsm::human_size(total)
903        );
904        if trunc {
905            s.push_str(" (truncated)");
906        }
907        if let Some(e) = self.selected(a) {
908            s.push_str(&format!("   |   {}", fsm::describe(&e)));
909        }
910        self.ui.status.set_text(&s);
911        trace!("STATUS {s}");
912    }
913
914    fn print_bounds(&self) {
915        if !tracing() {
916            return;
917        }
918        let u = &self.ui;
919        let (b, ids): (Rect, Vec<(&str, Widget)>) = (
920            u.win.bounds(),
921            vec![
922                ("tree", *u.tree),
923                ("tableA", *u.tables[0]),
924                ("tableB", *u.tables[1]),
925                ("labelA", *u.pane_labels[0]),
926                ("labelB", *u.pane_labels[1]),
927                ("preview", *u.preview),
928                ("image", *u.image),
929                ("path", *u.path),
930                ("up", *u.up),
931                ("refresh", *u.refresh),
932                ("copy", *u.copy_btn),
933                ("move", *u.move_btn),
934                ("status", *u.status),
935                ("body", *u.body),
936                ("right", *u.right),
937                ("panes", *u.panes),
938            ],
939        );
940        let _ = b;
941        for (n, w) in ids {
942            let r = w.bounds();
943            println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
944        }
945    }
946
947    // ---------------------------------------------------------------- tree
948
949    fn init_tree(self: &Rc<Self>) {
950        let t = self.ui.tree;
951        t.clear();
952        let mut roots: Vec<(String, PathBuf)> = Vec::new();
953        if let Some(h) = home_dir() {
954            roots.push(("Home".into(), h));
955        }
956        #[cfg(windows)]
957        for d in b'A'..=b'Z' {
958            let p = PathBuf::from(format!("{}:\\", d as char));
959            if p.is_dir() {
960                roots.push((format!("{}:\\", d as char), p));
961            }
962        }
963        #[cfg(not(windows))]
964        roots.push(("File System (/)".into(), PathBuf::from("/")));
965        let mut st = self.st.borrow_mut();
966        st.node_paths.clear();
967        st.loaded.clear();
968        for (name, p) in roots {
969            let n = t.add(None, &name);
970            t.set_has_children(n, true);
971            st.node_paths.insert(n, p);
972        }
973    }
974
975    pub fn node_path(&self, n: TreeNodeId) -> Option<PathBuf> {
976        self.st.borrow().node_paths.get(&n).cloned()
977    }
978
979    /// Add the sub-folders of `node` the first time it is needed.
980    pub fn tree_load(&self, node: TreeNodeId) {
981        let Some(path) = self.node_path(node) else {
982            return;
983        };
984        if !self.st.borrow_mut().loaded.insert(node) {
985            return;
986        }
987        let hidden = self.st.borrow().show_hidden;
988        let dirs = fsm::subdirs(&path, hidden);
989        let t = self.ui.tree;
990        let mut new = Vec::new();
991        t.batch(|t| {
992            for d in &dirs {
993                let c = t.add(Some(node), &d.name);
994                t.set_has_children(c, true);
995                new.push((c, d.path.clone()));
996            }
997            t.set_has_children(node, !dirs.is_empty());
998        });
999        self.st.borrow_mut().node_paths.extend(new);
1000    }
1001
1002    /// Expand the tree down to `path` and select it (no callbacks fire).
1003    fn tree_reveal(&self, path: &Path) {
1004        let t = self.ui.tree;
1005        let mut best: Option<(TreeNodeId, usize)> = None;
1006        for r in t.children(None) {
1007            if let Some(rp) = self.node_path(r) {
1008                let depth = rp.components().count();
1009                if path.starts_with(&rp) && best.is_none_or(|(_, d)| depth > d) {
1010                    best = Some((r, depth));
1011                }
1012            }
1013        }
1014        let Some((mut node, _)) = best else { return };
1015        let Some(root_path) = self.node_path(node) else {
1016            return;
1017        };
1018        let Ok(rest) = path.strip_prefix(&root_path) else {
1019            return;
1020        };
1021        let mut cur = root_path;
1022        for comp in rest.components() {
1023            self.tree_load(node);
1024            cur.push(comp);
1025            match t
1026                .children(Some(node))
1027                .into_iter()
1028                .find(|c| self.node_path(*c).as_deref() == Some(cur.as_path()))
1029            {
1030                Some(c) => node = c,
1031                None => break,
1032            }
1033        }
1034        self.tree_load(node); // set_selected expands its ancestors; the node itself must not show a placeholder
1035        t.set_selected(Some(node));
1036    }
1037
1038    fn on_tree_selected(self: &Rc<Self>, n: Option<TreeNodeId>) {
1039        let Some(path) = n.and_then(|n| self.node_path(n)) else {
1040            return;
1041        };
1042        let a = self.active();
1043        if path != self.path_of(a) {
1044            trace!("TREE {}", path.display());
1045            self.navigate(a, path, None, false, false);
1046        }
1047    }
1048
1049    // ---------------------------------------------------------------- operations
1050
1051    fn confirm(&self, title: &str, text: &str) -> bool {
1052        message_box(
1053            Some(self.ui.win),
1054            MessageKind::Question,
1055            Buttons::YesNo,
1056            title,
1057            text,
1058        ) == Answer::Yes
1059    }
1060
1061    /// Reload every pane showing `dir` (or all, if `dir` is None) and select `select` in the active one.
1062    fn refresh_after(self: &Rc<Self>, select: Option<PathBuf>) {
1063        let a = self.active();
1064        for i in 0..2 {
1065            let keep = if i == a { select.clone() } else { None };
1066            self.reload(i, keep);
1067        }
1068    }
1069
1070    fn op_new_folder(self: &Rc<Self>) {
1071        let a = self.active();
1072        let dir = self.path_of(a);
1073        self.dialog(
1074            "New Folder",
1075            "Name of the new folder:",
1076            "New Folder",
1077            move |fm, name| {
1078                let p = fsm::make_dir(&dir, name)?;
1079                trace!("MKDIR {}", p.display());
1080                fm.refresh_after(Some(p));
1081                fm.say(&format!("Created folder \"{name}\""));
1082                Ok(())
1083            },
1084        );
1085    }
1086
1087    fn op_rename(self: &Rc<Self>) {
1088        let Some(e) = self.target() else {
1089            self.say("Select an item to rename first");
1090            return;
1091        };
1092        let old = e
1093            .path
1094            .file_name()
1095            .map(|n| n.to_string_lossy().into_owned())
1096            .unwrap_or_default();
1097        let (prompt, initial) = (format!("New name for \"{old}\":"), old.clone());
1098        self.dialog("Rename", &prompt, &initial, move |fm, name| {
1099            let p = fsm::rename_path(&e.path, name)?;
1100            trace!("RENAME {} {}", e.name, name);
1101            fm.refresh_after(Some(p));
1102            fm.say(&format!("Renamed \"{old}\" to \"{name}\""));
1103            Ok(())
1104        });
1105    }
1106
1107    fn op_delete(self: &Rc<Self>) {
1108        let Some(e) = self.target() else {
1109            self.say("Select an item to delete first");
1110            return;
1111        };
1112        let what = if e.is_dir && !e.is_link {
1113            "folder and everything in it"
1114        } else {
1115            "item"
1116        };
1117        if !self.confirm(
1118            "Delete",
1119            &format!(
1120                "Delete the {what} \"{}\"?\n\nThis cannot be undone.",
1121                e.name
1122            ),
1123        ) {
1124            self.say("Delete cancelled");
1125            return;
1126        }
1127        match fsm::remove_path(&e.path) {
1128            Ok(()) => {
1129                trace!("DELETE {}", e.name);
1130                self.refresh_after(None);
1131                self.say(&format!("Deleted \"{}\"", e.name));
1132            }
1133            Err(err) => {
1134                trace!("ERROR DELETE {}", e.name);
1135                self.say(&format!("Cannot delete \"{}\": {err}", e.name));
1136            }
1137        }
1138    }
1139
1140    fn op_copy(self: &Rc<Self>) {
1141        self.transfer(false)
1142    }
1143
1144    fn op_move(self: &Rc<Self>) {
1145        self.transfer(true)
1146    }
1147
1148    fn transfer(self: &Rc<Self>, mv: bool) {
1149        let verb = if mv { "Move" } else { "Copy" };
1150        let Some(e) = self.target() else {
1151            self.say(&format!("Select an item to {} first", verb.to_lowercase()));
1152            return;
1153        };
1154        let a = self.active();
1155        let dst_dir = self.path_of(1 - a);
1156        let dest = match fsm::check_transfer(&e.path, &dst_dir) {
1157            Ok(d) => d,
1158            Err(err) => {
1159                self.say(&err);
1160                return;
1161            }
1162        };
1163        if std::fs::symlink_metadata(&dest).is_ok() {
1164            if !self.confirm(
1165                "Overwrite",
1166                &format!(
1167                    "\"{}\" already exists in {}.\n\nReplace it?",
1168                    e.name,
1169                    dst_dir.display()
1170                ),
1171            ) {
1172                self.say(&format!("{verb} cancelled"));
1173                return;
1174            }
1175            if let Err(err) = fsm::remove_path(&dest) {
1176                self.say(&format!("Cannot replace \"{}\": {err}", e.name));
1177                return;
1178            }
1179        }
1180        let r = if mv {
1181            fsm::move_into(&e.path, &dst_dir)
1182        } else {
1183            fsm::copy_into(&e.path, &dst_dir)
1184        };
1185        match r {
1186            Ok(new) => {
1187                trace!("{} {} {}", verb.to_uppercase(), e.name, dst_dir.display());
1188                // both panes re-read; the other pane shows the new item selected
1189                self.reload(a, None);
1190                self.reload(1 - a, Some(new));
1191                self.say(&format!(
1192                    "{} \"{}\" to {}",
1193                    if mv { "Moved" } else { "Copied" },
1194                    e.name,
1195                    dst_dir.display()
1196                ));
1197            }
1198            Err(err) => {
1199                trace!("ERROR {} {}", verb.to_uppercase(), e.name);
1200                self.say(&err);
1201            }
1202        }
1203    }
1204
1205    fn about(&self) {
1206        message_box(
1207            Some(self.ui.win),
1208            MessageKind::Info,
1209            Buttons::Ok,
1210            "About File Manager",
1211            "A dual-pane file manager written with rungui's public API only.\n\nF2 rename, F5 copy, F6 move, F7 new folder, F8 delete,\nF9 switch pane, Ctrl+H hidden files, Ctrl+R refresh.\nTimes are shown in UTC.",
1212        );
1213    }
1214
1215    // ---------------------------------------------------------------- the rename / new folder dialog
1216
1217    /// A small window with a text field and OK / Cancel (rungui has no input-dialog API).
1218    /// `action` returns an error message to keep the dialog open.
1219    fn dialog(
1220        self: &Rc<Self>,
1221        title: &str,
1222        prompt: &str,
1223        initial: &str,
1224        action: impl Fn(&Rc<Fm>, &str) -> std::result::Result<(), String> + 'static,
1225    ) {
1226        if let Some(old) = self.st.borrow_mut().dialog.take() {
1227            old.destroy();
1228        }
1229        let w = Window::new(title);
1230        w.set_size(380, 150);
1231        w.set_resizable(false);
1232        let col = VBox::new(w);
1233        col.set_spacing(8);
1234        Label::new(col, prompt);
1235        let input = TextInput::new(col);
1236        input.set_text(initial);
1237        input.set_a11y_name(title);
1238        let err = Label::new(col, "");
1239        let row = HBox::new(col);
1240        row.set_spacing(8);
1241        Spacer::new(row);
1242        let cancel = Button::new(row, "Cancel");
1243        let ok = Button::new(row, "OK");
1244        self.st.borrow_mut().dialog = Some(w);
1245        self.dialog_ui.set(Some((w, input, ok, cancel)));
1246        trace!("DIALOG open {title}");
1247        {
1248            let fm = self.clone();
1249            ok.on_click(move || {
1250                let text = input.text();
1251                match action(&fm, text.trim()) {
1252                    Ok(()) => {
1253                        trace!("DIALOG done");
1254                        fm.st.borrow_mut().dialog = None;
1255                        w.destroy();
1256                    }
1257                    Err(e) => {
1258                        trace!("DIALOG error {e}");
1259                        err.set_text(&e);
1260                    }
1261                }
1262            });
1263            let fm = self.clone();
1264            cancel.on_click(move || {
1265                trace!("DIALOG cancel");
1266                fm.st.borrow_mut().dialog = None;
1267                w.destroy();
1268            });
1269            let fm = self.clone();
1270            w.on_close(move || {
1271                fm.st.borrow_mut().dialog = None;
1272                true
1273            });
1274        }
1275        w.show();
1276        input.focus();
1277        if tracing() {
1278            Timer::once(300, move || {
1279                for (n, wd) in [
1280                    ("dlg_input", *input),
1281                    ("dlg_ok", *ok),
1282                    ("dlg_cancel", *cancel),
1283                ] {
1284                    let r = wd.bounds();
1285                    println!("BOUNDS {n} {} {} {} {}", r.x, r.y, r.w, r.h);
1286                }
1287            });
1288        }
1289    }
Source

pub fn set_a11y_description(&self, s: &str)

Override the accessible description (otherwise the tooltip).

Examples found in repository?
examples/kitchen_sink.rs (line 189)
4fn main() {
5    let app = App::new("kitchen-sink").expect("init");
6    let win = Window::new("rungui kitchen sink");
7
8    // Menus
9    let bar = MenuBar::new(win);
10    let file = Menu::new(bar, "File");
11    let open = MenuItem::new(file, "Open...");
12    open.set_accel("Ctrl+O");
13    let wrap = CheckMenuItem::new(file, "Word wrap");
14    wrap.set_checked(true);
15    let mono = CheckMenuItem::new(file, "Monospace notes");
16    MenuSeparator::new(file);
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(App::quit);
20
21    let root = VBox::new(win);
22    let status = Label::new(root, "Ready");
23    let tabs = Tabs::new(root);
24    tabs.set_expand(1.0);
25
26    // Page 1: form in a grid
27    let form = tabs.add_page("Form");
28    let grid = Grid::new(form, 2);
29    Label::new(grid, "Name");
30    let name = TextInput::new(grid);
31    name.set_expand(1.0);
32    Label::new(grid, "Password");
33    TextInput::password(grid);
34    Label::new(grid, "Colour");
35    let combo = ComboBox::new(grid);
36    combo.set_items(&["Red", "Green", "Blue"]);
37    combo.set_selected(Some(0));
38    Label::new(grid, "Count");
39    let spin = SpinBox::new(grid, 0.0, 10.0, 1.0);
40    Label::new(grid, "Level");
41    let slider = Slider::new(grid, 0.0, 100.0);
42    let progress = ProgressBar::new(form);
43    slider.on_change(move |v| progress.set_fraction(v / 100.0));
44    spin.on_change(move |v| status.set_text(&format!("count = {v}")));
45    combo.on_select(move |i| status.set_text(&format!("colour index {i:?}")));
46
47    // Page 2: choices
48    let choices = tabs.add_page("Choices");
49    let boxed = GroupBox::new(choices, "Options");
50    let group = RadioGroup::new();
51    let a = RadioButton::new(boxed, &group, "Option A");
52    RadioButton::new(boxed, &group, "Option B");
53    a.set_checked(true);
54    let check = CheckBox::new(boxed, "Enabled");
55    check.set_checked(true);
56    let list = ListBox::new(choices);
57    list.set_items(&["alpha", "beta", "gamma", "delta"]);
58    list.set_expand(1.0);
59    list.on_activate(move |i| status.set_text(&format!("activated {i}")));
60
61    // Page 3: text; a vertical splitter with notes on top and a fixed-pitch, unwrapped view below
62    let notes = tabs.add_page("Notes");
63    let vsplit = Splitter::new(notes, Orientation::Vertical);
64    let area = TextArea::new(vsplit);
65    let code = TextArea::new(vsplit);
66    code.set_monospace(true);
67    code.set_wrap(false);
68    code.set_read_only(true);
69    code.set_text(
70        "fn main() {\n    println!(\"a long line that does not wrap: {}\", \"-\".repeat(60));\n}\n",
71    );
72    vsplit.set_position(120);
73    vsplit.set_min_pane_sizes(40, 40);
74    vsplit.on_move(move |p| status.set_text(&format!("notes split at {p}px")));
75    wrap.on_toggle(move |on| area.set_wrap(on));
76    mono.on_toggle(move |on| area.set_monospace(on));
77
78    // Page 4: table, tree and a context menu
79    let data = tabs.add_page("Data");
80    let split = Splitter::new(data, Orientation::Horizontal);
81    split.on_move(move |p| status.set_text(&format!("data split at {p}px")));
82    let table = Table::new(split);
83    table.set_columns(&[
84        Column::new("Name").width(140).sortable(true),
85        Column::new("Size")
86            .width(70)
87            .align(ColumnAlign::Right)
88            .sortable(true),
89    ]);
90    table.set_rows(&[
91        vec!["kernel", "9120"],
92        vec!["README", "312"],
93        vec!["Cargo.toml", "1024"],
94    ]);
95    table.on_select(move |r| status.set_text(&format!("row {r:?}")));
96    table.on_activate(move |r| status.set_text(&format!("row {r} activated")));
97    table.on_column_click(move |c| {
98        // sorting is the app's job: reorder the rows, then show the arrow
99        let ascending = table.sort_indicator() != Some((c, true));
100        let mut rows = table.rows();
101        rows.sort_by(|a, b| match c {
102            1 => a[1]
103                .parse::<u64>()
104                .unwrap_or(0)
105                .cmp(&b[1].parse::<u64>().unwrap_or(0)),
106            _ => a[c].cmp(&b[c]),
107        });
108        if !ascending {
109            rows.reverse();
110        }
111        table.set_rows(&rows);
112        table.set_sort_indicator(Some((c, ascending)));
113    });
114
115    let tree = Tree::new(split);
116    let src = tree.add(None, "src");
117    tree.add(Some(src), "lib.rs");
118    tree.add(Some(src), "core.rs");
119    let docs = tree.add(None, "doc");
120    tree.set_has_children(docs, true); // lazily filled when first expanded
121    tree.set_expanded(src, true);
122    tree.on_select(move |n| status.set_text(&format!("node {:?}", n.map(|n| tree.text(n)))));
123    tree.on_expand(move |n, open| {
124        if open && tree.children(Some(n)).is_empty() {
125            tree.add(Some(n), "DESIGN.md");
126            tree.add(Some(n), "BUILDING.md");
127        }
128    });
129
130    // Page 5: a calendar, a multi-select list and a prompt
131    let dates = tabs.add_page("Dates");
132    let cal = Calendar::new(dates);
133    cal.on_change(move |d| status.set_text(&format!("{}-{:02}-{:02}", d.year, d.month, d.day)));
134    let many = ListBox::new(dates);
135    many.set_items(&["one", "two", "three", "four"]);
136    many.set_multi_select(true);
137    many.set_expand(1.0);
138    many.on_selection(move |rows| status.set_text(&format!("selected {rows:?}")));
139    let ask = Button::new(dates, "Ask...");
140    ask.on_click(move || {
141        let r = prompt(Some(win), "Name", "What is your name?", "");
142        status.set_text(&format!("name: {r:?}"));
143    });
144
145    // Right-click the table for a context menu; its items are rebuilt/enabled just before display.
146    let popup = PopupMenu::new();
147    let del = MenuItem::new(popup, "Delete row");
148    MenuSeparator::new(popup);
149    let hdr = CheckMenuItem::new(popup, "Show sizes");
150    hdr.set_checked(true);
151    table.set_context_menu(popup);
152    table.on_context_menu(move |_, _| del.set_enabled(table.selected().is_some()));
153    del.on_click(move || {
154        if let Some(r) = table.selected() {
155            table.remove_row(r);
156        }
157    });
158    hdr.on_toggle(move |on| status.set_text(&format!("show sizes: {on}")));
159    tree.set_context_menu(popup);
160
161    open.on_click(move || {
162        if let Some(p) = FileDialog::new()
163            .title("Open")
164            .filter("Text", &["txt", "md"])
165            .open(Some(win))
166        {
167            if let Ok(s) = std::fs::read_to_string(&p) {
168                area.set_text(&s);
169            }
170            status.set_text(&format!("opened {}", p.display()));
171        }
172    });
173
174    // Buttons row
175    let row = HBox::new(root);
176    Spacer::new(row);
177    let about = Button::new(row, "About");
178    about.on_click(move || {
179        message_box(
180            Some(win),
181            MessageKind::Info,
182            Buttons::Ok,
183            "About",
184            "rungui kitchen sink",
185        );
186    });
187    let ok = Button::new(row, "Close");
188    ok.on_click(move || win.close());
189    ok.set_a11y_description("Closes the window");
190
191    let n = std::cell::Cell::new(0);
192    Timer::every(1000, move || {
193        n.set(n.get() + 1);
194        status.set_text(&format!("uptime {}s", n.get()));
195    });
196
197    win.set_size(480, 400);
198    win.show();
199    app.run();
200}
Source

pub fn set_a11y_role(&self, r: A11yRole)

Override the accessible role (otherwise the kind’s default).

Source

pub fn a11y(&self) -> A11yProps

The accessibility overrides set on the widget.

Source

pub fn set_context_menu(&self, popup: impl Into<WidgetId>)

Attach a PopupMenu shown on right-click / Menu key / Shift+F10 (children without their own menu inherit it). Works on any widget and on windows.

Examples found in repository?
examples/smoke_controls.rs (lines 50-54)
5fn main() {
6    let app = App::new("smoke").expect("init");
7    let a = Window::new("smoke-a");
8    let col = VBox::new(a);
9    let btn = Button::new(col, "Press ünï");
10    let txt = TextInput::new(col);
11    let chk = CheckBox::new(col, "Check");
12    let list = ListBox::new(col);
13    list.set_items(&["one", "two", "three"]);
14    let slider = Slider::new(col, 0.0, 100.0);
15    let combo = ComboBox::new(col);
16    combo.set_items(&["x", "y"]);
17    let dlg = Button::new(col, "Dialog");
18    dlg.on_click(move || {
19        let r = message_box(
20            Some(a),
21            MessageKind::Question,
22            Buttons::YesNo,
23            "Title ü",
24            "Really?",
25        );
26        println!("DIALOG {r:?}");
27    });
28    let g = RadioGroup::new();
29    let ra = RadioButton::new(col, &g, "Ra");
30    let rb = RadioButton::new(col, &g, "Rb");
31    ra.set_checked(true);
32    ra.on_toggle(|v| println!("RA {v}"));
33    rb.on_toggle(|v| println!("RB {v}"));
34    let table = Table::new(col);
35    table.set_columns(&[
36        Column::new("Name").width(80).sortable(true),
37        Column::new("Size").align(ColumnAlign::Right),
38    ]);
39    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
40    table.on_select(|i| println!("TABLE_SEL {i:?}"));
41    table.on_column_click(|c| println!("TABLE_COL {c}"));
42    let tree = Tree::new(col);
43    let root = tree.add(None, "root");
44    let kid = tree.add(Some(root), "kid");
45    let lazy = tree.add(None, "lazy");
46    tree.set_has_children(lazy, true);
47    let _ = kid;
48    tree.on_select(|n| println!("TREE_SEL {}", n.is_some()));
49    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
50    a.set_context_menu({
51        let p = PopupMenu::new();
52        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
53        p
54    });
55    btn.on_click(|| println!("CLICK"));
56    txt.on_change(|t| println!("TEXT {t}"));
57    chk.on_toggle(|b| println!("TOGGLE {b}"));
58    list.on_select(|i| println!("SELECT {i:?}"));
59    slider.on_change(|v| println!("VALUE {v:.0}"));
60    combo.on_select(|i| println!("COMBO {i:?}"));
61    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
62    a.on_close(|| {
63        println!("CLOSE_REQUESTED");
64        true
65    });
66
67    let b = Window::new("smoke-b");
68    let bar = MenuBar::new(b);
69    let file = Menu::new(bar, "File");
70    let item = MenuItem::new(file, "Quit");
71    item.set_accel("Ctrl+Q");
72    item.on_click(|| {
73        println!("MENU_QUIT");
74        App::quit();
75    });
76    let ck = CheckMenuItem::new(file, "Flag");
77    ck.on_toggle(|v| println!("MENUTOGGLE {v}"));
78    Label::new(b, "second window");
79
80    a.show();
81    b.show();
82    println!(
83        "HANDLE {}",
84        a.native_handle().is_some() && btn.native_handle().is_some()
85    );
86    let _t = Timer::once(600, move || {
87        for (n, w) in [
88            ("btn", btn.bounds()),
89            ("txt", txt.bounds()),
90            ("chk", chk.bounds()),
91            ("list", list.bounds()),
92            ("slider", slider.bounds()),
93            ("combo", combo.bounds()),
94            ("dlg", dlg.bounds()),
95            ("rb", rb.bounds()),
96            ("table", table.bounds()),
97            ("tree", tree.bounds()),
98        ] {
99            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
100        }
101        println!("READY");
102    });
103    // CI: RUNGUI_EXIT_AFTER_MS=n quits the loop after n ms so a startup crash shows up as a failure.
104    let _exit = std::env::var("RUNGUI_EXIT_AFTER_MS")
105        .ok()
106        .and_then(|v| v.parse::<u32>().ok())
107        .map(|ms| Timer::once(ms, App::quit));
108    app.run();
109    println!("BYE");
110}
More examples
Hide additional examples
examples/smoke_cocoa.rs (lines 94-98)
6fn main() {
7    let app = App::new("smoke-cocoa").expect("init");
8    let a = Window::new("cc-a");
9    let bar = MenuBar::new(a);
10    let file = Menu::new(bar, "File");
11    let flag = CheckMenuItem::new(file, "Flag");
12    flag.set_accel("Ctrl+K");
13    flag.on_toggle(|v| println!("MENUTOGGLE {v}"));
14    let go = MenuItem::new(file, "Go");
15    go.set_accel("Ctrl+Shift+G");
16    go.on_click(|| println!("MENU_GO"));
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(|| {
20        println!("MENU_QUIT");
21        App::quit();
22    });
23
24    let col = VBox::new(a);
25    let row = HBox::new(col);
26    let btn = Button::new(row, "Press ünï");
27    let spin = SpinBox::new(row, 0.0, 10.0, 1.0);
28    let txt = TextInput::new(col);
29    let chk = CheckBox::new(col, "Monospace");
30    let hs = Splitter::new(col, Orientation::Horizontal);
31    let ta1 = TextArea::new(hs);
32    let ta2 = TextArea::new(hs);
33    ta2.set_text(
34        "long line without wrapping: 0123456789 0123456789 0123456789 0123456789 0123456789",
35    );
36    ta2.set_wrap(false);
37    hs.set_position(200);
38    hs.set_min_pane_sizes(60, 60);
39    let slider = Slider::new(col, 0.0, 100.0);
40    let combo = ComboBox::new(col);
41    combo.set_items(&["x", "y", "z"]);
42    let tabs = Tabs::new(col);
43    let p1 = tabs.add_page("First");
44    let p2 = tabs.add_page("Second");
45    Label::new(p1, "page one");
46    Label::new(p2, "page two");
47    let vs = Splitter::new(col, Orientation::Vertical);
48    let table = Table::new(vs);
49    table.set_columns(&[
50        Column::new("Name").width(80).sortable(true),
51        Column::new("Size").align(ColumnAlign::Right),
52    ]);
53    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
54    let tree = Tree::new(vs);
55    let root = tree.add(None, "root");
56    tree.add(Some(root), "kid");
57    let lazy = tree.add(None, "lazy");
58    tree.set_has_children(lazy, true);
59    vs.set_position(100);
60    vs.set_min_pane_sizes(40, 40);
61
62    btn.on_click(|| println!("CLICK"));
63    spin.on_change(|v| println!("SPIN {v}"));
64    txt.on_change(|t| println!("TEXT {t}"));
65    ta1.on_change(|t| println!("AREA {}", t.replace('\n', "|")));
66    chk.on_toggle(move |on| {
67        println!("MONO {on}");
68        txt.set_monospace(on);
69        ta1.set_monospace(on);
70    });
71    hs.on_move(|p| println!("HSPLIT {p}"));
72    vs.on_move(|p| println!("VSPLIT {p}"));
73    slider.on_change(|v| println!("VALUE {v:.0}"));
74    combo.on_select(|i| println!("COMBO {i:?}"));
75    tabs.on_select(|i| println!("TAB {i:?}"));
76    table.on_select(|i| println!("TABLE_SEL {i:?}"));
77    table.on_column_click(move |c| {
78        let ascending = table.sort_indicator() != Some((c, true));
79        let mut rows = table.rows();
80        rows.sort_by(|x, y| x[c].cmp(&y[c]));
81        if !ascending {
82            rows.reverse();
83        }
84        table.set_rows(&rows);
85        table.set_sort_indicator(Some((c, ascending)));
86        println!(
87            "TABLE_COL {c} {} {}",
88            if ascending { "asc" } else { "desc" },
89            rows[0][0]
90        );
91    });
92    tree.on_select(move |n| println!("TREE_SEL {}", n.is_some()));
93    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
94    a.set_context_menu({
95        let p = PopupMenu::new();
96        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
97        p
98    });
99    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
100    a.on_move(|x, y| println!("MOVED {x} {y}"));
101    a.set_min_size(300, 400);
102    a.set_position(220, 100);
103    a.set_size(560, 700);
104    a.on_close(|| {
105        println!("CLOSE_REQUESTED");
106        true
107    });
108    a.show();
109    println!(
110        "HANDLE {}",
111        a.native_handle().is_some() && btn.native_handle().is_some()
112    );
113    let _t = Timer::once(700, move || {
114        for (n, w) in [
115            ("btn", btn.bounds()),
116            ("spin", spin.bounds()),
117            ("txt", txt.bounds()),
118            ("chk", chk.bounds()),
119            ("hs", hs.bounds()),
120            ("slider", slider.bounds()),
121            ("combo", combo.bounds()),
122            ("tabs", tabs.bounds()),
123            ("vs", vs.bounds()),
124            ("table", table.bounds()),
125            ("tree", tree.bounds()),
126        ] {
127            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
128        }
129        println!("SPLITPOS h {} v {}", hs.position(), vs.position());
130        println!("READY");
131    });
132    app.run();
133    println!("BYE");
134}
examples/file_manager/app.rs (line 282)
162pub fn build(opts: Options) -> Rc<Fm> {
163    let win = Window::new("File Manager");
164    win.set_size(1000, 700);
165    win.set_min_size(640, 420);
166
167    // ---- menus (accelerators are the keyboard interface; there is no key-event API)
168    let bar = MenuBar::new(win);
169    let file = Menu::new(bar, "File");
170    let new_folder = MenuItem::new(file, "New Folder");
171    new_folder.set_accel("F7");
172    let rename = MenuItem::new(file, "Rename");
173    rename.set_accel("F2");
174    MenuSeparator::new(file);
175    let copy = MenuItem::new(file, "Copy to Other Pane");
176    copy.set_accel("F5");
177    let mv = MenuItem::new(file, "Move to Other Pane");
178    mv.set_accel("F6");
179    let delete = MenuItem::new(file, "Delete");
180    delete.set_accel("F8");
181    MenuSeparator::new(file);
182    let quit = MenuItem::new(file, "Quit");
183    quit.set_accel("Ctrl+Q");
184    let view = Menu::new(bar, "View");
185    let hidden = CheckMenuItem::new(view, "Show Hidden Files");
186    hidden.set_accel("Ctrl+H");
187    let refresh_item = MenuItem::new(view, "Refresh");
188    refresh_item.set_accel("Ctrl+R");
189    let go = Menu::new(bar, "Go");
190    let up_item = MenuItem::new(go, "Up One Level");
191    up_item.set_accel("Alt+Up");
192    let home_item = MenuItem::new(go, "Home Folder");
193    home_item.set_accel("Alt+Home");
194    let switch = MenuItem::new(go, "Switch Active Pane");
195    switch.set_accel("F9");
196    let helpm = Menu::new(bar, "Help");
197    let about = MenuItem::new(helpm, "About");
198
199    // ---- layout
200    let root = VBox::new(win);
201    root.set_spacing(6);
202    root.set_expand(1.0); // a window stacks its children vertically; give the whole area to this one
203
204    let tools = HBox::new(root);
205    tools.set_spacing(6);
206    let up = Button::new(tools, "\u{2191} Up");
207    up.set_tooltip("Go to the parent folder (Alt+Up)");
208    let refresh = Button::new(tools, "Refresh");
209    refresh.set_tooltip("Reload both panes (Ctrl+R)");
210    let path = TextInput::new(tools);
211    path.set_expand(1.0);
212    path.set_monospace(true);
213    path.set_tooltip("Type a folder path to open it in the active pane");
214    path.set_a11y_name("Path of the active pane");
215    let copy_btn = Button::new(tools, "Copy \u{2192}");
216    copy_btn.set_tooltip("Copy the selected item to the other pane (F5)");
217    let move_btn = Button::new(tools, "Move \u{2192}");
218    move_btn.set_tooltip("Move the selected item to the other pane (F6)");
219
220    let body = Splitter::new(root, Orientation::Horizontal);
221    body.set_expand(1.0);
222    let tree = Tree::new(body);
223    tree.set_a11y_name("Folders");
224    let right = Splitter::new(body, Orientation::Vertical);
225    let panes = Splitter::new(right, Orientation::Horizontal);
226    let mut tables = Vec::new();
227    let mut pane_labels = Vec::new();
228    for (i, n) in PANE_NAMES.iter().enumerate() {
229        let col = VBox::new(panes);
230        col.set_spacing(2);
231        pane_labels.push(Label::new(col, ""));
232        let t = Table::new(col);
233        t.set_expand(1.0);
234        t.set_a11y_name(&format!("Files, pane {n}"));
235        t.set_columns(&[
236            Column::new("Name").width(125).sortable(true),
237            Column::new("Size")
238                .width(62)
239                .align(ColumnAlign::Right)
240                .sortable(true),
241            Column::new("Modified").width(128).sortable(true),
242            Column::new("Kind").width(90).sortable(true),
243        ]);
244        let _ = i;
245        tables.push(t);
246    }
247    let pv = VBox::new(right);
248    pv.set_spacing(2);
249    let preview_title = Label::new(pv, "Preview");
250    let pv_row = HBox::new(pv);
251    pv_row.set_expand(1.0);
252    let image = Image::new(pv_row);
253    image.set_visible(false);
254    image.set_align(Align::Start);
255    let preview = TextArea::new(pv_row);
256    preview.set_expand(1.0);
257    preview.set_read_only(true);
258    preview.set_monospace(true);
259    preview.set_wrap(false);
260    preview.set_a11y_name("Preview");
261
262    let sbar = HBox::new(root);
263    let status = Label::new(sbar, "");
264    status.set_expand(1.0);
265    let tag = Label::new(sbar, "");
266
267    body.set_position(170);
268    body.set_min_pane_sizes(100, 300);
269    right.set_position(400);
270    right.set_min_pane_sizes(120, 80);
271    panes.set_min_pane_sizes(180, 180);
272
273    // ---- context menu shared by both tables
274    let popup = PopupMenu::new();
275    let ctx_open = MenuItem::new(popup, "Open");
276    let ctx_rename = MenuItem::new(popup, "Rename...");
277    let ctx_delete = MenuItem::new(popup, "Delete...");
278    MenuSeparator::new(popup);
279    let ctx_copy = MenuItem::new(popup, "Copy to Other Pane");
280    let ctx_new = MenuItem::new(popup, "New Folder...");
281    for t in &tables {
282        t.set_context_menu(popup);
283    }
284
285    let ui = Ui {
286        win,
287        body,
288        right,
289        panes,
290        tree,
291        tables: [tables[0], tables[1]],
292        pane_labels: [pane_labels[0], pane_labels[1]],
293        path,
294        up,
295        refresh,
296        copy_btn,
297        move_btn,
298        preview_title,
299        preview,
300        image,
301        status,
302        tag,
303        popup,
304        items: Items {
305            new_folder,
306            rename,
307            copy,
308            mv,
309            delete,
310            quit,
311            hidden,
312            refresh: refresh_item,
313            up: up_item,
314            home: home_item,
315            switch,
316            about,
317            ctx_open,
318            ctx_rename,
319            ctx_delete,
320            ctx_copy,
321            ctx_new,
322        },
323    };
324    let fm = Rc::new(Fm {
325        ui,
326        st: RefCell::new(State::default()),
327        quiet: Cell::new(0),
328        typing: Cell::new(false),
329        dialog_ui: Cell::new(None),
330    });
331    fm.wire();
332    fm.init_tree();
333    {
334        let mut st = fm.st.borrow_mut();
335        for p in &opts.dirs {
336            st.panes.push(Pane {
337                path: p.clone(),
338                entries: vec![],
339                sort: (SortKey::Name, true),
340                mtime: None,
341                truncated: false,
342            });
343        }
344    }
345    for (i, p) in opts.dirs.iter().enumerate() {
346        if !fm.navigate(i, p.clone(), None, true, false) {
347            // an unreadable start directory falls back to the home folder, then to "/"
348            let fallback = home_dir().unwrap_or_else(|| PathBuf::from("/"));
349            fm.navigate(i, fallback, None, true, false);
350        }
351    }
352    fm.set_active(0);
353    let first = fm.path_of(0);
354    fm.tree_reveal(&first);
355    fm.ui.win.show();
356    fm
357}
examples/kitchen_sink.rs (line 151)
4fn main() {
5    let app = App::new("kitchen-sink").expect("init");
6    let win = Window::new("rungui kitchen sink");
7
8    // Menus
9    let bar = MenuBar::new(win);
10    let file = Menu::new(bar, "File");
11    let open = MenuItem::new(file, "Open...");
12    open.set_accel("Ctrl+O");
13    let wrap = CheckMenuItem::new(file, "Word wrap");
14    wrap.set_checked(true);
15    let mono = CheckMenuItem::new(file, "Monospace notes");
16    MenuSeparator::new(file);
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(App::quit);
20
21    let root = VBox::new(win);
22    let status = Label::new(root, "Ready");
23    let tabs = Tabs::new(root);
24    tabs.set_expand(1.0);
25
26    // Page 1: form in a grid
27    let form = tabs.add_page("Form");
28    let grid = Grid::new(form, 2);
29    Label::new(grid, "Name");
30    let name = TextInput::new(grid);
31    name.set_expand(1.0);
32    Label::new(grid, "Password");
33    TextInput::password(grid);
34    Label::new(grid, "Colour");
35    let combo = ComboBox::new(grid);
36    combo.set_items(&["Red", "Green", "Blue"]);
37    combo.set_selected(Some(0));
38    Label::new(grid, "Count");
39    let spin = SpinBox::new(grid, 0.0, 10.0, 1.0);
40    Label::new(grid, "Level");
41    let slider = Slider::new(grid, 0.0, 100.0);
42    let progress = ProgressBar::new(form);
43    slider.on_change(move |v| progress.set_fraction(v / 100.0));
44    spin.on_change(move |v| status.set_text(&format!("count = {v}")));
45    combo.on_select(move |i| status.set_text(&format!("colour index {i:?}")));
46
47    // Page 2: choices
48    let choices = tabs.add_page("Choices");
49    let boxed = GroupBox::new(choices, "Options");
50    let group = RadioGroup::new();
51    let a = RadioButton::new(boxed, &group, "Option A");
52    RadioButton::new(boxed, &group, "Option B");
53    a.set_checked(true);
54    let check = CheckBox::new(boxed, "Enabled");
55    check.set_checked(true);
56    let list = ListBox::new(choices);
57    list.set_items(&["alpha", "beta", "gamma", "delta"]);
58    list.set_expand(1.0);
59    list.on_activate(move |i| status.set_text(&format!("activated {i}")));
60
61    // Page 3: text; a vertical splitter with notes on top and a fixed-pitch, unwrapped view below
62    let notes = tabs.add_page("Notes");
63    let vsplit = Splitter::new(notes, Orientation::Vertical);
64    let area = TextArea::new(vsplit);
65    let code = TextArea::new(vsplit);
66    code.set_monospace(true);
67    code.set_wrap(false);
68    code.set_read_only(true);
69    code.set_text(
70        "fn main() {\n    println!(\"a long line that does not wrap: {}\", \"-\".repeat(60));\n}\n",
71    );
72    vsplit.set_position(120);
73    vsplit.set_min_pane_sizes(40, 40);
74    vsplit.on_move(move |p| status.set_text(&format!("notes split at {p}px")));
75    wrap.on_toggle(move |on| area.set_wrap(on));
76    mono.on_toggle(move |on| area.set_monospace(on));
77
78    // Page 4: table, tree and a context menu
79    let data = tabs.add_page("Data");
80    let split = Splitter::new(data, Orientation::Horizontal);
81    split.on_move(move |p| status.set_text(&format!("data split at {p}px")));
82    let table = Table::new(split);
83    table.set_columns(&[
84        Column::new("Name").width(140).sortable(true),
85        Column::new("Size")
86            .width(70)
87            .align(ColumnAlign::Right)
88            .sortable(true),
89    ]);
90    table.set_rows(&[
91        vec!["kernel", "9120"],
92        vec!["README", "312"],
93        vec!["Cargo.toml", "1024"],
94    ]);
95    table.on_select(move |r| status.set_text(&format!("row {r:?}")));
96    table.on_activate(move |r| status.set_text(&format!("row {r} activated")));
97    table.on_column_click(move |c| {
98        // sorting is the app's job: reorder the rows, then show the arrow
99        let ascending = table.sort_indicator() != Some((c, true));
100        let mut rows = table.rows();
101        rows.sort_by(|a, b| match c {
102            1 => a[1]
103                .parse::<u64>()
104                .unwrap_or(0)
105                .cmp(&b[1].parse::<u64>().unwrap_or(0)),
106            _ => a[c].cmp(&b[c]),
107        });
108        if !ascending {
109            rows.reverse();
110        }
111        table.set_rows(&rows);
112        table.set_sort_indicator(Some((c, ascending)));
113    });
114
115    let tree = Tree::new(split);
116    let src = tree.add(None, "src");
117    tree.add(Some(src), "lib.rs");
118    tree.add(Some(src), "core.rs");
119    let docs = tree.add(None, "doc");
120    tree.set_has_children(docs, true); // lazily filled when first expanded
121    tree.set_expanded(src, true);
122    tree.on_select(move |n| status.set_text(&format!("node {:?}", n.map(|n| tree.text(n)))));
123    tree.on_expand(move |n, open| {
124        if open && tree.children(Some(n)).is_empty() {
125            tree.add(Some(n), "DESIGN.md");
126            tree.add(Some(n), "BUILDING.md");
127        }
128    });
129
130    // Page 5: a calendar, a multi-select list and a prompt
131    let dates = tabs.add_page("Dates");
132    let cal = Calendar::new(dates);
133    cal.on_change(move |d| status.set_text(&format!("{}-{:02}-{:02}", d.year, d.month, d.day)));
134    let many = ListBox::new(dates);
135    many.set_items(&["one", "two", "three", "four"]);
136    many.set_multi_select(true);
137    many.set_expand(1.0);
138    many.on_selection(move |rows| status.set_text(&format!("selected {rows:?}")));
139    let ask = Button::new(dates, "Ask...");
140    ask.on_click(move || {
141        let r = prompt(Some(win), "Name", "What is your name?", "");
142        status.set_text(&format!("name: {r:?}"));
143    });
144
145    // Right-click the table for a context menu; its items are rebuilt/enabled just before display.
146    let popup = PopupMenu::new();
147    let del = MenuItem::new(popup, "Delete row");
148    MenuSeparator::new(popup);
149    let hdr = CheckMenuItem::new(popup, "Show sizes");
150    hdr.set_checked(true);
151    table.set_context_menu(popup);
152    table.on_context_menu(move |_, _| del.set_enabled(table.selected().is_some()));
153    del.on_click(move || {
154        if let Some(r) = table.selected() {
155            table.remove_row(r);
156        }
157    });
158    hdr.on_toggle(move |on| status.set_text(&format!("show sizes: {on}")));
159    tree.set_context_menu(popup);
160
161    open.on_click(move || {
162        if let Some(p) = FileDialog::new()
163            .title("Open")
164            .filter("Text", &["txt", "md"])
165            .open(Some(win))
166        {
167            if let Ok(s) = std::fs::read_to_string(&p) {
168                area.set_text(&s);
169            }
170            status.set_text(&format!("opened {}", p.display()));
171        }
172    });
173
174    // Buttons row
175    let row = HBox::new(root);
176    Spacer::new(row);
177    let about = Button::new(row, "About");
178    about.on_click(move || {
179        message_box(
180            Some(win),
181            MessageKind::Info,
182            Buttons::Ok,
183            "About",
184            "rungui kitchen sink",
185        );
186    });
187    let ok = Button::new(row, "Close");
188    ok.on_click(move || win.close());
189    ok.set_a11y_description("Closes the window");
190
191    let n = std::cell::Cell::new(0);
192    Timer::every(1000, move || {
193        n.set(n.get() + 1);
194        status.set_text(&format!("uptime {}s", n.get()));
195    });
196
197    win.set_size(480, 400);
198    win.show();
199    app.run();
200}
Source

pub fn clear_context_menu(&self)

Detach the context menu.

Source

pub fn on_context_menu(&self, f: impl FnMut(i32, i32) + 'static)

Called with window-client coordinates just before the context menu is shown (and even when no menu is attached), so the app can rebuild/enable items or attach a different menu.

Examples found in repository?
examples/file_manager/app.rs (line 402)
360    fn wire(self: &Rc<Self>) {
361        let u = &self.ui;
362        let it = u.items;
363        macro_rules! click {
364            ($btn:expr, $f:ident) => {{
365                let fm = self.clone();
366                $btn.on_click(move || fm.$f());
367            }};
368        }
369        click!(it.new_folder, op_new_folder);
370        click!(it.ctx_new, op_new_folder);
371        click!(it.rename, op_rename);
372        click!(it.ctx_rename, op_rename);
373        click!(it.delete, op_delete);
374        click!(it.ctx_delete, op_delete);
375        click!(it.copy, op_copy);
376        click!(it.ctx_copy, op_copy);
377        click!(u.copy_btn, op_copy);
378        click!(it.mv, op_move);
379        click!(u.move_btn, op_move);
380        click!(it.ctx_open, op_open);
381        click!(it.refresh, refresh_all);
382        click!(u.refresh, refresh_all);
383        click!(it.up, go_up);
384        click!(u.up, go_up);
385        click!(it.home, go_home);
386        click!(it.switch, switch_pane);
387        click!(it.about, about);
388        it.quit.on_click(App::quit);
389        {
390            let fm = self.clone();
391            it.hidden.on_toggle(move |on| fm.set_show_hidden(on));
392        }
393        for i in 0..2 {
394            let t = u.tables[i];
395            let fm = self.clone();
396            t.on_select(move |r| fm.on_row_selected(i, r));
397            let fm = self.clone();
398            t.on_activate(move |r| fm.on_row_activated(i, r));
399            let fm = self.clone();
400            t.on_column_click(move |c| fm.sort_by_column(i, c));
401            let fm = self.clone();
402            t.on_context_menu(move |_, _| fm.prepare_context_menu(i));
403        }
404        {
405            let fm = self.clone();
406            u.path.on_change(move |text| fm.on_path_typed(text));
407        }
408        {
409            let fm = self.clone();
410            u.tree.on_select(move |n| fm.on_tree_selected(n));
411            let fm = self.clone();
412            u.tree.on_expand(move |n, open| {
413                if open {
414                    fm.tree_load(n);
415                }
416            });
417        }
418        {
419            let fm = self.clone();
420            u.win.on_resize(move |w, h| {
421                trace!("RESIZE {w} {h}");
422                fm.relabel_soon();
423            });
424            for sp in [u.body, u.right, u.panes] {
425                let fm = self.clone();
426                sp.on_move(move |_| fm.relabel_soon());
427            }
428        }
429        // pick up changes made by other programs
430        let fm = self.clone();
431        Timer::every(1500, move || fm.poll());
432        // report geometry once the first layout has happened
433        let fm = self.clone();
434        Timer::once(500, move || {
435            fm.print_bounds();
436            trace!("READY");
437        });
438    }
More examples
Hide additional examples
examples/kitchen_sink.rs (line 152)
4fn main() {
5    let app = App::new("kitchen-sink").expect("init");
6    let win = Window::new("rungui kitchen sink");
7
8    // Menus
9    let bar = MenuBar::new(win);
10    let file = Menu::new(bar, "File");
11    let open = MenuItem::new(file, "Open...");
12    open.set_accel("Ctrl+O");
13    let wrap = CheckMenuItem::new(file, "Word wrap");
14    wrap.set_checked(true);
15    let mono = CheckMenuItem::new(file, "Monospace notes");
16    MenuSeparator::new(file);
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(App::quit);
20
21    let root = VBox::new(win);
22    let status = Label::new(root, "Ready");
23    let tabs = Tabs::new(root);
24    tabs.set_expand(1.0);
25
26    // Page 1: form in a grid
27    let form = tabs.add_page("Form");
28    let grid = Grid::new(form, 2);
29    Label::new(grid, "Name");
30    let name = TextInput::new(grid);
31    name.set_expand(1.0);
32    Label::new(grid, "Password");
33    TextInput::password(grid);
34    Label::new(grid, "Colour");
35    let combo = ComboBox::new(grid);
36    combo.set_items(&["Red", "Green", "Blue"]);
37    combo.set_selected(Some(0));
38    Label::new(grid, "Count");
39    let spin = SpinBox::new(grid, 0.0, 10.0, 1.0);
40    Label::new(grid, "Level");
41    let slider = Slider::new(grid, 0.0, 100.0);
42    let progress = ProgressBar::new(form);
43    slider.on_change(move |v| progress.set_fraction(v / 100.0));
44    spin.on_change(move |v| status.set_text(&format!("count = {v}")));
45    combo.on_select(move |i| status.set_text(&format!("colour index {i:?}")));
46
47    // Page 2: choices
48    let choices = tabs.add_page("Choices");
49    let boxed = GroupBox::new(choices, "Options");
50    let group = RadioGroup::new();
51    let a = RadioButton::new(boxed, &group, "Option A");
52    RadioButton::new(boxed, &group, "Option B");
53    a.set_checked(true);
54    let check = CheckBox::new(boxed, "Enabled");
55    check.set_checked(true);
56    let list = ListBox::new(choices);
57    list.set_items(&["alpha", "beta", "gamma", "delta"]);
58    list.set_expand(1.0);
59    list.on_activate(move |i| status.set_text(&format!("activated {i}")));
60
61    // Page 3: text; a vertical splitter with notes on top and a fixed-pitch, unwrapped view below
62    let notes = tabs.add_page("Notes");
63    let vsplit = Splitter::new(notes, Orientation::Vertical);
64    let area = TextArea::new(vsplit);
65    let code = TextArea::new(vsplit);
66    code.set_monospace(true);
67    code.set_wrap(false);
68    code.set_read_only(true);
69    code.set_text(
70        "fn main() {\n    println!(\"a long line that does not wrap: {}\", \"-\".repeat(60));\n}\n",
71    );
72    vsplit.set_position(120);
73    vsplit.set_min_pane_sizes(40, 40);
74    vsplit.on_move(move |p| status.set_text(&format!("notes split at {p}px")));
75    wrap.on_toggle(move |on| area.set_wrap(on));
76    mono.on_toggle(move |on| area.set_monospace(on));
77
78    // Page 4: table, tree and a context menu
79    let data = tabs.add_page("Data");
80    let split = Splitter::new(data, Orientation::Horizontal);
81    split.on_move(move |p| status.set_text(&format!("data split at {p}px")));
82    let table = Table::new(split);
83    table.set_columns(&[
84        Column::new("Name").width(140).sortable(true),
85        Column::new("Size")
86            .width(70)
87            .align(ColumnAlign::Right)
88            .sortable(true),
89    ]);
90    table.set_rows(&[
91        vec!["kernel", "9120"],
92        vec!["README", "312"],
93        vec!["Cargo.toml", "1024"],
94    ]);
95    table.on_select(move |r| status.set_text(&format!("row {r:?}")));
96    table.on_activate(move |r| status.set_text(&format!("row {r} activated")));
97    table.on_column_click(move |c| {
98        // sorting is the app's job: reorder the rows, then show the arrow
99        let ascending = table.sort_indicator() != Some((c, true));
100        let mut rows = table.rows();
101        rows.sort_by(|a, b| match c {
102            1 => a[1]
103                .parse::<u64>()
104                .unwrap_or(0)
105                .cmp(&b[1].parse::<u64>().unwrap_or(0)),
106            _ => a[c].cmp(&b[c]),
107        });
108        if !ascending {
109            rows.reverse();
110        }
111        table.set_rows(&rows);
112        table.set_sort_indicator(Some((c, ascending)));
113    });
114
115    let tree = Tree::new(split);
116    let src = tree.add(None, "src");
117    tree.add(Some(src), "lib.rs");
118    tree.add(Some(src), "core.rs");
119    let docs = tree.add(None, "doc");
120    tree.set_has_children(docs, true); // lazily filled when first expanded
121    tree.set_expanded(src, true);
122    tree.on_select(move |n| status.set_text(&format!("node {:?}", n.map(|n| tree.text(n)))));
123    tree.on_expand(move |n, open| {
124        if open && tree.children(Some(n)).is_empty() {
125            tree.add(Some(n), "DESIGN.md");
126            tree.add(Some(n), "BUILDING.md");
127        }
128    });
129
130    // Page 5: a calendar, a multi-select list and a prompt
131    let dates = tabs.add_page("Dates");
132    let cal = Calendar::new(dates);
133    cal.on_change(move |d| status.set_text(&format!("{}-{:02}-{:02}", d.year, d.month, d.day)));
134    let many = ListBox::new(dates);
135    many.set_items(&["one", "two", "three", "four"]);
136    many.set_multi_select(true);
137    many.set_expand(1.0);
138    many.on_selection(move |rows| status.set_text(&format!("selected {rows:?}")));
139    let ask = Button::new(dates, "Ask...");
140    ask.on_click(move || {
141        let r = prompt(Some(win), "Name", "What is your name?", "");
142        status.set_text(&format!("name: {r:?}"));
143    });
144
145    // Right-click the table for a context menu; its items are rebuilt/enabled just before display.
146    let popup = PopupMenu::new();
147    let del = MenuItem::new(popup, "Delete row");
148    MenuSeparator::new(popup);
149    let hdr = CheckMenuItem::new(popup, "Show sizes");
150    hdr.set_checked(true);
151    table.set_context_menu(popup);
152    table.on_context_menu(move |_, _| del.set_enabled(table.selected().is_some()));
153    del.on_click(move || {
154        if let Some(r) = table.selected() {
155            table.remove_row(r);
156        }
157    });
158    hdr.on_toggle(move |on| status.set_text(&format!("show sizes: {on}")));
159    tree.set_context_menu(popup);
160
161    open.on_click(move || {
162        if let Some(p) = FileDialog::new()
163            .title("Open")
164            .filter("Text", &["txt", "md"])
165            .open(Some(win))
166        {
167            if let Ok(s) = std::fs::read_to_string(&p) {
168                area.set_text(&s);
169            }
170            status.set_text(&format!("opened {}", p.display()));
171        }
172    });
173
174    // Buttons row
175    let row = HBox::new(root);
176    Spacer::new(row);
177    let about = Button::new(row, "About");
178    about.on_click(move || {
179        message_box(
180            Some(win),
181            MessageKind::Info,
182            Buttons::Ok,
183            "About",
184            "rungui kitchen sink",
185        );
186    });
187    let ok = Button::new(row, "Close");
188    ok.on_click(move || win.close());
189    ok.set_a11y_description("Closes the window");
190
191    let n = std::cell::Cell::new(0);
192    Timer::every(1000, move || {
193        n.set(n.get() + 1);
194        status.set_text(&format!("uptime {}s", n.get()));
195    });
196
197    win.set_size(480, 400);
198    win.show();
199    app.run();
200}
Source

pub fn native_handle(&self) -> Option<NativeHandle>

The raw GtkWidget* / HWND / NSView* (or HMENU/NSMenu for menus) for platform-specific code.

Examples found in repository?
examples/smoke_controls.rs (line 84)
5fn main() {
6    let app = App::new("smoke").expect("init");
7    let a = Window::new("smoke-a");
8    let col = VBox::new(a);
9    let btn = Button::new(col, "Press ünï");
10    let txt = TextInput::new(col);
11    let chk = CheckBox::new(col, "Check");
12    let list = ListBox::new(col);
13    list.set_items(&["one", "two", "three"]);
14    let slider = Slider::new(col, 0.0, 100.0);
15    let combo = ComboBox::new(col);
16    combo.set_items(&["x", "y"]);
17    let dlg = Button::new(col, "Dialog");
18    dlg.on_click(move || {
19        let r = message_box(
20            Some(a),
21            MessageKind::Question,
22            Buttons::YesNo,
23            "Title ü",
24            "Really?",
25        );
26        println!("DIALOG {r:?}");
27    });
28    let g = RadioGroup::new();
29    let ra = RadioButton::new(col, &g, "Ra");
30    let rb = RadioButton::new(col, &g, "Rb");
31    ra.set_checked(true);
32    ra.on_toggle(|v| println!("RA {v}"));
33    rb.on_toggle(|v| println!("RB {v}"));
34    let table = Table::new(col);
35    table.set_columns(&[
36        Column::new("Name").width(80).sortable(true),
37        Column::new("Size").align(ColumnAlign::Right),
38    ]);
39    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
40    table.on_select(|i| println!("TABLE_SEL {i:?}"));
41    table.on_column_click(|c| println!("TABLE_COL {c}"));
42    let tree = Tree::new(col);
43    let root = tree.add(None, "root");
44    let kid = tree.add(Some(root), "kid");
45    let lazy = tree.add(None, "lazy");
46    tree.set_has_children(lazy, true);
47    let _ = kid;
48    tree.on_select(|n| println!("TREE_SEL {}", n.is_some()));
49    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
50    a.set_context_menu({
51        let p = PopupMenu::new();
52        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
53        p
54    });
55    btn.on_click(|| println!("CLICK"));
56    txt.on_change(|t| println!("TEXT {t}"));
57    chk.on_toggle(|b| println!("TOGGLE {b}"));
58    list.on_select(|i| println!("SELECT {i:?}"));
59    slider.on_change(|v| println!("VALUE {v:.0}"));
60    combo.on_select(|i| println!("COMBO {i:?}"));
61    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
62    a.on_close(|| {
63        println!("CLOSE_REQUESTED");
64        true
65    });
66
67    let b = Window::new("smoke-b");
68    let bar = MenuBar::new(b);
69    let file = Menu::new(bar, "File");
70    let item = MenuItem::new(file, "Quit");
71    item.set_accel("Ctrl+Q");
72    item.on_click(|| {
73        println!("MENU_QUIT");
74        App::quit();
75    });
76    let ck = CheckMenuItem::new(file, "Flag");
77    ck.on_toggle(|v| println!("MENUTOGGLE {v}"));
78    Label::new(b, "second window");
79
80    a.show();
81    b.show();
82    println!(
83        "HANDLE {}",
84        a.native_handle().is_some() && btn.native_handle().is_some()
85    );
86    let _t = Timer::once(600, move || {
87        for (n, w) in [
88            ("btn", btn.bounds()),
89            ("txt", txt.bounds()),
90            ("chk", chk.bounds()),
91            ("list", list.bounds()),
92            ("slider", slider.bounds()),
93            ("combo", combo.bounds()),
94            ("dlg", dlg.bounds()),
95            ("rb", rb.bounds()),
96            ("table", table.bounds()),
97            ("tree", tree.bounds()),
98        ] {
99            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
100        }
101        println!("READY");
102    });
103    // CI: RUNGUI_EXIT_AFTER_MS=n quits the loop after n ms so a startup crash shows up as a failure.
104    let _exit = std::env::var("RUNGUI_EXIT_AFTER_MS")
105        .ok()
106        .and_then(|v| v.parse::<u32>().ok())
107        .map(|ms| Timer::once(ms, App::quit));
108    app.run();
109    println!("BYE");
110}
More examples
Hide additional examples
examples/smoke_cocoa.rs (line 111)
6fn main() {
7    let app = App::new("smoke-cocoa").expect("init");
8    let a = Window::new("cc-a");
9    let bar = MenuBar::new(a);
10    let file = Menu::new(bar, "File");
11    let flag = CheckMenuItem::new(file, "Flag");
12    flag.set_accel("Ctrl+K");
13    flag.on_toggle(|v| println!("MENUTOGGLE {v}"));
14    let go = MenuItem::new(file, "Go");
15    go.set_accel("Ctrl+Shift+G");
16    go.on_click(|| println!("MENU_GO"));
17    let quit = MenuItem::new(file, "Quit");
18    quit.set_accel("Ctrl+Q");
19    quit.on_click(|| {
20        println!("MENU_QUIT");
21        App::quit();
22    });
23
24    let col = VBox::new(a);
25    let row = HBox::new(col);
26    let btn = Button::new(row, "Press ünï");
27    let spin = SpinBox::new(row, 0.0, 10.0, 1.0);
28    let txt = TextInput::new(col);
29    let chk = CheckBox::new(col, "Monospace");
30    let hs = Splitter::new(col, Orientation::Horizontal);
31    let ta1 = TextArea::new(hs);
32    let ta2 = TextArea::new(hs);
33    ta2.set_text(
34        "long line without wrapping: 0123456789 0123456789 0123456789 0123456789 0123456789",
35    );
36    ta2.set_wrap(false);
37    hs.set_position(200);
38    hs.set_min_pane_sizes(60, 60);
39    let slider = Slider::new(col, 0.0, 100.0);
40    let combo = ComboBox::new(col);
41    combo.set_items(&["x", "y", "z"]);
42    let tabs = Tabs::new(col);
43    let p1 = tabs.add_page("First");
44    let p2 = tabs.add_page("Second");
45    Label::new(p1, "page one");
46    Label::new(p2, "page two");
47    let vs = Splitter::new(col, Orientation::Vertical);
48    let table = Table::new(vs);
49    table.set_columns(&[
50        Column::new("Name").width(80).sortable(true),
51        Column::new("Size").align(ColumnAlign::Right),
52    ]);
53    table.set_rows(&[vec!["a", "1"], vec!["b", "2"], vec!["c", "3"]]);
54    let tree = Tree::new(vs);
55    let root = tree.add(None, "root");
56    tree.add(Some(root), "kid");
57    let lazy = tree.add(None, "lazy");
58    tree.set_has_children(lazy, true);
59    vs.set_position(100);
60    vs.set_min_pane_sizes(40, 40);
61
62    btn.on_click(|| println!("CLICK"));
63    spin.on_change(|v| println!("SPIN {v}"));
64    txt.on_change(|t| println!("TEXT {t}"));
65    ta1.on_change(|t| println!("AREA {}", t.replace('\n', "|")));
66    chk.on_toggle(move |on| {
67        println!("MONO {on}");
68        txt.set_monospace(on);
69        ta1.set_monospace(on);
70    });
71    hs.on_move(|p| println!("HSPLIT {p}"));
72    vs.on_move(|p| println!("VSPLIT {p}"));
73    slider.on_change(|v| println!("VALUE {v:.0}"));
74    combo.on_select(|i| println!("COMBO {i:?}"));
75    tabs.on_select(|i| println!("TAB {i:?}"));
76    table.on_select(|i| println!("TABLE_SEL {i:?}"));
77    table.on_column_click(move |c| {
78        let ascending = table.sort_indicator() != Some((c, true));
79        let mut rows = table.rows();
80        rows.sort_by(|x, y| x[c].cmp(&y[c]));
81        if !ascending {
82            rows.reverse();
83        }
84        table.set_rows(&rows);
85        table.set_sort_indicator(Some((c, ascending)));
86        println!(
87            "TABLE_COL {c} {} {}",
88            if ascending { "asc" } else { "desc" },
89            rows[0][0]
90        );
91    });
92    tree.on_select(move |n| println!("TREE_SEL {}", n.is_some()));
93    tree.on_expand(|_, open| println!("TREE_EXPAND {open}"));
94    a.set_context_menu({
95        let p = PopupMenu::new();
96        MenuItem::new(p, "Ctx item").on_click(|| println!("CTXMENU"));
97        p
98    });
99    a.on_resize(|w, h| println!("RESIZED {w} {h}"));
100    a.on_move(|x, y| println!("MOVED {x} {y}"));
101    a.set_min_size(300, 400);
102    a.set_position(220, 100);
103    a.set_size(560, 700);
104    a.on_close(|| {
105        println!("CLOSE_REQUESTED");
106        true
107    });
108    a.show();
109    println!(
110        "HANDLE {}",
111        a.native_handle().is_some() && btn.native_handle().is_some()
112    );
113    let _t = Timer::once(700, move || {
114        for (n, w) in [
115            ("btn", btn.bounds()),
116            ("spin", spin.bounds()),
117            ("txt", txt.bounds()),
118            ("chk", chk.bounds()),
119            ("hs", hs.bounds()),
120            ("slider", slider.bounds()),
121            ("combo", combo.bounds()),
122            ("tabs", tabs.bounds()),
123            ("vs", vs.bounds()),
124            ("table", table.bounds()),
125            ("tree", tree.bounds()),
126        ] {
127            println!("BOUNDS {n} {} {} {} {}", w.x, w.y, w.w, w.h);
128        }
129        println!("SPLITPOS h {} v {}", hs.position(), vs.position());
130        println!("READY");
131    });
132    app.run();
133    println!("BYE");
134}

Trait Implementations§

Source§

impl Clone for Window

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl Copy for Window

Source§

impl Debug for Window

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Deref for Window

Source§

type Target = Widget

The resulting type after dereferencing.
Source§

fn deref(&self) -> &Widget

Dereferences the value.
Source§

impl Eq for Window

Source§

impl From<&Window> for WidgetId

Source§

fn from(h: &Window) -> WidgetId

Converts to this type from the input type.
Source§

impl From<Window> for WidgetId

Source§

fn from(h: Window) -> WidgetId

Converts to this type from the input type.
Source§

impl Hash for Window

Source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
Source§

impl PartialEq for Window

Source§

fn eq(&self, other: &Self) -> bool

Equality operator ==. Read more
1.0.0 (const: unstable) · Source§

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=. Read more
Source§

impl StructuralPartialEq for Window

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.