file_helper.h

#pragma once
 
#include <cgv/gui/property_string.h>
#include <cgv/gui/provider.h>
#include <cgv/utils/file.h>
#include <cgv/utils/scan.h>
 
namespace cgv {
namespace gui {
 
class file_helper {
public:
    enum class Mode {
        kOpen,
        kSave,
        kOpenAndSave
    };
 
private:
    provider* provider_ptr_ = nullptr;
 
    Mode mode_ = Mode::kOpen;
    std::string open_title_ = "";
    std::string save_title_ = "";
    std::string open_filter_ = "";
    std::string save_filter_ = "";
    std::string open_path_ = "";
    std::string save_path_ = "";
 
    bool mode_allows_open(Mode mode) const {
        return mode == Mode::kOpenAndSave || mode == Mode::kOpen;
    }
 
    bool mode_allows_save(Mode mode) const {
        return mode == Mode::kOpenAndSave || mode == Mode::kSave;
    }
 
    void extend_filter_string(const std::string& entry, std::string& to_filter) {
        if(!to_filter.empty())
            to_filter += "|";
 
        to_filter += entry;
    }
 
    void add_filter_entry(const std::string& entry, Mode mode) {
        if(mode_allows_open(mode))
            extend_filter_string(entry, open_filter_);
 
        if(mode_allows_save(mode))
            extend_filter_string(entry, save_filter_);
    }
 
public:
    std::string file_name = "";
 
    file_helper() {}
 
    file_helper(provider* p, const std::string& title, Mode mode) : provider_ptr_(p), mode_(mode) {
        if(mode_allows_open(mode_))
            open_title_ = title;
 
        if(mode_allows_save(mode_))
            save_title_ = title;
    }
 
    bool can_open() const {
        return mode_allows_open(mode_);
    }
 
    bool can_save() const {
        return mode_allows_save(mode_);
    }
 
    const std::string& get_title(Mode mode = Mode::kOpenAndSave) const {
        if(mode_allows_open(mode))
            return open_title_;
 
        return save_title_;
    }
 
    void set_title(const std::string& title, Mode mode = Mode::kOpenAndSave) {
        if(mode_allows_open(mode))
            open_title_ = title;
 
        if(mode_allows_save(mode))
            save_title_ = title;
 
        if(provider_ptr_) {
            provider_ptr_->set_control_property(file_name, "open_title", open_title_);
            provider_ptr_->set_control_property(file_name, "save_title", save_title_);
        }
    }
 
    const std::string& get_default_path(Mode mode = Mode::kOpenAndSave) const {
        if(mode_allows_open(mode))
            return open_path_;
 
        return save_path_;
    }
 
    void set_default_path(const std::string& path, Mode mode = Mode::kOpenAndSave) {
        if(mode_allows_open(mode))
            open_path_ = path;
 
        if(mode_allows_save(mode))
            save_path_ = path;
 
        if(provider_ptr_) {
            provider_ptr_->set_control_property(file_name, "open_path", open_path_);
            provider_ptr_->set_control_property(file_name, "save_path", save_path_);
        }
    }
 
    void set_file_name(const std::string& file_name) {
        this->file_name = file_name;
 
        if(provider_ptr_)
            provider_ptr_->update_member(&this->file_name);
    }
 
    void clear_filters() {
        open_filter_ = "";
        save_filter_ = "";
    }
 
    void add_filter(const std::string& name, const std::string& extension, Mode mode = Mode::kOpenAndSave) {
        std::string entry = name + " (*." + extension + "):*." + extension;
        add_filter_entry(entry, mode);
    }
 
    void add_multi_filter(const std::string& name, const std::vector<std::string>& extensions, Mode mode = Mode::kOpenAndSave) {
        std::string entry = name + " (*." + cgv::utils::join(extensions, ", *.") + "):*." + cgv::utils::join(extensions, ";*.");
        add_filter_entry(entry, mode);
    }
 
    void add_filter_for_all_files(Mode mode = Mode::kOpenAndSave) {
        add_filter_entry("All Files (*.*):*.*", mode);
    }
 
    bool compare_extension(const std::string& extension) const {
        return cgv::utils::to_upper(cgv::utils::file::get_extension(file_name)) == cgv::utils::to_upper(extension);
    }
 
    const std::string ensure_extension(const std::string& extension, bool force = false) {
        std::string current_extension = cgv::utils::file::get_extension(file_name);
 
        if(cgv::utils::to_upper(current_extension) != cgv::utils::to_upper(extension)) {
            if(current_extension.empty() || force) {
                set_file_name(file_name + "." + extension);
                return extension;
            }
        }
 
        return current_extension;
    }
 
    void create_gui(const std::string& label, const std::string& extra_options = "") {
        property_string options;
 
        options.add("open", can_open());
        options.add("save", can_save());
 
        options.add_bracketed("open_title", open_title_);
        options.add_bracketed("save_title", save_title_);
 
        options.add_bracketed("open_filter", open_filter_);
        options.add_bracketed("save_filter", save_filter_);
 
        options.add_bracketed("open_path", open_path_);
        options.add_bracketed("save_path", save_path_);
 
        options.add("", extra_options);
 
        if(provider_ptr_)
            provider_ptr_->add_gui(label, file_name, "file_name", options);
    }
 
    bool is_save_action() const {
        return provider_ptr_ ? provider_ptr_->ref_tree_node_visible_flag(file_name) : false;
    }
};
 
}
}