1use crate::fsmodel::{self as fsm, Entry, Preview, SortKey};
21use rungui::*;
22use std::cell::{Cell, RefCell};
23use std::collections::{HashMap, HashSet};
24use std::path::{Path, PathBuf};
25use std::rc::Rc;
26use std::sync::OnceLock;
27use std::time::SystemTime;
28
29pub fn tracing() -> bool {
32 static T: OnceLock<bool> = OnceLock::new();
33 *T.get_or_init(|| {
34 std::env::var_os("RUNGUI_FM_TRACE").is_some_and(|v| !v.is_empty() && v != "0")
35 })
36}
37macro_rules! trace {
38 ($($a:tt)*) => { if tracing() { println!($($a)*) } };
39}
40
41const PANE_NAMES: [&str; 2] = ["A", "B"];
42
43pub struct Options {
44 pub dirs: [PathBuf; 2],
45}
46
47#[allow(dead_code)]
49pub struct Ui {
50 pub win: Window,
51 pub body: Splitter,
52 pub right: Splitter,
53 pub panes: Splitter,
54 pub tree: Tree,
55 pub tables: [Table; 2],
56 pub pane_labels: [Label; 2],
57 pub path: TextInput,
58 pub up: Button,
59 pub refresh: Button,
60 pub copy_btn: Button,
61 pub move_btn: Button,
62 pub preview_title: Label,
63 pub preview: TextArea,
64 pub image: Image,
65 pub status: Label,
66 pub tag: Label,
67 pub popup: PopupMenu,
68 pub items: Items,
69}
70
71#[derive(Copy, Clone)]
72pub struct Items {
73 pub new_folder: MenuItem,
74 pub rename: MenuItem,
75 pub copy: MenuItem,
76 pub mv: MenuItem,
77 pub delete: MenuItem,
78 pub quit: MenuItem,
79 pub hidden: CheckMenuItem,
80 pub refresh: MenuItem,
81 pub up: MenuItem,
82 pub home: MenuItem,
83 pub switch: MenuItem,
84 pub about: MenuItem,
85 pub ctx_open: MenuItem,
86 pub ctx_rename: MenuItem,
87 pub ctx_delete: MenuItem,
88 pub ctx_copy: MenuItem,
89 pub ctx_new: MenuItem,
90}
91
92struct Pane {
93 path: PathBuf,
94 entries: Vec<Entry>,
96 sort: (SortKey, bool),
97 mtime: Option<SystemTime>,
98 truncated: bool,
99}
100
101#[derive(Default)]
102struct State {
103 panes: Vec<Pane>,
104 active: usize,
105 show_hidden: bool,
106 node_paths: HashMap<TreeNodeId, PathBuf>,
107 loaded: HashSet<TreeNodeId>,
108 dialog: Option<Window>,
109}
110
111pub struct Fm {
112 pub ui: Ui,
113 st: RefCell<State>,
114 quiet: Cell<u32>,
116 typing: Cell<bool>,
118 pub dialog_ui: Cell<Option<(Window, TextInput, Button, Button)>>,
120}
121
122fn home_dir() -> Option<PathBuf> {
123 std::env::var_os("HOME")
124 .or_else(|| std::env::var_os("USERPROFILE"))
125 .map(PathBuf::from)
126 .filter(|p| p.is_dir())
127}
128
129fn row_of(e: &Entry) -> Vec<String> {
130 let mark = if e.is_dir { "\u{25B8} " } else { " " }; vec![
132 format!("{mark}{}", e.name),
133 e.size_text(),
134 e.time_text(),
135 e.kind(),
136 ]
137}
138
139fn scaled(img: &ImageData) -> ImageData {
141 let k = (128 / img.w.max(img.h).max(1)).clamp(1, 8) as usize;
142 if k == 1 {
143 return img.clone();
144 }
145 let (w, h) = (img.w as usize, img.h as usize);
146 let mut rgba = Vec::with_capacity(w * h * k * k * 4);
147 for y in 0..h * k {
148 for x in 0..w * k {
149 let s = ((y / k) * w + x / k) * 4;
150 rgba.extend_from_slice(&img.rgba[s..s + 4]);
151 }
152 }
153 ImageData {
154 w: (w * k) as u32,
155 h: (h * k) as u32,
156 rgba,
157 }
158}
159
160pub 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 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 let root = VBox::new(win);
201 root.set_spacing(6);
202 root.set_expand(1.0); 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 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 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 let fm = self.clone();
431 Timer::every(1500, move || fm.poll());
432 let fm = self.clone();
434 Timer::once(500, move || {
435 fm.print_bounds();
436 trace!("READY");
437 });
438 }
439
440 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 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 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 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 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 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 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 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)] 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 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 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 fn relabel_soon(self: &Rc<Self>) {
704 let fm = self.clone();
705 Timer::once(10, move || fm.refresh_labels());
706 }
707
708 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 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 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 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 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 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 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 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); 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 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 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 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 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 }
1290}