#include <LiveScanDialog.hpp>

Inheritance diagram for LiveScanDialog:

Public Member Functions
	LiveScanDialog (Gtk::Window *parent, const std::string &path)
	~LiveScanDialog () override
void	append_output (const std::string &line)
void	mark_finished ()
bool	cancelled () const
std::string	get_full_output () const

Private Member Functions
void	flush_output_idle ()

Private Attributes
Gtk::Box	root_
Gtk::ProgressBar	progress_
Gtk::ScrolledWindow	scroller_
Gtk::TextView	text_view_
Gtk::Button	btn_cancel_
std::atomic< bool >	finished_ {false}
std::atomic< bool >	cancelled_ {false}
std::atomic< bool >	flush_pending_ {false}
std::mutex	mtx_
std::vector< std::string >	pending_lines_
std::string	full_output_
BastionGuard::AliveFlag	alive_

Detailed Description

Definition at line 30 of file LiveScanDialog.hpp.

Constructor & Destructor Documentation

◆ LiveScanDialog()

LiveScanDialog::LiveScanDialog	(	Gtk::Window *	parent,
		const std::string &	path )

Definition at line 40 of file LiveScanDialog.cpp.

    : 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();
}

References _, alive_, btn_cancel_, cancelled_, finished_, progress_, resource(), root_, scroller_, text_view_, and usb_live_resolve_theme_css().

◆ ~LiveScanDialog()

LiveScanDialog::~LiveScanDialog ( )

override

Definition at line 154 of file LiveScanDialog.cpp.

{
    // 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);
}

References alive_.

Member Function Documentation

◆ append_output()

void LiveScanDialog::append_output ( const std::string & line )

Definition at line 162 of file LiveScanDialog.cpp.

{
    {
        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();
            });
        });
    }
}

References alive_, flush_output_idle(), flush_pending_, BastionGuard::if_alive(), mtx_, and pending_lines_.

◆ cancelled()

bool LiveScanDialog::cancelled ( ) const

inline

Definition at line 37 of file LiveScanDialog.hpp.

37{ return cancelled_.load(); }

References cancelled_.

◆ flush_output_idle()

void LiveScanDialog::flush_output_idle ( )

private

Definition at line 180 of file LiveScanDialog.cpp.

{
    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());
}

References flush_pending_, full_output_, mtx_, pending_lines_, scroller_, and text_view_.

Referenced by append_output(), and mark_finished().

◆ get_full_output()

std::string LiveScanDialog::get_full_output ( ) const

Definition at line 225 of file LiveScanDialog.cpp.

{
    std::lock_guard<std::mutex> lock(mtx_);
    return full_output_;
}

References full_output_, and mtx_.

◆ mark_finished()

void LiveScanDialog::mark_finished ( )

Definition at line 207 of file LiveScanDialog.cpp.

{
    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"));
        });
    });
}