LiveScanDialog.cpp

Go to the documentation of this file.

/*
 * BastionGuard™
 * Copyright (C) 2025–2026 Calogero Scarnà
 *
 * 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, version 3.
 *
 * 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.  If not, see <https://www.gnu.org/licenses/>.
 *
 * BastionGuard™ is a trademark of Calogero Scarnà.
 * The BastionGuard™ name and branding are not licensed under the GPL.
 */
 
#include "LiveScanDialog.hpp"
#include "../Resource.hpp"
#include <fstream>
#include <glibmm/i18n.h>
#include <glibmm/miscutils.h>
 
// Sceglie il CSS in base al tema salvato in ~/.config/BastionGuard/theme.conf.
// Stessa logica di StyleProvider::load_style(), così il popup di
// scansione USB segue il tema (dark/light) impostato dall'utente.
static std::string usb_live_resolve_theme_css() {
    const std::string conf =
        Glib::get_home_dir() + "/.config/BastionGuard/theme.conf";
    std::ifstream tf(conf);
    std::string theme;
    if (tf >> theme && theme == "dark")
        return "BastionGuard-dark.css";
    return "BastionGuard.css";
}
 
LiveScanDialog::LiveScanDialog(Gtk::Window* parent, const std::string& path)
    : root_(Gtk::Orientation::VERTICAL, 16),
      alive_(BastionGuard::make_alive_flag())
{
    set_title("");
    set_default_size(620, 420);
    set_resizable(false);
    set_modal(true);
    if (parent) set_transient_for(*parent);
 
    add_css_class("app-dialog");
    add_css_class("main-window");
    add_css_class("app-window");
 
    try {
        auto css = Gtk::CssProvider::create();
        css->load_from_path(resource(usb_live_resolve_theme_css()));
        Gtk::StyleContext::add_provider_for_display(
            Gdk::Display::get_default(), css,
            GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
        );
    } catch (...) {}
 
    auto *header = Gtk::make_managed<Gtk::HeaderBar>();
    header->set_show_title_buttons(false);
    header->set_decoration_layout("");
    header->add_css_class("custom-headerbar");
 
    auto *close_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    close_box->set_margin_end(6);
 
    try {
        auto px = Gdk::Pixbuf::create_from_file(resource("icon-close.png"), 28, 28, true);
        auto btn = Gtk::make_managed<Gtk::Button>();
        btn->set_child(*Gtk::make_managed<Gtk::Image>(px));
        btn->add_css_class("header-button");
        btn->signal_clicked().connect([this]() { hide(); });
        close_box->append(*btn);
    } catch (...) {}
 
    header->pack_end(*close_box);
 
    auto *header_wrap = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    header_wrap->append(*header);
    set_titlebar(*header_wrap);
 
    root_.set_margin(20);
 
    auto title = Gtk::make_managed<Gtk::Label>(
        _("Scansione della periferica USB in corso")
    );
    title->add_css_class("title");
    title->set_halign(Gtk::Align::CENTER);
    root_.append(*title);
 
    auto *icon = Gtk::make_managed<Gtk::Picture>();
    icon->set_halign(Gtk::Align::CENTER);
    icon->set_margin_bottom(10);
    try {
        auto pb = Gdk::Pixbuf::create_from_file(resource("icons/scan.png"));
        auto scaled = pb->scale_simple(64, 64, Gdk::InterpType::BILINEAR);
        icon->set_paintable(Gdk::Texture::create_for_pixbuf(scaled));
    } catch (...) {}
    root_.append(*icon);
 
    auto device_label = Gtk::make_managed<Gtk::Label>(
        _("Percorso analizzato:\n") + path
    );
    device_label->set_wrap(true);
    device_label->set_halign(Gtk::Align::CENTER);
    root_.append(*device_label);
 
    progress_.set_pulse_step(0.1);
    progress_.set_show_text(true);
    progress_.set_text(_("Analisi in corso..."));
    root_.append(progress_);
 
    text_view_.set_editable(false);
    scroller_.set_child(text_view_);
    scroller_.set_vexpand(true);
    scroller_.add_css_class("scroller");
    root_.append(scroller_);
    btn_cancel_.set_label(_("Annulla"));
    btn_cancel_.add_css_class("btn-danger");
    btn_cancel_.set_halign(Gtk::Align::CENTER);
    btn_cancel_.signal_clicked().connect([this]() {
        cancelled_.store(true);
        btn_cancel_.set_sensitive(false);
        progress_.set_text(_("Interruzione in corso..."));
    });
    root_.append(btn_cancel_);
 
    set_child(root_);
 
    {
        auto alive = alive_;
        Glib::signal_timeout().connect(
            [this, alive]() -> bool {
                if (!alive || !alive->load(std::memory_order_acquire)) {
                    return false;  // oggetto morto: disconnette il timer
                }
                if (finished_) return false;
                progress_.pulse();
                return true;
            },
            120
        );
    }
 
    present();
}
 
 
 
LiveScanDialog::~LiveScanDialog()
{
    // Segnala ai lambda in volo (signal_idle non ancora eseguito,
    // timeout pulse pending) che l'oggetto sta per sparire.
    if (alive_) alive_->store(false, std::memory_order_release);
}
 
 
void LiveScanDialog::append_output(const std::string& line)
{
    {
        std::lock_guard<std::mutex> lock(mtx_);
        pending_lines_.push_back(line + "\n");
    }
 
    if (!flush_pending_.exchange(true)) {
        auto alive = alive_;
        Glib::signal_idle().connect_once([this, alive]() {
            BastionGuard::if_alive(alive, [this]() {
                flush_output_idle();
            });
        });
    }
}
 
 
void LiveScanDialog::flush_output_idle()
{
    flush_pending_.store(false);
 
    std::vector<std::string> lines;
    {
        std::lock_guard<std::mutex> lock(mtx_);
        lines.swap(pending_lines_);
    }
 
    if (lines.empty())
        return;
 
    auto buf = text_view_.get_buffer();
    Gtk::TextIter it = buf->end();
 
    for (auto& l : lines) {
        buf->insert(it, l);
        it = buf->end();
        full_output_ += l;
    }
 
    if (auto adj = scroller_.get_vadjustment())
        adj->set_value(adj->get_upper());
}
 
 
void LiveScanDialog::mark_finished()
{
    finished_.store(true);
 
    // Forza ultimo flush
    flush_pending_.store(true);
 
    auto alive = alive_;
    Glib::signal_idle().connect_once([this, alive]() {
        BastionGuard::if_alive(alive, [this]() {
            flush_output_idle();
            progress_.set_fraction(1.0);
            progress_.set_text(_("Completato"));
        });
    });
}
 
 
std::string LiveScanDialog::get_full_output() const
{
    std::lock_guard<std::mutex> lock(mtx_);
    return full_output_;
}