PasswordManagerPage Class Reference

#include <PasswordManagerPage.hpp>

Inheritance diagram for PasswordManagerPage:

Public Member Functions
	PasswordManagerPage ()
	~PasswordManagerPage () override

Private Member Functions
void	buildUi ()
void	setVaultState (bool unlocked, const std::string &msg="")
void	reload ()
void	refreshEntries (const std::string &filter="")
void	createEntryRow (const PasswordEntry &entry)
void	onUnlockClicked ()
void	onLockClicked ()
void	onAddClicked ()
void	onImportClicked ()
void	onVaultViewClicked ()
void	onDeleteAllClicked ()
void	onRefreshClicked ()
void	onSearchChanged ()
void	onRevealEntry (const PasswordEntry &entry)
void	onEditEntry (const PasswordEntry &entry)
void	onDeleteEntry (const PasswordEntry &entry)
Gtk::Window *	getParentWindow ()
void	logSafe (const std::string &msg)

Private Attributes
PasswordVault	vault_
std::vector< PasswordEntry >	entriesCache_
Gtk::Box	securityBanner_
Gtk::Label	securityIcon_
Gtk::Label	securityLabel_
Gtk::Box	topBar_
Gtk::Button	unlockButton_
Gtk::Button	lockButton_
Gtk::Box	stateBox_
Gtk::Label	stateLabel_
Gtk::Box	actionBar_
Gtk::Button	addButton_
Gtk::Button	importButton_
Gtk::Button	vaultViewButton_
Gtk::Button	refreshButton_
Gtk::Button	deleteAllButton_
Gtk::SearchEntry	searchEntry_
Gtk::ScrolledWindow	listScrolled_
Gtk::Box	entriesBox_
Gtk::ScrolledWindow	logScrolled_
Gtk::TextView	outputView_
Glib::RefPtr< Gtk::TextBuffer >	buffer_
BastionGuard::AliveFlag	alive_ = BastionGuard::make_alive_flag()

Detailed Description

Definition at line 31 of file PasswordManagerPage.hpp.

Constructor & Destructor Documentation

PasswordManagerPage()

PasswordManagerPage::PasswordManagerPage

(

)

Definition at line 32 of file PasswordManagerPage.cpp.

: Gtk::Box(Gtk::Orientation::VERTICAL, 6),
  securityBanner_(Gtk::Orientation::HORIZONTAL, 8),
  topBar_(Gtk::Orientation::HORIZONTAL, 8),
  unlockButton_(_("🔓  Sblocca vault")),
  lockButton_(_("🔒  Blocca")),
  stateBox_(Gtk::Orientation::HORIZONTAL, 0),
  actionBar_(Gtk::Orientation::HORIZONTAL, 8),
  addButton_(_("＋  Nuova")),
  importButton_(_("⬆  Importa")),
  vaultViewButton_(_("🗄  Vault")),
  refreshButton_(_("↺  Aggiorna")),
  deleteAllButton_(_("🗑  Elimina tutto")),
  entriesBox_(Gtk::Orientation::VERTICAL, 6)
{
    auto cssProvider = Gtk::CssProvider::create();
    Gtk::StyleContext::add_provider_for_display(
        Gdk::Display::get_default(),
        cssProvider,
        GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
 
    buildUi();
    vault_.initialize();
 
    unlockButton_.signal_clicked().connect(sigc::mem_fun(*this, &PasswordManagerPage::onUnlockClicked));
    lockButton_.signal_clicked().connect(sigc::mem_fun(*this, &PasswordManagerPage::onLockClicked));
    addButton_.signal_clicked().connect(sigc::mem_fun(*this, &PasswordManagerPage::onAddClicked));
    importButton_.signal_clicked().connect(sigc::mem_fun(*this, &PasswordManagerPage::onImportClicked));
    vaultViewButton_.signal_clicked().connect(sigc::mem_fun(*this, &PasswordManagerPage::onVaultViewClicked));
    refreshButton_.signal_clicked().connect(sigc::mem_fun(*this, &PasswordManagerPage::onRefreshClicked));
    deleteAllButton_.signal_clicked().connect(sigc::mem_fun(*this, &PasswordManagerPage::onDeleteAllClicked));
    searchEntry_.signal_search_changed().connect(sigc::mem_fun(*this, &PasswordManagerPage::onSearchChanged));
 
    reload();
}

References _, actionBar_, addButton_, buildUi(), deleteAllButton_, entriesBox_, importButton_, PasswordVault::initialize(), lockButton_, onAddClicked(), onDeleteAllClicked(), onImportClicked(), onLockClicked(), onRefreshClicked(), onSearchChanged(), onUnlockClicked(), onVaultViewClicked(), refreshButton_, reload(), searchEntry_, securityBanner_, stateBox_, topBar_, unlockButton_, vault_, and vaultViewButton_.

~PasswordManagerPage()

PasswordManagerPage::~PasswordManagerPage ( )

override

Definition at line 68 of file PasswordManagerPage.cpp.

                                          {
    if (alive_) alive_->store(false, std::memory_order_release);
}

References alive_.

Member Function Documentation

buildUi()

void PasswordManagerPage::buildUi ( )

private

Definition at line 73 of file PasswordManagerPage.cpp.

                                  {
    buffer_ = Gtk::TextBuffer::create();
    outputView_.set_buffer(buffer_);
    outputView_.set_editable(false);
    outputView_.set_monospace(true);
 
    set_margin_top(8);
    set_margin_bottom(8);
    set_margin_start(8);
    set_margin_end(8);
 
    securityBanner_.get_style_context()->add_class("security-banner");
    securityBanner_.get_style_context()->add_class("alert-info");
    securityIcon_.set_text("🔐");
    securityBanner_.append(securityIcon_);
 
    securityLabel_.set_markup(_(
    "<b>Protezione avanzata AES-256-GCM</b> — "
    "Le password sono cifrate con AES-256-GCM e la chiave è derivata dalla master password "
    "tramite PBKDF2-SHA256 (100.000 iterazioni). Il file cifrato include un tag di "
    "autenticazione: qualsiasi manipolazione esterna renderà il vault permanentemente illeggibile."
    ));
    securityLabel_.set_wrap(true);
    securityLabel_.set_xalign(0.0f);
    securityLabel_.set_hexpand(true);
    securityBanner_.append(securityLabel_);
 
    auto* dangerBanner = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
    dangerBanner->get_style_context()->add_class("security-banner");
    dangerBanner->get_style_context()->add_class("alert-danger");
 
    auto* dangerIcon = Gtk::make_managed<Gtk::Label>();
    dangerIcon->set_text("⚠️");
    dangerBanner->append(*dangerIcon);
 
    auto* dangerLabel = Gtk::make_managed<Gtk::Label>();
    dangerLabel->set_markup(_(
    "<b>Attenzione:</b> — L'esportazione del vault salva il file CSV con password in chiaro. "
    "Salvare il file in un luogo sicuro e non accessibile."
    ));
    dangerLabel->set_wrap(true);
    dangerLabel->set_xalign(0.0f);
    dangerLabel->set_hexpand(true);
    dangerBanner->append(*dangerLabel);
 
    topBar_.set_margin_bottom(4);
    topBar_.append(unlockButton_);
    topBar_.append(lockButton_);
 
    auto* spacer1 = Gtk::make_managed<Gtk::Box>();
    spacer1->set_hexpand(true);
    topBar_.append(*spacer1);
    stateBox_.set_margin_start(4);
    stateLabel_.set_text(_("🔒  Vault bloccato"));
    stateBox_.append(stateLabel_);
    stateBox_.get_style_context()->add_class("alert-success");
    topBar_.append(stateBox_);
    actionBar_.set_margin_bottom(4);
 
    addButton_.get_style_context()->add_class("suggested-action");
    actionBar_.append(addButton_);
 
    {
        importButton_.get_style_context()->add_class("suggested-action");
        auto p = Gtk::CssProvider::create();
        p->load_from_data(
            "button.suggested-action#importBtn {"
            "  background:linear-gradient(to bottom,#33d17a,#26a269);"
            "  color:white;font-weight:bold;"
            "  padding:6px 16px;border-radius:6px;"
            "  border:1px solid #1e8449;"
            "}");
        importButton_.set_name("importBtn");
        importButton_.get_style_context()->add_provider(p, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
    }
    actionBar_.append(importButton_);
    {
        vaultViewButton_.get_style_context()->add_class("suggested-action");
        auto p = Gtk::CssProvider::create();
        p->load_from_data(
            "button.suggested-action#vaultBtn {"
            "  background:linear-gradient(to bottom,#3584e4,#1c71d8);"
            "  color:white;font-weight:bold;"
            "  padding:6px 16px;border-radius:6px;"
            "  border:1px solid #1558b0;"
            "}");
        vaultViewButton_.set_name("vaultBtn");
        vaultViewButton_.get_style_context()->add_provider(p, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
    }
    actionBar_.append(vaultViewButton_);
    actionBar_.append(refreshButton_);
 
    auto* spacer2 = Gtk::make_managed<Gtk::Box>();
    spacer2->set_hexpand(true);
    actionBar_.append(*spacer2);
 
    deleteAllButton_.get_style_context()->add_class("destructive-action");
    actionBar_.append(deleteAllButton_);
 
    searchEntry_.set_placeholder_text(_("Cerca credenziali..."));
    searchEntry_.set_size_request(200, -1);
    actionBar_.append(searchEntry_);
 
    auto* sep = Gtk::make_managed<Gtk::Separator>(Gtk::Orientation::HORIZONTAL);
 
    listScrolled_.set_child(entriesBox_);
    listScrolled_.set_expand(true);
 
    logScrolled_.set_child(outputView_);
    logScrolled_.set_min_content_height(100);
    logScrolled_.set_expand(false);
 
    append(securityBanner_);
    append(*dangerBanner);
    append(topBar_);
    append(actionBar_);
    append(*sep);
    append(listScrolled_);
    append(logScrolled_);
}

References _, actionBar_, addButton_, buffer_, deleteAllButton_, entriesBox_, importButton_, listScrolled_, lockButton_, logScrolled_, outputView_, refreshButton_, searchEntry_, securityBanner_, securityIcon_, securityLabel_, stateBox_, stateLabel_, topBar_, unlockButton_, and vaultViewButton_.

Referenced by PasswordManagerPage().

createEntryRow()

void PasswordManagerPage::createEntryRow ( const PasswordEntry & entry )

private

Definition at line 233 of file PasswordManagerPage.cpp.

                                                                   {
    auto* row = Gtk::make_managed<PasswordSearchRow>(entry);
    row->signal_reveal().connect([this](const PasswordEntry& e) { onRevealEntry(e); });
    row->signal_edit().connect([this](const PasswordEntry& e)   { onEditEntry(e); });
    row->signal_delete().connect([this](const PasswordEntry& e) { onDeleteEntry(e); });
    entriesBox_.append(*row);
}

References entriesBox_, onDeleteEntry(), onEditEntry(), and onRevealEntry().

Referenced by refreshEntries().

getParentWindow()

Gtk::Window * PasswordManagerPage::getParentWindow ( )

private

Definition at line 581 of file PasswordManagerPage.cpp.

                                                {
    auto* root = get_root();
    return dynamic_cast<Gtk::Window*>(root);
}

Referenced by onAddClicked(), onDeleteAllClicked(), onDeleteEntry(), onEditEntry(), onImportClicked(), onRevealEntry(), onUnlockClicked(), and onVaultViewClicked().

logSafe()

void PasswordManagerPage::logSafe ( const std::string & msg )

private

Definition at line 586 of file PasswordManagerPage.cpp.

                                                      {
    auto alive = alive_;
    Glib::signal_idle().connect_once([this, alive, msg]() {
        BastionGuard::if_alive(alive, [this, &msg]() {
            buffer_->insert(buffer_->end(), msg);
        });
    });
}

References alive_, buffer_, and BastionGuard::if_alive().

Referenced by onAddClicked(), onDeleteAllClicked(), onDeleteEntry(), onEditEntry(), onImportClicked(), onLockClicked(), onRefreshClicked(), onRevealEntry(), onUnlockClicked(), and onVaultViewClicked().

onAddClicked()

void PasswordManagerPage::onAddClicked ( )

private

Definition at line 360 of file PasswordManagerPage.cpp.

                                       {
 
    if (!vault_.isUnlocked()) { logSafe(_("Sblocca il vault prima.\n")); return; }
    auto* parent = getParentWindow();
    if (!parent) return;
 
    auto* dialog = new PasswordDialog(*parent, _("Nuova credenziale"));
    dialog->signal_response().connect([this, dialog](int response) {
        if (response == Gtk::ResponseType::OK) {
            PasswordEntry entry = dialog->getEntry();
            if (entry.name.empty()) {
                logSafe(_("Nome credenziale obbligatorio.\n"));
            } else {
                entry.id         = vault_.generateId();
                entry.created_at = vault_.nowIso();
                entry.updated_at = entry.created_at;
                if (vault_.addEntry(entry, dialog->getSecret())) {
                    logSafe(std::string(_("Credenziale aggiunta: ")) + entry.name + "\n");
                    reload();
                } else {
                    logSafe(_("Errore durante il salvataggio.\n"));
                }
            }
        }
        dialog->hide();
        delete dialog;
    });
    dialog->present();
}

References _, PasswordVault::addEntry(), PasswordEntry::created_at, PasswordVault::generateId(), getParentWindow(), PasswordEntry::id, PasswordVault::isUnlocked(), logSafe(), PasswordEntry::name, PasswordVault::nowIso(), PasswordDialog::PasswordDialog(), reload(), PasswordEntry::updated_at, and vault_.

Referenced by PasswordManagerPage().

onDeleteAllClicked()

void PasswordManagerPage::onDeleteAllClicked ( )

private

Definition at line 441 of file PasswordManagerPage.cpp.

                                             {
 
    if (!vault_.isUnlocked()) { logSafe(_("Sblocca il vault prima.\n")); return; }
    auto* parent = getParentWindow();
    if (!parent) return;
 
    const auto count = entriesCache_.size();
    if (count == 0) { logSafe(_("Nessuna credenziale da eliminare.\n")); return; }
 
    auto* confirm1 = new Gtk::MessageDialog(
        *parent, _("Eliminare tutte le credenziali?"),
        false, Gtk::MessageType::WARNING, Gtk::ButtonsType::OK_CANCEL, true);
    confirm1->set_secondary_text(
        std::string(_("Questa operazione eliminerà ")) + std::to_string(count) +
        std::string(_(" credenziali e non può essere annullata.")));
 
    confirm1->signal_response().connect([this, confirm1, parent](int r1) {
        confirm1->hide();
        if (r1 != Gtk::ResponseType::OK) { delete confirm1; return; }
 
        auto* confirm2 = new Gtk::MessageDialog(
            *parent, _("Sei sicuro? L'operazione è irreversibile."),
            false, Gtk::MessageType::ERROR, Gtk::ButtonsType::NONE, true);
        confirm2->set_secondary_text(_("Il file cifrato verrà eliminato definitivamente."));
        confirm2->add_button(_("Annulla"),           Gtk::ResponseType::CANCEL);
        confirm2->add_button(_("Sì, elimina tutto"), Gtk::ResponseType::OK);
        auto* ok_btn = confirm2->get_widget_for_response(Gtk::ResponseType::OK);
        if (ok_btn) ok_btn->get_style_context()->add_class("destructive-action");
 
        confirm2->signal_response().connect([this, confirm2](int r2) {
            confirm2->hide();
            if (r2 == Gtk::ResponseType::OK) {
                logSafe(_("Eliminazione in corso…\n"));
                vault_.deleteAllEntries([this](bool ok) {
                    logSafe(ok ? _("✔ Tutte le credenziali eliminate.\n")
                               : _("Errore durante l'eliminazione.\n"));
                    reload();
                });
            }
            delete confirm2;
        });
        confirm2->present();
        delete confirm1;
    });
    confirm1->present();
}

References _, PasswordVault::deleteAllEntries(), entriesCache_, getParentWindow(), PasswordVault::isUnlocked(), logSafe(), reload(), and vault_.

Referenced by PasswordManagerPage().

onDeleteEntry()

void PasswordManagerPage::onDeleteEntry ( const PasswordEntry & entry )

private

Definition at line 555 of file PasswordManagerPage.cpp.

                                                                  {
 
    if (!vault_.isUnlocked()) { logSafe(_("Vault bloccato.\n")); return; }
    auto* parent = getParentWindow();
    if (!parent) return;
 
    auto* confirm = new Gtk::MessageDialog(
        *parent, _("Eliminare la credenziale selezionata?"),
        false, Gtk::MessageType::QUESTION, Gtk::ButtonsType::OK_CANCEL, true);
    confirm->set_secondary_text(entry.name);
    confirm->signal_response().connect([this, confirm, entry](int response) {
        if (response == Gtk::ResponseType::OK) {
            if (vault_.deleteEntry(entry.id)) {
                logSafe(std::string(_("Credenziale eliminata: ")) + entry.name + "\n");
                reload();
            } else {
                logSafe(_("Errore durante l'eliminazione.\n"));
            }
        }
        confirm->hide();
        delete confirm;
    });
    confirm->present();
}

References _, PasswordVault::deleteEntry(), getParentWindow(), PasswordEntry::id, PasswordVault::isUnlocked(), logSafe(), PasswordEntry::name, reload(), and vault_.

Referenced by createEntryRow().

onEditEntry()

void PasswordManagerPage::onEditEntry ( const PasswordEntry & entry )

private

Definition at line 521 of file PasswordManagerPage.cpp.

                                                                {
 
    if (!vault_.isUnlocked()) { logSafe(_("Vault bloccato.\n")); return; }
    auto* parent = getParentWindow();
    if (!parent) return;
 
    auto alive = alive_;
    vault_.getSecretAsync(entry.id, [this, alive, entry](std::string secret) {
        if (!alive || !alive->load(std::memory_order_acquire)) return;
        auto* p = getParentWindow();
        if (!p) return;
        auto* dialog = new PasswordDialog(
            *p, _("Modifica credenziale"), entry, secret);
        dialog->signal_response().connect([this, dialog, entry](int response) {
            if (response == Gtk::ResponseType::OK) {
                PasswordEntry updated = dialog->getEntry();
                updated.id         = entry.id;
                updated.created_at = entry.created_at;
                updated.updated_at = vault_.nowIso();
                if (vault_.updateEntry(updated, dialog->getSecret())) {
                    logSafe(std::string(_("Credenziale aggiornata: ")) + updated.name + "\n");
                    reload();
                } else {
                    logSafe(_("Errore durante l'aggiornamento.\n"));
                }
            }
            dialog->hide();
            delete dialog;
        });
        dialog->present();
    });
}

References _, alive_, getParentWindow(), PasswordVault::getSecretAsync(), PasswordEntry::id, PasswordVault::isUnlocked(), logSafe(), and vault_.

Referenced by createEntryRow().

onImportClicked()

void PasswordManagerPage::onImportClicked ( )

private

Definition at line 391 of file PasswordManagerPage.cpp.

                                          {
 
    if (!vault_.isUnlocked()) { logSafe(_("Sblocca il vault prima di importare.\n")); return; }
    auto* parent = getParentWindow();
    if (!parent) return;
 
    auto* dialog = new PasswordImportDialog(*parent);
    dialog->signal_import_confirmed().connect(
        [this, dialog](std::vector<PasswordImportDialog::BulkItem> items) {
            dialog->hide();
            if (items.empty()) { delete dialog; return; }
 
            const std::string now = vault_.nowIso();
            for (auto& [entry, pwd] : items) {
                entry.id         = vault_.generateId();
                entry.created_at = now;
                entry.updated_at = now;
                if (entry.name.empty() && !entry.url.empty()) {
                    auto url = entry.url;
                    auto p = url.find("://");
                    if (p != std::string::npos) url = url.substr(p + 3);
                    auto sl = url.find('/');
                    if (sl != std::string::npos) url = url.substr(0, sl);
                    entry.name = url;
                }
            }
 
            vault_.addEntriesBulk(items, [this, dialog](int ok, int fail) {
                logSafe(std::string(_("Import completato: ")) + std::to_string(ok) +
                        std::string(_(" importate")) +
                        (fail > 0 ? (", " + std::to_string(fail) + std::string(_(" fallite"))) : "") +
                        ".\n");
                reload();
                delete dialog;
            });
        });
    dialog->present();
}

References _, PasswordVault::addEntriesBulk(), PasswordVault::generateId(), getParentWindow(), PasswordVault::isUnlocked(), logSafe(), PasswordVault::nowIso(), PasswordImportDialog::PasswordImportDialog(), reload(), and vault_.

Referenced by PasswordManagerPage().

onLockClicked()

void PasswordManagerPage::onLockClicked ( )

private

Definition at line 352 of file PasswordManagerPage.cpp.

                                        {
 
    vault_.lock();
    setVaultState(false);
    logSafe(_("Vault bloccato.\n"));
}

References _, PasswordVault::lock(), logSafe(), setVaultState(), and vault_.

Referenced by PasswordManagerPage().

onRefreshClicked()

void PasswordManagerPage::onRefreshClicked ( )

private

Definition at line 489 of file PasswordManagerPage.cpp.

                                           {
 
    reload();
    logSafe(_("Elenco aggiornato.\n"));
}

References _, logSafe(), and reload().

Referenced by PasswordManagerPage().

onRevealEntry()

void PasswordManagerPage::onRevealEntry ( const PasswordEntry & entry )

private

Definition at line 500 of file PasswordManagerPage.cpp.

                                                                  {
 
    if (!vault_.isUnlocked()) { logSafe(_("Vault bloccato.\n")); return; }
    auto* parent = getParentWindow();
    if (!parent) return;
 
    auto alive = alive_;
    vault_.getSecretAsync(entry.id, [this, alive, entry](std::string secret) {
        if (!alive || !alive->load(std::memory_order_acquire)) return;
        auto* p = getParentWindow();
        if (!p) return;
        auto* reveal = new Gtk::MessageDialog(
            *p, _("Password per: ") + entry.name,
            false, Gtk::MessageType::INFO, Gtk::ButtonsType::CLOSE, true);
        reveal->set_secondary_text(secret, false);
        reveal->signal_response().connect([reveal](int) { reveal->hide(); delete reveal; });
        reveal->present();
    });
}

References _, alive_, getParentWindow(), PasswordVault::getSecretAsync(), PasswordEntry::id, PasswordVault::isUnlocked(), logSafe(), and vault_.

Referenced by createEntryRow().

onSearchChanged()

void PasswordManagerPage::onSearchChanged ( )

private

Definition at line 495 of file PasswordManagerPage.cpp.

                                          {
 
    refreshEntries(searchEntry_.get_text());
}

References refreshEntries(), and searchEntry_.

Referenced by PasswordManagerPage().

onUnlockClicked()

void PasswordManagerPage::onUnlockClicked ( )

private

Definition at line 242 of file PasswordManagerPage.cpp.

                                          {
 
    auto* parent = getParentWindow();
    if (!parent) { logSafe(_("Impossibile trovare la finestra padre.\n")); return; }
 
    if (vault_.isFirstRun()) {
        auto* dialog = Gtk::make_managed<Gtk::Dialog>(_("Crea master password"), *parent, true);
        dialog->get_content_area()->set_margin(12);
        dialog->get_content_area()->set_spacing(8);
 
        auto* infoLabel = Gtk::make_managed<Gtk::Label>(
            _("Prima configurazione: scegli una master password.\n"
              "Minimo 8 caratteri. Non può essere recuperata se dimenticata."));
        infoLabel->set_wrap(true);
        infoLabel->set_xalign(0.0f);
        infoLabel->get_style_context()->add_class("dim-label");
 
        auto* entry1 = Gtk::make_managed<Gtk::Entry>();
        entry1->set_placeholder_text(_("Nuova master password"));
        entry1->set_visibility(false);
        entry1->set_input_purpose(Gtk::InputPurpose::PASSWORD);
 
        auto* entry2 = Gtk::make_managed<Gtk::Entry>();
        entry2->set_placeholder_text(_("Conferma master password"));
        entry2->set_visibility(false);
        entry2->set_input_purpose(Gtk::InputPurpose::PASSWORD);
        entry2->set_activates_default(true);
 
        auto* strengthLabel = Gtk::make_managed<Gtk::Label>("");
        strengthLabel->set_xalign(0.0f);
 
        dialog->get_content_area()->append(*infoLabel);
        dialog->get_content_area()->append(*entry1);
        dialog->get_content_area()->append(*entry2);
        dialog->get_content_area()->append(*strengthLabel);
        dialog->add_button(_("Annulla"), Gtk::ResponseType::CANCEL);
        dialog->add_button(_("Crea vault"), Gtk::ResponseType::OK);
        dialog->set_default_response(Gtk::ResponseType::OK);
 
        entry1->signal_changed().connect([entry1, strengthLabel]() {
            const auto pwd = entry1->get_text();
            const size_t len = pwd.size();
            bool hasUpper = false, hasLower = false, hasDigit = false, hasSymbol = false;
            for (char c : pwd) {
                if (std::isupper(c))      hasUpper  = true;
                else if (std::islower(c)) hasLower  = true;
                else if (std::isdigit(c)) hasDigit  = true;
                else                      hasSymbol = true;
            }
            const int score = (len >= 8) + (len >= 12) + hasUpper + hasLower + hasDigit + hasSymbol;
            std::string markup;
            if (len == 0)        markup = "";
            else if (score <= 2) markup = "<span foreground='red'>⚠ Debole</span>";
            else if (score <= 4) markup = "<span foreground='orange'>◑ Media</span>";
            else                 markup = "<span foreground='green'>✔ Forte</span>";
            strengthLabel->set_markup(markup);
        });
 
        dialog->signal_response().connect([this, dialog, entry1, entry2](int response) {
            if (response == Gtk::ResponseType::OK) {
                const auto pwd1 = entry1->get_text();
                const auto pwd2 = entry2->get_text();
                if (pwd1 != pwd2) {
                    logSafe(_("Le password non coincidono.\n"));
                } else if (pwd1.size() < 8) {
                    logSafe(_("La master password deve essere di almeno 8 caratteri.\n"));
                } else if (vault_.createMasterPassword(pwd1)) {
                    setVaultState(true, _("🔓  Vault creato e sbloccato"));
                    logSafe(_("Vault creato. Master password impostata.\n"));
                } else {
                    logSafe(_("Errore durante la creazione del vault.\n"));
                }
            }
            dialog->hide();
        });
        dialog->present();
 
    } else {
        auto* dialog = Gtk::make_managed<Gtk::Dialog>(_("Sblocca vault"), *parent, true);
        auto* entry  = Gtk::make_managed<Gtk::Entry>();
        entry->set_placeholder_text(_("Master password"));
        entry->set_visibility(false);
        entry->set_input_purpose(Gtk::InputPurpose::PASSWORD);
        entry->set_activates_default(true);
        dialog->get_content_area()->set_margin(12);
        dialog->get_content_area()->append(*entry);
        dialog->add_button(_("Annulla"), Gtk::ResponseType::CANCEL);
        dialog->add_button(_("Sblocca"), Gtk::ResponseType::OK);
        dialog->set_default_response(Gtk::ResponseType::OK);
 
        dialog->signal_response().connect([this, dialog, entry](int response) {
            if (response == Gtk::ResponseType::OK) {
                if (vault_.unlock(entry->get_text())) {
                    setVaultState(true, _("🔓  Vault sbloccato — caricamento cache…"));
                    logSafe(_("Vault sbloccato. Precaricamento password in background…\n"));
                    Glib::signal_timeout().connect_once([this]() {
                        if (vault_.isUnlocked())
                            setVaultState(true);
                    }, 3000);
                } else {
                    logSafe(_("Password errata.\n"));
                }
            }
            dialog->hide();
        });
        dialog->present();
    }
}

References _, PasswordVault::createMasterPassword(), getParentWindow(), PasswordVault::isFirstRun(), PasswordVault::isUnlocked(), logSafe(), setVaultState(), PasswordVault::unlock(), and vault_.

Referenced by PasswordManagerPage().

onVaultViewClicked()

void PasswordManagerPage::onVaultViewClicked ( )

private

Definition at line 431 of file PasswordManagerPage.cpp.

                                             {
 
    if (!vault_.isUnlocked()) { logSafe(_("Sblocca il vault prima.\n")); return; }
    auto* parent = getParentWindow();
    if (!parent) return;
    auto* view = new PasswordVaultView(*parent, vault_);
    view->present();
}

References _, getParentWindow(), PasswordVault::isUnlocked(), logSafe(), PasswordVaultView::PasswordVaultView(), and vault_.

Referenced by PasswordManagerPage().

refreshEntries()

void PasswordManagerPage::refreshEntries ( const std::string & filter = "" )

private

Definition at line 218 of file PasswordManagerPage.cpp.

                                                                {
    while (auto* child = entriesBox_.get_first_child())
        entriesBox_.remove(*child);
 
    std::string needle = filter;
    std::transform(needle.begin(), needle.end(), needle.begin(), ::tolower);
 
    for (const auto& entry : entriesCache_) {
        std::string hay = entry.name + " " + entry.username + " " + entry.url + " " + entry.notes;
        std::transform(hay.begin(), hay.end(), hay.begin(), ::tolower);
        if (!needle.empty() && hay.find(needle) == std::string::npos) continue;
        createEntryRow(entry);
    }
}

References createEntryRow(), entriesBox_, and entriesCache_.

Referenced by onSearchChanged(), and reload().

reload()

void PasswordManagerPage::reload ( )

private

Definition at line 213 of file PasswordManagerPage.cpp.

                                 {
    entriesCache_ = vault_.loadIndex();
    refreshEntries(searchEntry_.get_text());
}

References entriesCache_, PasswordVault::loadIndex(), refreshEntries(), searchEntry_, and vault_.

Referenced by onAddClicked(), onDeleteAllClicked(), onDeleteEntry(), onImportClicked(), onRefreshClicked(), and PasswordManagerPage().

setVaultState()

void PasswordManagerPage::setVaultState ( bool unlocked, const std::string & msg = "" )

private

Definition at line 198 of file PasswordManagerPage.cpp.

                                                                           {
    auto ctx = stateBox_.get_style_context();
    ctx->remove_class("alert-success");
    ctx->remove_class("alert-danger");
 
    if (unlocked) {
        ctx->add_class("alert-danger");
        stateLabel_.set_text(msg.empty() ? _("🔓  Vault sbloccato") : msg);
    } else {
        ctx->add_class("alert-success");
        stateLabel_.set_text(msg.empty() ? _("🔒  Vault bloccato") : msg);
    }
}

References _, stateBox_, and stateLabel_.

Referenced by onLockClicked(), and onUnlockClicked().

Member Data Documentation

actionBar_

Gtk::Box PasswordManagerPage::actionBar_

private

Definition at line 49 of file PasswordManagerPage.hpp.

Referenced by buildUi(), and PasswordManagerPage().

addButton_

Gtk::Button PasswordManagerPage::addButton_

private

Definition at line 50 of file PasswordManagerPage.hpp.

Referenced by buildUi(), and PasswordManagerPage().

alive_

BastionGuard::AliveFlag PasswordManagerPage::alive_ = BastionGuard::make_alive_flag()

private

Definition at line 86 of file PasswordManagerPage.hpp.

Referenced by logSafe(), onEditEntry(), onRevealEntry(), and ~PasswordManagerPage().

buffer_

Glib::RefPtr<Gtk::TextBuffer> PasswordManagerPage::buffer_

private

Definition at line 62 of file PasswordManagerPage.hpp.

Referenced by buildUi(), and logSafe().

deleteAllButton_

Gtk::Button PasswordManagerPage::deleteAllButton_

private

Definition at line 54 of file PasswordManagerPage.hpp.

Referenced by buildUi(), and PasswordManagerPage().

entriesBox_

Gtk::Box PasswordManagerPage::entriesBox_

private

Definition at line 58 of file PasswordManagerPage.hpp.

Referenced by buildUi(), createEntryRow(), PasswordManagerPage(), and refreshEntries().

entriesCache_

std::vector<PasswordEntry> PasswordManagerPage::entriesCache_

private

Definition at line 38 of file PasswordManagerPage.hpp.

Referenced by onDeleteAllClicked(), refreshEntries(), and reload().

importButton_

Gtk::Button PasswordManagerPage::importButton_

private

Definition at line 51 of file PasswordManagerPage.hpp.

Referenced by buildUi(), and PasswordManagerPage().

listScrolled_

Gtk::ScrolledWindow PasswordManagerPage::listScrolled_

private

Definition at line 57 of file PasswordManagerPage.hpp.

Referenced by buildUi().

lockButton_

Gtk::Button PasswordManagerPage::lockButton_

private

Definition at line 44 of file PasswordManagerPage.hpp.

Referenced by buildUi(), and PasswordManagerPage().

logScrolled_

Gtk::ScrolledWindow PasswordManagerPage::logScrolled_

private

Definition at line 60 of file PasswordManagerPage.hpp.

Referenced by buildUi().

outputView_

Gtk::TextView PasswordManagerPage::outputView_

private

Definition at line 61 of file PasswordManagerPage.hpp.

Referenced by buildUi().

refreshButton_

Gtk::Button PasswordManagerPage::refreshButton_

private

Definition at line 53 of file PasswordManagerPage.hpp.

Referenced by buildUi(), and PasswordManagerPage().

searchEntry_

Gtk::SearchEntry PasswordManagerPage::searchEntry_

private

Definition at line 55 of file PasswordManagerPage.hpp.

Referenced by buildUi(), onSearchChanged(), PasswordManagerPage(), and reload().

securityBanner_

Gtk::Box PasswordManagerPage::securityBanner_

private

Definition at line 39 of file PasswordManagerPage.hpp.

Referenced by buildUi(), and PasswordManagerPage().

securityIcon_

Gtk::Label PasswordManagerPage::securityIcon_

private

Definition at line 40 of file PasswordManagerPage.hpp.

Referenced by buildUi().

securityLabel_

Gtk::Label PasswordManagerPage::securityLabel_

private

Definition at line 41 of file PasswordManagerPage.hpp.

Referenced by buildUi().

stateBox_

Gtk::Box PasswordManagerPage::stateBox_

private

Definition at line 45 of file PasswordManagerPage.hpp.

Referenced by buildUi(), PasswordManagerPage(), and setVaultState().

stateLabel_

Gtk::Label PasswordManagerPage::stateLabel_

private

Definition at line 46 of file PasswordManagerPage.hpp.

Referenced by buildUi(), and setVaultState().

topBar_

Gtk::Box PasswordManagerPage::topBar_

private

Definition at line 42 of file PasswordManagerPage.hpp.

Referenced by buildUi(), and PasswordManagerPage().

unlockButton_

Gtk::Button PasswordManagerPage::unlockButton_

private

Definition at line 43 of file PasswordManagerPage.hpp.

Referenced by buildUi(), and PasswordManagerPage().

vault_

PasswordVault PasswordManagerPage::vault_

private

Definition at line 37 of file PasswordManagerPage.hpp.

Referenced by onAddClicked(), onDeleteAllClicked(), onDeleteEntry(), onEditEntry(), onImportClicked(), onLockClicked(), onRevealEntry(), onUnlockClicked(), onVaultViewClicked(), PasswordManagerPage(), and reload().

vaultViewButton_

Gtk::Button PasswordManagerPage::vaultViewButton_

private

Definition at line 52 of file PasswordManagerPage.hpp.

Referenced by buildUi(), and PasswordManagerPage().

---

The documentation for this class was generated from the following files:

• BastionGuard/src/password_manager/PasswordManagerPage.hpp
• BastionGuard/src/password_manager/PasswordManagerPage.cpp