FirewallChoiceDialog.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 "FirewallChoiceDialog.hpp"
#include "Utils.hpp"
#include <iostream>
#include <filesystem>
#include <fstream>
#include <glib/gi18n.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ì la finestra di
// configurazione del firewall IP segue il tema (dark/light) impostato
// dall'utente in Settings.
static std::string firewall_choice_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";
}
 
FirewallChoiceDialog::FirewallChoiceDialog()
    : vbox(Gtk::Orientation::VERTICAL, 15),
      titleLabel(_("Protezione Firewall")),
      descriptionLabel(_("Scegli quale firewall usare per bloccare gli IP malevoli:")),
      firewalldButton(_("Usa firewalld")),
      ufwButton(_("Usa UFW")),
      installButton(_("Installa firewall")),
      cancelButton(_("Annulla"))
{
    detected = FirewallDetector::detectFirewall();
    distro    = FirewallDetector::detectDistro();
 
 
    set_title("");
    set_default_size(520, 260);
    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(firewall_choice_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->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.add_css_class("title");
 
    descriptionLabel.set_wrap(true);
    descriptionLabel.set_halign(Gtk::Align::CENTER);
    descriptionLabel.set_margin_bottom(10);
 
    firewalldButton.add_css_class("btn-success");
    ufwButton.add_css_class("btn-success");
    installButton.add_css_class("btn-warning");
    cancelButton.add_css_class("btn-danger");
 
    auto *buttonBox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 10);
    buttonBox->set_halign(Gtk::Align::CENTER);
 
    if (FirewallDetector::isFirewalldPresent())
        buttonBox->append(firewalldButton);
 
    if (FirewallDetector::isUfwPresent())
        buttonBox->append(ufwButton);
 
    if (detected == FirewallType::NONE) {
        std::string cmd = FirewallInstaller::getInstallCommand(distro);
 
        if (!cmd.empty()) {
            installButton.set_label(
                Glib::ustring::compose(
                    _("Installa firewall (%1)"),
                    cmd
                )
            );
            buttonBox->append(installButton);
        }
    }
 
    buttonBox->append(cancelButton);
 
    set_child(vbox);
    vbox.set_margin(25);
    vbox.set_halign(Gtk::Align::CENTER);
 
    vbox.append(titleLabel);
    vbox.append(descriptionLabel);
    vbox.append(*buttonBox);
 
 
    firewalldButton.signal_clicked().connect([this]() {
        signal_firewall_selected.emit(FirewallType::FIREWALLD);
        hide();
    });
 
    ufwButton.signal_clicked().connect([this]() {
        signal_firewall_selected.emit(FirewallType::UFW);
        hide();
    });
 
    installButton.signal_clicked().connect([this]() {
        Utils::show_message(
            this,
            _("Per installare il firewall esegui il comando:\n\n") +
             FirewallInstaller::getInstallCommand(distro),
            Gtk::MessageType::INFO
        );
    });
 
    cancelButton.signal_clicked().connect([this]() {
        hide();
    });
 
}