bankgui-main.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 <gtkmm.h>
#include <giomm.h>
#include <glib/gi18n.h>
#include <csignal>
#include <iostream>
#include <cstdio>
#include <memory>
#include <array>
#include <fstream>
#include <unistd.h>
#include <clocale>
#include <glibmm/miscutils.h>
#include "StyleProvider.hpp"
#include "Resource.hpp"
 
#ifndef LOCALEDIR
#error "LOCALEDIR non definita per questo target"
#endif
 
class BankGuiWindow : public Gtk::Window {
public:
    BankGuiWindow() {
    set_title("");
    set_resizable(false);
    set_default_size(640, 300);
    build_headerbar();
 
 
    auto main_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 0);
    set_child(*main_box);
 
 
    auto sidebar = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 10);
    sidebar->set_size_request(240, -1);
    sidebar->get_style_context()->add_class("sidebar");
 
 
    {
        auto header = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
        header->get_style_context()->add_class("sidebar-header");
 
        try {
            auto pixbuf = Gdk::Pixbuf::create_from_file(resource("logo-sidebar.png"), 96, 96, true);
            auto logo = Gtk::make_managed<Gtk::Image>(pixbuf);
            header->append(*logo);
        } catch (...) {
            std::cerr << _("⚠ Impossibile caricare data/logo-sidebar.png") << "\n";
        }
 
        auto lbl = Gtk::make_managed<Gtk::Label>("BastionGuard");
        lbl->set_halign(Gtk::Align::START);
        lbl->get_style_context()->add_class("sidebar-title");
        header->append(*lbl);
 
        sidebar->append(*header);
    }
 
 
    auto spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    spacer->set_vexpand(true);
    sidebar->append(*spacer);
 
    main_box->append(*sidebar);
 
 
    auto content_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 10);
    content_box->set_margin(24);
    content_box->set_hexpand(true);
    content_box->get_style_context()->add_class("content");
    main_box->append(*content_box);
 
    auto label = Gtk::make_managed<Gtk::Label>(
        _("Inserisci l'URL della banca o un identificatore:")
    );
    label->set_wrap(true);
    label->set_halign(Gtk::Align::START);
    content_box->append(*label);
 
    entry_.set_placeholder_text("https://www.miabanca.it");
    entry_.set_activates_default(true);
    content_box->append(entry_);
 
    auto buttons = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
    buttons->set_halign(Gtk::Align::END);
 
    btn_cancel_.set_label(_("Annulla"));
    btn_cancel_.signal_clicked().connect(sigc::mem_fun(*this, &BankGuiWindow::on_cancel_clicked));
    buttons->append(btn_cancel_);
 
    btn_open_.set_label(_("Apri in Secure Browser"));
    btn_open_.signal_clicked().connect(sigc::mem_fun(*this, &BankGuiWindow::on_open_clicked));
    buttons->append(btn_open_);
 
    content_box->append(*buttons);
}
 
 
protected:
    bool on_close_request() override {
        terminate_sandbox();
        return false;
    }
 
private:
    Gtk::Entry entry_;
    Gtk::Button btn_open_;
    Gtk::Button btn_cancel_;
    Glib::RefPtr<Gio::Subprocess> sandbox_proc_;
    std::string sandbox_cmd_;
 
    // ===== HeaderBar come in MainWindow =====
    void 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");
 
    // Titolo centrato
    auto title_label = Gtk::make_managed<Gtk::Label>("BastionGuard Secure Browser");
    title_label->get_style_context()->add_class("header-title");
    title_label->set_halign(Gtk::Align::CENTER);
    title_label->set_valign(Gtk::Align::CENTER);
    header->set_title_widget(*title_label);
 
    // ---- Destra (pulsanti finestra) ----
    auto header_right = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    header_right->get_style_context()->add_class("header-right");
 
    try {
        auto pix_min = Gdk::Pixbuf::create_from_file(resource("icon-minimize.png"), 32, 32, true);
        auto btn_min = Gtk::make_managed<Gtk::Button>();
        btn_min->set_child(*Gtk::make_managed<Gtk::Image>(pix_min));
        btn_min->get_style_context()->add_class("header-button");
        header_right->append(*btn_min);
        btn_min->signal_clicked().connect([this]() { minimize(); });
    } catch (...) {
        std::cerr << _("⚠ Errore caricamento icona minimize") << "\n";
    }
 
    try {
        auto pix_close = 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_close));
        btn_close->get_style_context()->add_class("header-button");
        header_right->append(*btn_close);
        btn_close->signal_clicked().connect([this]() {
            terminate_sandbox();
            this->hide();
        });
    } catch (...) {
        std::cerr << _("⚠ Errore caricamento icona close") << "\n";
    }
 
    header->pack_end(*header_right);
    set_titlebar(*header);
    }
 
 
    void minimize() {
#if GTKMM_CHECK_VERSION(4,10,0)
        this->hide();
#endif
    }
 
    void on_cancel_clicked() {
        terminate_sandbox();
        hide();
    }
 
    void on_open_clicked() {
        auto url = entry_.get_text();
        if (url.empty()) {
            show_warning(_("Inserisci un URL valido."), _("Il campo non può essere vuoto."));
            return;
        }
 
        set_sensitive(false);
        try {
            sandbox_cmd_ = "BastionGuard-bankopener \"" + url + "\"";
            sandbox_proc_ = Gio::Subprocess::create(
                {"BastionGuard-bankopener", url},
                Gio::Subprocess::Flags::NONE
            );
            sandbox_proc_->wait_check_async(
                sigc::mem_fun(*this, &BankGuiWindow::on_sandbox_finished)
            );
        } catch (const Glib::Error& ex) {
            show_warning(_("Errore avvio subprocess."), ex.what());
            set_sensitive(true);
        }
    }
 
    void show_warning(const Glib::ustring& msg, const Glib::ustring& secondary = {}) {
        auto* dialog = new Gtk::MessageDialog(
            *this, msg, false, Gtk::MessageType::WARNING, Gtk::ButtonsType::OK, true);
        if (!secondary.empty()) dialog->set_secondary_text(secondary);
        dialog->set_modal(true);
        dialog->signal_response().connect([dialog](int){ dialog->hide(); delete dialog; });
        dialog->present();
    }
 
    void on_sandbox_finished(const Glib::RefPtr<Gio::AsyncResult>& /*res*/) {
        hide();
    }
 
    void terminate_sandbox() {
        if (!sandbox_proc_) return;
        // Only terminate the subprocess started by this window. Never search
        // the entire process table with an untrusted URL in a shell command.
        sandbox_proc_->force_exit();
        sandbox_proc_.reset();
    }
};
 
static bool load_lang_conf()
{
    const std::string lang_conf = Glib::get_home_dir() + "/.config/BastionGuard/lang.conf";
    std::ifstream f(lang_conf);
    if (!f.is_open())
        return false;
 
    std::string line;
    bool any = false;
 
    while (std::getline(f, line)) {
        if (line.empty() || line[0] == '#')
            continue;
 
        auto pos = line.find('=');
        if (pos == std::string::npos)
            continue;
 
        std::string key = line.substr(0, pos);
        std::string val = line.substr(pos + 1);
 
        auto ltrim = [](std::string& s){
            s.erase(0, s.find_first_not_of(" \t\r\n"));
        };
        auto rtrim = [](std::string& s){
            s.erase(s.find_last_not_of(" \t\r\n") + 1);
        };
        ltrim(key); rtrim(key);
        ltrim(val); rtrim(val);
 
        if (!key.empty() && !val.empty()) {
            setenv(key.c_str(), val.c_str(), 1);
            any = true;
        }
    }
 
    return any;
}
 
int main(int argc, char* argv[])
{
    bool loaded = load_lang_conf();
 
    std::setlocale(LC_ALL, "");
 
 
    bindtextdomain("BastionGuard", LOCALEDIR);
    bind_textdomain_codeset("BastionGuard", "UTF-8");
    textdomain("BastionGuard");
 
    if (loaded) {
        std::cerr << _("[Lang] Config caricata da ~/.config/BastionGuard/lang.conf") << "\n";
    } else {
        std::cerr << _("[Lang] Nessuna config trovata, uso locale di sistema") << "\n";
    }
 
    auto app = Gtk::Application::create("org.BastionGuard.bankgui");
    load_style();
    return app->make_window_and_run<BankGuiWindow>(argc, argv);
}