LanguageDialog.cpp

Go to the documentation of this file.

/*
 * BastionGuard™ Secure Connection
 * Copyright (C) 2025–2026 Calogero Scarnà
 * GPL-3.0 — BastionGuard™ is a trademark of Calogero Scarnà.
 */
 
#include "LanguageDialog.hpp"
#include <gdkmm/pixbuf.h>
#include "../Resource.hpp"
 
#include <glibmm/i18n.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <unistd.h>
#include <linux/limits.h>
 
// ---------------------------------------------------------------------------
// Lingue disponibili — aggiungerne di nuove qui quando si aggiungono i .po
// ---------------------------------------------------------------------------
const std::vector<LanguageDialog::LangEntry>& LanguageDialog::availableLanguages()
{
    static const std::vector<LangEntry> langs = {
        { "",      "System default" },
        { "en_US", "English (US)"   },
        { "it_IT", "Italiano"       },
        { "de_DE", "Deutsch"        },
        { "fr_FR", "Français"       },
        { "es_ES", "Español"        },
        { "pt_BR", "Português (BR)" },
        { "zh_CN", "中文 (简体)"    },
        { "ja_JP", "日本語"         },
    };
    return langs;
}
 
// ---------------------------------------------------------------------------
// Costruttore
// ---------------------------------------------------------------------------
LanguageDialog::LanguageDialog(const std::string& configFile,
                               const std::string& currentLang)
    : Gtk::Dialog()
    , m_configFile(configFile)
    , m_selected(currentLang)
{
    set_default_size(400, -1);
    set_resizable(false);
    buildHeaderBar();
    buildUI(currentLang);
}
 
 
// ---------------------------------------------------------------------------
// HeaderBar identica a MainWindow
// ---------------------------------------------------------------------------
 
void LanguageDialog::buildHeaderBar()
{
    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 titleLabel = Gtk::make_managed<Gtk::Label>();
    titleLabel->set_markup("<b>" + Glib::ustring(_("Seleziona lingua")) + "</b>");
    titleLabel->get_style_context()->add_class("headerbar-title");
    header->set_title_widget(*titleLabel);
 
    // Pulsanti destra: minimizza + chiudi
    auto headerRight = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 4);
    headerRight->get_style_context()->add_class("header-right");
 
    auto closeBtn = Gtk::make_managed<Gtk::Button>();
    closeBtn->get_style_context()->add_class("header-button");
    try {
        auto pix = Gdk::Pixbuf::create_from_file(resource("icon-close.png"), 32, 32, true);
        closeBtn->set_child(*Gtk::make_managed<Gtk::Image>(pix));
    } catch (...) {
        closeBtn->set_label("✕");
    }
    closeBtn->signal_clicked().connect([this]() { hide(); });
    headerRight->append(*closeBtn);
 
    header->pack_end(*headerRight);
    set_titlebar(*header);
}
 
void LanguageDialog::buildUI(const std::string& currentLang)
{
    auto* area = get_content_area();
    area->set_spacing(12);
    area->set_margin_top(16);
    area->set_margin_bottom(4);
    area->set_margin_start(16);
    area->set_margin_end(16);
 
    // Titolo interno
    auto title = Gtk::make_managed<Gtk::Label>();
    title->set_markup(
        Glib::ustring("<b>") + _("Lingua dell'interfaccia") + "</b>");
    title->set_halign(Gtk::Align::START);
    area->append(*title);
 
    // ComboBox con le lingue
    for (const auto& lang : availableLanguages())
        m_combo.append(lang.code, lang.label);
 
    // Seleziona quella corrente
    if (currentLang.empty())
        m_combo.set_active_id("");
    else
        m_combo.set_active_id(currentLang);
 
    if (m_combo.get_active_row_number() < 0)
        m_combo.set_active(0);   // fallback: System default
 
        area->append(m_combo);
 
    // Nota riavvio
    auto note = Gtk::make_managed<Gtk::Label>(
        _("⚠ L'applicazione verrà riavviata automaticamente per applicare la lingua."));
    note->set_wrap(true);
    note->set_max_width_chars(48);
    note->set_halign(Gtk::Align::START);
    note->get_style_context()->add_class("dim-label");
    area->append(*note);
 
    // Pulsanti
    add_button(_("Annulla"), Gtk::ResponseType::CANCEL);
    add_button(_("Applica"),  Gtk::ResponseType::APPLY);
    set_default_response(Gtk::ResponseType::APPLY);
 
    signal_response().connect([this](int response) {
        // Ignora risposte che non siano APPLY o CANCEL (es. DELETE_EVENT)
        if (response == static_cast<int>(Gtk::ResponseType::APPLY)) {
            onApply();
            // onApply() chiama execvp — se arriviamo qui execvp è fallito
            hide();
        } else if (response == static_cast<int>(Gtk::ResponseType::CANCEL)) {
            hide();
        }
        // Nessun hide() per altri response (evita doppio trigger)
    });
}
 
// ---------------------------------------------------------------------------
// Salvataggio scelta
// ---------------------------------------------------------------------------
void LanguageDialog::onApply()
{
    m_selected = m_combo.get_active_id();
    if (!saveLangToConfig(m_selected)) {
        std::cerr << "[LanguageDialog] Impossibile salvare la lingua nel config\n";
        return;
    }
 
    // Riavvia il processo per applicare subito la lingua.
    // IMPORTANTE: prima di execvp puliamo LANGUAGE e LANG dall'ambiente
    // del processo corrente — altrimenti il processo figlio erediterebbe
    // le variabili vecchie e la lingua non cambierebbe (es. en_US → it_IT
    // funziona, ma it_IT → en_US no perché LANGUAGE=it_IT resterebbe).
    ::unsetenv("LANGUAGE");
    ::unsetenv("LANG");
    ::unsetenv("LC_ALL");
    ::unsetenv("LC_MESSAGES");
 
    // Imposta le nuove variabili solo se non è "System default"
    if (!m_selected.empty()) {
        const std::string lang_utf8 = m_selected + ".UTF-8";
        ::setenv("LANGUAGE", m_selected.c_str(),   1);
        ::setenv("LANG",     lang_utf8.c_str(),     1);
        ::setenv("LC_ALL",   lang_utf8.c_str(),     1);
    }
 
    char exe[PATH_MAX];
    ssize_t len = ::readlink("/proc/self/exe", exe, sizeof(exe) - 1);
    if (len > 0) {
        exe[len] = '\0';
        char* argv[] = { exe, nullptr };
        ::execvp(exe, argv);
        std::perror("[LanguageDialog] execvp fallito");
    }
    std::exit(0);
}
 
bool LanguageDialog::saveLangToConfig(const std::string& lang)
{
    // Leggi il file corrente (se esiste)
    std::string content;
    {
        std::ifstream in(m_configFile);
        if (in.is_open()) {
            std::ostringstream ss;
            ss << in.rdbuf();
            content = ss.str();
        }
    }
 
    // Rimuovi eventuale riga language= precedente
    {
        std::istringstream lines(content);
        std::ostringstream out;
        std::string line;
        while (std::getline(lines, line)) {
            if (line.rfind("language=", 0) == 0)
                continue;   // salta la vecchia riga
                out << line << "\n";
        }
        content = out.str();
    }
 
    // Assicura sezione [General]
    if (content.find("[General]") == std::string::npos)
        content = "[General]\n" + content;
 
    // Aggiungi la nuova riga dopo [General]
    const std::string marker = "[General]\n";
    auto pos = content.find(marker);
    if (pos != std::string::npos)
        content.insert(pos + marker.size(),
                       "language=" + lang + "\n");
 
        // Scrivi
        std::ofstream out(m_configFile, std::ios::trunc);
    if (!out.is_open())
        return false;
    out << content;
    return true;
}