Skip to main content

file_manager/
app.rs

1//! The file manager UI: a dual-pane browser built only from rungui's public API.
2//!
3//! Layout (every `Splitter` is draggable where the backend has a sash):
4//!
5//! ```text
6//! menu bar
7//! toolbar: Up | Refresh | path box | Copy -> | Move ->
8//! +--------+--------------------------------------+
9//! | tree   |  pane A table   |   pane B table     |
10//! | (lazy) +--------------------------------------+
11//! |        |  preview: image + monospace text     |
12//! +--------+--------------------------------------+
13//! status bar
14//! ```
15//!
16//! Every handle is `Copy`, so the UI is a plain struct of handles; the mutable model (paths,
17//! listings) lives in a `RefCell` that is never borrowed across a call into rungui, because
18//! those calls can re-enter our callbacks.
19
20use 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
29/// `RUNGUI_FM_TRACE=1`: print machine-readable lines (NAV, SELECT, PREVIEW, BOUNDS, ...) on stdout
30/// so scripts/smoke-filemanager.sh and the tests can follow what the app did.
31pub 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/// All widgets. Public so the mock-backend test can drive them.
48#[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    /// Row `i` of the table is `entries[i]`; a leading ".." row if the directory has a parent.
95    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    /// >0 while we change the table ourselves: ignore the selection events that causes.
115    quiet: Cell<u32>,
116    /// The user is typing in the path box: do not rewrite its text under their cursor.
117    typing: Cell<bool>,
118    /// The open rename / new-folder dialog: (window, input, ok, cancel). For tests.
119    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 { "   " }; // small right-pointing triangle for folders
131    vec![
132        format!("{mark}{}", e.name),
133        e.size_text(),
134        e.time_text(),
135        e.kind(),
136    ]
137}
138
139/// Integer upscale so tiny images (icons) are visible: nearest neighbour, longest edge up to ~128.
140fn 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
160// ------------------------------------------------------------------ construction
161
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    }
1290}