pub struct GroupBox(/* private fields */);Expand description
Titled frame container.
A handle to a GroupBox; Copy, and inert once the widget is destroyed.
Implementations§
Source§impl GroupBox
impl GroupBox
Sourcepub fn new(parent: impl Into<WidgetId>, title: &str) -> GroupBox
pub fn new(parent: impl Into<WidgetId>, title: &str) -> GroupBox
A titled frame around its children (which stack vertically like a window’s).
Examples found in repository?
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}Methods from Deref<Target = Widget>§
Sourcepub fn is_alive(&self) -> bool
pub fn is_alive(&self) -> bool
False after destroy, or if creation failed (see crate::last_error).
Sourcepub fn destroy(&self)
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?
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
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 }Sourcepub fn set_enabled(&self, v: bool)
pub fn set_enabled(&self, v: bool)
Enable or disable the widget and everything inside it.
Examples found in repository?
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
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}Sourcepub fn enabled(&self) -> bool
pub fn enabled(&self) -> bool
Whether the widget itself is enabled (a disabled ancestor still disables it on screen).
Sourcepub fn set_visible(&self, v: bool)
pub fn set_visible(&self, v: bool)
Hidden widgets take no layout space. Hiding a box hides everything inside it.
Examples found in repository?
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 }Sourcepub fn visible(&self) -> bool
pub fn visible(&self) -> bool
Whether the widget itself is shown (a hidden ancestor still hides it).
Sourcepub fn set_tooltip(&self, t: &str)
pub fn set_tooltip(&self, t: &str)
Set the tooltip text (empty removes it); also the default accessible description.
Examples found in repository?
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}Sourcepub fn focus(&self)
pub fn focus(&self)
Move keyboard focus to the widget.
Examples found in repository?
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 }Sourcepub fn set_expand(&self, weight: f32)
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?
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
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}Sourcepub fn set_align(&self, a: Align)
pub fn set_align(&self, a: Align)
Alignment inside the parent’s cell/cross axis (default Fill).
Examples found in repository?
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}Sourcepub fn set_min_size(&self, w: i32, h: i32)
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?
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
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}Sourcepub fn set_fixed_size(&self, w: i32, h: i32)
pub fn set_fixed_size(&self, w: i32, h: i32)
Force the natural size (overrides the toolkit’s preferred size).
Sourcepub fn set_spacing(&self, px: i32)
pub fn set_spacing(&self, px: i32)
Space between children (stacks/grids/containers).
Examples found in repository?
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 }Sourcepub fn set_padding(&self, px: i32)
pub fn set_padding(&self, px: i32)
Inner margin of a container.
Sourcepub fn set_cell(&self, col: usize, row: usize, colspan: usize, rowspan: usize)
pub fn set_cell(&self, col: usize, row: usize, colspan: usize, rowspan: usize)
Explicit grid cell in the parent Grid (otherwise children auto-flow).
Sourcepub fn bounds(&self) -> Rect
pub fn bounds(&self) -> Rect
Last laid-out bounds, relative to the nearest native parent (logical pixels).
Examples found in repository?
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
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}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}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}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}Sourcepub fn set_a11y_name(&self, s: &str)
pub fn set_a11y_name(&self, s: &str)
Accessible name override (otherwise derived from the widget text / preceding label).
Examples found in repository?
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 }Sourcepub fn set_a11y_description(&self, s: &str)
pub fn set_a11y_description(&self, s: &str)
Override the accessible description (otherwise the tooltip).
Examples found in repository?
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}Sourcepub fn set_a11y_role(&self, r: A11yRole)
pub fn set_a11y_role(&self, r: A11yRole)
Override the accessible role (otherwise the kind’s default).
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?
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
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}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}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}Detach the context menu.
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?
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
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}Sourcepub fn native_handle(&self) -> Option<NativeHandle>
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?
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
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}