#include <AlertWindowRealtime.hpp>

Inheritance diagram for AlertWindowRealtime:

Public Member Functions
	AlertWindowRealtime (const std::string &file, const std::string &family, size_t pending=0)

Public Attributes
sigc::signal< void()>	signal_ignore_all

Private Member Functions
void	move_to_quarantine ()

Private Attributes
std::string	filePath
Gtk::Box	vbox
Gtk::Label	titleLabel
Gtk::Label	messageLabel
Gtk::Label	pendingLabel
Gtk::Button	quarantineButton
Gtk::Button	ignoreButton
Gtk::Button	ignoreAllButton

Detailed Description

Definition at line 25 of file AlertWindowRealtime.hpp.

Constructor & Destructor Documentation

◆ AlertWindowRealtime()

AlertWindowRealtime::AlertWindowRealtime	(	const std::string &	file,
		const std::string &	family,
		size_t	pending = 0 )

Definition at line 40 of file AlertWindowRealtime.cpp.

    : filePath(file),
      vbox(Gtk::Orientation::VERTICAL, 15),
      titleLabel(_("⚠️ Ransomware rilevato in tempo reale")),
      messageLabel(
            Glib::ustring::compose(
                _("Famiglia: %1\nFile: %2"),
                family,
                file
            )
        ),
      quarantineButton(_("Metti in quarantena")),
      ignoreButton(_("Ignora")),
      ignoreAllButton(_("Ignora tutti"))
{
 
    set_title("");
    set_default_size(620, 240);
    set_resizable(false);
    set_modal(true);
 
    auto ctx = get_style_context();
    ctx->add_class("app-dialog");
    ctx->add_class("main-window");
    ctx->add_class("app-window");
 
    try {
        auto css = Gtk::CssProvider::create();
        css->load_from_path(resource(resolve_theme_css()));
        Gtk::StyleContext::add_provider_for_display(
            Gdk::Display::get_default(),
            css,
            GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
        );
    } catch (...) {
        std::cerr << _("Errore caricamento CSS\n");
    }
 
    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 (...) {
        std::cerr << _("Icona X non trovata\n");
    }
 
    header->pack_end(*close_box);
 
    auto *header_wrapper = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    header_wrapper->append(*header);
    set_titlebar(*header_wrapper);
    titleLabel.set_halign(Gtk::Align::CENTER);
    titleLabel.set_margin_bottom(5);
    titleLabel.add_css_class("title");
 
    std::string iconPath =
        (family == "OK" || family == "Clean" || family == "None")
        ? "/usr/share/BastionGuard/data/icons/true.png"
        : "/usr/share/BastionGuard/data/icons/false.png";
 
    auto icon = Gtk::make_managed<Gtk::Picture>();
    icon->set_halign(Gtk::Align::CENTER);
    icon->set_margin_bottom(10);
 
    if (std::filesystem::exists(iconPath)) {
        try {
            auto pb = Gdk::Pixbuf::create_from_file(iconPath);
            auto scaled = pb->scale_simple(68, 68, Gdk::InterpType::BILINEAR);
            auto tex = Gdk::Texture::create_for_pixbuf(scaled);
            icon->set_paintable(tex);
        } catch (...) {
            std::cerr << _("Errore caricamento icona alert\n");
        }
    }
 
    messageLabel.set_wrap(true);
    messageLabel.set_justify(Gtk::Justification::CENTER);
    messageLabel.set_halign(Gtk::Align::CENTER);
 
   if (pending > 0) {
        pendingLabel.set_text(
            Glib::ustring::compose(
                _("🕒 %1 altri in attesa..."),
                pending
            )
        );
        pendingLabel.set_halign(Gtk::Align::CENTER);
    }
 
 
    quarantineButton.add_css_class("btn-danger");
    ignoreButton.add_css_class("btn-success");
    ignoreAllButton.add_css_class("btn-warning");
 
    auto buttonBox =
        Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 20);
    buttonBox->set_halign(Gtk::Align::CENTER);
    buttonBox->append(quarantineButton);
    buttonBox->append(ignoreButton);
    buttonBox->append(ignoreAllButton);
    set_child(vbox);
    vbox.set_margin(25);
    vbox.set_halign(Gtk::Align::CENTER);
    vbox.append(titleLabel);
    vbox.append(*icon);
    vbox.append(messageLabel);
    if (pending > 0) vbox.append(pendingLabel);
    vbox.append(*buttonBox);
    quarantineButton.signal_clicked().connect([this]() {
        move_to_quarantine();
        hide();
    });
    ignoreButton.signal_clicked().connect([this]() { hide(); });
    ignoreAllButton.signal_clicked().connect([this]() {
        signal_ignore_all.emit();
        hide();
    });
}

References _, filePath, ignoreAllButton, ignoreButton, messageLabel, move_to_quarantine(), pendingLabel, quarantineButton, resolve_theme_css(), resource(), signal_ignore_all, titleLabel, and vbox.

Member Function Documentation

◆ move_to_quarantine()

void AlertWindowRealtime::move_to_quarantine ( )

private

Definition at line 174 of file AlertWindowRealtime.cpp.

                                             {
    if (Quarantine::move(filePath))
        std::cout << Glib::ustring::compose(
            _("[✔] File quarantena: %1"),
            filePath
        ) << "\n";
    else
        std::cerr << Glib::ustring::compose(
            _("[ERROR] Quarantena fallita per: %1"),
            filePath
        ) << std::endl;
 
}