app_window.cpp

Go to the documentation of this file.

#include "app_window.hpp"
#include "i18n.hpp"
#include "report_exporter.hpp"
 
#include <iomanip>
#include <sstream>
#include <cstring>
#include <memory>
 
Glib::RefPtr<ResultRow> ResultRow::create(const Glib::ustring& v_offset,
                                          const Glib::ustring& v_size,
                                          const Glib::ustring& v_type,
                                          const Glib::ustring& v_source,
                                          const Glib::ustring& v_detail,
                                          const Glib::ustring& v_confidence) {
    auto row = Glib::make_refptr_for_instance<ResultRow>(new ResultRow());
    row->offset = v_offset;
    row->size = v_size;
    row->type = v_type;
    row->source = v_source;
    row->detail = v_detail;
    row->confidence = v_confidence;
    return row;
}
 
ResultRow::ResultRow()
    : Glib::ObjectBase("ResultRow"),
      offset(*this, "offset", ""),
      size(*this, "size", ""),
      type(*this, "type", ""),
      source(*this, "source", ""),
      detail(*this, "detail", ""),
      confidence(*this, "confidence", "") {}
 
AppWindow::AppWindow()
    : btn_open_(tr("Open image")),
      btn_scan_(tr("Scan")),
      btn_save_report_(tr("Save report")),
      btn_recover_(tr("Recover data")),
      status_(tr("Ready")) {
    set_title(tr("BastionGuard Recovery Data"));
    set_default_size(1280, 760);
 
    set_child(root_);
    root_.set_margin_top(12);
    root_.set_margin_bottom(12);
    root_.set_margin_start(12);
    root_.set_margin_end(12);
 
    entry_path_.set_hexpand(true);
    entry_path_.set_editable(false);
    btn_save_report_.set_sensitive(false);
    btn_recover_.set_sensitive(false);
    btn_recover_.set_sensitive(false);
 
    toolbar_.append(btn_open_);
    toolbar_.append(entry_path_);
    toolbar_.append(btn_scan_);
    toolbar_.append(btn_save_report_);
    toolbar_.append(btn_recover_);
 
    root_.append(toolbar_);
    root_.append(status_);
 
    store_ = Gio::ListStore<ResultRow>::create();
    selection_model_ = Gtk::SingleSelection::create(store_);
    column_view_.set_model(selection_model_);
    setup_columns();
 
    results_scroller_.set_child(column_view_);
    results_scroller_.set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
 
    log_buffer_ = Gtk::TextBuffer::create();
    log_view_.set_buffer(log_buffer_);
    log_view_.set_editable(false);
    log_view_.set_monospace(true);
    logs_scroller_.set_child(log_view_);
 
    paned_.set_start_child(results_scroller_);
    paned_.set_end_child(logs_scroller_);
    paned_.set_position(460);
 
    root_.append(paned_);
 
    btn_open_.signal_clicked().connect(sigc::mem_fun(*this, &AppWindow::on_choose_file));
    btn_scan_.signal_clicked().connect(sigc::mem_fun(*this, &AppWindow::on_scan_clicked));
    btn_save_report_.signal_clicked().connect(sigc::mem_fun(*this, &AppWindow::on_save_report_clicked));
    btn_recover_.signal_clicked().connect(sigc::mem_fun(*this, &AppWindow::on_choose_output_folder));
}
 
AppWindow::~AppWindow() = default;
 
void AppWindow::setup_columns() {
    add_text_column(tr("Offset"), "offset");
    add_text_column(tr("Size"), "size");
    add_text_column(tr("Type"), "type");
    add_text_column(tr("Source"), "source");
    add_text_column(tr("Detail"), "detail");
    add_text_column(tr("Confidence"), "confidence");
}
 
void AppWindow::add_text_column(const Glib::ustring& title, const char* property_name) {
    auto factory = Gtk::SignalListItemFactory::create();
 
    factory->signal_setup().connect([](const Glib::RefPtr<Gtk::ListItem>& item) {
        auto* label = Gtk::make_managed<Gtk::Label>();
        label->set_xalign(0.0f);
        label->set_selectable(true);
        label->set_wrap(true);
        item->set_child(*label);
    });
 
    factory->signal_bind().connect([property_name](const Glib::RefPtr<Gtk::ListItem>& item) {
        auto base = item->get_item();
        auto row = std::dynamic_pointer_cast<ResultRow>(base);
        auto* label = dynamic_cast<Gtk::Label*>(item->get_child());
 
        if (!row || !label) {
            return;
        }
 
        Glib::ustring text;
 
        if (std::strcmp(property_name, "offset") == 0) {
            text = row->offset.get_value();
        } else if (std::strcmp(property_name, "size") == 0) {
            text = row->size.get_value();
        } else if (std::strcmp(property_name, "type") == 0) {
            text = row->type.get_value();
        } else if (std::strcmp(property_name, "source") == 0) {
            text = row->source.get_value();
        } else if (std::strcmp(property_name, "detail") == 0) {
            text = row->detail.get_value();
        } else if (std::strcmp(property_name, "confidence") == 0) {
            text = row->confidence.get_value();
        }
 
        label->set_text(text);
    });
 
    auto column = Gtk::ColumnViewColumn::create(title, factory);
    column->set_resizable(true);
    column_view_.append_column(column);
}
 
void AppWindow::on_choose_file() {
    file_dialog_ = Gtk::FileDialog::create();
    file_dialog_->set_title(tr("Select disk image"));
    file_dialog_->open(*this, sigc::mem_fun(*this, &AppWindow::on_file_chosen));
}
 
void AppWindow::on_file_chosen(const Glib::RefPtr<Gio::AsyncResult>& result) {
    try {
        if (!file_dialog_) {
            append_log(trs("Internal error: file dialog unavailable."));
            return;
        }
        auto file = file_dialog_->open_finish(result);
        if (file) {
            selected_path_ = file->get_path();
            entry_path_.set_text(selected_path_);
            append_log(trs("Selected file:") + " " + selected_path_);
            status_.set_text(tr("File ready for scan"));
        }
    } catch (const Glib::Error& ex) {
        append_log(trs("File selection cancelled or failed:") + " " + ex.what());
    }
    file_dialog_.reset();
}
 
void AppWindow::on_scan_clicked() {
    if (selected_path_.empty()) {
        append_log(trs("No file selected."));
        status_.set_text(tr("Select a file first"));
        return;
    }
    if (worker_.running()) {
        append_log(trs("A scan is already running."));
        return;
    }
 
    while (store_->get_n_items() > 0) {
        store_->remove(store_->get_n_items() - 1);
    }
    last_report_ = {};
    log_buffer_->set_text("");
    append_log(trs("Starting read-only scan..."));
    status_.set_text(tr("Scanning in progress..."));
    btn_open_.set_sensitive(false);
    btn_scan_.set_sensitive(false);
    btn_save_report_.set_sensitive(false);
    btn_recover_.set_sensitive(false);
 
    worker_.start(selected_path_, [this](const ScanReport& report) {
        Glib::signal_idle().connect_once([this, report]() {
            on_scan_completed(report);
        });
    });
}
 
void AppWindow::on_scan_completed(const ScanReport& report) {
    last_report_ = report;
 
    for (const auto& line : report.logs) {
        append_log(line);
    }
 
    for (const auto& r : report.results) {
        std::ostringstream conf;
        conf << std::fixed << std::setprecision(2) << (r.confidence * 100.0) << "%";
        store_->append(ResultRow::create(human_offset(r.offset_bytes),
                                         human_size(r.size_bytes),
                                         r.type,
                                         r.source,
                                         r.detail,
                                         conf.str()));
    }
 
    status_.set_text(tr("Scan completed"));
    btn_open_.set_sensitive(true);
    btn_scan_.set_sensitive(true);
    btn_save_report_.set_sensitive(true);
    btn_recover_.set_sensitive(true);
}
 
void AppWindow::on_save_report_clicked() {
    if (last_report_.input_path.empty()) {
        append_log(trs("No scan report available."));
        return;
    }
 
    save_dialog_ = Gtk::FileDialog::create();
    save_dialog_->set_title(tr("Save report"));
    save_dialog_->save(*this, sigc::mem_fun(*this, &AppWindow::on_report_file_chosen));
}
 
void AppWindow::on_report_file_chosen(const Glib::RefPtr<Gio::AsyncResult>& result) {
    try {
        if (!save_dialog_) {
            append_log(trs("Internal error: save dialog unavailable."));
            return;
        }
 
        auto file = save_dialog_->save_finish(result);
        if (!file) {
            save_dialog_.reset();
            return;
        }
 
        const std::string path = file->get_path();
        std::string err;
        bool ok = false;
        if (path.size() >= 5 && path.substr(path.size() - 5) == ".json") {
            ok = ReportExporter::save_json(last_report_, path, err);
        } else {
            ok = ReportExporter::save_text(last_report_, path, err);
        }
 
        if (ok) {
            append_log(trs("Report saved:") + " " + path);
            status_.set_text(tr("Report saved"));
        } else {
            append_log(trs("Failed to save report:") + " " + err);
            status_.set_text(tr("Report save failed"));
        }
    } catch (const Glib::Error& ex) {
        append_log(trs("Report save cancelled or failed:") + " " + ex.what());
    }
    save_dialog_.reset();
}
 
void AppWindow::append_log(const std::string& line) {
    auto iter = log_buffer_->end();
    log_buffer_->insert(iter, line + "\n");
}
 
std::string AppWindow::human_size(uint64_t bytes) {
    const char* units[] = {"B", "KiB", "MiB", "GiB", "TiB"};
    double value = static_cast<double>(bytes);
    int idx = 0;
    while (value >= 1024.0 && idx < 4) {
        value /= 1024.0;
        ++idx;
    }
    std::ostringstream oss;
    oss << std::fixed << std::setprecision(2) << value << ' ' << units[idx];
    return oss.str();
}
 
std::string AppWindow::human_offset(uint64_t bytes) {
    std::ostringstream oss;
    oss << bytes << " (0x" << std::hex << std::uppercase << bytes << ')';
    return oss.str();
}
 
void AppWindow::on_choose_output_folder() {
    if (last_report_.input_path.empty()) {
        append_log(trs("No scan report available."));
        return;
    }
    if (recovery_worker_.running()) {
        append_log(trs("A recovery task is already running."));
        return;
    }
 
    output_dialog_ = Gtk::FileDialog::create();
    output_dialog_->set_title(tr("Select destination folder"));
    output_dialog_->select_folder(*this, sigc::mem_fun(*this, &AppWindow::on_output_folder_chosen));
}
 
void AppWindow::on_output_folder_chosen(const Glib::RefPtr<Gio::AsyncResult>& result) {
    try {
        if (!output_dialog_) {
            append_log(trs("Internal error: output dialog unavailable."));
            return;
        }
        auto file = output_dialog_->select_folder_finish(result);
        if (!file) {
            output_dialog_.reset();
            return;
        }
        output_dir_ = file->get_path();
        append_log(trs("Recovery destination:") + std::string(" ") + output_dir_);
        status_.set_text(tr("Recovery in progress..."));
        btn_open_.set_sensitive(false);
        btn_scan_.set_sensitive(false);
        btn_save_report_.set_sensitive(false);
        btn_recover_.set_sensitive(false);
 
        recovery_worker_.start(last_report_, output_dir_, [this](const RecoveryResult& rr) {
            Glib::signal_idle().connect_once([this, rr]() {
                on_recovery_completed(rr);
            });
        });
    } catch (const Glib::Error& ex) {
        append_log(trs("Destination selection cancelled or failed:") + std::string(" ") + ex.what());
    }
    output_dialog_.reset();
}
 
void AppWindow::on_recovery_completed(const RecoveryResult& result) {
    for (const auto& line : result.logs) {
        append_log(line);
    }
    if (result.ok) {
        append_log(trs("Exported images:") + std::string(" ") + std::to_string(result.summary.exported_images.size()));
        append_log(trs("Recovered files:") + std::string(" ") + std::to_string(result.summary.recovered_files.size()));
        status_.set_text(tr("Recovery completed"));
    } else {
        append_log(trs("Recovery failed:") + std::string(" ") + result.error);
        status_.set_text(tr("Recovery failed"));
    }
    btn_open_.set_sensitive(true);
    btn_scan_.set_sensitive(true);
    btn_save_report_.set_sensitive(true);
    btn_recover_.set_sensitive(true);
}