AlertWindowRealtime.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 "AlertWindowRealtime.hpp"
#include "Quarantine.hpp"
#include "Resource.hpp"
#include <filesystem>
#include <iostream>
#include <fstream>
#include <glib/gi18n.h>
#include <glibmm/miscutils.h>
 
 
static std::string 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";
}
AlertWindowRealtime::AlertWindowRealtime(
        const std::string& file,
        const std::string& family,
        size_t pending)
    : 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();
    });
}
 
void AlertWindowRealtime::move_to_quarantine() {
    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;
 
}