portapack-mayhem/firmware/application/apps/ui_fileman.cpp

/*
 * Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
 * Copyright (C) 2017 Furrtek
 *
 * This file is part of PortaPack.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street,
 * Boston, MA 02110-1301, USA.
 */

/* TODO:
 * - Paging menu items
 */

#include <algorithm>
#include "ui_fileman.hpp"
#include "ui_playlist.hpp"
#include "ui_ss_viewer.hpp"
#include "ui_bmp_file_viewer.hpp"
#include "ui_text_editor.hpp"
#include "ui_iq_trim.hpp"
#include "string_format.hpp"
#include "portapack.hpp"
#include "event_m0.hpp"
#include "file_path.hpp"

using namespace portapack;
namespace fs = std::filesystem;

namespace ui {
static const fs::path txt_ext{u".TXT"};
static const fs::path ppl_ext{u".PPL"};
static const fs::path c8_ext{u".C8"};
static const fs::path c16_ext{u".C16"};
static const fs::path cxx_ext{u".C*"};
static const fs::path png_ext{u".PNG"};
static const fs::path bmp_ext{u".BMP"};
static const fs::path rem_ext{u".REM"};
}  // namespace ui

namespace {
using namespace ui;

bool is_hidden_file(const fs::path& path) {
    return !path.empty() && path.native()[0] == u'.';
}

// Gets a truncated name from a path for display.
std::string truncate(const fs::path& path, size_t max_length) {
    return ::truncate(path.string(), max_length);
}

// Inserts the entry into the entry list sorted directories first then by file name.
void insert_sorted(std::list<fileman_entry>& entries, fileman_entry&& entry) {
    auto it = std::lower_bound(
        std::begin(entries), std::end(entries), entry,
        [](const fileman_entry& lhs, const fileman_entry& rhs) {
            if (lhs.is_directory && !rhs.is_directory)
                return true;
            else if (!lhs.is_directory && rhs.is_directory)
                return false;
            else
                return lhs.path < rhs.path;
        });

    entries.insert(it, std::move(entry));
}

// Returns the partner file path or an empty path if no partner is found.
fs::path get_partner_file(fs::path path) {
    if (fs::is_directory(path))
        return {};
    auto ext = path.extension();

    if (is_cxx_capture_file(path))
        path.replace_extension(txt_ext);
    else if (path_iequal(ext, txt_ext)) {
        path.replace_extension(c8_ext);
        if (!fs::file_exists(path))
            path.replace_extension(c16_ext);
    } else
        return {};

    return fs::file_exists(path) && !fs::is_directory(path) ? path : fs::path{};
}

// Modal prompt to update the partner file if it exists.
// Runs continuation on_partner_action to update the partner file.
// Returns true is a partner is found, otherwise false.
// Path must be the full path to the file.
bool partner_file_prompt(
    NavigationView& nav,
    const fs::path& path,
    std::string action_name,
    std::function<void(const fs::path&, bool)> on_partner_action) {
    auto partner = get_partner_file(path);

    if (partner.empty())
        return false;

    // Display the continuation UI once the current has been popped.
    nav.set_on_pop([&nav, partner, action_name, on_partner_action] {
        nav.display_modal(
            "Partner File",
            partner.filename().string() + "\n" + action_name + " this file too?",
            YESNO,
            [&nav, partner, on_partner_action](bool choice) {
                if (on_partner_action)
                    on_partner_action(partner, choice);
            });
    });

    return true;
}

fs::path get_unique_filename(const fs::path& path, const fs::path& file) {
    auto stem = file.stem();
    auto ext = file.extension();
    auto serial = 1;
    fs::path new_path = file;

    while (fs::file_exists(path / new_path)) {
        new_path = stem;
        new_path += fs::path{u"_"};
        new_path += to_string_dec_int(serial++);
        new_path += ext;
    }

    return new_path;
}

}  // namespace

namespace ui {

/* FileManBaseView ***********************************************************/

void FileManBaseView::load_directory_contents_unordered(const fs::path& dir_path, size_t file_cnt) {
    current_path = dir_path;
    entry_list.clear();
    menu_view.clear();
    auto filtering = !extension_filter.empty();
    bool cxx_file = path_iequal(cxx_ext, extension_filter);

    text_current.set(dir_path.empty() ? "(sd root)" : truncate(dir_path, 24));

    nb_pages = 1 + (file_cnt / items_per_page);
    size_t start = pagination * items_per_page;
    size_t stop = start + items_per_page;
    if (file_cnt < stop) stop = file_cnt;
    if (start > file_cnt) start = 0;  // shouldn't hapen but check against it won't hurt

    size_t curr = 0;

    for (const auto& entry : fs::directory_iterator(dir_path, u"*")) {
        if (entry_list.size() >= items_per_page) {
            break;
        }
        // Hide files starting with '.' (hidden / tmp).
        if (!show_hidden_files && is_hidden_file(entry.path()))
            continue;

        if (fs::is_regular_file(entry.status())) {
            if (!filtering || path_iequal(entry.path().extension(), extension_filter) || (cxx_file && is_cxx_capture_file(entry.path()))) {
                curr++;
                if (curr >= start) insert_sorted(entry_list, {entry.path().string(), (uint32_t)entry.size(), false});
            }

        } else if (fs::is_directory(entry.status())) {
            curr++;
            if (curr >= start) insert_sorted(entry_list, {entry.path().string(), 0, true});
        }
    }

    // Add "parent" directory if not at the root.
    if (!dir_path.empty() && pagination == 0)
        entry_list.insert(entry_list.begin(), {parent_dir_path.string(), 0, true});

    // add next page
    if (file_cnt > start + items_per_page) {
        entry_list.push_back({str_next, (uint32_t)pagination + 1, true});
    }

    // add prev page
    if (pagination > 0) {
        entry_list.insert(entry_list.begin(), {str_back, (uint32_t)pagination - 1, true});
    }
}

int FileManBaseView::file_count_filtered(const fs::path& directory) {
    int count{0};
    auto filtering = !extension_filter.empty();
    bool cxx_file = path_iequal(cxx_ext, extension_filter);

    for (auto& entry : std::filesystem::directory_iterator(directory, (const TCHAR*)u"*")) {
        if (fs::is_regular_file(entry.status())) {
            if (!filtering || path_iequal(entry.path().extension(), extension_filter) || (cxx_file && is_cxx_capture_file(entry.path())))
                ++count;
        } else
            ++count;
    }
    return count;
}

void FileManBaseView::load_directory_contents(const fs::path& dir_path) {
    size_t file_cnt = file_count_filtered(dir_path);
    if (file_cnt >= max_items_loaded) {
        load_directory_contents_unordered(dir_path, file_cnt);
        return;
    }
    current_path = dir_path;
    entry_list.clear();
    menu_view.clear();
    auto filtering = !extension_filter.empty();
    bool cxx_file = path_iequal(cxx_ext, extension_filter);

    text_current.set(dir_path.empty() ? "(sd root)" : truncate(dir_path, 24));

    for (const auto& entry : fs::directory_iterator(dir_path, u"*")) {
        // Hide files starting with '.' (hidden / tmp).
        if (!show_hidden_files && is_hidden_file(entry.path()))
            continue;

        if (fs::is_regular_file(entry.status())) {
            if (!filtering || path_iequal(entry.path().extension(), extension_filter) || (cxx_file && is_cxx_capture_file(entry.path())))
                insert_sorted(entry_list, {entry.path().string(), (uint32_t)entry.size(), false});
        } else if (fs::is_directory(entry.status())) {
            insert_sorted(entry_list, {entry.path().string(), 0, true});
        }
    }

    // paginating
    auto list_size = entry_list.size();
    nb_pages = 1 + (list_size / items_per_page);
    size_t start = pagination * items_per_page;
    size_t stop = start + items_per_page;
    if (list_size > start) {
        if (list_size < stop)
            stop = list_size;
        entry_list.erase(std::next(entry_list.begin(), stop), entry_list.end());
        entry_list.erase(entry_list.begin(), std::next(entry_list.begin(), start));
    }

    // Add "parent" directory if not at the root.
    if (!dir_path.empty() && pagination == 0)
        entry_list.insert(entry_list.begin(), {parent_dir_path.string(), 0, true});

    // add next page
    if (list_size > start + items_per_page) {
        entry_list.push_back({str_next, (uint32_t)pagination + 1, true});
    }

    // add prev page
    if (pagination > 0) {
        entry_list.insert(entry_list.begin(), {str_back, (uint32_t)pagination - 1, true});
    }
}

fs::path FileManBaseView::get_selected_full_path() const {
    if (get_selected_entry().path == parent_dir_path.string())
        return current_path.parent_path();

    return current_path / get_selected_entry().path;
}

const fileman_entry& FileManBaseView::get_selected_entry() const {
    // TODO: return reference to an "empty" entry on OOB?
    auto it = entry_list.begin();
    if (menu_view.highlighted_index() >= 1) std::advance(it, menu_view.highlighted_index());
    return *it;
    // return entry_list[menu_view.highlighted_index()];
}

FileManBaseView::FileManBaseView(
    NavigationView& nav,
    std::string filter)
    : nav_{nav},
      extension_filter{filter} {
    add_children({&labels,
                  &text_current,
                  &button_exit});

    button_exit.on_select = [this](Button&) {
        nav_.pop();
    };

    if (!sdcIsCardInserted(&SDCD1)) {
        empty_ = EmptyReason::NoSDC;
        text_current.set("NO SD CARD!");
        return;
    }

    load_directory_contents(current_path);

    if (!entry_list.size()) {
        empty_ = EmptyReason::NoFiles;
        text_current.set("EMPTY SD CARD!");
    } else {
        menu_view.on_left = [this]() {
            pop_dir();
        };
    }
}

void FileManBaseView::focus() {
    if (empty_ != EmptyReason::NotEmpty) {
        button_exit.focus();
    } else {
        menu_view.focus();
    }
}

void FileManBaseView::push_dir(const fs::path& path) {
    if (path == parent_dir_path) {
        pop_dir();
    } else {
        current_path /= path;
        saved_index_stack.push_back(menu_view.highlighted_index());
        menu_view.set_highlighted(0);
        reload_current(true);
    }
}

void FileManBaseView::pop_dir() {
    if (saved_index_stack.empty())
        return;

    current_path = current_path.parent_path();
    reload_current(true);
    menu_view.set_highlighted(saved_index_stack.back());
    saved_index_stack.pop_back();
}

std::string get_extension(std::string t) {
    const auto index = t.find_last_of(u'.');
    if (index == t.npos) {
        return {};
    } else {
        return t.substr(index);
    }
}

std::string get_stem(std::string t) {
    const auto index = t.find_last_of(u'.');
    if (index == t.npos) {
        return t;
    } else {
        return t.substr(0, index);
    }
}
std::string get_filename(std::string _s) {
    const auto index = _s.find_last_of("/");
    if (index == _s.npos) {
        return _s;
    } else {
        return _s.substr(index + 1);
    }
}
void FileManBaseView::refresh_list() {
    if (on_refresh_widgets)
        on_refresh_widgets(false);

    prev_highlight = menu_view.highlighted_index();
    menu_view.clear();

    for (const auto& entry : entry_list) {
        auto entry_name = std::string{entry.path.length() <= 20 ? entry.path : entry.path.substr(0, 20)};

        if (entry.is_directory) {
            std::string size_str{};
            if (entry.path == str_next || entry.path == str_back) {
                size_str = to_string_dec_uint(1 + entry.size) + "/" + to_string_dec_uint(nb_pages);  // show computed number of pages
            } else {
                size_str = (entry.path == parent_dir_path.string()) ? "" : to_string_dec_uint(file_count(current_path / entry.path));
            }

            menu_view.add_item(
                {entry_name.substr(0, max_filename_length) + std::string(21 - entry_name.length(), ' ') + size_str,
                 Theme::getInstance()->fg_yellow->foreground,
                 &bitmap_icon_dir,
                 [this](KeyEvent key) {
                     if (on_select_entry)
                         on_select_entry(key);
                 }});

        } else {
            const auto& assoc = get_assoc(get_extension(entry.path));
            auto size_str = to_string_file_size(entry.size);

            menu_view.add_item(
                {entry_name.substr(0, max_filename_length) + std::string(21 - entry_name.length(), ' ') + size_str,
                 assoc.color,
                 assoc.icon,
                 [this](KeyEvent key) {
                     if (on_select_entry)
                         on_select_entry(key);
                 }});
        }
    }

    menu_view.set_highlighted(prev_highlight);
}

void FileManBaseView::reload_current(bool reset_pagination) {
    if (reset_pagination) pagination = 0;
    load_directory_contents(current_path);
    refresh_list();
}

const FileManBaseView::file_assoc_t& FileManBaseView::get_assoc(
    const fs::path& ext) const {
    size_t index = 0;

    for (; index < file_types.size() - 1; ++index)
        if (path_iequal(ext, file_types[index].extension))
            return file_types[index];

    // Default to last entry in the list.
    return file_types[index];
}

/* FileLoadView **************************************************************/

FileLoadView::FileLoadView(
    NavigationView& nav,
    std::string filter)
    : FileManBaseView(nav, filter) {
    on_refresh_widgets = [this](bool v) {
        refresh_widgets(v);
    };

    add_children({&menu_view});

    // Resize menu view to fill screen
    menu_view.set_parent_rect({0, 3 * 8, 240, 29 * 8});

    refresh_list();

    on_select_entry = [this](KeyEvent) {
        if (get_selected_entry().is_directory) {
            if (get_selected_entry().path == str_full) {
                return;
            }
            if (get_selected_entry().path == str_back) {
                pagination--;
                menu_view.set_highlighted(0);
                reload_current(false);
                return;
            }
            if (get_selected_entry().path == str_next) {
                pagination++;
                menu_view.set_highlighted(0);
                reload_current(false);
                return;
            }
            push_dir(get_selected_entry().path);
        } else {
            if (on_changed)
                on_changed(get_selected_full_path());
            nav_.pop();
        }
    };
}

void FileLoadView::refresh_widgets(const bool) {
    set_dirty();
}

/* FileSaveView **************************************************************/
/*
FileSaveView::FileSaveView(
        NavigationView& nav,
        const fs::path& path,
        const fs::path& file
) : nav_{ nav },
        path_{ path },
        file_{ file }
{
        add_children({
                &text_path,
                &button_edit_path,
                &text_name,
                &button_edit_name,
                &button_save,
                &button_cancel,
        });

        button_edit_path.on_select = [this](Button&) {
                buffer_ = path_.string();
                text_prompt(nav_, buffer_, max_filename_length,
                        [this](std::string&) {
                                path_ = buffer_;
                                refresh_widgets();
                        });
        };

        button_edit_name.on_select = [this](Button&) {
                buffer_ = file_.string();
                text_prompt(nav_, buffer_, max_filename_length,
                        [this](std::string&) {
                                file_ = buffer_;
                                refresh_widgets();
                        });
        };

        button_save.on_select = [this](Button&) {
                if (on_save)
                        on_save(path_ / file_);
                else
                        nav_.pop();
        };

        button_cancel.on_select = [this](Button&) {
                nav_.pop();
        };

        refresh_widgets();
}

void FileSaveView::refresh_widgets() {
        text_path.set(truncate(path_, 30));
        text_name.set(truncate(file_, 30));
        set_dirty();
}
*/
/* FileManagerView ***********************************************************/

void FileManagerView::refresh_widgets(const bool v) {
    button_rename.hidden(v);
    button_delete.hidden(v);
    button_clean.hidden(v);
    button_cut.hidden(v);
    button_copy.hidden(v);
    button_paste.hidden(v);
    button_new_dir.hidden(v);
    button_new_file.hidden(v);

    set_dirty();
}

void FileManagerView::on_rename(std::string_view hint) {
    auto& entry = get_selected_entry();

    // Append the hint to the filename stem as a rename suggestion.
    name_buffer = get_stem(entry.path);
    if (!hint.empty())
        name_buffer += "_" + std::string{hint};
    name_buffer += get_extension(entry.path);

    // Set the rename cursor to before the extension to make renaming simpler.
    uint32_t cursor_pos = (uint32_t)name_buffer.length();
    if (auto pos = name_buffer.find_last_of(".");
        pos != name_buffer.npos && !entry.is_directory)
        cursor_pos = pos;

    text_prompt(
        nav_, name_buffer, cursor_pos, max_filename_length,
        [this](std::string& renamed) {
            auto renamed_path = fs::path{renamed};
            rename_file(get_selected_full_path(), current_path / renamed_path);

            auto has_partner = partner_file_prompt(
                nav_, get_selected_full_path(), "Rename",
                [this, renamed_path](const fs::path& partner, bool should_rename) mutable {
                    if (should_rename) {
                        auto new_name = renamed_path.replace_extension(partner.extension());
                        rename_file(partner, current_path / new_name);
                    }
                    reload_current(false);
                });

            if (!has_partner)
                reload_current(false);
        });
}

void FileManagerView::on_delete() {
    if (is_directory(get_selected_full_path()) && !is_empty_directory(get_selected_full_path())) {
        nav_.display_modal("Delete", " Folder is not empty;\n Use \"Clean\" button to\n empty it first.");
        return;
    }

    auto name = get_filename(get_selected_entry().path);
    nav_.push<ModalMessageView>(
        "Delete", "Delete " + name + "\nAre you sure?", YESNO,
        [this](bool choice) {
            if (choice) {
                delete_file(get_selected_full_path());

                auto has_partner = partner_file_prompt(
                    nav_, get_selected_full_path(), "Delete",
                    [this](const fs::path& partner, bool should_delete) {
                        if (should_delete)
                            delete_file(partner);
                        reload_current(true);
                    });

                if (!has_partner)
                    reload_current(true);
            }
        });
}

void FileManagerView::on_clean() {
    if (is_empty_directory(get_selected_full_path())) {
        nav_.display_modal("Clean", "Folder is Empty;\nUse \"Delete\" button instead\nof \"Clean\" button to delete\nit.");
        return;
    }

    auto path_name = is_directory(get_selected_full_path()) ? get_selected_full_path() : get_selected_full_path().parent_path();

    // selected either a single file (delete files in this directory) or a directory that is not empty (del sub files)
    nav_.push<ModalMessageView>(
        "Clean", " ALL FILES in this folder\n (excluding sub-folders)\n will be DELETED!\n\n Delete all files?", YESNO,
        [this, path_name](bool choice) {
            if (choice) {
                std::vector<std::filesystem::path> file_list;
                file_list = scan_root_files(path_name, u"*");

                for (const auto& file_name : file_list) {
                    std::filesystem::path current_full_path = path_name / file_name;
                    delete_file(current_full_path);
                }
                reload_current(true);
            }
        });
}

void FileManagerView::on_new_dir() {
    name_buffer = "";
    text_prompt(nav_, name_buffer, max_filename_length, [this](std::string& dir_name) {
        make_new_directory(current_path / dir_name);
        reload_current(true);
    });
}

void FileManagerView::on_paste() {
    // TODO: handle partner file. Need to fix nav stack first.
    auto new_name = get_unique_filename(current_path, clipboard_path.filename());
    fs::filesystem_error result;

    if (clipboard_mode == ClipboardMode::Cut)
        if ((current_path / clipboard_path.filename()) == clipboard_path)
            result = FR_OK;  // Skip paste to avoid renaming if path is unchanged
        else
            result = rename_file(clipboard_path, current_path / new_name);

    else if (clipboard_mode == ClipboardMode::Copy)
        result = copy_file(clipboard_path, current_path / new_name);

    if (result.code() != FR_OK)
        nav_.display_modal("Paste Failed", result.what());

    clipboard_path = fs::path{};
    clipboard_mode = ClipboardMode::None;
    menu_view.focus();
    reload_current(true);
}

void FileManagerView::on_new_file() {
    name_buffer = "";
    text_prompt(nav_, name_buffer, max_filename_length, [this](std::string& file_name) {
        make_new_file(current_path / file_name);
        reload_current(true);
    });
}

bool FileManagerView::handle_file_open() {
    if (!selected_is_valid())
        return false;

    auto path = get_selected_full_path();
    auto ext = path.extension();

    if (path_iequal(txt_ext, ext)) {
        nav_.push<TextEditorView>(path);
        return true;
    } else if (is_cxx_capture_file(path) || path_iequal(ppl_ext, ext)) {
        // TODO: Enough memory to push?
        nav_.push<PlaylistView>(path);
        return true;
    } else if (path_iequal(png_ext, ext)) {
        nav_.push<ScreenshotViewer>(path);
        return true;
    } else if (path_iequal(bmp_ext, ext)) {
        if (path_iequal(current_path, u"/" + splash_dir)) {
            nav_.push<SplashViewer>(path);  // splash, so load that viewer
        } else {
            nav_.push<BMPFileViewer>(path);  // any other bmp
        }

        reload_current(false);
        return true;
    }
    /*else if (path_iequal(rem_ext, ext)) {
        nav_.push<RemoteView>(path);
        return true;
    }*/

    return false;
}

bool FileManagerView::selected_is_valid() const {
    return !entry_list.empty() &&
           get_selected_entry().path != parent_dir_path.string();
}

FileManagerView::FileManagerView(
    NavigationView& nav)
    : FileManBaseView(nav, "") {
    // Don't bother with the UI in the case of no SDC.
    if (empty_ == EmptyReason::NoSDC)
        return;

    on_refresh_widgets = [this](bool v) {
        refresh_widgets(v);
    };

    add_children({
        &menu_view,
        &text_date,
        &button_rename,
        &button_delete,
        &button_clean,
        &button_cut,
        &button_copy,
        &button_paste,
        &button_new_dir,
        &button_new_file,
        &button_open_notepad,
        &button_rename_timestamp,
        &button_open_iq_trim,
        &button_show_hidden_files,
    });

    menu_view.on_highlight = [this]() {
        if (menu_view.highlighted_index() >= max_items_loaded - 1) {  // todo check this if correct
            text_date.set_style(Theme::getInstance()->fg_red);
            text_date.set("Too many files!");
        } else {
            text_date.set_style(Theme::getInstance()->fg_medium);
            if (selected_is_valid()) {
                if (get_selected_entry().path == str_back) {
                    text_date.set("Go page " + std::to_string(pagination + 1 - 1));  // for better explain, pagination start with 0 AKA real page - 1
                } else if (get_selected_entry().path == str_next) {
                    text_date.set("Go page " + std::to_string(pagination + 1 + 1));  // when show this, it should display current AKA (pagination + 1) + 1 AKA next page
                } else {
                    text_date.set((is_directory(get_selected_full_path()) ? "Created " : "Modified ") + to_string_FAT_timestamp(file_created_date(get_selected_full_path())));
                }
            } else {
                text_date.set("");
            }
        }
    };

    refresh_list();

    on_select_entry = [this](KeyEvent key) {
        if (key == KeyEvent::Select) {
            if (get_selected_entry().is_directory) {
                if (get_selected_entry().path == str_full) {
                    return;
                }
                if (get_selected_entry().path == str_back) {
                    pagination--;
                    menu_view.set_highlighted(0);
                    reload_current(false);
                    return;
                }
                if (get_selected_entry().path == str_next) {
                    pagination++;
                    menu_view.set_highlighted(0);
                    reload_current(false);
                    return;
                }
                push_dir(get_selected_entry().path);
                return;
            } else if (handle_file_open()) {
                return;
            }
        }
        button_rename.focus();
    };

    button_rename.on_select = [this]() {
        if (selected_is_valid())
            on_rename("");
    };

    button_delete.on_select = [this]() {
        if (selected_is_valid())
            on_delete();
    };

    button_clean.on_select = [this]() {
        if (selected_is_valid())
            on_clean();
    };

    button_cut.on_select = [this]() {
        if (selected_is_valid()) {
            clipboard_path = get_selected_full_path();
            clipboard_mode = ClipboardMode::Cut;
        } else
            nav_.display_modal("Cut", "Can't cut that.");
    };

    button_copy.on_select = [this]() {
        if (selected_is_valid() && !get_selected_entry().is_directory) {
            clipboard_path = get_selected_full_path();
            clipboard_mode = ClipboardMode::Copy;
        } else
            nav_.display_modal("Copy", "Can't copy that.");
    };

    button_paste.on_select = [this]() {
        if (clipboard_mode != ClipboardMode::None)
            on_paste();
        else
            nav_.display_modal("Paste", "    Cut or copy a file,\n  or cut a folder, first.");
    };

    button_new_dir.on_select = [this]() {
        on_new_dir();
    };

    button_new_file.on_select = [this]() {
        on_new_file();
    };

    button_open_notepad.on_select = [this]() {
        if (selected_is_valid() && !get_selected_entry().is_directory) {
            auto path = get_selected_full_path();
            nav_.push<TextEditorView>(path);
        } else
            nav_.display_modal("Open in Notepad", "Can't open that in Notepad.");
    };

    button_rename_timestamp.on_select = [this]() {
        if (selected_is_valid()) {
            on_rename(::truncate(to_string_timestamp(rtc_time::now()), 8));
        } else
            nav_.display_modal("Timestamp Rename", "Can't rename that.");
    };

    button_open_iq_trim.on_select = [this]() {
        auto path = get_selected_full_path();
        if (selected_is_valid() && !get_selected_entry().is_directory && is_cxx_capture_file(path)) {
            nav_.push<IQTrimView>(path);
        } else
            nav_.display_modal("IQ Trim", "Not a capture file.");
    };

    button_show_hidden_files.on_select = [this]() {
        show_hidden_files = !show_hidden_files;
        button_show_hidden_files.set_color(show_hidden_files ? *Theme::getInstance()->status_active : Theme::getInstance()->bg_dark->background);
        reload_current();
    };
}

}  // namespace ui