SettingsWindow.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 "SettingsWindow.hpp"
#include "Resource.hpp"
#include "StyleProvider.hpp"
#include <gdkmm/pixbuf.h>
#include <glibmm/i18n.h>
#include <iostream>
#include <set>
 
SettingsWindow::SettingsWindow(ClamdConfig& config)
{
    set_title("");
    set_default_size(600, 400);
    set_modal(true);
    set_resizable(true);
 
    build_headerbar();
 
    stack_.get_style_context()->add_class("content");
    stack_.set_transition_type(Gtk::StackTransitionType::SLIDE_LEFT_RIGHT);
    stack_.set_transition_duration(220);
    stack_.set_interpolate_size(true);
 
    settingsPage_ = Gtk::make_managed<SettingsPage>(config);
    settingsPage_->set_notebook_no_tabs();
    settingsPage_->set_hexpand(true);
    settingsPage_->set_vexpand(true);
 
    stack_.add(*settingsPage_, "settings_root");
 
    mainBox_.get_style_context()->add_class("settings-main");
    build_sidebar(config);
    mainBox_.append(stack_);
    stack_.set_hexpand(true);
    stack_.set_vexpand(true);
    mainBox_.set_margin(0);
    mainBox_.set_margin_top(0);
    mainBox_.set_margin_bottom(0);
    mainBox_.set_margin_start(0);
    mainBox_.set_margin_end(0);
 
    mainBox_.set_hexpand(true);
    mainBox_.set_vexpand(true);
    set_child(mainBox_);
    get_style_context()->add_class("settings-window");
 
    load_style();
 
    signal_map().connect([this]() {
        if (global_css)
            get_style_context()->add_provider(global_css, GTK_STYLE_PROVIDER_PRIORITY_USER);
    });
 
    signal_hide().connect([this]() {
        active_button_ = nullptr;
        active_page_   = 0;
    });
 
    signal_show().connect([this]() {
        settingsPage_->goto_page(0);
        if (!all_leaf_buttons_.empty())
            activate_button(all_leaf_buttons_.front());
    });
}
 
Gtk::Button* SettingsWindow::make_group_button(const std::string& icon_path,
                                               const std::string& label_text,
                                               Gtk::Box** out_submenu)
{
    auto outer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);
 
    auto icon_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    icon_box->set_size_request(16, 16);
    icon_box->set_halign(Gtk::Align::START);
    icon_box->set_valign(Gtk::Align::CENTER);
 
    auto pic = Gtk::make_managed<Gtk::Picture>();
    if (!icon_path.empty()) {
        try {
            auto pb     = Gdk::Pixbuf::create_from_file(icon_path);
            auto scaled = pb->scale_simple(16, 16, Gdk::InterpType::BILINEAR);
            pic->set_paintable(Gdk::Texture::create_for_pixbuf(scaled));
            pic->set_content_fit(Gtk::ContentFit::FILL);
            pic->set_keep_aspect_ratio(true);
        } catch (...) {}
    }
 
    icon_box->append(*pic);
    outer->append(*icon_box);
 
    auto lbl = Gtk::make_managed<Gtk::Label>(label_text);
    lbl->set_halign(Gtk::Align::START);
    lbl->set_hexpand(true);
    outer->append(*lbl);
 
    auto chevron = Gtk::make_managed<Gtk::Label>("▸");
    chevron->set_halign(Gtk::Align::END);
    outer->append(*chevron);
 
    auto btn = Gtk::make_managed<Gtk::Button>();
    btn->set_child(*outer);
    btn->get_style_context()->add_class("sidebar-button");
 
    if (out_submenu) {
        auto sub = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 2);
        sub->set_visible(false);
        sub->get_style_context()->add_class("sidebar-submenu");
        *out_submenu = sub;
 
        btn->signal_clicked().connect([sub, chevron]() {
            bool vis = sub->get_visible();
            sub->set_visible(!vis);
            chevron->set_text(vis ? "▸" : "▾");
        });
    }
 
    return btn;
}
 
Gtk::Button* SettingsWindow::make_leaf_button(const std::string& label_text,
                                              bool indent,
                                              Gtk::Box* parent_submenu)
{
    auto lbl = Gtk::make_managed<Gtk::Label>(label_text);
    lbl->set_halign(Gtk::Align::START);
 
    auto btn = Gtk::make_managed<Gtk::Button>();
    btn->set_child(*lbl);
    btn->get_style_context()->add_class("sidebar-button");
    btn->get_style_context()->add_class("sidebar-leaf");
 
    if (indent)
        btn->get_style_context()->add_class("sidebar-leaf-indent");
 
    all_leaf_buttons_.push_back(btn);
    button_submenu_[btn] = parent_submenu;
    return btn;
}
 
void SettingsWindow::activate_button(Gtk::Button* btn)
{
    active_button_ = btn;
 
    for (auto* b : all_leaf_buttons_)
        b->get_style_context()->remove_class("active-sidebar-button");
 
    if (btn)
        btn->get_style_context()->add_class("active-sidebar-button");
 
    Gtk::Box* active_sub = button_submenu_.count(btn) ? button_submenu_.at(btn) : nullptr;
 
    std::set<Gtk::Box*> all_submenus;
    for (auto& [b, sub] : button_submenu_)
        if (sub)
            all_submenus.insert(sub);
 
    for (auto* sub : all_submenus) {
        const bool should_open = (sub == active_sub);
        sub->set_visible(should_open);
 
        if (auto* parent_box = dynamic_cast<Gtk::Box*>(sub->get_parent())) {
            Gtk::Widget* prev = nullptr;
 
            for (auto* child = parent_box->get_first_child();
                 child != nullptr;
            child = child->get_next_sibling())
                 {
                     if (child == sub) {
                         if (auto* grp_btn = dynamic_cast<Gtk::Button*>(prev)) {
                             if (auto* outer = dynamic_cast<Gtk::Box*>(grp_btn->get_child())) {
                                 Gtk::Widget* last = nullptr;
                                 for (auto* w = outer->get_first_child(); w; w = w->get_next_sibling())
                                     last = w;
 
                                 if (auto* chev = dynamic_cast<Gtk::Label*>(last))
                                     chev->set_text(should_open ? "▾" : "▸");
                             }
                         }
                         break;
                     }
                     prev = child;
                 }
        }
    }
}
 
void SettingsWindow::build_sidebar(ClamdConfig&)
{
    sidebar_box_ = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 6);
    sidebar_box_->set_size_request(220, -1);
    sidebar_box_->get_style_context()->add_class("sidebar");
    sidebar_box_->set_vexpand(true);
 
    {
        auto header = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
        header->get_style_context()->add_class("sidebar-header");
 
        try {
            auto pix = Gdk::Pixbuf::create_from_file(resource("logo-sidebar.png"), 48, 48, true);
            header->append(*Gtk::make_managed<Gtk::Image>(pix));
        } catch (...) {}
 
        auto title_lbl = Gtk::make_managed<Gtk::Label>(_("Impostazioni"));
        title_lbl->set_halign(Gtk::Align::START);
        title_lbl->get_style_context()->add_class("sidebar-title");
        header->append(*title_lbl);
        sidebar_box_->append(*header);
    }
 
    {
        auto sep = Gtk::make_managed<Gtk::Separator>(Gtk::Orientation::HORIZONTAL);
        sep->get_style_context()->add_class("sidebar-separator");
        sidebar_box_->append(*sep);
    }
 
    auto menu_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 2);
    menu_box->set_margin_top(4);
    menu_box->set_margin_bottom(4);
    menu_box->set_vexpand(true);
 
    auto go = [this](int idx) {
        active_page_ = idx;
        settingsPage_->goto_page(idx);
    };
 
    {
        auto* btn = make_leaf_button(_("Base"), false, nullptr);
        btn->signal_clicked().connect([this, btn, go]() {
            activate_button(btn);
            go(0);
        });
        menu_box->append(*btn);
    }
 
    {
        auto* btn = make_leaf_button(_("Avanzate"), false, nullptr);
        btn->signal_clicked().connect([this, btn, go]() {
            activate_button(btn);
            go(1);
        });
        menu_box->append(*btn);
    }
 
    {
        Gtk::Box* submenu = nullptr;
        auto* grp = make_group_button(resource("icons/ransomware.svg"),
                                      _("Anti-Ransomware"),
                                      &submenu);
        menu_box->append(*grp);
        menu_box->append(*submenu);
 
        auto* sub_base = make_leaf_button(_("Base"), true, submenu);
        sub_base->signal_clicked().connect([this, sub_base, go]() {
            activate_button(sub_base);
            go(2);
        });
        submenu->append(*sub_base);
 
        auto* sub_adv = make_leaf_button(_("Avanzate"), true, submenu);
        sub_adv->signal_clicked().connect([this, sub_adv, go]() {
            activate_button(sub_adv);
            go(3);
        });
        submenu->append(*sub_adv);
    }
 
    {
        Gtk::Box* submenu = nullptr;
        auto* grp = make_group_button(resource("icons/scan.svg"),
                                      _("Anti-Phishing"),
                                      &submenu);
        menu_box->append(*grp);
        menu_box->append(*submenu);
 
        auto* sub_prot = make_leaf_button(_("Protezione"), true, submenu);
        sub_prot->signal_clicked().connect([this, sub_prot, go]() {
            activate_button(sub_prot);
            go(4);
        });
        submenu->append(*sub_prot);
 
        auto* sub_wl = make_leaf_button(_("Whitelist / Blacklist"), true, submenu);
        sub_wl->signal_clicked().connect([this, sub_wl, go]() {
            activate_button(sub_wl);
            go(5);
        });
        submenu->append(*sub_wl);
    }
 
    {
        Gtk::Box* submenu = nullptr;
        auto* grp = make_group_button(resource("icons/payments.svg"),
                                      _("Pagamenti Sicuri"),
                                      &submenu);
        menu_box->append(*grp);
        menu_box->append(*submenu);
 
        auto* sub_pay = make_leaf_button(_("Domini Pagamenti"), true, submenu);
        sub_pay->signal_clicked().connect([this, sub_pay, go]() {
            activate_button(sub_pay);
            go(6);
        });
        submenu->append(*sub_pay);
 
        auto* sub_bypass = make_leaf_button(_("Bypass Proxy"), true, submenu);
        sub_bypass->signal_clicked().connect([this, sub_bypass, go]() {
            activate_button(sub_bypass);
            go(7);
        });
        submenu->append(*sub_bypass);
    }
 
    {
        Gtk::Box* submenu = nullptr;
        auto* grp = make_group_button(resource("icons/settings.svg"),
                                      _("Servizi"),
                                      &submenu);
        menu_box->append(*grp);
        menu_box->append(*submenu);
 
        auto* sub_user = make_leaf_button(_("Servizi Utente"), true, submenu);
        sub_user->signal_clicked().connect([this, sub_user, go]() {
            activate_button(sub_user);
            go(8);
        });
        submenu->append(*sub_user);
 
        auto* sub_sys = make_leaf_button(_("Servizi Sistema"), true, submenu);
        sub_sys->signal_clicked().connect([this, sub_sys, go]() {
            activate_button(sub_sys);
            go(10);
        });
        submenu->append(*sub_sys);
    }
 
    {
        auto* btn = make_leaf_button(_("Email"), false, nullptr);
        btn->signal_clicked().connect([this, btn, go]() {
            activate_button(btn);
            go(9);
        });
        menu_box->append(*btn);
    }
 
    {
        auto* btn = make_leaf_button(_("DB ClamAV"), false, nullptr);
        btn->signal_clicked().connect([this, btn, go]() {
            activate_button(btn);
            go(11);
        });
        menu_box->append(*btn);
    }
 
    {
        auto* btn = make_leaf_button(_("Opzioni"), false, nullptr);
        btn->signal_clicked().connect([this, btn, go]() {
            activate_button(btn);
            go(12);
        });
        menu_box->append(*btn);
    }
 
    sidebar_box_->append(*menu_box);
 
    {
        auto* spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
        spacer->set_vexpand(true);
        sidebar_box_->append(*spacer);
 
        auto* sep = Gtk::make_managed<Gtk::Separator>(Gtk::Orientation::HORIZONTAL);
        sep->get_style_context()->add_class("sidebar-separator");
        sidebar_box_->append(*sep);
    }
 
    mainBox_.append(*sidebar_box_);
 
    if (!all_leaf_buttons_.empty())
        activate_button(all_leaf_buttons_.front());
 
    settingsPage_->goto_page(0);
}
 
void SettingsWindow::build_headerbar()
{
    auto header = Gtk::make_managed<Gtk::HeaderBar>();
    header->set_show_title_buttons(false);
    header->set_decoration_layout("");
    header->get_style_context()->add_class("custom-headerbar");
 
    auto header_left = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    header_left->set_size_request(220, -1);
    header_left->get_style_context()->add_class("header-left");
 
    auto accent = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    accent->set_size_request(6, -1);
    accent->get_style_context()->add_class("header-accent");
    header_left->append(*accent);
 
    header->pack_start(*header_left);
 
    auto header_spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    header_spacer->set_hexpand(true);
    header->pack_start(*header_spacer);
 
    auto header_right = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    header_right->get_style_context()->add_class("header-right");
 
    try {
        auto pix = Gdk::Pixbuf::create_from_file(resource("icon-close.png"), 32, 32, true);
        auto btn_close = Gtk::make_managed<Gtk::Button>();
        btn_close->set_child(*Gtk::make_managed<Gtk::Image>(pix));
        btn_close->get_style_context()->add_class("header-button");
        btn_close->signal_clicked().connect([this]() { this->close(); });
        header_right->append(*btn_close);
    } catch (...) {
        std::cerr << _("⚠ Errore caricamento icona close") << "\n";
    }
 
    header->pack_end(*header_right);
    set_titlebar(*header);
}