BackupPage Class Reference

#include <BackupPage.hpp>

Inheritance diagram for BackupPage:

Public Member Functions
	BackupPage ()
	~BackupPage () override

Private Member Functions
Gtk::Widget *	buildBackupTab ()
Gtk::Widget *	buildGrubTab ()
Gtk::Widget *	buildLogSection ()
void	onBuildRecovery ()
void	onInstallGrub ()
void	onRemoveGrub ()
void	logSafe (const std::string &msg)
void	runAsyncStreaming (const std::string &cmd, bool show_success=false)
void	updateRecoveryStatus ()
void	setResult (bool success, const std::string &msg)

Private Attributes
Gtk::Notebook	notebook
Gtk::Button	buildRecoveryButton
Gtk::Button	installGrubButton
Gtk::Button	removeGrubButton
Gtk::Label	recoveryStatusLabel
Gtk::Label	recoverySpaceLabel
Gtk::Label	recoveryResultLabel
Gtk::ProgressBar	recoveryProgress
Gtk::TextView	logView
Glib::RefPtr< Gtk::TextBuffer >	logBuffer
sigc::connection	pulseTimer
bool	buildRunning = false
BastionGuard::AliveFlag	alive_ = BastionGuard::make_alive_flag()

Detailed Description

Definition at line 12 of file BackupPage.hpp.

Constructor & Destructor Documentation

BackupPage()

BackupPage::BackupPage

(

)

Definition at line 61 of file BackupPage.cpp.

: Gtk::Box(Gtk::Orientation::VERTICAL, 0)
{
    logBuffer = Gtk::TextBuffer::create();
 
    notebook.append_page(*buildBackupTab(), _("💾 Backup"));
    notebook.append_page(*buildGrubTab(),   _("🛡 Recovery GRUB"));
 
    // Layout a due colonne: tab operative a sinistra e log a destra.
    auto* columns = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 0);
 
    auto* leftColumn = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 0);
    leftColumn->set_hexpand(true);
    notebook.set_vexpand(true);
    leftColumn->append(notebook);
 
    auto* rightColumn = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 0);
    rightColumn->set_size_request(340, -1);   // colonna laterale ~340px
    rightColumn->append(*buildLogSection());
 
    columns->append(*leftColumn);
    columns->append(*rightColumn);
 
    set_vexpand(true);
    append(*columns);
    columns->set_vexpand(true);
 
    // Aggiorna stato immagine all'avvio
    updateRecoveryStatus();
}

References _, buildBackupTab(), buildGrubTab(), buildLogSection(), logBuffer, notebook, and updateRecoveryStatus().

~BackupPage()

BackupPage::~BackupPage ( )

override

Definition at line 92 of file BackupPage.cpp.

{
    if (alive_) alive_->store(false, std::memory_order_release);
    if (pulseTimer.connected()) pulseTimer.disconnect();
}

References alive_, and pulseTimer.

Member Function Documentation

buildBackupTab()

Gtk::Widget * BackupPage::buildBackupTab ( )

private

Definition at line 102 of file BackupPage.cpp.

{
    auto box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 16);
    box->set_margin_top(20);
    box->set_margin_bottom(20);
    box->set_margin_start(20);
    box->set_margin_end(20);
 
    auto label = Gtk::make_managed<Gtk::Label>();
    label->set_markup(
        _("<b>Gestione snapshot BastionGuard</b>\n\n"
        "Per creare, eliminare e ripristinare snapshot "
        "aprire l'interfaccia grafica dedicata.\n"));
    label->set_wrap(true);
    label->set_halign(Gtk::Align::START);
    box->append(*label);
 
    auto launchButton = Gtk::make_managed<Gtk::Button>();
    launchButton->set_label(_("🛡 Apri Gestione Backup"));
    launchButton->get_style_context()->add_class("suggested-action");
    launchButton->signal_clicked().connect([this]() {
        try {
            Glib::spawn_command_line_async(BG_BACKUP_LAUNCHER);
            logSafe(Glib::ustring(_("Avvio gestore backup BastionGuard...\n")).raw());
        } catch (...) {
            logSafe(Glib::ustring(_("Errore durante l'avvio del gestore backup BastionGuard.\n")).raw());
        }
    });
    box->append(*launchButton);
 
    return box;
}

References _, BG_BACKUP_LAUNCHER, and logSafe().

Referenced by BackupPage().

buildGrubTab()

Gtk::Widget * BackupPage::buildGrubTab ( )

private

Definition at line 139 of file BackupPage.cpp.

{
    auto box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 14);
    box->set_margin_top(16);
    box->set_margin_bottom(16);
    box->set_margin_start(16);
    box->set_margin_end(16);
 
    // ── Descrizione ────────────────────────────────────────────────────
    auto desc = Gtk::make_managed<Gtk::Label>();
    desc->set_markup(
        _("<b>BastionGuard Recovery Environment</b>\n\n"
        "Installa una voce GRUB per avviare un sistema Linux "
        "minimale isolato e ripristinare snapshot in sicurezza.\n\n"
        "<b>⚠ Requisiti:</b>\n"
        "  • Almeno <b>2 GB</b> di spazio libero sulla partizione <tt>/boot</tt>\n"
        "  • Connessione internet per il download dei pacchetti Debian\n"
        "  • La build può richiedere 10–20 minuti"));
    desc->set_wrap(true);
    desc->set_halign(Gtk::Align::START);
    box->append(*desc);
 
    // ── Card stato immagine ─────────────────────────────────────────────
    auto card = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 6);
    card->get_style_context()->add_class("card");
    card->set_margin_top(4);
 
    recoveryStatusLabel.set_halign(Gtk::Align::START);
    recoveryStatusLabel.set_use_markup(true);
    card->append(recoveryStatusLabel);
 
    recoverySpaceLabel.set_halign(Gtk::Align::START);
    recoverySpaceLabel.set_use_markup(true);
    card->append(recoverySpaceLabel);
 
    box->append(*card);
 
    // ── Risultato ultimo comando ────────────────────────────────────────
    recoveryResultLabel.set_halign(Gtk::Align::START);
    recoveryResultLabel.set_use_markup(true);
    recoveryResultLabel.hide();
    box->append(recoveryResultLabel);
 
    // ── Progress bar ────────────────────────────────────────────────────
    recoveryProgress.set_show_text(true);
    recoveryProgress.set_text(_("In attesa..."));
    recoveryProgress.hide();
    box->append(recoveryProgress);
 
    // ── Pulsanti ────────────────────────────────────────────────────────
    auto btnBox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
 
    buildRecoveryButton.set_label(_("🔨 Build filesystem squashfs"));
    buildRecoveryButton.signal_clicked().connect(
        sigc::mem_fun(*this, &BackupPage::onBuildRecovery));
    btnBox->append(buildRecoveryButton);
 
    installGrubButton.set_label(_("⬆ Installa voce GRUB"));
    installGrubButton.get_style_context()->add_class("suggested-action");
    installGrubButton.signal_clicked().connect(
        sigc::mem_fun(*this, &BackupPage::onInstallGrub));
    btnBox->append(installGrubButton);
 
    removeGrubButton.set_label(_("🗑 Rimuovi voce GRUB"));
    removeGrubButton.get_style_context()->add_class("destructive-action");
    removeGrubButton.signal_clicked().connect(
        sigc::mem_fun(*this, &BackupPage::onRemoveGrub));
    btnBox->append(removeGrubButton);
 
    box->append(*btnBox);
 
    return box;
}

References _, buildRecoveryButton, installGrubButton, onBuildRecovery(), onInstallGrub(), onRemoveGrub(), recoveryProgress, recoveryResultLabel, recoverySpaceLabel, recoveryStatusLabel, and removeGrubButton.

Referenced by BackupPage().

buildLogSection()

Gtk::Widget * BackupPage::buildLogSection ( )

private

Definition at line 217 of file BackupPage.cpp.

{
    auto frame = Gtk::make_managed<Gtk::Frame>(_("Log operazioni"));
 
    logView.set_buffer(logBuffer);
    logView.set_editable(false);
    logView.set_monospace(true);
    logView.set_wrap_mode(Gtk::WrapMode::WORD_CHAR);
 
    auto scroll = Gtk::make_managed<Gtk::ScrolledWindow>();
    scroll->set_child(logView);
    // Pannello laterale: si espande in ALTEZZA per riempire lo spazio delle
    // tab, e ha una larghezza contenuta così non ruba spazio al contenuto.
    scroll->set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
    scroll->set_vexpand(true);
 
    frame->set_child(*scroll);
    frame->set_vexpand(true);
    frame->set_size_request(340, -1);   // larghezza ~340px, altezza flessibile
    frame->set_margin_top(10);
    frame->set_margin_bottom(10);
    frame->set_margin_end(12);
    frame->set_margin_start(6);
    return frame;
}

References _, logBuffer, and logView.

Referenced by BackupPage().

logSafe()

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

private

Definition at line 574 of file BackupPage.cpp.

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

References alive_, BastionGuard::if_alive(), logBuffer, and logView.

Referenced by buildBackupTab(), onBuildRecovery(), onInstallGrub(), onRemoveGrub(), and runAsyncStreaming().

onBuildRecovery()

void BackupPage::onBuildRecovery ( )

private

Definition at line 343 of file BackupPage.cpp.

{
 
    std::string cmd = std::string("pkexec bash \"") + BUILD_SCRIPT + "\"";
    logSafe(Glib::ustring(_("==> Avvio build Recovery environment...\n")).raw());
    logSafe(Glib::ustring(_("    (può richiedere 10-20 minuti)\n")).raw());
    runAsyncStreaming(cmd, true);
}

References _, BUILD_SCRIPT, logSafe(), and runAsyncStreaming().

Referenced by buildGrubTab().

onInstallGrub()

void BackupPage::onInstallGrub ( )

private

Definition at line 352 of file BackupPage.cpp.

{
 
    std::string cmd = std::string("pkexec bash \"") + INSTALL_GRUB_SCRIPT + "\"";
    logSafe(Glib::ustring(_("==> Installazione voce GRUB...\n")).raw());
    runAsyncStreaming(cmd, true);
}

References _, INSTALL_GRUB_SCRIPT, logSafe(), and runAsyncStreaming().

Referenced by buildGrubTab().

onRemoveGrub()

void BackupPage::onRemoveGrub ( )

private

Definition at line 360 of file BackupPage.cpp.

{
 
    std::string cmd =
    "pkexec bash -c 'rm -f /etc/grub.d/42_bastionguard-recovery && update-grub'";
    logSafe(Glib::ustring(_("==> Rimozione voce GRUB...\n")).raw());
    runAsyncStreaming(cmd, false);
}

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

Referenced by buildGrubTab().

runAsyncStreaming()

void BackupPage::runAsyncStreaming ( const std::string & cmd, bool show_success = false )

private

Definition at line 373 of file BackupPage.cpp.

{
    if (buildRunning) {
        logSafe(Glib::ustring(_("⚠ Operazione già in corso.\n")).raw());
        return;
    }
 
    buildRunning = true;
    buildRecoveryButton.set_sensitive(false);
    installGrubButton.set_sensitive(false);
    removeGrubButton.set_sensitive(false);
 
    recoveryProgress.set_text(_("Operazione in corso..."));
    recoveryProgress.show();
    recoveryResultLabel.hide();
 
    pulseTimer = Glib::signal_timeout().connect([this]() -> bool {
        if (!buildRunning)
            return false;
        recoveryProgress.pulse();
        return true;
    }, 200);
 
    std::vector<std::string> argv = { "/bin/bash", "-c", cmd };
    int stdout_fd = -1;
    int stderr_fd = -1;
    Glib::Pid pid = 0;
 
    try {
        Glib::spawn_async_with_pipes(
            "",
            argv,
            Glib::SpawnFlags::SEARCH_PATH | Glib::SpawnFlags::DO_NOT_REAP_CHILD,
            sigc::slot<void()>(),
                                     &pid,
                                     nullptr,
                                     &stdout_fd,
                                     &stderr_fd
        );
    } catch (const Glib::Error& e) {
        logSafe(
            Glib::ustring::compose(_("Errore avvio processo: %1\n"), e.what()).raw()
        );
        buildRunning = false;
        pulseTimer.disconnect();
        recoveryProgress.hide();
        buildRecoveryButton.set_sensitive(true);
        installGrubButton.set_sensitive(true);
        removeGrubButton.set_sensitive(true);
        setResult(false, _("Errore avvio processo"));
        return;
    }
 
    auto stdout_ch = Glib::IOChannel::create_from_fd(stdout_fd);
    auto stderr_ch = Glib::IOChannel::create_from_fd(stderr_fd);
    stdout_ch->set_encoding("");
    stderr_ch->set_encoding("");
    stdout_ch->set_flags(Glib::IOFlags::NONBLOCK);
    stderr_ch->set_flags(Glib::IOFlags::NONBLOCK);
 
    // ANTI-BOOTLOOP: condividiamo le sigc::connection per le due signal_io
    // dentro shared_ptr, così sia le callback I/O (in caso di HUP/ERR) sia
    // il child_watch possono disconnetterle. Senza questa disconnessione
    // esplicita, quando il processo termina i fd vanno in IO_HUP e GLib
    // continua a richiamare la callback all'infinito (busy loop sul main
    // loop → BackupPage va in "bootloop" e la UI si blocca, specie durante
    // build pesanti come `build-recovery-squashfs.sh` che dura 10-20 min).
    auto stdout_conn = std::make_shared<sigc::connection>();
    auto stderr_conn = std::make_shared<sigc::connection>();
    auto alive = alive_;
 
    // Helper che drena ciò che resta sul channel in modo non bloccante,
    // ignorando errori. Chiamato sia su HUP sia alla terminazione del child.
    auto drain_channel = [this, alive](Glib::RefPtr<Glib::IOChannel> ch, bool is_stderr) {
        if (!ch) return;
        try {
            for (;;) {
                Glib::ustring line;
                auto st = ch->read_line(line);
                if (st != Glib::IOStatus::NORMAL || line.empty()) break;
                BastionGuard::if_alive(alive, [this, &line, is_stderr]() {
                    if (is_stderr) {
                        logSafe(Glib::ustring::compose(_("⚠ %1"), line.raw()).raw());
                    } else {
                        logSafe(line.raw());
                    }
                });
            }
        } catch (...) {}
    };
 
    // Leggi stdout
    *stdout_conn = Glib::signal_io().connect(
        [this, alive, stdout_ch, stdout_conn, drain_channel](Glib::IOCondition cond) -> bool {
            // Drena tutto ciò che è disponibile.
            if ((cond & Glib::IOCondition::IO_IN) != Glib::IOCondition()) {
                try {
                    Glib::ustring line;
                    auto status = stdout_ch->read_line(line);
                    if (status == Glib::IOStatus::NORMAL && !line.empty()) {
                        BastionGuard::if_alive(alive, [this, &line]() {
                            logSafe(line.raw());
                        });
                    }
                } catch (...) {}
            }
            // FIX BOOTLOOP: HUP/ERR → drena residuo, poi stacca la sorgente
            // ritornando false. Senza questo, GLib richiama la callback
            // all'infinito perché HUP è level-triggered.
            if ((cond & (Glib::IOCondition::IO_HUP | Glib::IOCondition::IO_ERR))
                != Glib::IOCondition()) {
                drain_channel(stdout_ch, false);
                return false;
            }
            return true;
        },
        stdout_fd, Glib::IOCondition::IO_IN | Glib::IOCondition::IO_HUP | Glib::IOCondition::IO_ERR
    );
 
    // Leggi stderr
    *stderr_conn = Glib::signal_io().connect(
        [this, alive, stderr_ch, stderr_conn, drain_channel](Glib::IOCondition cond) -> bool {
            if ((cond & Glib::IOCondition::IO_IN) != Glib::IOCondition()) {
                try {
                    Glib::ustring line;
                    auto status = stderr_ch->read_line(line);
                    if (status == Glib::IOStatus::NORMAL && !line.empty()) {
                        BastionGuard::if_alive(alive, [this, &line]() {
                            logSafe(Glib::ustring::compose(_("⚠ %1"), line.raw()).raw());
                        });
                    }
                } catch (...) {}
            }
            if ((cond & (Glib::IOCondition::IO_HUP | Glib::IOCondition::IO_ERR))
                != Glib::IOCondition()) {
                drain_channel(stderr_ch, true);
                return false;
            }
            return true;
        },
        stderr_fd, Glib::IOCondition::IO_IN | Glib::IOCondition::IO_HUP | Glib::IOCondition::IO_ERR
    );
 
    // Attendi completamento processo
    Glib::signal_child_watch().connect(
        [this, alive, show_success, stdout_ch, stderr_ch, stdout_conn, stderr_conn, drain_channel]
        (Glib::Pid p, int status) {
            // FIX BOOTLOOP: stacca esplicitamente le due signal_io PRIMA
            // di chiudere i channel, altrimenti se il fd viene riciclato
            // dal kernel le callback si riarmano su un altro fd.
            if (stdout_conn && stdout_conn->connected()) stdout_conn->disconnect();
            if (stderr_conn && stderr_conn->connected()) stderr_conn->disconnect();
 
            // Drena eventuale residuo prima di chiudere.
            drain_channel(stdout_ch, false);
            drain_channel(stderr_ch, true);
 
            try { stdout_ch->close(); } catch (...) {}
            try { stderr_ch->close(); } catch (...) {}
            Glib::spawn_close_pid(p);
 
            BastionGuard::if_alive(alive, [this, show_success, status]() {
                pulseTimer.disconnect();
                buildRunning = false;
                recoveryProgress.hide();
                buildRecoveryButton.set_sensitive(true);
                installGrubButton.set_sensitive(true);
                removeGrubButton.set_sensitive(true);
 
                bool ok = (WIFEXITED(status) && WEXITSTATUS(status) == 0);
 
                if (ok) {
                    logSafe(Glib::ustring(_("==> Operazione completata con successo.\n")).raw());
                    if (show_success)
                        setResult(true, _("Completato — disponibile al prossimo avvio"));
                } else {
                    int code = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
                    logSafe(
                        Glib::ustring::compose(
                            _("==> Operazione terminata con errore (codice: %1)\n"),
                                               code
                        ).raw()
                    );
                    setResult(
                        false,
                        Glib::ustring::compose(
                            _("Operazione fallita (codice %1)"),
                                               code
                        ).raw()
                    );
                }
            });
        },
        pid
    );
}

References _, alive_, buildRecoveryButton, buildRunning, BastionGuard::if_alive(), installGrubButton, logSafe(), pulseTimer, recoveryProgress, recoveryResultLabel, removeGrubButton, and setResult().

Referenced by onBuildRecovery(), onInstallGrub(), and onRemoveGrub().

setResult()

void BackupPage::setResult ( bool success, const std::string & msg )

private

Definition at line 311 of file BackupPage.cpp.

{
    if (success) {
        recoveryResultLabel.set_markup(
            Glib::ustring::compose(
                "<span foreground='#ffffff' background='#22c55e'> ✅  %1 </span>",
                msg
            )
        );
        recoveryResultLabel.get_style_context()->add_class("alert-success");
        recoveryResultLabel.get_style_context()->remove_class("alert-danger");
    } else {
        recoveryResultLabel.set_markup(
            Glib::ustring::compose(
                "<span foreground='#ffffff' background='#c0392b'> ❌  %1 </span>",
                msg
            )
        );
        recoveryResultLabel.get_style_context()->add_class("alert-danger");
        recoveryResultLabel.get_style_context()->remove_class("alert-success");
    }
 
    recoveryResultLabel.show();
    updateRecoveryStatus();
}

References recoveryResultLabel, and updateRecoveryStatus().

Referenced by runAsyncStreaming().

updateRecoveryStatus()

void BackupPage::updateRecoveryStatus ( )

private

Definition at line 247 of file BackupPage.cpp.

{
    bool squashfs_ok = Glib::file_test(RECOVERY_SQUASHFS, Glib::FileTest::EXISTS);
    bool kernel_ok   = Glib::file_test(RECOVERY_KERNEL,   Glib::FileTest::EXISTS);
    bool grub_ok     = Glib::file_test(GRUB_ENTRY,        Glib::FileTest::EXISTS);
 
    std::string status_markup;
 
    if (squashfs_ok && kernel_ok) {
        std::string size_str = "?";
        try {
            auto info = Gio::File::create_for_path(RECOVERY_SQUASHFS)
            ->query_info("standard::size");
            size_str = fmtSize((guint64)info->get_size());
        } catch (...) {}
 
        status_markup = Glib::ustring::compose(
            _("<span foreground='#22c55e'>✅ <b>Immagine recovery presente</b></span>\n"
            "<small><tt>%1</tt>\n"
            "filesystem.squashfs: %2\n"
            "Voce GRUB: %3</small>"),
            RECOVERY_DIR,
            size_str,
            grub_ok ? _("✅ installata") : _("⚠ non installata")
        );
    } else {
        status_markup =
        _("<span foreground='#f59e0b'>⚠ <b>Immagine recovery non trovata</b></span>\n"
        "<small>Usare \"Build filesystem squashfs\" per crearla.</small>");
    }
 
    recoveryStatusLabel.set_markup(status_markup);
 
    // Spazio disponibile su /boot
    struct statvfs vfs;
    std::string space_markup;
 
    const char* check_path = Glib::file_test("/boot", Glib::FileTest::IS_DIR)
    ? "/boot" : "/";
 
    if (statvfs(check_path, &vfs) == 0) {
        guint64 free_bytes = (guint64)vfs.f_bavail * vfs.f_frsize;
        std::string free_str = fmtSize(free_bytes);
        bool enough = free_bytes >= MIN_SPACE_BYTES;
 
        space_markup = Glib::ustring::compose(
            _("Spazio libero su <tt>%1</tt>: <b>%2</b> %3"),
                                              check_path,
                                              free_str,
                                              enough
                                              ? _("<span foreground='#22c55e'>✅ sufficiente</span>")
                                              : _("<span foreground='#ef4444'>❌ insufficiente (minimo 2 GB)</span>")
        );
    } else {
        space_markup = _("Spazio disponibile: <i>non rilevato</i>");
    }
 
    recoverySpaceLabel.set_markup(space_markup);
}

References _, fmtSize(), GRUB_ENTRY, MIN_SPACE_BYTES, RECOVERY_DIR, RECOVERY_KERNEL, RECOVERY_SQUASHFS, recoverySpaceLabel, and recoveryStatusLabel.

Referenced by BackupPage(), and setResult().

Member Data Documentation

alive_

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

private

Definition at line 58 of file BackupPage.hpp.

Referenced by logSafe(), runAsyncStreaming(), and ~BackupPage().

buildRecoveryButton

Gtk::Button BackupPage::buildRecoveryButton

private

Definition at line 25 of file BackupPage.hpp.

Referenced by buildGrubTab(), and runAsyncStreaming().

buildRunning

bool BackupPage::buildRunning = false

private

Definition at line 56 of file BackupPage.hpp.

Referenced by runAsyncStreaming().

installGrubButton

Gtk::Button BackupPage::installGrubButton

private

Definition at line 26 of file BackupPage.hpp.

Referenced by buildGrubTab(), and runAsyncStreaming().

logBuffer

Glib::RefPtr<Gtk::TextBuffer> BackupPage::logBuffer

private

Definition at line 36 of file BackupPage.hpp.

Referenced by BackupPage(), buildLogSection(), and logSafe().

logView

Gtk::TextView BackupPage::logView

private

Definition at line 35 of file BackupPage.hpp.

Referenced by buildLogSection(), and logSafe().

notebook

Gtk::Notebook BackupPage::notebook

private

Definition at line 22 of file BackupPage.hpp.

Referenced by BackupPage().

pulseTimer

sigc::connection BackupPage::pulseTimer

private

Definition at line 55 of file BackupPage.hpp.

Referenced by runAsyncStreaming(), and ~BackupPage().

recoveryProgress

Gtk::ProgressBar BackupPage::recoveryProgress

private

Definition at line 32 of file BackupPage.hpp.

Referenced by buildGrubTab(), and runAsyncStreaming().

recoveryResultLabel

Gtk::Label BackupPage::recoveryResultLabel

private

Definition at line 31 of file BackupPage.hpp.

Referenced by buildGrubTab(), runAsyncStreaming(), and setResult().

recoverySpaceLabel

Gtk::Label BackupPage::recoverySpaceLabel

private

Definition at line 30 of file BackupPage.hpp.

Referenced by buildGrubTab(), and updateRecoveryStatus().

recoveryStatusLabel

Gtk::Label BackupPage::recoveryStatusLabel

private

Definition at line 29 of file BackupPage.hpp.

Referenced by buildGrubTab(), and updateRecoveryStatus().

removeGrubButton

Gtk::Button BackupPage::removeGrubButton

private

Definition at line 27 of file BackupPage.hpp.

Referenced by buildGrubTab(), and runAsyncStreaming().

---

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

• BastionGuard/src/backup/BackupPage.hpp
• BastionGuard/src/backup/BackupPage.cpp