MainWindow Class Reference

#include <MainWindow.hpp>

Inheritance diagram for MainWindow:

Public Member Functions
	MainWindow ()
	~MainWindow () override=default
void	showDashboard ()
void	open_settings_window ()
	MainWindow ()
void	create_snapshot ()
void	delete_selected ()
void	mark_selected ()
void	browse_selected ()
void	view_snapshot_log (bool view_restore_log)
void	show_settings ()
	MainWindow ()
	~MainWindow () override
	MainWindow ()
	~MainWindow () override

Protected Member Functions
bool	on_close_request () override

Private Types
enum class	ThemeMode { Dark , Light }
enum class	WizardStep { Source , Destination , Scan , Recover }

Private Member Functions
void	build_headerbar ()
void	build_sidebar (ClamdConfig &clamdConfig)
void	activate_sidebar_button (Gtk::Button *btn)
void	minimize ()
void	build_headerbar ()
bool	load_theme_preference ()
void	save_theme_preference (bool use_dark)
string	load_language_preference ()
void	save_language_preference (string lang_code)
void	apply_language_env (string lang_code)
void	on_language_changed ()
void	restart_application ()
void	load_css (bool use_dark=false)
void	apply_theme (bool use_dark)
void	update_theme_buttons ()
void	init_sidebar ()
Gtk.Button	make_nav_btn (string icon, string label, string page)
Gtk.Button	make_theme_btn (string icon, string label)
void	activate_nav (Gtk.Button btn, string page)
void	show_snapshots_page ()
bool	page_requires_expanded_window (string page)
void	remember_compact_window_size ()
void	resize_main_window (int width, int height)
void	apply_window_mode_for_page (string page)
void	set_dynamic_page (string name, ref Gtk.Widget? slot, Gtk.Widget widget)
void	open_backup_flow ()
void	open_delete_flow ()
void	open_restore_flow ()
void	open_rsync_log_page (string log_file)
void	init_settings_page ()
void	init_wizard_page ()
void	init_about_page ()
void	init_content ()
void	init_snapshots_page ()
Gtk.Box	make_card (bool hexpand)
Gtk.Button	make_action_btn (string icon, string label, bool primary, bool danger, string css_class="")
bool	init_delayed ()
bool	refresh_all ()
bool	on_close_request ()
void	btn_restore_clicked ()
bool	check_if_deletion_running ()
void	restore ()
void	btn_settings_clicked ()
void	btn_wizard_clicked ()
void	settings_changed (bool btrfs_mode_prev)
void	btn_about_clicked ()
void	ui_sensitive (bool enable)
void	update_statusbar ()
Gtk.Image	themed_icon (string icon_name, int size)
void	reload_themed_icons ()
void	build_headerbar ()
void	build_sidebar ()
void	build_dashboard ()
void	build_recovery_page ()
void	build_wizard ()
void	build_about_page ()
void	update_action_controls ()
void	apply_theme (ThemeMode mode)
void	apply_inline_css ()
void	update_theme_buttons ()
void	activate_sidebar_button (Gtk::Button *button)
void	refresh_devices ()
void	populate_device_lists ()
void	select_source (const std::string &path, const std::string &label)
void	update_source_state ()
void	update_wizard_step ()
void	append_log (const std::string &line)
void	on_sidebar_dashboard ()
void	on_sidebar_recovery ()
void	on_sidebar_about ()
void	on_refresh_devices ()
void	on_language_changed ()
void	on_open_image ()
void	on_choose_destination ()
void	on_use_selected_device ()
void	on_dashboard_device_activated (Gtk::ListBoxRow *row)
void	on_recovery_device_activated (Gtk::ListBoxRow *row)
void	on_theme_dark ()
void	on_theme_light ()
void	on_wizard_back ()
void	on_wizard_next ()
void	on_scan_now ()
void	on_recover_now ()
void	on_launch_elevated ()
void	on_scan_progress (const ScanProgress &progress)
void	on_scan_completed (const ScanReport &report)
void	on_recovery_completed (const RecoveryResult &result)
void	populate_scan_results (const ScanReport &report)
void	update_selected_results_state ()
std::vector< size_t >	selected_result_indices () const
void	set_all_results_selected (bool selected)
void	minimize_window ()
void	hide_window ()
void	buildHeaderBar ()
void	buildSidebar ()
Gtk::Button *	makeSidebarButton (const std::string &iconPath, const std::string &label, const std::string &pageName)
void	activateSidebarButton (Gtk::Button *btn)
void	loadTheme (bool dark)
void	applyTheme (bool dark)
void	saveConfig ()
void	loadConfig ()
void	applyLanguage (const std::string &lang)
void	showLanguageDialog ()
void	onDaemonConnected ()
void	onDaemonDisconnected ()
void	onNewConnection (const ConnectionInfo &info)
void	onDaemonAlert (const AlertInfo &alert)
void	onVerdict (Verdict v, const ConnectionInfo &info)
void	setStatus (const std::string &msg)
void	applyProtectionEnabled (bool enabled)
void	refreshSystemIntegrationStatus ()
void	startDesktopActivityMonitor ()
bool	pollDesktopActivity ()
void	noteDesktopActivity ()
void	sendDesktopActivityState (bool active, bool force=false)
bool	on_close_request () override

Static Private Member Functions
static std::string	result_group_label (const ScanResult &result)
static std::string	result_subgroup_label (const ScanResult &result)
static std::string	human_size (uint64_t bytes)
static std::string	read_language ()
static void	save_language (const std::string &lang_code)
static std::string	read_theme ()
static void	save_theme (const std::string &theme_code)
static std::string	cacheKey (const std::string &app, const std::string &host, const std::string &ip)

Private Attributes
Gtk::Box	mainBox {Gtk::Orientation::HORIZONTAL}
Gtk::Stack	stack_
std::vector< Gtk::Button * >	sidebar_buttons_
AboutPage	about_page_
DonatePage	donate_page_
DashboardPage	dashboard_page_
ScanPage	scan_page_ {*this}
LogPage	log_page_
ClamdConfig	clamdConfig_
SettingsWindow *	settings_window_ = nullptr
BankPage *	bank_page_ = nullptr
QuarantinePage	quarantine_page_
PhishingPage *	phishing_page_ = nullptr
VpnPage *	vpn_page_ = nullptr
UpdatePage	update_page_
PrivacyPage *	privacy_page_
RootGuardPage *	rootguard_page_ = nullptr
AntiRansomwarePage *	anti_ransomware_page_ = nullptr
USBScanPage *	usb_page_ = nullptr
SambaPage *	samba_page_ = nullptr
IdentityLeakPage *	identity_leak_page_ = nullptr
PasswordManagerPage *	password_manager_page_ = nullptr
BackupPage *	backup_page_ = nullptr
Gtk::Button *	dashboard_button_ = nullptr
Gtk.Box	hbox_root
Gtk.Box	vbox_sidebar
Gtk.Stack	content_stack
Gtk.? Widget	settings_page_widget = null
Gtk.? Widget	wizard_page_widget = null
Gtk.? Widget	about_page_widget = null
Gtk.? Widget	backup_page_widget = null
Gtk.? Widget	restore_page_widget = null
Gtk.? Widget	delete_page_widget = null
Gtk.? Widget	rsync_log_page_widget = null
Gtk.Button	btn_nav_snapshots
Gtk.Button	btn_nav_settings
Gtk.Button	btn_nav_wizard
Gtk.Button	btn_nav_about
Gtk.? Button	current_nav_btn = null
Gtk.? CssProvider	css_provider = null
bool	dark_mode = false
Gtk.? Button	btn_theme_light = null
Gtk.? Button	btn_theme_dark = null
Gtk.? ComboBoxText	lang_combo = null
string	current_lang = "en_US"
Gtk.Button	btn_backup
Gtk.Button	btn_restore
Gtk.Button	btn_delete_snapshot
Gtk.Button	btn_browse_snapshot
Gee.ArrayList< Gtk.Image >	themed_img_list = new Gee.ArrayList<Gtk.Image>()
Gee.ArrayList< string >	themed_img_name = new Gee.ArrayList<string>()
Gee.ArrayList< int >	themed_img_size = new Gee.ArrayList<int>()
SettingsWindow?	embedded_settings = null
SetupWizardWindow?	embedded_wizard = null
SnapshotListBox	snapshot_list_box
Gtk.Image	img_shield
Gtk.Label	lbl_status_title
Gtk.Label	lbl_status_detail
Gtk.Label	lbl_snap_count
Gtk.Label	lbl_free_space
Gtk.Label	lbl_device_name
uint	tmr_init
int	def_width = 500
int	def_height = -1
int	compact_window_width = 980
int	compact_window_height = 520
bool	window_in_expanded_mode = false
ThemeMode	current_theme_ = ThemeMode::Dark
WizardStep	current_step_ = WizardStep::Source
Glib::RefPtr< Gtk::CssProvider >	css_provider_
Gtk::Box	main_box_ {Gtk::Orientation::HORIZONTAL, 0}
Gtk::Stack	page_stack_
Gtk::Box	sidebar_ {Gtk::Orientation::VERTICAL, 10}
Gtk::Box	dashboard_page_ {Gtk::Orientation::VERTICAL, 16}
Gtk::Box	recovery_page_ {Gtk::Orientation::VERTICAL, 16}
Gtk::Box	about_page_ {Gtk::Orientation::VERTICAL, 24}
Gtk::Grid	cards_grid_
Gtk::Frame	card_status_
Gtk::Frame	card_source_
Gtk::Frame	card_update_
Gtk::Label	status_card_label_
Gtk::Label	source_card_label_
Gtk::Label	update_card_label_
Gtk::Frame	devices_frame_
Gtk::ScrolledWindow	devices_scroller_
Gtk::ListBox	devices_list_
Gtk::Label	brand_label_
Gtk::Button	btn_dashboard_
Gtk::Button	btn_recovery_
Gtk::Button	btn_about_
Gtk::Button	btn_refresh_
Gtk::Button	btn_theme_dark_
Gtk::Button	btn_theme_light_
Gtk::Button *	recovery_button_ = nullptr
Gtk::Button *	about_button_ = nullptr
Gtk::DropDown	lang_combo_
bool	lang_changing_ = false
Gtk::Box	recovery_header_ {Gtk::Orientation::VERTICAL, 8}
Gtk::Label	recovery_title_
Gtk::Label	recovery_subtitle_
Gtk::Frame	wizard_frame_
Gtk::Box	wizard_root_ {Gtk::Orientation::VERTICAL, 12}
Gtk::Stack	wizard_stack_
Gtk::Box	wizard_nav_ {Gtk::Orientation::HORIZONTAL, 8}
Gtk::Button	btn_wizard_back_
Gtk::Button	btn_wizard_next_
Gtk::Label	wizard_notice_label_
Gtk::Box	source_step_box_ {Gtk::Orientation::VERTICAL, 8}
Gtk::Label	source_step_label_
Gtk::Box	source_button_row_ {Gtk::Orientation::HORIZONTAL, 8}
Gtk::Button	btn_open_image_
Gtk::Button	btn_use_selected_device_
Gtk::Button	btn_launch_elevated_
Gtk::ScrolledWindow	recovery_devices_scroller_
Gtk::ListBox	recovery_devices_list_
Gtk::Box	destination_step_box_ {Gtk::Orientation::VERTICAL, 8}
Gtk::Label	destination_step_label_
Gtk::Box	destination_button_row_ {Gtk::Orientation::HORIZONTAL, 8}
Gtk::Entry	entry_output_
Gtk::Button	btn_choose_destination_
Gtk::Box	scan_step_box_ {Gtk::Orientation::VERTICAL, 8}
Gtk::Label	scan_step_label_
Gtk::ProgressBar	scan_progress_bar_
Gtk::Label	scan_status_label_
Gtk::Label	scan_timer_label_
Gtk::Button	btn_scan_now_
Gtk::Box	recover_step_box_ {Gtk::Orientation::VERTICAL, 8}
Gtk::Label	recover_step_label_
Gtk::Frame	results_frame_
Gtk::ScrolledWindow	results_scroller_
Gtk::Box	results_tree_box_ {Gtk::Orientation::VERTICAL, 8}
Gtk::Label	results_count_label_
Gtk::Label	results_selected_label_
Gtk::Box	results_actions_row_ {Gtk::Orientation::HORIZONTAL, 8}
Gtk::Button	btn_results_select_all_
Gtk::Button	btn_results_clear_
Gtk::Button	btn_recover_now_
Gtk::ScrolledWindow	log_scroller_
Gtk::TextView	log_view_
Glib::RefPtr< Gtk::TextBuffer >	log_buffer_
Glib::RefPtr< Gtk::FileDialog >	file_dialog_
Glib::RefPtr< Gtk::FileDialog >	folder_dialog_
std::vector< DeviceInfo >	devices_
std::string	selected_source_path_
std::string	selected_source_label_
std::string	output_dir_
ScanReport	last_report_
std::vector< bool >	result_selection_
std::vector< Gtk::CheckButton * >	result_check_buttons_
ScanWorker	scan_worker_
RecoveryWorker	recovery_worker_
ScanProgress	last_scan_progress_
sigc::connection	scan_timer_connection_
std::chrono::steady_clock::time_point	scan_started_at_ {}
Gtk::Box	m_mainBox { Gtk::Orientation::HORIZONTAL, 0 }
Gtk::Stack	m_stack
UIServer	m_uiServer
ConnectionsPage	m_connectionsPage { m_uiServer }
AppsPage	m_appsPage
NetworkPage	m_networkPage
RulesPage	m_rulesPage
StatsPage	m_statsPage
AboutPage	m_aboutPage
SettingsPage	m_settingsPage
TrayIcon	m_tray
std::unique_ptr< AlertDialog >	m_alertDialog
std::unique_ptr< LanguageDialog >	m_langDialog
std::map< std::string, ReplyAction >	m_verdictCache
std::vector< Gtk::Button * >	m_sidebarButtons
Gtk::Button *	m_activeButton = nullptr
Gtk::Label *	m_daemonLabel = nullptr
Glib::RefPtr< Gtk::CssProvider >	m_cssProvider
bool	m_darkMode = false
Gtk::Button *	m_btnLight = nullptr
Gtk::Button *	m_btnDark = nullptr
Gtk::Statusbar	m_statusbar
guint	m_statusCtx = 0
uint64_t	m_statAllowed = 0
uint64_t	m_statDenied = 0
std::string	m_configFile
std::string	m_language
bool	m_protectionEnabled = true
std::string	m_autostartBackupFile
guint	m_desktopActivityTimer = 0
bool	m_desktopActiveSent = true
std::chrono::steady_clock::time_point	m_lastUiActivity {}

Static Private Attributes
const string	THEME_CONFIG_DIR = "/etc/bastionguard-backup"
const string	THEME_CONFIG_FILE = "/etc/bastionguard-backup/theme.json"
const string	LANG_CONFIG_FILE = "/etc/bastionguard-backup/language.json"
static string[]	LANG_CODES
static string[]	LANG_NAMES

Detailed Description

Definition at line 53 of file MainWindow.hpp.

Member Enumeration Documentation

ThemeMode

enum class MainWindow::ThemeMode

strongprivate

Enumerator
Dark
Light

Definition at line 22 of file main_window.hpp.

{ Dark, Light };

WizardStep

enum class MainWindow::WizardStep

strongprivate

Enumerator
Source
Destination
Scan
Recover

Definition at line 23 of file main_window.hpp.

{ Source, Destination, Scan, Recover };

Constructor & Destructor Documentation

MainWindow() [1/4]

MainWindow::MainWindow

(

)

Definition at line 39 of file MainWindow.cpp.

                       {
    set_title("");
    set_resizable(true);
    set_default_size(1000, 680);
    set_size_request(800, 560);
 
    std::vector<std::string> conf_paths = {
        "/etc/clamd/clamd.conf",
        "/etc/clamav/clamd.conf",
        "/etc/clamd.d/clamd.conf",
        "/etc/clamd.conf"
    };
 
    bool loaded = false;
    for (const auto& path : conf_paths) {
        if (clamdConfig_.load(path)) {
            std::cout << _("✔ Caricato config da: ") << path << std::endl;
            loaded = true;
            break;
        }
    }
 
    if (!loaded) {
        std::cerr << _("❌ Errore: impossibile leggere clamd.conf in nessuno dei percorsi noti") << "\n";
    }
 
 
 
    build_headerbar();
 
 
    stack_.get_style_context()->add_class("content");
    stack_.set_transition_type(Gtk::StackTransitionType::SLIDE_LEFT_RIGHT);
    stack_.set_transition_duration(220);
    stack_.add(dashboard_page_, "dashboard");
    stack_.add(scan_page_, "scan");
    samba_page_ = Gtk::make_managed<SambaPage>();
    stack_.add(*samba_page_, "samba");
    anti_ransomware_page_ = Gtk::make_managed<AntiRansomwarePage>(*this);
    stack_.add(*anti_ransomware_page_, "antiransomware");
    backup_page_ = Gtk::make_managed<BackupPage>();
    stack_.add(*backup_page_, "backup");
    stack_.add(log_page_, "log");
#if BASTIONGUARD_HAS_CEF
    if (BastionGuard::Platform::cef_available()) {
        bank_page_ = Gtk::make_managed<BankPage>();
        stack_.add(*bank_page_, "bank");
    }
#endif
    privacy_page_ = Gtk::make_managed<PrivacyPage>();
    stack_.add(*privacy_page_, "privacy");
    rootguard_page_ = Gtk::make_managed<RootGuardPage>();
    stack_.add(*rootguard_page_, "rootguard");
    stack_.add(quarantine_page_, "quarantine");
    usb_page_ = Gtk::make_managed<USBScanPage>();
    stack_.add(*usb_page_, "usbscan");
    stack_.add(update_page_, "update");
    stack_.add(about_page_, "about");
    stack_.add(donate_page_, "donate");
    password_manager_page_ = Gtk::make_managed<PasswordManagerPage>();
    stack_.add(*password_manager_page_, "passwordmanager");
    identity_leak_page_ = Gtk::make_managed<IdentityLeakPage>(*this);
    stack_.add(*identity_leak_page_, "identityleak");
 
    phishing_page_ = Gtk::make_managed<PhishingPage>();
    stack_.add(*phishing_page_, "phishing");
    vpn_page_ = Gtk::make_managed<VpnPage>();
    stack_.add(*vpn_page_, "vpn");
 
    build_sidebar(clamdConfig_);
    mainBox.append(stack_);
    set_child(mainBox);
 
 
    auto get_cvd_version = [](const std::string& path) -> std::string {
        std::ifstream file(path, std::ios::binary);
        if (!file.is_open()) return "";
 
        std::string header;
        header.resize(512);
        file.read(&header[0], 512);
 
        std::regex re("ClamAV-VDB:.*:([0-9]+):");
        std::smatch match;
        if (std::regex_search(header, match, re)) {
            return match[1];
        }
        return "";
    };
 
    std::string db_version;
    std::string daily    = get_cvd_version("/var/lib/clamav/daily.cvd");
    std::string main     = get_cvd_version("/var/lib/clamav/main.cvd");
    std::string bytecode = get_cvd_version("/var/lib/clamav/bytecode.cvd");
 
    if (!daily.empty())    db_version += "daily: "    + daily    + " ";
    if (!main.empty())     db_version += "main: "     + main     + " ";
    if (!bytecode.empty()) db_version += "bytecode: " + bytecode + " ";
    if (db_version.empty()) db_version = _("sconosciuta");
 
    bool on_access_enabled = true;
    dashboard_page_.update_from_logs("", db_version, on_access_enabled);
    activate_sidebar_button(dashboard_button_);
}

References _, about_page_, activate_sidebar_button(), anti_ransomware_page_, backup_page_, bank_page_, build_headerbar(), build_sidebar(), BastionGuard::Platform::cef_available(), clamdConfig_, dashboard_button_, dashboard_page_, donate_page_, identity_leak_page_, ClamdConfig::load(), log_page_, main(), mainBox, password_manager_page_, phishing_page_, privacy_page_, quarantine_page_, rootguard_page_, samba_page_, scan_page_, stack_, DashboardPage::update_from_logs(), update_page_, usb_page_, and vpn_page_.

Referenced by ClamApp::launch_main_window(), AppGtk::start_application(), and startDesktopActivityMonitor().

~MainWindow() [1/3]

MainWindow::~MainWindow ( )

overridedefault

Definition at line 292 of file MainWindow.cpp.

{
    if (m_desktopActivityTimer != 0) {
        g_source_remove(m_desktopActivityTimer);
        m_desktopActivityTimer = 0;
    }
 
    // Salva i log — vengono letti al prossimo avvio.
    // Il file viene cancellato solo da "Pulisci" nelle rispettive pagine.
    m_connectionsPage.saveLog();
    m_networkPage.saveLog();
 
    m_tray.stop();
    m_uiServer.stop();
}

References m_connectionsPage, m_desktopActivityTimer, m_networkPage, m_tray, m_uiServer, ConnectionsPage::saveLog(), NetworkPage::saveLog(), TrayIcon::stop(), and UIServer::stop().

MainWindow() [2/4]

MainWindow.MainWindow ( )

inline

Definition at line 104 of file MainWindow.vala.

                         {
 
        log_debug("MainWindow: MainWindow()");
 
        this.title = "BastionGuard™ Backup";
        this.modal = true;
        this.set_default_size(980, 520);
        this.set_resizable(true);
        this.close_request.connect(on_close_request);
        this.set_icon_name("bastionguard-backup");
        this.set_titlebar(HeaderFactory.create_main_headerbar(this, 0));
 
        // Carica lingua da config (prima del CSS, prima di qualsiasi _())
        current_lang = load_language_preference();
        apply_language_env(current_lang);
 
        // Carica tema da config
        dark_mode = load_theme_preference();
        IconManager.use_dark = dark_mode;  // set before first icon creation
        load_css(dark_mode);
 
        this.set_titlebar(HeaderFactory.create_main_headerbar(this, 180));
 
        hbox_root = new Gtk.Box(Orientation.HORIZONTAL, 0);
        set_child(hbox_root);
        hbox_root.hexpand = true;
        hbox_root.vexpand = false;
        hbox_root.halign = Gtk.Align.FILL;
        hbox_root.valign = Gtk.Align.FILL;
 
        init_sidebar();
        init_content();
        activate_nav(btn_nav_snapshots, "snapshots");
        update_theme_buttons();
 
        if (App.live_system()) {
            btn_backup.sensitive         = false;
            btn_nav_settings.sensitive   = false;
            btn_nav_wizard.sensitive     = false;
        }
 
        tmr_init = Timeout.add(100, init_delayed);
        log_debug("MainWindow: MainWindow(): exit");
    }

References activate_nav(), App, apply_language_env(), btn_nav_snapshots, HeaderFactory.create_main_headerbar(), current_lang, dark_mode, hbox_root, init_content(), init_delayed(), init_sidebar(), Main.live_system(), load_css(), load_language_preference(), load_theme_preference(), TeeJee.Logging.log_debug(), on_close_request(), tmr_init, update_theme_buttons(), and IconManager.use_dark.

MainWindow() [3/4]

MainWindow::MainWindow

(

)

~MainWindow() [2/3]

MainWindow::~MainWindow ( )

override

MainWindow() [4/4]

MainWindow::MainWindow

(

)

~MainWindow() [3/3]

MainWindow::~MainWindow ( )

override

Member Function Documentation

activate_nav()

void MainWindow.activate_nav ( Gtk.Button btn, string page )

inlineprivate

Definition at line 657 of file MainWindow.vala.

                                                           {
        if (current_nav_btn != null)
            current_nav_btn.get_style_context().remove_class("active-sidebar-button");
        btn.get_style_context().add_class("active-sidebar-button");
        current_nav_btn = btn;
 
        switch (page) {
            case "snapshots":
            case "settings_page":
            case "wizard":
            case "about":
            case "backup_flow":
            case "restore_flow":
            case "delete_flow":
            case "rsync_log":
                content_stack.set_visible_child_name(page);
                apply_window_mode_for_page(page);
                break;
        }
    }

References apply_window_mode_for_page(), content_stack, and current_nav_btn.

Referenced by MainWindow(), make_nav_btn(), and show_snapshots_page().

activate_sidebar_button() [1/2]

void MainWindow::activate_sidebar_button ( Gtk::Button * btn )

private

Definition at line 440 of file MainWindow.cpp.

{
    for (auto b : sidebar_buttons_)
        b->get_style_context()->remove_class("active-sidebar-button");
 
    if (btn)
        btn->get_style_context()->add_class("active-sidebar-button");
}

References sidebar_buttons_.

Referenced by MainWindow(), on_sidebar_about(), on_sidebar_dashboard(), on_sidebar_recovery(), and showDashboard().

activate_sidebar_button() [2/2]

void MainWindow::activate_sidebar_button ( Gtk::Button * button )

private

References append_log(), on_refresh_devices(), on_sidebar_about(), on_sidebar_dashboard(), on_sidebar_recovery(), populate_device_lists(), refresh_devices(), select_source(), update_source_state(), and update_wizard_step().

activateSidebarButton()

void MainWindow::activateSidebarButton ( Gtk::Button * btn )

private

Definition at line 680 of file MainWindow.cpp.

{
    for (auto* b : m_sidebarButtons)
        b->get_style_context()->remove_class("active-sidebar-button");
 
    if (btn) {
        btn->get_style_context()->add_class("active-sidebar-button");
        m_activeButton = btn;
    }
}

References m_activeButton, and m_sidebarButtons.

Referenced by makeSidebarButton().

append_log()

void MainWindow::append_log ( const std::string & line )

private

Definition at line 799 of file main_window.cpp.

                                                 {
    if (!log_buffer_) return;
    auto iter = log_buffer_->end();
    log_buffer_->insert(iter, line + "\n");
}

References log_buffer_.

Referenced by activate_sidebar_button(), on_choose_destination(), on_launch_elevated(), on_recover_now(), on_recovery_completed(), on_refresh_devices(), on_scan_completed(), on_scan_now(), on_use_selected_device(), and select_source().

apply_inline_css()

void MainWindow::apply_inline_css ( )

private

apply_language_env()

void MainWindow.apply_language_env ( string lang_code )

inlineprivate

Sets the process locale WITHOUT touching system settings. Must be called before any _() translation is evaluated. lang_code matches the .po filename: en_US, it_IT, de_DE, etc.

Definition at line 331 of file MainWindow.vala.

                                                      {
        string locale_val;
        switch (lang_code) {
            case "ar_SA": locale_val = "ar_SA.UTF-8"; break;
            case "de_DE": locale_val = "de_DE.UTF-8"; break;
            case "es_ES": locale_val = "es_ES.UTF-8"; break;
            case "fr_FR": locale_val = "fr_FR.UTF-8"; break;
            case "it_IT": locale_val = "it_IT.UTF-8"; break;
            case "ja_JP": locale_val = "ja_JP.UTF-8"; break;
            case "nl_NL": locale_val = "nl_NL.UTF-8"; break;
            case "pl_PL": locale_val = "pl_PL.UTF-8"; break;
            case "pt_PT": locale_val = "pt_PT.UTF-8"; break;
            case "ru_RU": locale_val = "ru_RU.UTF-8"; break;
            default:      locale_val = "en_US.UTF-8"; break;
        }
 
        GLib.Environment.set_variable("LANGUAGE",    lang_code, true);
        GLib.Environment.set_variable("LC_MESSAGES", locale_val, true);
        GLib.Environment.set_variable("LANG",        locale_val, true);
 
        GLib.Intl.setlocale(GLib.LocaleCategory.MESSAGES, locale_val);
        GLib.Intl.bindtextdomain(GETTEXT_PACKAGE, LOCALE_DIR);
        GLib.Intl.bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
        GLib.Intl.textdomain(GETTEXT_PACKAGE);
 
        if (lang_code == "ar_SA") {
            Gtk.Widget.set_default_direction(Gtk.TextDirection.RTL);
        } else {
            Gtk.Widget.set_default_direction(Gtk.TextDirection.LTR);
        }
 
        log_debug("Locale applicato (processo): " + locale_val);
    }

References TeeJee.Logging.log_debug().

Referenced by MainWindow().

apply_theme() [1/2]

void MainWindow.apply_theme ( bool use_dark )

inlineprivate

Definition at line 482 of file MainWindow.vala.

                                            {
        load_css(use_dark);
        save_theme_preference(use_dark);
        this.queue_draw();
    }

References load_css(), and save_theme_preference().

Referenced by build_headerbar(), init_sidebar(), on_theme_dark(), and on_theme_light().

apply_theme() [2/2]

void MainWindow::apply_theme ( ThemeMode mode )

private

Definition at line 595 of file main_window.cpp.

                                           {
    current_theme_ = mode;
 
    const std::string css_path =
    (mode == ThemeMode::Dark)
    ? resource("BastionGuard-dark.css")
    : resource("BastionGuard.css");
 
    if (!css_provider_) {
        css_provider_ = Gtk::CssProvider::create();
    }
 
    try {
        css_provider_->load_from_path(css_path);
    } catch (const Glib::Error& ex) {
        std::cerr << "Errore caricando CSS '" << css_path << "': " << ex.what() << std::endl;
        return;
    }
 
    auto display = Gdk::Display::get_default();
    if (display) {
        gtk_style_context_add_provider_for_display(
            display->gobj(),
                                                   GTK_STYLE_PROVIDER(css_provider_->gobj()),
                                                   GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
        );
    }
 
    update_theme_buttons();
}

References css_provider_, current_theme_, Dark, resource(), and update_theme_buttons().

apply_window_mode_for_page()

void MainWindow.apply_window_mode_for_page ( string page )

inlineprivate

Definition at line 719 of file MainWindow.vala.

                                                         {
        if (page_requires_expanded_window(page)) {
            remember_compact_window_size();
            window_in_expanded_mode = true;
 
            switch (page) {
                case "settings_page":
                    resize_main_window(1100, 760);
                    break;
                case "wizard":
                    resize_main_window(980, 620);
                    break;
                case "backup_flow":
                    resize_main_window(980, 680);
                    break;
                case "restore_flow":
                    resize_main_window(1080, 720);
                    break;
                case "delete_flow":
                    resize_main_window(500, 500);
                    break;
                case "rsync_log":
                    resize_main_window(800, 600);
                    break;
            }
        }
        else {
            window_in_expanded_mode = false;
            resize_main_window(compact_window_width, compact_window_height);
        }
    }

References compact_window_height, compact_window_width, page_requires_expanded_window(), remember_compact_window_size(), resize_main_window(), and window_in_expanded_mode.

Referenced by activate_nav(), and set_dynamic_page().

applyLanguage()

void MainWindow::applyLanguage ( const std::string & lang )

private

Imposta la variabile d'ambiente LANGUAGE e reinizializza gettext. Deve essere chiamata PRIMA che qualsiasi stringa tradotta venga costruita. Poiché GTK/GLib non supportano il cambio di lingua a runtime senza riavvio, il metodo si limita a impostare l'ambiente: l'effetto si vedrà al prossimo avvio (il LanguageDialog avvisa l'utente di questo).

Definition at line 399 of file MainWindow.cpp.

{
    if (!lang.empty()) {
        ::setenv("LANGUAGE", lang.c_str(), 1);
        ::setenv("LANG",     (lang + ".UTF-8").c_str(), 1);
        ::setlocale(LC_ALL, (lang + ".UTF-8").c_str());
    } else {
        ::unsetenv("LANGUAGE");
        ::setlocale(LC_ALL, "");
    }
 
    // Reinizializza gettext (il dominio e la dir devono già essere configurati in main.cpp)
    ::textdomain("bastionguard-sc");
}

applyProtectionEnabled()

void MainWindow::applyProtectionEnabled ( bool enabled )

private

Definition at line 982 of file MainWindow.cpp.

{
    const std::filesystem::path cfgDir = std::filesystem::path(m_configFile).parent_path();
    const std::filesystem::path generatedAutostart = cfgDir / "bastionguard-sc-autostart.desktop";
    const std::string backupFile = kSystemAutostartBackupDesktop;
 
    // Settings e systray passano da qui. About resta solo informativa, quindi
    // l'attivazione/disattivazione non è duplicata in più pagine.
    bool ok = !enabled || writeConfigAutostartDesktop(generatedAutostart);
    std::string status;
 
    if (ok) {
        std::ostringstream script;
        script << "set -eu; ";
 
        if (!enabled) {
            // Prima di rimuovere l'autostart attivo da /etc/xdg/autostart,
            // conserva un backup nello stesso percorso di sistema con estensione .bak.
            script << "if [ -f " << shellQuote(kSystemAutostartDesktop) << " ]; then "
                   << "install -m 0644 " << shellQuote(kSystemAutostartDesktop) << " " << shellQuote(backupFile) << "; fi; ";
            script << "if [ ! -f " << shellQuote(backupFile) << " ] && [ -f " << shellQuote(kFallbackSystemAutostartDesktop) << " ]; then "
                   << "install -m 0644 " << shellQuote(kFallbackSystemAutostartDesktop) << " " << shellQuote(backupFile) << "; fi; ";
            script << "rm -f " << shellQuote(kSystemAutostartDesktop) << " " << shellQuote(kFallbackSystemAutostartDesktop) << "; ";
            script << "test -x " << shellQuote(kServiceCtlPath) << "; ";
            script << shellQuote(kServiceCtlPath) << " --system disable --now "
                   << shellQuote(kServiceName) << "; ";
        } else {
            script << "mkdir -p " << shellQuote(std::filesystem::path(kSystemAutostartDesktop).parent_path().string()) << "; ";
            script << "if [ -f " << shellQuote(backupFile) << " ]; then "
                   << "install -D -m 0644 " << shellQuote(backupFile) << " " << shellQuote(kSystemAutostartDesktop) << "; "
                   << "else install -D -m 0644 " << shellQuote(generatedAutostart.string()) << " " << shellQuote(kSystemAutostartDesktop) << "; fi; ";
            script << "rm -f " << shellQuote(kFallbackSystemAutostartDesktop) << "; ";
            script << "test -x " << shellQuote(kServiceCtlPath) << "; ";
            script << shellQuote(kServiceCtlPath) << " --system enable --now "
                   << shellQuote(kServiceName) << "; ";
        }
 
        ok = runCommand("pkexec /bin/sh -c " + shellQuote(script.str()));
    }
 
    if (ok) {
        ok = writeServiceControlPreference(enabled, backupFile);
        if (!ok) {
            status = _("Operazione di sistema completata, ma salvataggio della preferenza in ~/.config non riuscito.");
        }
    }
 
    if (ok) {
        m_protectionEnabled = enabled;
        m_autostartBackupFile = backupFile;
        saveConfig();
        status = enabled
        ? _("Avvio persistente attivato: autostart_enabled=true e daemon_enabled=true salvati, autostart installato e bsc-daemon abilitato.")
        : _("Protezione disattivata: enabled=false, autostart_enabled=false e daemon_enabled=false salvati, bsc-daemon fermato/disabilitato e autostart rimosso. Backup creato in /etc/xdg/autostart.");
    } else if (status.empty()) {
        status = enabled
        ? _("Riattivazione non completata. Controlla PolicyKit, il gestore servizi, il backup in /etc/xdg/autostart e il salvataggio config.")
        : _("Disattivazione non completata. Controlla PolicyKit, il gestore servizi, il backup in /etc/xdg/autostart, bsc-daemon e il salvataggio config.");
    }
 
    m_settingsPage.refreshState();
    m_settingsPage.setProtectionEnabled(m_protectionEnabled);
    m_settingsPage.setSystemIntegrationStatus(status);
    setStatus(status);
}

References _, m_autostartBackupFile, m_configFile, m_protectionEnabled, m_settingsPage, SettingsPage::refreshState(), saveConfig(), SettingsPage::setProtectionEnabled(), setStatus(), and SettingsPage::setSystemIntegrationStatus().

applyTheme()

void MainWindow::applyTheme ( bool dark )

private

Definition at line 449 of file MainWindow.cpp.

{
    m_darkMode = dark;
    loadTheme(dark);
    saveConfig();
 
    if (m_btnLight && m_btnDark) {
        if (dark) {
            m_btnLight->get_style_context()->remove_class("theme-btn-active");
            m_btnDark->get_style_context()->add_class("theme-btn-active");
        } else {
            m_btnDark->get_style_context()->remove_class("theme-btn-active");
            m_btnLight->get_style_context()->add_class("theme-btn-active");
        }
    }
}

References loadTheme(), m_btnDark, m_btnLight, m_darkMode, and saveConfig().

Referenced by buildHeaderBar().

browse_selected()

void MainWindow.browse_selected ( )

inline

Definition at line 1217 of file MainWindow.vala.

                                  {
        var selected = snapshot_list_box.selected_snapshots();
        if (selected.size == 0) {
            TeeJee.System.xdg_open(
                File.new_for_path(App.repo.snapshots_path).query_exists()
                ? App.repo.snapshots_path : App.repo.mount_path);
            return;
        }
        var bak = selected[0];
        TeeJee.System.xdg_open(App.btrfs_mode ? bak.path : bak.path + "/localhost");
    }

References App, Main.btrfs_mode, SnapshotRepo.mount_path, Main.repo, SnapshotListBox.selected_snapshots(), snapshot_list_box, and SnapshotRepo.snapshots_path.

Referenced by init_snapshots_page().

btn_about_clicked()

void MainWindow.btn_about_clicked ( )

inlineprivate

Definition at line 1310 of file MainWindow.vala.

                                     {
        content_stack.set_visible_child_name("about");
    }

References content_stack.

Referenced by init_snapshots_page().

btn_restore_clicked()

void MainWindow.btn_restore_clicked ( )

inlineprivate

Definition at line 1242 of file MainWindow.vala.

                                       {
        if (check_if_deletion_running()) return;
        App.mirror_system = false;
        restore();
    }

References check_if_deletion_running(), and restore().

Referenced by init_snapshots_page().

btn_settings_clicked()

void MainWindow.btn_settings_clicked ( )

inlineprivate

Definition at line 1288 of file MainWindow.vala.

                                        {
        content_stack.set_visible_child_name("settings_page");
    }

References content_stack.

Referenced by show_settings().

btn_wizard_clicked()

void MainWindow.btn_wizard_clicked ( )

inlineprivate

Definition at line 1292 of file MainWindow.vala.

                                      {
        content_stack.set_visible_child_name("wizard");
    }

References content_stack.

Referenced by init_delayed(), and on_close_request().

build_about_page()

void MainWindow::build_about_page ( )

private

Definition at line 1325 of file main_window.cpp.

                                  {
    about_page_.set_hexpand(true);
    about_page_.set_vexpand(true);
    about_page_.set_margin_top(32);
    about_page_.set_margin_bottom(32);
    about_page_.set_margin_start(48);
    about_page_.set_margin_end(48);
    about_page_.set_halign(Gtk::Align::CENTER);
    about_page_.set_valign(Gtk::Align::CENTER);
 
    try {
        auto* logo_img = Gtk::make_managed<Gtk::Image>();
        try {
            auto texture = Gdk::Texture::create_from_filename(resource("logo.svg"));
            logo_img->set(texture);
            logo_img->set_pixel_size(192);
        } catch (...) {}
        logo_img->set_margin_bottom(12);
        about_page_.append(*logo_img);
    } catch (...) {}
 
    auto* name_label = Gtk::make_managed<Gtk::Label>(tr("BastionGuard™ Recovery Data"));
    name_label->add_css_class("page-title");
    name_label->set_margin_bottom(4);
    about_page_.append(*name_label);
 
    std::string version_str = "unknown";
    {
        const std::string version_path = resource("version.bs");
        std::ifstream vf(version_path);
        if (vf.is_open()) {
            std::getline(vf, version_str);
            version_str.erase(version_str.find_last_not_of(" \t\r\n") + 1);
            version_str.erase(0, version_str.find_first_not_of(" \t\r\n"));
        }
    }
 
    auto* version_label = Gtk::make_managed<Gtk::Label>(trs("Version ") + version_str);
    version_label->add_css_class("small-label");
    version_label->set_margin_bottom(18);
    about_page_.append(*version_label);
 
    auto* about_notebook = Gtk::make_managed<Gtk::Notebook>();
    about_notebook->set_hexpand(true);
    about_notebook->set_vexpand(true);
    about_notebook->set_halign(Gtk::Align::FILL);
    about_notebook->set_valign(Gtk::Align::FILL);
    about_notebook->set_size_request(680, 360);
 
    auto* overview_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 18);
    overview_box->set_margin_top(24);
    overview_box->set_margin_bottom(24);
    overview_box->set_margin_start(24);
    overview_box->set_margin_end(24);
 
    auto* desc_label = Gtk::make_managed<Gtk::Label>(
        tr("A read-only forensic recovery tool supporting ext4, btrfs, NTFS, FAT32,exFAT, XFS and HFS+.\nScan physical disks or image files without writing a single byte to the source."));
    desc_label->set_wrap(true);
    desc_label->set_justify(Gtk::Justification::CENTER);
    overview_box->append(*desc_label);
 
    auto* fs_label = Gtk::make_managed<Gtk::Label>(
        tr("Supported filesystems:  ext4  •  Btrfs  •  NTFS  •  FAT32  •  exFAT  •  XFS  •  HFS+"));
    fs_label->add_css_class("subtitle");
    fs_label->set_wrap(true);
    fs_label->set_justify(Gtk::Justification::CENTER);
    overview_box->append(*fs_label);
 
    auto* license_summary = Gtk::make_managed<Gtk::Label>(
        tr("Released under GNU GPLv3 or later. BastionGuard™ is a trademark of Calogero Scarnà."));
    license_summary->add_css_class("small-label");
    license_summary->set_justify(Gtk::Justification::CENTER);
    license_summary->set_wrap(true);
    overview_box->append(*license_summary);
 
    auto* overview_tab = Gtk::make_managed<Gtk::Label>(tr("Overview"));
    about_notebook->append_page(*overview_box, *overview_tab);
 
    auto* license_scroller = Gtk::make_managed<Gtk::ScrolledWindow>();
    license_scroller->set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
    license_scroller->set_min_content_width(640);
    license_scroller->set_min_content_height(300);
 
    auto* license_text = Gtk::make_managed<Gtk::TextView>();
    license_text->set_editable(false);
    license_text->set_cursor_visible(false);
    license_text->set_wrap_mode(Gtk::WrapMode::WORD);
    license_text->set_left_margin(14);
    license_text->set_right_margin(14);
    license_text->set_top_margin(14);
    license_text->set_bottom_margin(14);
 
    auto license_buffer = Gtk::TextBuffer::create();
    license_buffer->set_text(load_license_text());
    license_text->set_buffer(license_buffer);
    license_scroller->set_child(*license_text);
 
    auto* license_tab = Gtk::make_managed<Gtk::Label>(tr("License"));
    about_notebook->append_page(*license_scroller, *license_tab);
 
    about_page_.append(*about_notebook);
}

References about_page_, resource(), tr(), and trs().

Referenced by build_headerbar().

build_dashboard()

void MainWindow::build_dashboard ( )

private

Definition at line 391 of file main_window.cpp.

                                 {
    dashboard_page_.set_hexpand(true);
    dashboard_page_.set_vexpand(true);
    dashboard_page_.set_margin_top(24);
    dashboard_page_.set_margin_bottom(24);
    dashboard_page_.set_margin_start(24);
    dashboard_page_.set_margin_end(24);
 
    cards_grid_.set_column_spacing(16);
    cards_grid_.set_row_spacing(16);
 
    card_status_.set_child(status_card_label_);
    card_source_.set_child(source_card_label_);
    card_update_.set_child(update_card_label_);
 
    card_status_.add_css_class("card");
    card_source_.add_css_class("card");
    card_update_.add_css_class("card");
 
    status_card_label_.set_text(tr("Core engine: Ready\nRead-only mode: Active"));
    source_card_label_.set_text(tr("No source selected"));
    update_card_label_.set_text(tr("Device inventory available"));
 
    status_card_label_.set_wrap(true);
    source_card_label_.set_wrap(true);
    update_card_label_.set_wrap(true);
 
    status_card_label_.set_margin_top(20);
    status_card_label_.set_margin_bottom(20);
    status_card_label_.set_margin_start(20);
    status_card_label_.set_margin_end(20);
 
    source_card_label_.set_margin_top(20);
    source_card_label_.set_margin_bottom(20);
    source_card_label_.set_margin_start(20);
    source_card_label_.set_margin_end(20);
 
    update_card_label_.set_margin_top(20);
    update_card_label_.set_margin_bottom(20);
    update_card_label_.set_margin_start(20);
    update_card_label_.set_margin_end(20);
 
    cards_grid_.attach(card_status_, 0, 0, 1, 1);
    cards_grid_.attach(card_source_, 1, 0, 1, 1);
    cards_grid_.attach(card_update_, 2, 0, 1, 1);
 
    devices_frame_.set_label(tr("Available disks"));
    devices_frame_.add_css_class("card");
 
    devices_scroller_.set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
    devices_scroller_.set_vexpand(true);
    devices_scroller_.set_child(devices_list_);
 
    devices_list_.add_css_class("scan-file-list");
 
    devices_frame_.set_child(devices_scroller_);
 
    dashboard_page_.append(cards_grid_);
    dashboard_page_.append(devices_frame_);
}

References card_source_, card_status_, card_update_, cards_grid_, dashboard_page_, devices_frame_, devices_list_, devices_scroller_, source_card_label_, status_card_label_, tr(), and update_card_label_.

Referenced by build_headerbar().

build_headerbar() [1/3]

void MainWindow.build_headerbar ( )

inlineprivate

Definition at line 152 of file MainWindow.vala.

                                   {
 
        var header = new Gtk.HeaderBar();
        header.set_show_title_buttons(false);
        header.set_decoration_layout("");
        header.get_style_context().add_class("custom-headerbar");
 
        var header_left = new Gtk.Box(Orientation.HORIZONTAL, 0);
        header_left.set_size_request(180, -1);
        header_left.get_style_context().add_class("header-left");
        header_left.margin_start = 0;
        header_left.margin_end   = 0;
        header_left.margin_top   = 0;
        header_left.margin_bottom = 0;
        header.set_title_widget(new Gtk.Box(Orientation.HORIZONTAL, 0));
        var header_root = (Gtk.Box) header.get_title_widget();
        header_root.hexpand = true;
        header_root.append(header_left);
 
        var header_mid = new Gtk.Box(Orientation.HORIZONTAL, 0);
        header_mid.hexpand = true;
        header_mid.get_style_context().add_class("header-right");
        header_root.append(header_mid);
 
        var header_right = new Gtk.Box(Orientation.HORIZONTAL, 0);
        header_right.get_style_context().add_class("header-right");
        header_right.valign = Gtk.Align.CENTER;
        header_right.margin_end = 6;
 
        var btn_min = new Gtk.Button();
        btn_min.set_child(themed_icon("window-minimize-symbolic", 16));
        btn_min.get_style_context().add_class("header-button");
                btn_min.clicked.connect(() => { this.minimize(); });
        header_right.append(btn_min);
 
        var btn_close = new Gtk.Button();
        btn_close.set_child(themed_icon("window-close-symbolic", 16));
        btn_close.get_style_context().add_class("header-button");
                btn_close.clicked.connect(() => { this.close(); });
        header_right.append(btn_close);
 
        header_root.append(header_right);
        this.set_titlebar(header);
    }

References minimize(), and themed_icon().

build_headerbar() [2/3]

void MainWindow::build_headerbar ( )

private

Definition at line 145 of file MainWindow.cpp.

                                 {
    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);
    // La larghezza è gestita dal CSS con min-width: 240px sul .header-left
    header_left->set_hexpand(false);
    header_left->get_style_context()->add_class("header-left");
    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_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]() {
            std::cout << _("[MainWindow] Pulsante close → nascondo nella tray") << "\n";
            this->hide();
        });
    } catch (...) {
        std::cerr << _("⚠ Errore caricamento icona close") << "\n";
    }
 
    header->pack_end(*header_right);
    set_titlebar(*header);
}

References _, minimize(), and resource().

Referenced by MainWindow().

build_headerbar() [3/3]

void MainWindow::build_headerbar ( )

private

References apply_theme(), build_about_page(), build_dashboard(), build_recovery_page(), build_sidebar(), build_wizard(), and update_action_controls().

build_recovery_page()

void MainWindow::build_recovery_page ( )

private

Definition at line 569 of file main_window.cpp.

                                     {
    recovery_page_.set_hexpand(true);
    recovery_page_.set_vexpand(true);
    recovery_page_.set_margin_top(24);
    recovery_page_.set_margin_bottom(24);
    recovery_page_.set_margin_start(24);
    recovery_page_.set_margin_end(24);
 
    recovery_title_.add_css_class("page-title");
    recovery_subtitle_.add_css_class("small-label");
    recovery_subtitle_.set_wrap(true);
    recovery_subtitle_.set_xalign(0.0f);
    recovery_header_.append(recovery_title_);
    recovery_header_.append(recovery_subtitle_);
 
    build_wizard();
 
    log_scroller_.set_vexpand(true);
    log_scroller_.add_css_class("BastionGuard-scroller");
    log_scroller_.set_child(log_view_);
 
    recovery_page_.append(recovery_header_);
    recovery_page_.append(wizard_frame_);
    recovery_page_.append(log_scroller_);
}

References build_wizard(), log_scroller_, log_view_, recovery_header_, recovery_page_, recovery_subtitle_, recovery_title_, and wizard_frame_.

Referenced by build_headerbar().

build_sidebar() [1/2]

void MainWindow::build_sidebar ( )

private

Definition at line 254 of file main_window.cpp.

                               {
    sidebar_.set_size_request(240, -1);
    sidebar_.add_css_class("sidebar");
 
    auto* hdr = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 8);
    hdr->add_css_class("sidebar-header");
 
    auto* logo_img = Gtk::make_managed<Gtk::Image>();
    try {
        auto texture = Gdk::Texture::create_from_filename(resource("logo-sidebar.png"));
        logo_img->set(texture);
        logo_img->set_pixel_size(48);
    } catch (...) {}
    logo_img->set_halign(Gtk::Align::START);
    logo_img->set_margin_bottom(4);
    hdr->append(*logo_img);
 
    brand_label_.set_text(tr("BastionGuard™\nRecovery Data"));
    brand_label_.set_halign(Gtk::Align::START);
    brand_label_.add_css_class("sidebar-title");
    hdr->append(brand_label_);
 
    sidebar_.append(*hdr);
 
    btn_dashboard_.add_css_class("sidebar-button");
    btn_recovery_.add_css_class("sidebar-button");
    btn_about_.add_css_class("sidebar-button");
    btn_refresh_.add_css_class("sidebar-button");
 
    btn_dashboard_.set_halign(Gtk::Align::FILL);
    btn_recovery_.set_halign(Gtk::Align::FILL);
    btn_about_.set_halign(Gtk::Align::FILL);
    btn_refresh_.set_halign(Gtk::Align::FILL);
 
    set_button_with_svg_icon(btn_dashboard_, resource("icons/icon-dashboard.svg"), tr("Dashboard"));
    set_button_with_svg_icon(btn_recovery_, resource("icons/icon-recovery.svg"), tr("Recovery wizard"));
    set_button_with_svg_icon(btn_refresh_, resource("icons/icon-refresh.svg"), tr("Refresh devices"));
    set_button_with_svg_icon(btn_about_, resource("icons/icon-about.svg"), tr("About"));
 
    dashboard_button_ = &btn_dashboard_;
    recovery_button_ = &btn_recovery_;
    about_button_ = &btn_about_;
 
    sidebar_buttons_.push_back(&btn_dashboard_);
    sidebar_buttons_.push_back(&btn_recovery_);
    sidebar_buttons_.push_back(&btn_about_);
 
    sidebar_.append(btn_dashboard_);
    sidebar_.append(btn_recovery_);
    sidebar_.append(btn_refresh_);
 
    auto* sep1 = Gtk::make_managed<Gtk::Separator>(Gtk::Orientation::HORIZONTAL);
    sep1->add_css_class("sidebar-separator");
    sidebar_.append(*sep1);
 
    auto* theme_title = Gtk::make_managed<Gtk::Label>(tr("Theme"));
    theme_title->set_halign(Gtk::Align::START);
    theme_title->add_css_class("sidebar-group-label");
    sidebar_.append(*theme_title);
 
    auto* theme_row = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 10);
    theme_row->add_css_class("sidebar-theme-row");
    theme_row->set_halign(Gtk::Align::FILL);
    theme_row->set_hexpand(true);
 
    btn_theme_dark_.add_css_class("theme-btn");
    btn_theme_light_.add_css_class("theme-btn");
 
    btn_theme_dark_.set_hexpand(true);
    btn_theme_light_.set_hexpand(true);
    btn_theme_dark_.set_halign(Gtk::Align::FILL);
    btn_theme_light_.set_halign(Gtk::Align::FILL);
 
    theme_row->append(btn_theme_dark_);
    theme_row->append(btn_theme_light_);
    sidebar_.append(*theme_row);
 
    auto* sep2 = Gtk::make_managed<Gtk::Separator>(Gtk::Orientation::HORIZONTAL);
    sep2->add_css_class("sidebar-separator");
    sidebar_.append(*sep2);
 
    auto* lang_title = Gtk::make_managed<Gtk::Label>(tr("Language"));
    lang_title->set_halign(Gtk::Align::START);
    lang_title->add_css_class("sidebar-group-label");
    sidebar_.append(*lang_title);
 
    lang_combo_.add_css_class("sidebar-lang-combo");
    lang_combo_.set_hexpand(true);
    lang_combo_.set_halign(Gtk::Align::FILL);
    auto lang_model = Gtk::StringList::create({
        "English",
        "Italiano",
        "Deutsch",
        "Español",
        "Français",
        "日本語",
        "Nederlands",
        "Polski",
        "Português",
        "Русский",
        "العربية"
    });
    lang_combo_.set_model(lang_model);
 
    {
        const std::string saved = read_language();
 
        if      (saved == "it") lang_combo_.set_selected(1);
        else if (saved == "de") lang_combo_.set_selected(2);
        else if (saved == "es") lang_combo_.set_selected(3);
        else if (saved == "fr") lang_combo_.set_selected(4);
        else if (saved == "ja") lang_combo_.set_selected(5);
        else if (saved == "nl") lang_combo_.set_selected(6);
        else if (saved == "pl") lang_combo_.set_selected(7);
        else if (saved == "pt") lang_combo_.set_selected(8);
        else if (saved == "ru") lang_combo_.set_selected(9);
        else if (saved == "ar") lang_combo_.set_selected(10);
        else                    lang_combo_.set_selected(0);
    }
 
    lang_combo_.property_selected().signal_changed().connect(
        sigc::mem_fun(*this, &MainWindow::on_language_changed));
 
    sidebar_.append(lang_combo_);
 
    auto* spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    spacer->set_vexpand(true);
    sidebar_.append(*spacer);
 
    sidebar_.append(btn_about_);
 
    auto* info = Gtk::make_managed<Gtk::Label>(tr("Read-only forensic mode"));
    info->set_halign(Gtk::Align::START);
    info->add_css_class("small-label");
    sidebar_.append(*info);
}

References about_button_, brand_label_, btn_about_, btn_dashboard_, btn_recovery_, btn_refresh_, btn_theme_dark_, btn_theme_light_, dashboard_button_, lang_combo_, on_language_changed(), read_language(), recovery_button_, resource(), sidebar_, sidebar_buttons_, and tr().

build_sidebar() [2/2]

void MainWindow::build_sidebar ( ClamdConfig & clamdConfig )

private

Definition at line 198 of file MainWindow.cpp.

                                           {
 
    // Ordine pagine per direzione animazione
    static const std::vector<std::string> kPageOrder = {
        "dashboard",
        "scan","antiransomware",
#if BASTIONGUARD_HAS_CEF
        "bank",
#endif
        "privacy","rootguard","usbscan","samba",
        "log","quarantine","identityleak","passwordmanager","backup","update",
        "phishing",
        "about","donate"
    };
 
    // Tracciamento revealer aperti — uno solo alla volta
    // Usiamo un vettore di puntatori ai revealer attivi
    auto open_revealers = std::make_shared<std::vector<Gtk::Revealer*>>();
 
    auto sidebar_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 10);
    sidebar_box->set_size_request(240, -1);
    sidebar_box->get_style_context()->add_class("sidebar");
 
    // ── Header: logo + titolo ───────────────────────────────────────────
    {
        auto hdr = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
        hdr->get_style_context()->add_class("sidebar-header");
        try {
            auto pb   = Gdk::Pixbuf::create_from_file(resource("logo-sidebar.png"), 128, 128, true);
            auto logo = Gtk::make_managed<Gtk::Image>(pb);
            hdr->append(*logo);
        } catch (...) {}
        auto lbl = Gtk::make_managed<Gtk::Label>("BastionGuard™ Endpoint");
        lbl->set_halign(Gtk::Align::START);
        lbl->get_style_context()->add_class("sidebar-title");
        hdr->append(*lbl);
        sidebar_box->append(*hdr);
    }
 
    // ── navigate_to: animazione direzionale ────────────────────────────
    auto navigate_to = [this, &kPageOrder](const std::string& page) {
        const std::string cur = stack_.get_visible_child_name();
        auto itC = std::find(kPageOrder.begin(), kPageOrder.end(), cur);
        auto itD = std::find(kPageOrder.begin(), kPageOrder.end(), page);
        if (itC != kPageOrder.end() && itD != kPageOrder.end()) {
            if (itD > itC)
                stack_.set_transition_type(Gtk::StackTransitionType::SLIDE_LEFT);
            else if (itD < itC)
                stack_.set_transition_type(Gtk::StackTransitionType::SLIDE_RIGHT);
        }
        stack_.set_visible_child(page);
    };
 
    // ── make_leaf: voce singola con icona ──────────────────────────────
    auto make_leaf = [&](const std::string& icon_path,
                         const std::string& label_text,
                         const std::string& page_name,
                         bool indent = false) -> Gtk::Button*
                         {
                             auto box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);
                             if (indent) box->set_margin_start(14);
 
                             auto ib = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
                             ib->set_size_request(16, 16);
                             ib->set_valign(Gtk::Align::CENTER);
                             auto pic = Gtk::make_managed<Gtk::Picture>();
                             try {
                                 auto pb = Gdk::Pixbuf::create_from_file(icon_path);
                                 auto sc = pb->scale_simple(16, 16, Gdk::InterpType::BILINEAR);
                                 pic->set_paintable(Gdk::Texture::create_for_pixbuf(sc));
                                 pic->set_content_fit(Gtk::ContentFit::FILL);
                             } catch (...) {}
                             ib->append(*pic);
                             box->append(*ib);
 
                             auto lbl = Gtk::make_managed<Gtk::Label>(_(label_text.c_str()));
                             lbl->set_halign(Gtk::Align::START);
                             lbl->get_style_context()->add_class("sidebar-group-label");
                             box->append(*lbl);
 
                             auto btn = Gtk::make_managed<Gtk::Button>();
                             btn->set_child(*box);
                             btn->get_style_context()->add_class("sidebar-button");
                             sidebar_buttons_.push_back(btn);
 
                             btn->signal_clicked().connect([this, btn, page_name, navigate_to]() {
                                 for (auto b : sidebar_buttons_)
                                     b->get_style_context()->remove_class("active-sidebar-button");
                                 btn->get_style_context()->add_class("active-sidebar-button");
                                 navigate_to(page_name);
                             });
                             return btn;
                         };
 
                         // ── make_group: gruppo espandibile, uno alla volta ─────────────────
                         auto make_group = [&](const std::string& icon_path,
                                               const std::string& label_text) -> Gtk::Box*
                                               {
                                                   auto arrow = Gtk::make_managed<Gtk::Label>("▸");
                                                   arrow->set_halign(Gtk::Align::END);
                                                   arrow->set_hexpand(true);
                                                   arrow->get_style_context()->add_class("sidebar-arrow");
 
                                                   auto box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);
                                                   auto ib  = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
                                                   ib->set_size_request(16, 16);
                                                   ib->set_valign(Gtk::Align::CENTER);
                                                   auto pic = Gtk::make_managed<Gtk::Picture>();
                                                   try {
                                                       auto pb = Gdk::Pixbuf::create_from_file(icon_path);
                                                       auto sc = pb->scale_simple(16, 16, Gdk::InterpType::BILINEAR);
                                                       pic->set_paintable(Gdk::Texture::create_for_pixbuf(sc));
                                                       pic->set_content_fit(Gtk::ContentFit::FILL);
                                                   } catch (...) {}
                                                   ib->append(*pic);
                                                   box->append(*ib);
 
                                                   auto lbl = Gtk::make_managed<Gtk::Label>(_(label_text.c_str()));
                                                   lbl->set_halign(Gtk::Align::START);
                                                   box->append(*lbl);
                                                   box->append(*arrow);
 
                                                   auto hbtn = Gtk::make_managed<Gtk::Button>();
                                                   hbtn->set_child(*box);
                                                   hbtn->get_style_context()->add_class("sidebar-group-button");
 
                                                   auto revealer = Gtk::make_managed<Gtk::Revealer>();
                                                   revealer->set_transition_type(Gtk::RevealerTransitionType::SLIDE_DOWN);
                                                   revealer->set_transition_duration(200);
                                                   revealer->set_reveal_child(false);  // chiuso all'avvio
 
                                                   auto children = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 0);
                                                   revealer->set_child(*children);
 
                                                   // Registra questo revealer nella lista
                                                   open_revealers->push_back(revealer);
 
                                                   hbtn->signal_clicked().connect([revealer, arrow, open_revealers]() {
                                                       bool opening = !revealer->get_reveal_child();
                                                       // Chiudi tutti gli altri
                                                       for (auto* r : *open_revealers) {
                                                           if (r != revealer && r->get_reveal_child()) {
                                                               r->set_reveal_child(false);
                                                               // Aggiorna la freccia del revealer che stiamo chiudendo
                                                               // (non abbiamo accesso diretto alla freccia degli altri,
                                                               //  ma il CSS transition lo gestisce visivamente)
                                                           }
                                                       }
                                                       revealer->set_reveal_child(opening);
                                                       arrow->set_text(opening ? "▾" : "▸");
                                                   });
 
                                                   sidebar_box->append(*hbtn);
                                                   sidebar_box->append(*revealer);
                                                   return children;
                                               };
 
                                               // ═══════════════════════════════════════════════════════════════════
                                               // Dashboard
                                               // ═══════════════════════════════════════════════════════════════════
                                               auto* db_btn = make_leaf(resource("icons/dashboard.svg"), _("Dashboard"), "dashboard");
                                               dashboard_button_ = db_btn;
                                               sidebar_box->append(*db_btn);
 
                                               // ═══════════════════════════════════════════════════════════════════
                                               // Gruppo: Protezione
                                               // ═══════════════════════════════════════════════════════════════════
                                               auto* grp_prot = make_group(resource("icons/scan.svg"), _("Protezione"));
                                               grp_prot->append(*make_leaf(resource("icons/scan.svg"),       _("Scansione in tempo reale"), "scan",           true));
                                               grp_prot->append(*make_leaf(resource("icons/ransomware.svg"), _("Protezione Ransomware"),    "antiransomware", true));
#if BASTIONGUARD_HAS_CEF
                                               if (BastionGuard::Platform::cef_available()) {
                                                   grp_prot->append(*make_leaf(resource("icons/bank.svg"), _("Banche"), "bank", true));
                                               }
#endif
                                               grp_prot->append(*make_leaf(resource("icons/privacy.svg"),    _("Privacy Webcam"),            "privacy",        true));
                                               grp_prot->append(*make_leaf(resource("icons/rootguard.svg"),  _("RootGuard"),                 "rootguard",      true));
                                               grp_prot->append(*make_leaf(resource("icons/usb.svg"),        _("Periferiche USB"),           "usbscan",        true));
                                               grp_prot->append(*make_leaf(resource("icons/samba.svg"),      _("Samba"),                    "samba",          true));
 
                                               // ═══════════════════════════════════════════════════════════════════
                                               // Gruppo: Sicurezza
                                               // ═══════════════════════════════════════════════════════════════════
                                               auto* grp_sec = make_group(resource("icons/log.svg"), _("Sicurezza"));
                                               grp_sec->append(*make_leaf(resource("icons/log.svg"),        _("Log"),                 "log",             true));
                                               grp_sec->append(*make_leaf(resource("icons/quarantine.svg"), _("Quarantena"),          "quarantine",      true));
                                               grp_sec->append(*make_leaf(resource("icons/identity.svg"),   _("Violazioni Identità"), "identityleak",    true));
                                               grp_sec->append(*make_leaf(resource("icons/password.svg"),   _("Password Manager"),    "passwordmanager", true));
                                               grp_sec->append(*make_leaf(resource("icons/backup.svg"),     _("Backup"),              "backup",          true));
                                               grp_sec->append(*make_leaf(resource("icons/update.svg"),     _("Aggiornamenti"),       "update",          true));
 
                                               // ═══════════════════════════════════════════════════════════════════
                                               // Phishing (voce singola)
                                               // ═══════════════════════════════════════════════════════════════════
                                               sidebar_box->append(*make_leaf(resource("icons/phishing.svg"), _("Phishing Search"), "phishing"));
 
                                               // ═══════════════════════════════════════════════════════════════════
                                               // VPN (voce singola)
                                               // ═══════════════════════════════════════════════════════════════════
                                               sidebar_box->append(*make_leaf(resource("icons/vpn.svg"), _("VPN WireGuard"), "vpn"));
 
                                               // ═══════════════════════════════════════════════════════════════════
                                               // Impostazioni (apre finestra separata)
                                               // ═══════════════════════════════════════════════════════════════════
                                               {
                                                   auto box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);
                                                   auto ib  = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
                                                   ib->set_size_request(16, 16);
                                                   ib->set_valign(Gtk::Align::CENTER);
                                                   auto pic = Gtk::make_managed<Gtk::Picture>();
                                                   try {
                                                       auto pb = Gdk::Pixbuf::create_from_file(resource("icons/settings.svg"));
                                                       auto sc = pb->scale_simple(16, 16, Gdk::InterpType::BILINEAR);
                                                       pic->set_paintable(Gdk::Texture::create_for_pixbuf(sc));
                                                   } catch (...) {}
                                                   ib->append(*pic);
                                                   box->append(*ib);
                                                   auto lbl = Gtk::make_managed<Gtk::Label>(_("Impostazioni"));
                                                   lbl->set_halign(Gtk::Align::START);
                                                   box->append(*lbl);
                                                   auto btn = Gtk::make_managed<Gtk::Button>();
                                                   btn->set_child(*box);
                                                   btn->get_style_context()->add_class("sidebar-button");
                                                   btn->signal_clicked().connect([this]() { open_settings_window(); });
                                                   sidebar_box->append(*btn);
                                               }
 
                                               // Spacer + separatore
                                               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);
 
                                               sidebar_box->append(*make_leaf(resource("icons/about.svg"),  _("Informazioni"), "about"));
                                               sidebar_box->append(*make_leaf(resource("icons/donate.svg"), _("Donazioni"),    "donate"));
 
                                               mainBox.append(*sidebar_box);
}

References _, BastionGuard::Platform::cef_available(), dashboard_button_, mainBox, open_settings_window(), resource(), sidebar_buttons_, and stack_.

Referenced by build_headerbar(), and MainWindow().

build_wizard()

void MainWindow::build_wizard ( )

private

Definition at line 452 of file main_window.cpp.

                              {
    wizard_frame_.add_css_class("card");
    wizard_root_.set_margin_top(14);
    wizard_root_.set_margin_bottom(14);
    wizard_root_.set_margin_start(14);
    wizard_root_.set_margin_end(14);
 
    source_step_label_.set_wrap(true);
    source_step_label_.set_xalign(0.0f);
    source_button_row_.append(btn_open_image_);
    source_button_row_.append(btn_use_selected_device_);
    source_button_row_.append(btn_launch_elevated_);
    recovery_devices_scroller_.set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
    recovery_devices_scroller_.set_vexpand(true);
    recovery_devices_scroller_.set_child(recovery_devices_list_);
    source_step_box_.append(source_step_label_);
    source_step_box_.append(source_button_row_);
    source_step_box_.append(recovery_devices_scroller_);
 
    destination_step_label_.set_wrap(true);
    destination_step_label_.set_xalign(0.0f);
    entry_output_.set_hexpand(true);
    entry_output_.set_editable(false);
    destination_button_row_.append(entry_output_);
    destination_button_row_.append(btn_choose_destination_);
    destination_step_box_.append(destination_step_label_);
    destination_step_box_.append(destination_button_row_);
 
    wizard_notice_label_.set_wrap(true);
    wizard_notice_label_.set_xalign(0.0f);
    wizard_notice_label_.add_css_class("alert-danger");
    wizard_notice_label_.set_text(tr("Avviso: non si garantisce il recupero totale dei file. La quantità e l'integrità dei dati recuperati dipendono da danni al filesystem, sovrascritture, frammentazione, cifratura, compressione e stato del dispositivo."));
 
    scan_step_label_.set_wrap(true);
    scan_step_label_.set_xalign(0.0f);
    scan_progress_bar_.set_show_text(true);
    scan_progress_bar_.set_fraction(0.0);
    scan_progress_bar_.set_hexpand(true);
    scan_status_label_.set_xalign(0.0f);
    scan_status_label_.add_css_class("small-label");
    scan_timer_label_.set_xalign(0.0f);
    scan_timer_label_.add_css_class("small-label");
    scan_timer_label_.set_text(tr("Elapsed: 00:00"));
    scan_step_box_.append(scan_step_label_);
    scan_step_box_.append(scan_progress_bar_);
    scan_step_box_.append(scan_status_label_);
    scan_step_box_.append(scan_timer_label_);
    scan_step_box_.append(btn_scan_now_);
 
    recover_step_label_.set_wrap(true);
    recover_step_label_.set_xalign(0.0f);
 
    results_count_label_.set_halign(Gtk::Align::START);
    results_count_label_.set_xalign(0.0f);
    results_count_label_.add_css_class("small-label");
    results_count_label_.set_margin_bottom(2);
 
    results_selected_label_.set_halign(Gtk::Align::START);
    results_selected_label_.set_xalign(0.0f);
    results_selected_label_.add_css_class("small-label");
    results_selected_label_.set_margin_bottom(6);
 
    btn_results_select_all_.add_css_class("sidebar-button");
    btn_results_clear_.add_css_class("sidebar-button");
    results_actions_row_.append(btn_results_select_all_);
    results_actions_row_.append(btn_results_clear_);
 
    results_tree_box_.add_css_class("scan-file-list");
 
    results_scroller_.set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
    results_scroller_.set_vexpand(true);
    results_scroller_.set_child(results_tree_box_);
 
    results_frame_.set_label(tr("Detected items"));
    results_frame_.add_css_class("card");
    results_frame_.set_vexpand(true);
 
    auto* results_inner = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 6);
    results_inner->set_margin_top(10);
    results_inner->set_margin_bottom(10);
    results_inner->set_margin_start(10);
    results_inner->set_margin_end(10);
    results_inner->append(results_count_label_);
    results_inner->append(results_selected_label_);
    results_inner->append(results_actions_row_);
    results_inner->append(results_scroller_);
    results_frame_.set_child(*results_inner);
 
    btn_recover_now_.add_css_class("btn-primary");
    btn_recover_now_.set_halign(Gtk::Align::END);
 
    recover_step_box_.append(recover_step_label_);
    recover_step_box_.append(results_frame_);
    recover_step_box_.append(btn_recover_now_);
 
    wizard_stack_.add(source_step_box_, "wizard-source", tr("Source"));
    wizard_stack_.add(destination_step_box_, "wizard-destination", tr("Destination"));
    wizard_stack_.add(scan_step_box_, "wizard-scan", tr("Scan"));
    wizard_stack_.add(recover_step_box_, "wizard-recover", tr("Recover"));
    wizard_stack_.set_visible_child(source_step_box_);
    wizard_stack_.set_hexpand(true);
    wizard_stack_.set_vexpand(true);
 
    btn_wizard_back_.add_css_class("sidebar-button");
    btn_wizard_next_.add_css_class("btn-primary");
    wizard_nav_.append(btn_wizard_back_);
    auto* spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    spacer->set_hexpand(true);
    wizard_nav_.append(*spacer);
    wizard_nav_.append(btn_wizard_next_);
 
    wizard_root_.append(wizard_notice_label_);
    wizard_root_.append(wizard_stack_);
    wizard_root_.append(wizard_nav_);
    wizard_frame_.set_child(wizard_root_);
}

References btn_choose_destination_, btn_launch_elevated_, btn_open_image_, btn_recover_now_, btn_results_clear_, btn_results_select_all_, btn_scan_now_, btn_use_selected_device_, btn_wizard_back_, btn_wizard_next_, destination_button_row_, destination_step_box_, destination_step_label_, entry_output_, recover_step_box_, recover_step_label_, recovery_devices_list_, recovery_devices_scroller_, results_actions_row_, results_count_label_, results_frame_, results_scroller_, results_selected_label_, results_tree_box_, scan_progress_bar_, scan_status_label_, scan_step_box_, scan_step_label_, scan_timer_label_, source_button_row_, source_step_box_, source_step_label_, tr(), wizard_frame_, wizard_nav_, wizard_notice_label_, wizard_root_, and wizard_stack_.

Referenced by build_headerbar(), and build_recovery_page().

buildHeaderBar()

void MainWindow::buildHeaderBar ( )

private

Definition at line 470 of file MainWindow.cpp.

{
    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 headerLeft = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    headerLeft->set_size_request(240, -1);
    headerLeft->set_hexpand(false);
    headerLeft->get_style_context()->add_class("header-left");
    header->pack_start(*headerLeft);
 
    auto spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    spacer->set_hexpand(true);
    header->pack_start(*spacer);
 
    auto headerRight = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 4);
    headerRight->set_hexpand(false);
    headerRight->get_style_context()->add_class("header-right");
 
    // ── Bottone selezione lingua ────────────────────────────────────────
    auto btnLang = Gtk::make_managed<Gtk::Button>("🌐");
    btnLang->get_style_context()->add_class("theme-btn");
    btnLang->set_tooltip_text(_("Cambia lingua"));
    btnLang->signal_clicked().connect(
        sigc::mem_fun(*this, &MainWindow::showLanguageDialog));
    headerRight->append(*btnLang);
 
    // ── Tema ────────────────────────────────────────────────────────────
    m_btnLight = Gtk::make_managed<Gtk::Button>("☀");
    m_btnDark  = Gtk::make_managed<Gtk::Button>("🌙");
 
    m_btnLight->get_style_context()->add_class("theme-btn");
    m_btnDark->get_style_context()->add_class("theme-btn");
 
    m_btnLight->set_tooltip_text(_("Tema chiaro"));
    m_btnDark->set_tooltip_text(_("Tema scuro"));
 
    if (m_darkMode)
        m_btnDark->get_style_context()->add_class("theme-btn-active");
    else
        m_btnLight->get_style_context()->add_class("theme-btn-active");
 
    m_btnLight->signal_clicked().connect([this]() { applyTheme(false); });
    m_btnDark->signal_clicked().connect([this]() { applyTheme(true); });
 
    headerRight->append(*m_btnLight);
    headerRight->append(*m_btnDark);
 
    auto addWinBtn = [&](const std::string& iconRes,
                         const std::string& fallback,
                         auto cb)
    {
        auto btn = Gtk::make_managed<Gtk::Button>();
        btn->get_style_context()->add_class("header-button");
 
        try {
            auto pix = Gdk::Pixbuf::create_from_file(resource(iconRes), 32, 32, true);
            btn->set_child(*Gtk::make_managed<Gtk::Image>(pix));
        } catch (...) {
            btn->set_label(fallback);
        }
 
        btn->signal_clicked().connect(cb);
        headerRight->append(*btn);
    };
 
    addWinBtn("icon-minimize.png", "—", [this]() { minimize(); });
    addWinBtn("icon-close.png",    "✕", [this]() { hide(); });
 
    header->pack_end(*headerRight);
    set_titlebar(*header);
}

References _, applyTheme(), m_btnDark, m_btnLight, m_darkMode, minimize(), resource(), and showLanguageDialog().

buildSidebar()

void MainWindow::buildSidebar ( )

private

Definition at line 549 of file MainWindow.cpp.

{
    auto sidebar = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 10);
    sidebar->set_size_request(240, -1);
    sidebar->set_hexpand(false);
    sidebar->set_vexpand(true);
    sidebar->get_style_context()->add_class("sidebar");
 
    // Header logo + titolo
    {
        auto hdr = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
        hdr->set_hexpand(false);
        hdr->get_style_context()->add_class("sidebar-header");
 
        auto ico = Gtk::make_managed<Gtk::Image>();
        try {
            auto pix = Gdk::Pixbuf::create_from_file(
                resource("logo-sidebar.png"), 32, 32, true);
            ico->set(pix);
        } catch (...) {
            ico->set_from_icon_name("security-high-symbolic");
            ico->set_pixel_size(28);
        }
 
        ico->set_hexpand(false);
        hdr->append(*ico);
 
        auto lbl = Gtk::make_managed<Gtk::Label>(
            "BastionGuard™\nSecure Connection");
        lbl->set_justify(Gtk::Justification::LEFT);
        lbl->set_wrap(true);
        lbl->set_max_width_chars(16);
        lbl->set_width_chars(16);
        lbl->get_style_context()->add_class("sidebar-title");
        lbl->set_halign(Gtk::Align::START);
        lbl->set_hexpand(false);
        hdr->append(*lbl);
 
        sidebar->append(*hdr);
    }
 
    sidebar->append(*makeSidebarButton(
        resource("icons/connections.svg"), _("Connessioni"), "connections"));
    sidebar->append(*makeSidebarButton(
        resource("icons/apps.svg"), _("Applicazioni"), "apps"));
    sidebar->append(*makeSidebarButton(
        resource("icons/network.svg"), _("Monitor di rete"), "network"));
    sidebar->append(*makeSidebarButton(
        resource("icons/rules.svg"), _("Regole"), "rules"));
    sidebar->append(*makeSidebarButton(
        resource("icons/stats.svg"), _("Statistiche"), "stats"));
    sidebar->append(*makeSidebarButton(
        resource("icons/about.svg"), _("Impostazioni"), "settings"));
 
    sidebar->append(*makeSidebarButton(
        resource("icons/about.svg"), _("Informazioni"), "about"));
 
    auto spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    spacer->set_vexpand(true);
    sidebar->append(*spacer);
 
    auto sep = Gtk::make_managed<Gtk::Separator>(Gtk::Orientation::HORIZONTAL);
    sep->get_style_context()->add_class("sidebar-separator");
    sidebar->append(*sep);
 
    m_daemonLabel = Gtk::make_managed<Gtk::Label>(_("⚙ Daemon: in attesa..."));
    m_daemonLabel->get_style_context()->add_class("daemon-status");
    m_daemonLabel->set_halign(Gtk::Align::START);
    m_daemonLabel->set_margin_top(6);
    m_daemonLabel->set_margin_start(8);
    m_daemonLabel->set_margin_bottom(6);
    sidebar->append(*m_daemonLabel);
 
    m_mainBox.append(*sidebar);
}

References _, m_daemonLabel, m_mainBox, makeSidebarButton(), and resource().

cacheKey()

std::string MainWindow::cacheKey ( const std::string & app, const std::string & host, const std::string & ip )

staticprivate

Definition at line 808 of file MainWindow.cpp.

{
    return app + "|" + host + "|" + ip;
}

Referenced by onNewConnection(), and onVerdict().

check_if_deletion_running()

bool MainWindow.check_if_deletion_running ( )

inlineprivate

Definition at line 1248 of file MainWindow.vala.

                                             {
        if (App.thread_delete_running) {
            ui_sensitive(true);
            gtk_messagebox(_("Snapshot deletion in progress..."), _("Please wait."), this, true);
            ui_sensitive(false);
            open_delete_flow();
            return true;
        }
        return false;
    }

References _, App, open_delete_flow(), Main.thread_delete_running, and ui_sensitive().

Referenced by btn_restore_clicked(), and create_snapshot().

create_snapshot()

void MainWindow.create_snapshot ( )

inline

Definition at line 1152 of file MainWindow.vala.

                                  {
        if (check_if_deletion_running()) return;
        ui_sensitive(false);
        if (App.btrfs_mode && (App.check_btrfs_layout_system(this) == false)) {
            ui_sensitive(true); return;
        }
        if (!App.repo.available())
            gtk_messagebox(App.repo.status_message, App.repo.status_details, this, true);
        open_backup_flow();
    }

References App, SnapshotRepo.available(), Main.btrfs_mode, Main.check_btrfs_layout_system(), check_if_deletion_running(), open_backup_flow(), Main.repo, SnapshotRepo.status_details, SnapshotRepo.status_message, and ui_sensitive().

Referenced by init_snapshots_page().

delete_selected()

void MainWindow.delete_selected ( )

inline

Definition at line 1163 of file MainWindow.vala.

                                  {
        if (!App.repo.available()) {
            gtk_messagebox(App.repo.status_message, _("Select another device"), this, false);
            return;
        }
        if (!App.repo.has_snapshots()) {
            gtk_messagebox(_("No snapshots on device"), _("Select another device"), this, false);
            return;
        }
        foreach (var bak in snapshot_list_box.selected_snapshots()) {
            if (bak.live) {
                gtk_messagebox(_("Cannot Delete Live Snapshot"),
                               _("Snapshot '%s' is in use").printf(bak.date_formatted), this, false);
                return;
            }
        }
        var dlg  = new Gtk.MessageDialog(this, Gtk.DialogFlags.MODAL,
                                         Gtk.MessageType.QUESTION, Gtk.ButtonsType.YES_NO,
                                   _("Are you sure you want to delete this snapshot?"));
        var resp = gtk_dialog_run(dlg); dlg.destroy();
        if (resp != Gtk.ResponseType.YES) return;
        if (!App.thread_delete_running) {
            foreach (var item in snapshot_list_box.selected_snapshots()) {
                bool dup = false;
                foreach (var bak in App.delete_list) {
                    if (bak.name == item.name) { dup = true; break; }
                }
                if (!dup) App.delete_list.add(item);
            }
        }
        ui_sensitive(false);
        open_delete_flow();
    }

References _, App, SnapshotRepo.available(), Main.delete_list, TeeJee.GtkHelper.gtk_dialog_run(), SnapshotRepo.has_snapshots(), open_delete_flow(), Main.repo, SnapshotListBox.selected_snapshots(), snapshot_list_box, SnapshotRepo.status_message, Main.thread_delete_running, and ui_sensitive().

Referenced by init_snapshots_page().

hide_window()

void MainWindow::hide_window ( )

private

Definition at line 1321 of file main_window.cpp.

                             {
    set_visible(false);
}

Referenced by on_language_changed().

human_size()

std::string MainWindow::human_size ( uint64_t bytes )

staticprivate

Definition at line 1560 of file main_window.cpp.

                                               {
    const char* units[] = {"B", "KiB", "MiB", "GiB", "TiB"};
    double value = static_cast<double>(bytes);
    int unit_index = 0;
 
    while (value >= 1024.0 && unit_index < 4) {
        value /= 1024.0;
        ++unit_index;
    }
 
    std::ostringstream oss;
    oss << std::fixed << std::setprecision(2) << value << ' ' << units[unit_index];
    return oss.str();
}

Referenced by on_dashboard_device_activated(), on_language_changed(), on_use_selected_device(), populate_device_lists(), and populate_scan_results().

init_about_page()

void MainWindow.init_about_page ( )

inlineprivate

Definition at line 820 of file MainWindow.vala.

                                   {
        var page = new Gtk.Box(Orientation.VERTICAL, 0);
        page.hexpand = true;
        page.vexpand = true;
        page.halign = Gtk.Align.FILL;
        page.valign = Gtk.Align.FILL;
 
        var title = new Gtk.Label(_("Informazioni su BastionGuard Backup"));
        title.xalign = 0;
        title.get_style_context().add_class("page-title");
        title.margin_start = 20;
        title.margin_top = 20;
        title.margin_bottom = 12;
        page.append(title);
 
        var card = make_card(true);
        card.margin_start = 14;
        card.margin_end = 14;
        card.margin_bottom = 16;
        page.append(card);
 
        var body = new Gtk.Box(Orientation.VERTICAL, 10);
        body.margin_start = 12;
        body.margin_end = 12;
        body.margin_top = 12;
        body.margin_bottom = 12;
        card.append(body);
 
        body.append(IconManager.lookup_image("bastionguard-backup", 96));
 
        var lbl_title = new Gtk.Label("BastionGuard™ Backup");
        lbl_title.xalign = 0.5f;
        lbl_title.wrap = true;
        lbl_title.get_style_context().add_class("title");
        body.append(lbl_title);
 
        var lbl_version = new Gtk.Label(AppVersion);
        lbl_version.xalign = 0.5f;
        body.append(lbl_version);
 
        var lbl_desc = new Gtk.Label("Fork di Timeshift con shell UI a pagina singola e sidebar persistente.");
        lbl_desc.xalign = 0.5f;
        lbl_desc.wrap = true;
        lbl_desc.set_justify(Gtk.Justification.CENTER);
        body.append(lbl_desc);
 
        var link = new Gtk.LinkButton.with_label("https://bastionguard.eu", "bastionguard.eu");
        link.set_halign(Gtk.Align.CENTER);
        link.activate_link.connect(() => {
            TeeJee.System.xdg_open("https://bastionguard.eu");
            return true;
        });
        body.append(link);
 
        var lbl_copy = new Gtk.Label("© 2025–2026 BastionGuard™. All Rights Reserved.");
        lbl_copy.xalign = 0.5f;
        lbl_copy.wrap = true;
        lbl_copy.set_justify(Gtk.Justification.CENTER);
        body.append(lbl_copy);
 
        var lbl_tm = new Gtk.Label("BastionGuard was filed by Calogero Scarnà with the Italian Patent and Trademark Office (UIBM) on 16/12/2025 – Application No. 302025000196519.
The BastionGuard™ name and branding are not licensed under the GPLv3.");
        lbl_tm.xalign = 0.5f;
        lbl_tm.wrap = true;
        lbl_tm.set_justify(Gtk.Justification.CENTER);
        body.append(lbl_tm);
 
        var lbl_license = new Gtk.Label(_("BastionGuard Backup is a fork of Timeshift by Tony George.
This program is free software licensed under GNU GPL v2 or later."));
        lbl_license.xalign = 0.5f;
        lbl_license.wrap = true;
        lbl_license.set_justify(Gtk.Justification.CENTER);
        body.append(lbl_license);
 
        var filler = new Gtk.Box(Orientation.VERTICAL, 0);
        filler.vexpand = true;
        page.append(filler);
 
        about_page_widget = page;
        content_stack.add_named(about_page_widget, "about");
    }

References _, about_page_widget, content_stack, IconManager.lookup_image(), and make_card().

Referenced by init_content().

init_content()

void MainWindow.init_content ( )

inlineprivate

Definition at line 906 of file MainWindow.vala.

                                {
        var vbox_content = new Gtk.Box(Orientation.VERTICAL, 0);
        vbox_content.hexpand = true;
        vbox_content.vexpand = false;
        vbox_content.halign = Gtk.Align.FILL;
        vbox_content.valign = Gtk.Align.FILL;
        hbox_root.append(vbox_content);
 
        content_stack = new Gtk.Stack();
        content_stack.hexpand = true;
        content_stack.vexpand = false;
        content_stack.set_hhomogeneous(false);
        content_stack.set_vhomogeneous(false);
        content_stack.halign = Gtk.Align.FILL;
        content_stack.valign = Gtk.Align.FILL;
        content_stack.transition_type     = Gtk.StackTransitionType.CROSSFADE;
        content_stack.transition_duration = 160;
        vbox_content.append(content_stack);
 
        init_snapshots_page();
        init_settings_page();
        init_wizard_page();
        init_about_page();
    }

References content_stack, hbox_root, init_about_page(), init_settings_page(), init_snapshots_page(), and init_wizard_page().

Referenced by MainWindow().

init_delayed()

bool MainWindow.init_delayed ( )

inlineprivate

Definition at line 1103 of file MainWindow.vala.

                                {
        if (tmr_init > 0) { Source.remove(tmr_init); tmr_init = 0; }
        if ((App.repo == null) || !App.repo.available()) {
            if (App.backup_parent_uuid.length > 0)
                App.repo = new SnapshotRepo.from_uuid(App.backup_parent_uuid, this, App.btrfs_mode);
        }
        refresh_all();
        if (App.first_run) btn_wizard_clicked();
        return false;
    }

References App, SnapshotRepo.available(), Main.backup_parent_uuid, btn_wizard_clicked(), Main.btrfs_mode, Main.first_run, SnapshotRepo.from_uuid(), refresh_all(), Main.repo, and tmr_init.

Referenced by MainWindow().

init_settings_page()

void MainWindow.init_settings_page ( )

inlineprivate

Definition at line 801 of file MainWindow.vala.

                                      {
        embedded_settings = new SettingsWindow(true);
        embedded_settings.request_close.connect(() => {
            show_snapshots_page();
        });
        settings_page_widget = embedded_settings.detach_root_widget();
        content_stack.add_named(settings_page_widget, "settings_page");
    }

References content_stack, SettingsWindow.detach_root_widget(), embedded_settings, SettingsWindow.request_close(), settings_page_widget, SettingsWindow.SettingsWindow(), and show_snapshots_page().

Referenced by init_content().

init_sidebar()

void MainWindow.init_sidebar ( )

inlineprivate

Definition at line 508 of file MainWindow.vala.

                                {
 
        vbox_sidebar = new Gtk.Box(Orientation.VERTICAL, 0);
        vbox_sidebar.set_size_request(180, -1);
        vbox_sidebar.get_style_context().add_class("sidebar");
        vbox_sidebar.hexpand = false;
        vbox_sidebar.vexpand = true;
        vbox_sidebar.halign = Gtk.Align.FILL;
        vbox_sidebar.valign = Gtk.Align.FILL;
        hbox_root.append(vbox_sidebar);
 
        var header_box = new Gtk.Box(Orientation.HORIZONTAL, 8);
        header_box.get_style_context().add_class("sidebar-header");
        vbox_sidebar.append(header_box);
 
        var logo = IconManager.lookup_image("bastionguard-backup", 32);
        header_box.append(logo);
 
        var title_lbl = new Gtk.Label("BastionGuard™\nBackup");
        title_lbl.xalign = 0;
        title_lbl.get_style_context().add_class("sidebar-title");
        header_box.append(title_lbl);
 
        vbox_sidebar.append(new Gtk.Box(Orientation.VERTICAL, 0));
 
        btn_nav_snapshots = make_nav_btn("document-save-symbolic",      _("Snapshot"), "snapshots");
        btn_nav_settings  = make_nav_btn("preferences-system-symbolic", _("Impostazioni"),  "settings_page");
        btn_nav_wizard    = make_nav_btn("emblem-default-symbolic",     _("Procedura guidata"),    "wizard");
 
        var spacer = new Gtk.Box(Orientation.VERTICAL, 0);
        spacer.vexpand = true;
        vbox_sidebar.append(spacer);
 
        // Theme section
        var theme_sep = new Gtk.Separator(Orientation.HORIZONTAL);
        theme_sep.margin_top    = 6;
        theme_sep.margin_bottom = 6;
        theme_sep.margin_start  = 8;
        theme_sep.margin_end    = 8;
        vbox_sidebar.append(theme_sep);
 
        var theme_title = new Gtk.Label(_("Theme"));
        theme_title.xalign = 0;
        theme_title.margin_start = 18;
        theme_title.margin_end   = 18;
        theme_title.margin_top   = 4;
        theme_title.margin_bottom = 6;
        vbox_sidebar.append(theme_title);
 
        var theme_box = new Gtk.Box(Orientation.HORIZONTAL, 6);
        theme_box.margin_start = 10;
        theme_box.margin_end   = 10;
        theme_box.margin_bottom = 8;
        vbox_sidebar.append(theme_box);
 
        btn_theme_light = make_theme_btn("weather-clear-symbolic", _("Chiaro"));
        btn_theme_light.clicked.connect(() => { apply_theme(false); });
        theme_box.append(btn_theme_light);
 
        btn_theme_dark = make_theme_btn("weather-clear-night-symbolic", _("Scuro"));
        btn_theme_dark.clicked.connect(() => { apply_theme(true); });
        theme_box.append(btn_theme_dark);
 
        // ── Language selector ──────────────────────────────────────────
        var lang_sep = new Gtk.Separator(Orientation.HORIZONTAL);
        lang_sep.margin_top    = 6;
        lang_sep.margin_bottom = 6;
        lang_sep.margin_start  = 8;
        lang_sep.margin_end    = 8;
        vbox_sidebar.append(lang_sep);
 
        var lang_title = new Gtk.Label(_("Language"));
        lang_title.xalign      = 0;
        lang_title.margin_start  = 18;
        lang_title.margin_end    = 18;
        lang_title.margin_top    = 2;
        lang_title.margin_bottom = 4;
        vbox_sidebar.append(lang_title);
 
        lang_combo = new Gtk.ComboBoxText();
        lang_combo.margin_start  = 10;
        lang_combo.margin_end    = 10;
        lang_combo.margin_bottom = 8;
        lang_combo.get_style_context().add_class("sidebar-combo");
 
        int active_idx = 0;
        for (int i = 0; i < LANG_CODES.length; i++) {
            lang_combo.append_text(LANG_NAMES[i]);
            if (LANG_CODES[i] == current_lang) active_idx = i;
        }
        lang_combo.set_active(active_idx);
        lang_combo.changed.connect(on_language_changed);
        vbox_sidebar.append(lang_combo);
        // ──────────────────────────────────────────────────────────────
 
        var sep = new Gtk.Separator(Orientation.HORIZONTAL);
        sep.margin_top    = 6;
        sep.margin_bottom = 6;
        sep.margin_start  = 8;
        sep.margin_end    = 8;
        vbox_sidebar.append(sep);
 
        btn_nav_about = make_nav_btn("help-about-symbolic", _("Informazioni"), "about");
 
        update_theme_buttons();
    }

References _, apply_theme(), btn_nav_about, btn_nav_settings, btn_nav_snapshots, btn_nav_wizard, btn_theme_dark, btn_theme_light, current_lang, hbox_root, LANG_CODES, lang_combo, LANG_NAMES, IconManager.lookup_image(), make_nav_btn(), make_theme_btn(), on_language_changed(), update_theme_buttons(), and vbox_sidebar.

Referenced by MainWindow().

init_snapshots_page()

void MainWindow.init_snapshots_page ( )

inlineprivate

Definition at line 931 of file MainWindow.vala.

                                       {
 
        var vbox = new Gtk.Box(Orientation.VERTICAL, 0);
        content_stack.add_named(vbox, "snapshots");
        vbox.hexpand = true;
        vbox.vexpand = false;
        vbox.halign = Gtk.Align.FILL;
        vbox.valign = Gtk.Align.FILL;
 
        var page_title = new Gtk.Label(_("Snapshots"));
        page_title.xalign = 0;
        page_title.get_style_context().add_class("page-title");
        page_title.margin_start  = 14;
        page_title.margin_top    = 8;
        page_title.margin_bottom = 6;
        vbox.append(page_title);
 
        var cards_box = new Gtk.Box(Orientation.HORIZONTAL, 0);
        cards_box.margin_start  = 14;
        cards_box.margin_end    = 14;
        cards_box.margin_bottom = 6;
        vbox.append(cards_box);
 
        var card_status = make_card(true);
        cards_box.append(card_status);
 
        var status_inner = new Gtk.Box(Orientation.HORIZONTAL, 12);
        card_status.append(status_inner);
 
        img_shield = new Gtk.Image();
        img_shield.set_from_pixbuf(IconManager.lookup(
            IconManager.SHIELD_HIGH, 48));
        status_inner.append(img_shield);
 
        var status_text = new Gtk.Box(Orientation.VERTICAL, 2);
        status_inner.append(status_text);
 
        lbl_status_title = new Gtk.Label("—");
        lbl_status_title.xalign = 0;
        lbl_status_title.get_style_context().add_class("title");
        lbl_status_title.wrap = true;
        status_text.append(lbl_status_title);
 
        lbl_status_detail = new Gtk.Label("");
        lbl_status_detail.xalign = 0;
        lbl_status_detail.wrap = true;
        status_text.append(lbl_status_detail);
 
        var card_snaps = make_card(false);
        card_snaps.set_size_request(150, -1);
        cards_box.append(card_snaps);
 
        var snaps_hdr = new Gtk.Label(_("Snapshots"));
        snaps_hdr.xalign = 0;
        card_snaps.append(snaps_hdr);
 
        lbl_snap_count = new Gtk.Label("0");
        lbl_snap_count.xalign = 0;
        lbl_snap_count.get_style_context().add_class("title");
        card_snaps.append(lbl_snap_count);
 
        var card_space = make_card(false);
        card_space.set_size_request(170, -1);
        cards_box.append(card_space);
 
        var space_hdr = new Gtk.Label(_("Free space"));
        space_hdr.xalign = 0;
        card_space.append(space_hdr);
 
        lbl_free_space = new Gtk.Label("—");
        lbl_free_space.xalign = 0;
        lbl_free_space.get_style_context().add_class("title");
        card_space.append(lbl_free_space);
 
        lbl_device_name = new Gtk.Label("");
        lbl_device_name.xalign = 0;
        card_space.append(lbl_device_name);
 
        var action_bar = new Gtk.Box(Orientation.HORIZONTAL, 4);
        action_bar.margin_start  = 14;
        action_bar.margin_end    = 14;
        action_bar.margin_bottom = 6;
        vbox.append(action_bar);
 
        btn_backup = make_action_btn("document-save-symbolic", _("Create"), false, false, "btn-success");
        action_bar.append(btn_backup);
        btn_backup.clicked.connect(create_snapshot);
 
        btn_restore = make_action_btn("document-open-recent-symbolic", _("Restore"), false, false, "btn-primary");
        action_bar.append(btn_restore);
        btn_restore.clicked.connect(btn_restore_clicked);
 
        btn_browse_snapshot = make_action_btn("folder-symbolic", _("Browse"), false, false, "btn-info");
        action_bar.append(btn_browse_snapshot);
        btn_browse_snapshot.clicked.connect(browse_selected);
 
        btn_delete_snapshot = make_action_btn("edit-delete-symbolic", _("Delete"), false, false, "btn-danger");
        action_bar.append(btn_delete_snapshot);
        btn_delete_snapshot.clicked.connect(delete_selected);
 
        var sep2 = new Gtk.Box(Orientation.HORIZONTAL, 0);
        sep2.hexpand = true;
        action_bar.append(sep2);
 
        var btn_menu = make_action_btn("open-menu-symbolic", "", false, false);
        btn_menu.set_tooltip_text(_("More options"));
        action_bar.append(btn_menu);
        btn_menu.clicked.connect(() => { btn_about_clicked(); });
 
        var list_card = new Gtk.Box(Orientation.VERTICAL, 0);
        list_card.get_style_context().add_class("card");
        list_card.margin_start  = 14;
        list_card.margin_end    = 14;
        list_card.margin_bottom = 6;
        list_card.hexpand = true;
        list_card.vexpand = false;
        list_card.halign = Gtk.Align.FILL;
        list_card.valign = Gtk.Align.FILL;
 
        snapshot_list_box = new SnapshotListBox(this);
        snapshot_list_box.vexpand = false;
        snapshot_list_box.hexpand = true;
        snapshot_list_box.halign = Gtk.Align.FILL;
        snapshot_list_box.valign = Gtk.Align.FILL;
        list_card.append(snapshot_list_box);
        vbox.append(list_card);
 
        snapshot_list_box.delete_selected.connect(delete_selected);
        snapshot_list_box.mark_selected.connect(mark_selected);
        snapshot_list_box.browse_selected.connect(browse_selected);
        snapshot_list_box.view_snapshot_log.connect(view_snapshot_log);
    }

References _, browse_selected(), SnapshotListBox.browse_selected(), btn_about_clicked(), btn_backup, btn_browse_snapshot, btn_delete_snapshot, btn_restore, btn_restore_clicked(), content_stack, create_snapshot(), delete_selected(), SnapshotListBox.delete_selected(), img_shield, lbl_device_name, lbl_free_space, lbl_snap_count, lbl_status_detail, lbl_status_title, IconManager.lookup(), make_action_btn(), make_card(), mark_selected(), SnapshotListBox.mark_selected(), IconManager.SHIELD_HIGH, snapshot_list_box, SnapshotListBox.SnapshotListBox(), view_snapshot_log(), and SnapshotListBox.view_snapshot_log().

Referenced by init_content().

init_wizard_page()

void MainWindow.init_wizard_page ( )

inlineprivate

Definition at line 810 of file MainWindow.vala.

                                    {
        embedded_wizard = new SetupWizardWindow(true);
        embedded_wizard.request_close.connect(() => {
            show_snapshots_page();
        });
        wizard_page_widget = embedded_wizard.detach_root_widget();
        content_stack.add_named(wizard_page_widget, "wizard");
    }

References content_stack, SetupWizardWindow.detach_root_widget(), embedded_wizard, SetupWizardWindow.request_close(), SetupWizardWindow.SetupWizardWindow(), show_snapshots_page(), and wizard_page_widget.

Referenced by init_content().

load_css()

void MainWindow.load_css ( bool use_dark = false )

inlineprivate

Definition at line 432 of file MainWindow.vala.

                                               {
 
        string css_name = use_dark ? "BastionGuard-dark.css" : "BastionGuard.css";
        string css_res = ResourceHelper.resource_prefix() + "/css/" + css_name;
        string? path = ResourceHelper.resolve_css(css_name);
 
        if (css_provider != null) {
            Gtk.StyleContext.remove_provider_for_display(
                Gdk.Display.get_default(),
                css_provider
            );
            css_provider = null;
        }
 
        css_provider = new Gtk.CssProvider();
        try {
            if (ResourceHelper.resource_exists("css/" + css_name)) {
                css_provider.load_from_resource(css_res);
                log_debug("CSS caricato da resource: " + css_res);
            } else if (path != null && FileUtils.test(path, FileTest.EXISTS)) {
                css_provider.load_from_path(path);
                log_debug("CSS caricato da path: " + path);
            } else {
                log_debug(css_name + " non trovato, uso stile di default");
                return;
            }
            Gtk.StyleContext.add_provider_for_display(
                Gdk.Display.get_default(),
                css_provider,
                Gtk.STYLE_PROVIDER_PRIORITY_USER
            );
 
                var gtk_settings = Gtk.Settings.get_default();
                if (gtk_settings != null) {
                    gtk_settings.gtk_application_prefer_dark_theme = use_dark;
                }
 
            dark_mode = use_dark;
            // Tell IconManager which theme is active so future lookups use the right icons
            IconManager.use_dark = use_dark;
            // Reload already-rendered themed icons to the correct colour variant
            reload_themed_icons();
            update_theme_buttons();
            return;
        }
        catch (Error e) {
            log_error("CSS error: " + e.message);
        }
    }

References css_provider, dark_mode, Error, TeeJee.Logging.log_debug(), TeeJee.Logging.log_error(), reload_themed_icons(), ResourceHelper.resolve_css(), ResourceHelper.resource_exists(), ResourceHelper.resource_prefix(), update_theme_buttons(), and IconManager.use_dark.

Referenced by apply_theme(), and MainWindow().

load_language_preference()

string MainWindow.load_language_preference ( )

inlineprivate

Reads the saved language code from language.json. Returns "en_US" if the file is absent or invalid (first run).

Definition at line 266 of file MainWindow.vala.

                                              {
        try {
            if (!FileUtils.test(LANG_CONFIG_FILE, FileTest.EXISTS)) {
                log_debug("Language config non trovato, uso English (en_US)");
                return "en_US";
            }
 
            string content;
            FileUtils.get_contents(LANG_CONFIG_FILE, out content);
 
            var parser = new Json.Parser();
            parser.load_from_data(content, -1);
 
            Json.Node root = parser.get_root();
            if (root == null || root.get_node_type() != Json.NodeType.OBJECT) {
                log_error("Language config non valido, uso en_US");
                return "en_US";
            }
 
            Json.Object obj = root.get_object();
            if (!obj.has_member("language")) {
                log_debug("Chiave 'language' mancante, uso en_US");
                return "en_US";
            }
 
            string lang = obj.get_string_member("language");
 
            // Validate against supported codes
            foreach (var code in LANG_CODES) {
                if (lang == code) {
                    log_debug("Lingua letta da config: " + lang);
                    return lang;
                }
            }
 
            log_debug("Lingua non supportata '%s', uso en_US".printf(lang));
            return "en_US";
        }
        catch (Error e) {
            log_error("Errore lettura language config: " + e.message);
            return "en_US";
        }
    }

References Error, LANG_CODES, LANG_CONFIG_FILE, TeeJee.Logging.log_debug(), and TeeJee.Logging.log_error().

Referenced by MainWindow().

load_theme_preference()

bool MainWindow.load_theme_preference ( )

inlineprivate

Definition at line 200 of file MainWindow.vala.

                                         {
        try {
            if (!FileUtils.test(THEME_CONFIG_FILE, FileTest.EXISTS)) {
                return false;
            }
 
            string content;
            FileUtils.get_contents(THEME_CONFIG_FILE, out content);
 
            var parser = new Json.Parser();
            parser.load_from_data(content, -1);
 
            Json.Node root = parser.get_root();
            if (root == null || root.get_node_type() != Json.NodeType.OBJECT) {
                log_error("Theme config non valido, uso light");
                return false;
            }
 
            Json.Object obj = root.get_object();
            if (!obj.has_member("theme")) {
                log_debug("Chiave 'theme' mancante, uso light");
                return false;
            }
 
            string theme = obj.get_string_member("theme");
            if (theme == "dark") {
                log_debug("Tema letto da config: dark");
                return true;
            }
 
            log_debug("Tema letto da config: light");
            return false;
        }
        catch (Error e) {
            log_error("Errore lettura theme config: " + e.message);
            return false;
        }
    }

References Error, TeeJee.Logging.log_debug(), TeeJee.Logging.log_error(), and THEME_CONFIG_FILE.

Referenced by MainWindow().

loadConfig()

void MainWindow::loadConfig ( )

private

Definition at line 330 of file MainWindow.cpp.

{
    m_darkMode = false;
    m_language.clear();
    m_protectionEnabled = true;
    m_autostartBackupFile = kSystemAutostartBackupDesktop;
 
    std::ifstream f(m_configFile);
    if (f.is_open()) {
        std::string line;
        while (std::getline(f, line)) {
            if (line.find("dark_mode=true") != std::string::npos)
                m_darkMode = true;
 
            // ── Lingua ──────────────────────────────────────────────────────
            const std::string langKey = "language=";
            auto pos = line.find(langKey);
            if (pos != std::string::npos)
                m_language = line.substr(pos + langKey.size());
 
            if (line.find("protection_enabled=false") != std::string::npos)
                m_protectionEnabled = false;
 
            const std::string backupKey = "autostart_backup=";
            pos = line.find(backupKey);
            if (pos != std::string::npos)
                m_autostartBackupFile = line.substr(pos + backupKey.size());
        }
    }
 
    // service-control.ini è la sorgente esplicita per autostart e daemon.
    // Se esiste, sincronizza lo stato UI anche dopo modifiche fatte da Settings.
    const std::filesystem::path serviceControlFile =
        std::filesystem::path(m_configFile).parent_path() / "service-control.ini";
    std::ifstream sc(serviceControlFile);
    bool sawServiceControlState = false;
    bool serviceControlEnabled = true;
    std::string line;
    while (std::getline(sc, line)) {
        if (line == "enabled=true" || line == "autostart_enabled=true" || line == "daemon_enabled=true") {
            sawServiceControlState = true;
        }
        if (line == "enabled=false" || line == "autostart_enabled=false" || line == "daemon_enabled=false") {
            sawServiceControlState = true;
            serviceControlEnabled = false;
        }
 
        const std::string backupPathKey = "backup_path=";
        auto backupPathPos = line.find(backupPathKey);
        if (backupPathPos == 0) {
            m_autostartBackupFile = line.substr(backupPathKey.size());
        }
    }
    if (sawServiceControlState) {
        m_protectionEnabled = serviceControlEnabled;
    }
}

References m_autostartBackupFile, m_configFile, m_darkMode, m_language, and m_protectionEnabled.

loadTheme()

void MainWindow::loadTheme ( bool dark )

private

Definition at line 435 of file MainWindow.cpp.

{
    const std::string cssFile = dark ? resource("BSC-dark.css") : resource("BSC.css");
    try {
        m_cssProvider->load_from_path(cssFile);
        Gtk::StyleContext::add_provider_for_display(
            get_display(),
                                                    m_cssProvider,
                                                    GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
    } catch (const Glib::Error& e) {
        std::cerr << "⚠ CSS: " << e.what() << "\n";
    }
}

References m_cssProvider, and resource().

Referenced by applyTheme().

make_action_btn()

Gtk.Button MainWindow.make_action_btn ( string icon, string label, bool primary, bool danger, string css_class = "" )

inlineprivate

Definition at line 1078 of file MainWindow.vala.

                                                                                                                  {
        var btn = new Gtk.Button();
        btn.get_style_context().add_class("action-btn");
        if (css_class.length > 0) {
            btn.get_style_context().add_class(css_class);
        } else {
            if (primary) btn.get_style_context().add_class("btn-success");
            if (danger)  btn.get_style_context().add_class("btn-danger");
        }
        btn.get_style_context().remove_class("button");
 
        if (label.length == 0) {
            btn.set_child(themed_icon(icon, 16));
        } else {
            var box = new Gtk.Box(Orientation.HORIZONTAL, 6);
            box.append(themed_icon(icon, 16));
            box.append(new Gtk.Label(label));
            btn.set_child(box);
        }
        return btn;
    }

References themed_icon().

Referenced by init_snapshots_page().

make_card()

Gtk.Box MainWindow.make_card ( bool hexpand )

inlineprivate

Definition at line 1067 of file MainWindow.vala.

                                            {
        var card = new Gtk.Box(Orientation.VERTICAL, 4);
        card.get_style_context().add_class("card");
        card.hexpand = hexpand;
        card.margin_start = 4;
        card.margin_end = 4;
        card.margin_top = 4;
        card.margin_bottom = 4;
        return card;
    }

Referenced by init_about_page(), and init_snapshots_page().

make_nav_btn()

Gtk.Button MainWindow.make_nav_btn ( string icon, string label, string page )

inlineprivate

Definition at line 615 of file MainWindow.vala.

                                                                            {
        var btn = new Gtk.Button();
        btn.get_style_context().add_class("sidebar-button");
                btn.hexpand = true;
 
        var box = new Gtk.Box(Orientation.HORIZONTAL, 12);
        box.margin_start = 6;
 
        var img = themed_icon(icon, 18);
        box.append(img);
 
        var lbl = new Gtk.Label(label);
        lbl.xalign = 0;
        box.append(lbl);
 
        btn.set_child(box);
        vbox_sidebar.append(btn);
 
        btn.clicked.connect(() => { activate_nav(btn, page); });
        return btn;
    }

References activate_nav(), themed_icon(), and vbox_sidebar.

Referenced by init_sidebar().

make_theme_btn()

Gtk.Button MainWindow.make_theme_btn ( string icon, string label )

inlineprivate

Definition at line 637 of file MainWindow.vala.

                                                                 {
        var btn = new Gtk.Button();
        btn.get_style_context().add_class("sidebar-button");
                btn.hexpand = true;
 
        var box = new Gtk.Box(Orientation.HORIZONTAL, 8);
        box.margin_start = 6;
        box.margin_end   = 6;
 
        var img = themed_icon(icon, 18);
        box.append(img);
 
        var lbl = new Gtk.Label(label);
        lbl.xalign = 0.5f;
        box.append(lbl);
 
        btn.set_child(box);
        return btn;
    }

References themed_icon().

Referenced by init_sidebar().

makeSidebarButton()

Gtk::Button * MainWindow::makeSidebarButton ( const std::string & iconPath, const std::string & label, const std::string & pageName )

private

Definition at line 625 of file MainWindow.cpp.

{
    auto box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);
 
    auto pic = Gtk::make_managed<Gtk::Picture>();
    try {
        auto pb = Gdk::Pixbuf::create_from_file(iconPath);
        auto scaled = pb->scale_simple(16, 16, Gdk::InterpType::BILINEAR);
        auto tex = Gdk::Texture::create_for_pixbuf(scaled);
        pic->set_paintable(tex);
        pic->set_content_fit(Gtk::ContentFit::FILL);
    } catch (...) {}
 
    auto iconBox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    iconBox->set_size_request(16, 16);
    iconBox->set_hexpand(false);
    iconBox->set_valign(Gtk::Align::CENTER);
    iconBox->append(*pic);
    box->append(*iconBox);
 
    auto lbl = Gtk::make_managed<Gtk::Label>(label);
    lbl->set_halign(Gtk::Align::START);
    lbl->set_hexpand(false);
    box->append(*lbl);
 
    auto btn = Gtk::make_managed<Gtk::Button>();
    btn->set_child(*box);
    btn->set_hexpand(true);
    btn->get_style_context()->add_class("sidebar-button");
    m_sidebarButtons.push_back(btn);
 
    btn->signal_clicked().connect([this, btn, pageName]() {
        // Determina direzione animazione in base all'ordine delle pagine
        static const std::vector<std::string> pageOrder = {
            "connections", "apps", "network", "rules", "stats", "settings", "about"
        };
        const std::string currentPage = m_stack.get_visible_child_name();
        auto itCur = std::find(pageOrder.begin(), pageOrder.end(), currentPage);
        auto itDst = std::find(pageOrder.begin(), pageOrder.end(), pageName);
        if (itCur != pageOrder.end() && itDst != pageOrder.end()) {
            if (itDst > itCur)
                m_stack.set_transition_type(Gtk::StackTransitionType::SLIDE_LEFT);
            else if (itDst < itCur)
                m_stack.set_transition_type(Gtk::StackTransitionType::SLIDE_RIGHT);
            // stessa pagina: nessun cambio di tipo
        }
        activateSidebarButton(btn);
        m_stack.set_visible_child(pageName);
    });
 
    return btn;
}

References activateSidebarButton(), m_sidebarButtons, and m_stack.

Referenced by buildSidebar().

mark_selected()

void MainWindow.mark_selected ( )

inline

Definition at line 1197 of file MainWindow.vala.

                                {
        var selected = snapshot_list_box.selected_snapshots();
        if (selected.size == 0) {
            gtk_messagebox(_("No Snapshots Selected"), _("Select the snapshots to mark"), this, false);
            return;
        }
        bool marked = false;
        foreach (var bak in selected) {
            bak.mark_for_deletion();
            marked = marked || bak.marked_for_deletion;
        }
        App.repo.load_snapshots();
        gtk_messagebox(
            marked ? _("Marked for deletion") : _("Unmarked"),
                       marked ? _("Snapshots will be removed at next scheduled run")
                       : _("Snapshots will not be removed"),
                       this, false);
        snapshot_list_box.refresh();
    }

References _, App, SnapshotRepo.load_snapshots(), SnapshotListBox.refresh(), Main.repo, SnapshotListBox.selected_snapshots(), and snapshot_list_box.

Referenced by init_snapshots_page().

minimize()

void MainWindow::minimize ( )

private

Definition at line 451 of file MainWindow.cpp.

                          {
    #if GTKMM_CHECK_VERSION(4,10,0)
    this->hide();
    #endif
}

Referenced by build_headerbar(), buildHeaderBar(), and minimize_window().

minimize_window()

void MainWindow::minimize_window ( )

private

Definition at line 1313 of file main_window.cpp.

                                 {
    #if GTKMM_CHECK_VERSION(4,10,0)
    minimize();
    #else
    set_visible(false);
    #endif
}

References minimize().

Referenced by on_language_changed().

noteDesktopActivity()

void MainWindow::noteDesktopActivity ( )

private

Definition at line 762 of file MainWindow.cpp.

{
    m_lastUiActivity = std::chrono::steady_clock::now();
    sendDesktopActivityState(true);
}

References m_lastUiActivity, and sendDesktopActivityState().

Referenced by startDesktopActivityMonitor().

on_choose_destination()

void MainWindow::on_choose_destination ( )

private

Definition at line 844 of file main_window.cpp.

                                       {
    folder_dialog_ = Gtk::FileDialog::create();
    folder_dialog_->set_title(tr("Select destination folder"));
 
    folder_dialog_->select_folder(*this, [this](const Glib::RefPtr<Gio::AsyncResult>& result) {
        try {
            if (!folder_dialog_) return;
            auto folder = folder_dialog_->select_folder_finish(result);
            if (!folder) return;
 
            output_dir_ = folder->get_path();
            entry_output_.set_text(output_dir_);
            append_log(trs("Recovery destination: ") + output_dir_);
            update_source_state();
            update_wizard_step();
            folder_dialog_.reset();
        } catch (const Glib::Error&) {
            folder_dialog_.reset();
        }
    });
}

References append_log(), entry_output_, folder_dialog_, output_dir_, tr(), trs(), update_source_state(), and update_wizard_step().

Referenced by on_language_changed().

on_close_request() [1/3]

bool MainWindow.on_close_request ( )

inlineprivate

Definition at line 1122 of file MainWindow.vala.

                                    {
        this.close_request.disconnect(on_close_request);
        if (App.task.status == AppStatus.RUNNING) {
            log_error(_("Main window closed by user"));
            App.task.stop();
        }
        if (App.thread_delete_running) {
            App.delete_list.clear();
            if (App.delete_file_task != null)
                App.delete_file_task.stop(AppStatus.CANCELLED);
        }
        if (!App.live_system()) {
            if (!App.repo.available() || !App.repo.has_space()) {
                var dlg  = new CustomMessageDialog(
                    App.repo.status_message, _("Select another device?"),
                                                   Gtk.MessageType.ERROR, this, Gtk.ButtonsType.YES_NO);
                var resp = gtk_dialog_run(dlg);
                dlg.destroy();
                if (resp == Gtk.ResponseType.YES) {
                    this.close_request.connect(on_close_request);
                    btn_wizard_clicked();
                    return true;
                }
                return false;
            }
        }
        App.exit_app(0);
        return false;
    }

References _, App, SnapshotRepo.available(), btn_wizard_clicked(), CustomMessageDialog.CustomMessageDialog(), Main.delete_file_task, Main.delete_list, Main.exit_app(), TeeJee.GtkHelper.gtk_dialog_run(), SnapshotRepo.has_space(), Main.live_system(), TeeJee.Logging.log_error(), on_close_request(), Main.repo, AsyncTask.status, SnapshotRepo.status_message, AsyncTask.stop(), Main.task, and Main.thread_delete_running.

on_close_request() [2/3]

bool MainWindow::on_close_request ( )

overrideprotected

Definition at line 458 of file MainWindow.cpp.

                                  {
    std::cout << _("[MainWindow] Nascondo finestra nella tray invece di chiudere") << "\n";
    this->hide();
    return true;
}

References _.

Referenced by MainWindow(), and on_close_request().

on_close_request() [3/3]

bool MainWindow::on_close_request ( )

overrideprivate

on_dashboard_device_activated()

void MainWindow::on_dashboard_device_activated ( Gtk::ListBoxRow * row )

private

Definition at line 881 of file main_window.cpp.

                                                                 {
    if (!row) return;
 
    const int idx = row->get_index();
    if (idx < 0 || static_cast<size_t>(idx) >= devices_.size()) return;
 
    const auto& d = devices_[static_cast<size_t>(idx)];
    select_source(d.path, d.path + " • " + human_size(d.size_bytes));
    current_step_ = WizardStep::Source;
    update_wizard_step();
    on_sidebar_recovery();
}

References current_step_, devices_, human_size(), on_sidebar_recovery(), select_source(), Source, and update_wizard_step().

Referenced by on_language_changed().

on_language_changed() [1/2]

void MainWindow.on_language_changed ( )

inlineprivate

Definition at line 365 of file MainWindow.vala.

                                       {
        if (lang_combo == null) return;
 
        int idx = lang_combo.get_active();
        if (idx < 0 || idx >= LANG_CODES.length) return;
 
        string new_lang = LANG_CODES[idx];
        if (new_lang == current_lang) return;
 
        save_language_preference(new_lang);
        current_lang = new_lang;
 
        // gettext caches translations at first use — the only reliable way
        // to switch language at runtime is to re-exec the current process.
        var dlg = new Gtk.MessageDialog(
            this,
            Gtk.DialogFlags.MODAL,
            Gtk.MessageType.QUESTION,
            Gtk.ButtonsType.YES_NO,
            _("Language saved. The application must restart to apply the new language.\n\nRestart now?")
        );
        var resp = gtk_dialog_run(dlg);
        dlg.destroy();
 
        if (resp == Gtk.ResponseType.YES) {
            restart_application();
        }
    }

References _, current_lang, TeeJee.GtkHelper.gtk_dialog_run(), LANG_CODES, lang_combo, restart_application(), and save_language_preference().

Referenced by build_sidebar(), and init_sidebar().

on_language_changed() [2/2]

void MainWindow::on_language_changed ( )

private

References hide_window(), human_size(), minimize_window(), on_choose_destination(), on_dashboard_device_activated(), on_launch_elevated(), on_open_image(), on_recover_now(), on_recovery_completed(), on_recovery_device_activated(), on_scan_completed(), on_scan_now(), on_scan_progress(), on_theme_dark(), on_theme_light(), on_use_selected_device(), on_wizard_back(), on_wizard_next(), populate_scan_results(), read_language(), read_theme(), result_group_label(), result_subgroup_label(), save_language(), save_theme(), selected_result_indices(), set_all_results_selected(), and update_selected_results_state().

on_launch_elevated()

void MainWindow::on_launch_elevated ( )

private

Definition at line 1015 of file main_window.cpp.

                                    {
    std::string error;
 
    if (PrivilegeUtils::is_running_as_root()) {
        append_log(trs("Already running with elevated privileges."));
        return;
    }
 
    if (!PrivilegeUtils::launch_pkexec_relaunch(error)) {
        append_log(trs("Failed to launch pkexec: ") + error);
        return;
    }
 
    append_log(trs("Requested pkexec relaunch."));
}

References append_log(), PrivilegeUtils::is_running_as_root(), PrivilegeUtils::launch_pkexec_relaunch(), and trs().

Referenced by on_language_changed().

on_open_image()

void MainWindow::on_open_image ( )

private

Definition at line 822 of file main_window.cpp.

                               {
    file_dialog_ = Gtk::FileDialog::create();
    file_dialog_->set_title(tr("Select image file"));
 
    file_dialog_->open(*this, [this](const Glib::RefPtr<Gio::AsyncResult>& result) {
        try {
            if (!file_dialog_) return;
            auto file = file_dialog_->open_finish(result);
            if (!file) return;
 
            const auto path = file->get_path();
            select_source(path, path);
            on_sidebar_recovery();
            file_dialog_.reset();
        } catch (const Glib::Error&) {
            file_dialog_.reset();
        }
 
        update_wizard_step();
    });
}

References file_dialog_, on_sidebar_recovery(), select_source(), tr(), and update_wizard_step().

Referenced by on_language_changed().

on_recover_now()

void MainWindow::on_recover_now ( )

private

Definition at line 984 of file main_window.cpp.

                                {
    if (last_report_.results.empty()) {
        append_log(trs("No scan report available."));
        return;
    }
 
    if (output_dir_.empty()) {
        append_log(trs("No output directory selected."));
        return;
    }
 
    if (recovery_worker_.running()) {
        append_log(trs("A recovery task is already running."));
        return;
    }
 
    const auto selected = selected_result_indices();
    if (selected.empty()) {
        append_log(trs("No recoverable items selected."));
        return;
    }
 
    append_log(trs("Starting recovery to: ") + output_dir_);
    append_log(trs("Selected items for recovery: ") + std::to_string(selected.size()));
    btn_recover_now_.set_sensitive(false);
 
    recovery_worker_.start(last_report_, output_dir_, selected, [this](const RecoveryResult& result) {
        Glib::signal_idle().connect_once([this, result]() { on_recovery_completed(result); });
    });
}

References append_log(), btn_recover_now_, last_report_, on_recovery_completed(), output_dir_, recovery_worker_, ScanReport::results, RecoveryWorker::running(), selected_result_indices(), RecoveryWorker::start(), and trs().

Referenced by on_language_changed().

on_recovery_completed()

void MainWindow::on_recovery_completed ( const RecoveryResult & result )

private

Definition at line 1299 of file main_window.cpp.

                                                                   {
    for (const auto& line : result.logs) append_log(line);
 
    if (result.ok) {
        append_log(trs("Recovery completed."));
        append_log(trs("Exported images: ") + std::to_string(result.summary.exported_images.size()));
        append_log(trs("Recovered files: ") + std::to_string(result.summary.recovered_files.size()));
    } else {
        append_log(trs("Recovery failed: ") + result.error);
    }
 
    update_selected_results_state();
}

References append_log(), RecoveryResult::error, RecoverySummary::exported_images, RecoveryResult::logs, RecoveryResult::ok, RecoverySummary::recovered_files, RecoveryResult::summary, trs(), and update_selected_results_state().

Referenced by on_language_changed(), and on_recover_now().

on_recovery_device_activated()

void MainWindow::on_recovery_device_activated ( Gtk::ListBoxRow * row )

private

Definition at line 894 of file main_window.cpp.

                                                                {
    if (!row) return;
    recovery_devices_list_.select_row(*row);
    on_use_selected_device();
}

References on_use_selected_device(), and recovery_devices_list_.

Referenced by on_language_changed().

on_refresh_devices()

void MainWindow::on_refresh_devices ( )

private

Definition at line 817 of file main_window.cpp.

                                    {
    refresh_devices();
    append_log(trs("Device list refreshed."));
}

References append_log(), refresh_devices(), and trs().

Referenced by activate_sidebar_button().

on_scan_completed()

void MainWindow::on_scan_completed ( const ScanReport & report )

private

Definition at line 1053 of file main_window.cpp.

                                                           {
    if (scan_timer_connection_.connected())
        scan_timer_connection_.disconnect();
 
    scan_progress_bar_.set_fraction(1.0);
    scan_progress_bar_.set_text("100%");
    scan_status_label_.set_text(trs("Completed • Scan finished"));
 
    scan_timer_label_.set_text(
        tr("Elapsed: ") + format_elapsed(std::chrono::steady_clock::now() - scan_started_at_)
    );
 
    last_report_ = report;
 
    for (const auto& line : report.logs)
        append_log(line);
 
    std::ostringstream ss;
    ss << trs("Scan completed. Results: ") << report.results.size();
    append_log(ss.str());
 
    populate_scan_results(report);
 
    btn_scan_now_.set_label(trs("Repeat scan"));
    update_action_controls();
 
    if (!report.results.empty())
        current_step_ = WizardStep::Recover;
 
    update_wizard_step();
}

References append_log(), btn_scan_now_, current_step_, last_report_, ScanReport::logs, populate_scan_results(), Recover, ScanReport::results, scan_progress_bar_, scan_started_at_, scan_status_label_, scan_timer_connection_, scan_timer_label_, tr(), trs(), update_action_controls(), and update_wizard_step().

Referenced by on_language_changed(), and on_scan_now().

on_scan_now()

void MainWindow::on_scan_now ( )

private

Definition at line 940 of file main_window.cpp.

                             {
    if (selected_source_path_.empty()) {
        append_log(trs("No source selected."));
        return;
    }
 
    if (scan_worker_.running()) {
        append_log(trs("A scan is already running."));
        return;
    }
 
    if (!PrivilegeUtils::can_read_source(selected_source_path_) && !PrivilegeUtils::is_running_as_root()) {
        append_log(trs("Source access denied. Relaunch with pkexec or adjust permissions."));
        return;
    }
 
    append_log(trs("Starting read-only scan on: ") + selected_source_path_);
    btn_scan_now_.set_sensitive(false);
    last_scan_progress_ = {};
    scan_started_at_ = std::chrono::steady_clock::now();
    scan_progress_bar_.set_fraction(0.0);
    scan_progress_bar_.set_text("0%");
    scan_status_label_.set_text(tr("Preparing scan..."));
    scan_timer_label_.set_text(tr("Elapsed: ") + std::string("00:00"));
 
    if (scan_timer_connection_.connected()) scan_timer_connection_.disconnect();
 
    scan_timer_connection_ = Glib::signal_timeout().connect([this]() {
        scan_timer_label_.set_text(
            tr("Elapsed: ") + format_elapsed(std::chrono::steady_clock::now() - scan_started_at_));
        return scan_worker_.running();
    }, 250);
 
    scan_worker_.start(
        selected_source_path_,
        [this](const ScanReport& report) {
            Glib::signal_idle().connect_once([this, report]() { on_scan_completed(report); });
        },
        [this](const ScanProgress& progress) {
            Glib::signal_idle().connect_once([this, progress]() { on_scan_progress(progress); });
        }
    );
}

References append_log(), btn_scan_now_, PrivilegeUtils::can_read_source(), PrivilegeUtils::is_running_as_root(), last_scan_progress_, on_scan_completed(), on_scan_progress(), ScanWorker::running(), scan_progress_bar_, scan_started_at_, scan_status_label_, scan_timer_connection_, scan_timer_label_, scan_worker_, selected_source_path_, ScanWorker::start(), tr(), and trs().

Referenced by on_language_changed().

on_scan_progress()

void MainWindow::on_scan_progress ( const ScanProgress & progress )

private

Definition at line 1031 of file main_window.cpp.

                                                              {
    last_scan_progress_ = progress;
 
    double fraction = progress.fraction;
    if (fraction < 0.0) fraction = 0.0;
    if (fraction > 1.0) fraction = 1.0;
 
    scan_progress_bar_.set_fraction(fraction);
 
    std::ostringstream pct;
    pct << static_cast<int>(fraction * 100.0) << '%';
    scan_progress_bar_.set_text(pct.str());
 
    std::string status = progress.stage;
    if (!progress.detail.empty()) {
        if (!status.empty()) status += " • ";
        status += progress.detail;
    }
 
    scan_status_label_.set_text(status.empty() ? tr("Scanning...") : status);
}

References ScanProgress::detail, ScanProgress::fraction, last_scan_progress_, scan_progress_bar_, scan_status_label_, ScanProgress::stage, and tr().

Referenced by on_language_changed(), and on_scan_now().

on_sidebar_about()

void MainWindow::on_sidebar_about ( )

private

Definition at line 1435 of file main_window.cpp.

                                  {
    page_stack_.set_transition_type(Gtk::StackTransitionType::SLIDE_LEFT);
    page_stack_.set_visible_child(about_page_);
    activate_sidebar_button(about_button_);
}

References about_button_, about_page_, activate_sidebar_button(), and page_stack_.

Referenced by activate_sidebar_button().

on_sidebar_dashboard()

void MainWindow::on_sidebar_dashboard ( )

private

Definition at line 805 of file main_window.cpp.

                                      {
    page_stack_.set_transition_type(Gtk::StackTransitionType::SLIDE_RIGHT);
    page_stack_.set_visible_child(dashboard_page_);
    activate_sidebar_button(dashboard_button_);
}

References activate_sidebar_button(), dashboard_button_, dashboard_page_, and page_stack_.

Referenced by activate_sidebar_button().

on_sidebar_recovery()

void MainWindow::on_sidebar_recovery ( )

private

Definition at line 811 of file main_window.cpp.

                                     {
    page_stack_.set_transition_type(Gtk::StackTransitionType::SLIDE_LEFT);
    page_stack_.set_visible_child(recovery_page_);
    activate_sidebar_button(recovery_button_);
}

References activate_sidebar_button(), page_stack_, recovery_button_, and recovery_page_.

Referenced by activate_sidebar_button(), on_dashboard_device_activated(), and on_open_image().

on_theme_dark()

void MainWindow::on_theme_dark ( )

private

Definition at line 900 of file main_window.cpp.

                               {
    current_theme_ = ThemeMode::Dark;
    save_theme("dark");
    apply_theme(current_theme_);
}

References apply_theme(), current_theme_, Dark, and save_theme().

Referenced by on_language_changed().

on_theme_light()

void MainWindow::on_theme_light ( )

private

Definition at line 906 of file main_window.cpp.

                                {
    current_theme_ = ThemeMode::Light;
    save_theme("light");
    apply_theme(current_theme_);
}

References apply_theme(), current_theme_, Light, and save_theme().

Referenced by on_language_changed().

on_use_selected_device()

void MainWindow::on_use_selected_device ( )

private

Definition at line 866 of file main_window.cpp.

                                        {
    auto* row = recovery_devices_list_.get_selected_row();
    if (!row) {
        append_log(trs("No device selected."));
        return;
    }
 
    const int idx = row->get_index();
    if (idx < 0 || static_cast<size_t>(idx) >= devices_.size()) return;
 
    const auto& d = devices_[static_cast<size_t>(idx)];
    select_source(d.path, d.path + " • " + human_size(d.size_bytes));
    update_wizard_step();
}

References append_log(), devices_, human_size(), recovery_devices_list_, select_source(), trs(), and update_wizard_step().

Referenced by on_language_changed(), and on_recovery_device_activated().

on_wizard_back()

void MainWindow::on_wizard_back ( )

private

Definition at line 912 of file main_window.cpp.

                                {
    switch (current_step_) {
        case WizardStep::Source: break;
        case WizardStep::Destination: current_step_ = WizardStep::Source; break;
        case WizardStep::Scan: current_step_ = WizardStep::Destination; break;
        case WizardStep::Recover: current_step_ = WizardStep::Scan; break;
    }
    update_wizard_step();
}

References current_step_, Destination, Recover, Scan, Source, and update_wizard_step().

Referenced by on_language_changed().

on_wizard_next()

void MainWindow::on_wizard_next ( )

private

Definition at line 922 of file main_window.cpp.

                                {
    switch (current_step_) {
        case WizardStep::Source:
            if (!selected_source_path_.empty()) current_step_ = WizardStep::Destination;
            break;
        case WizardStep::Destination:
            if (!output_dir_.empty()) current_step_ = WizardStep::Scan;
            break;
        case WizardStep::Scan:
            if (!last_report_.results.empty())
                current_step_ = WizardStep::Recover;
            break;
        case WizardStep::Recover:
            break;
    }
    update_wizard_step();
}

References current_step_, Destination, last_report_, output_dir_, Recover, ScanReport::results, Scan, selected_source_path_, Source, and update_wizard_step().

Referenced by on_language_changed().

onDaemonAlert()

void MainWindow::onDaemonAlert ( const AlertInfo & alert )

private

Definition at line 875 of file MainWindow.cpp.

{
    std::string text = alert.text.empty() ? _("Alert dal daemon") : alert.text;
 
    // Mapping dei codici `what` e `type` come definiti in ipc/UIServer.cpp:
    //   what:  0 generic, 2 firewall, 3 connection
    //   type:  0 error, 1 warning, 2 info
    constexpr int kWhatConnection = 3;
    constexpr int kTypeWarning    = 1;
 
    const bool is_connection_alert = alert.what == kWhatConnection && alert.has_connection;
 
    if (is_connection_alert) {
        m_connectionsPage.onNewConnection(alert.connection, /*pending=*/false);
        m_connectionsPage.saveLog();
        std::string esito;
        if (alert.type == kTypeWarning) {
            ++m_statDenied;
            esito = _("❌ Negato");
            m_connectionsPage.setLastVerdict(esito);
        } else {
            ++m_statAllowed;
            esito = _("✅ Consentito");
            m_connectionsPage.setLastVerdict(esito);
        }
        m_appsPage.noteConnection(alert.connection, esito);
        m_networkPage.noteConnection(alert.connection);
        m_statsPage.updateStats(m_statAllowed, m_statDenied, m_statAllowed + m_statDenied);
        setStatus(text);
        m_tray.set_tooltip("BastionGuard™ SC — " + text);
        return;
    }
 
    setStatus(text);
    m_tray.set_tooltip("BastionGuard™ SC — " + text);
 
    // NON chiamare present() qui: gli alert informativi passano tramite il
    // tray, non forzano l'apertura della main window. L'utente apre lei
    // attivamente cliccando sull'icona del tray.
}

References _, AlertInfo::connection, AlertInfo::has_connection, m_appsPage, m_connectionsPage, m_networkPage, m_statAllowed, m_statDenied, m_statsPage, m_tray, AppsPage::noteConnection(), NetworkPage::noteConnection(), ConnectionsPage::onNewConnection(), ConnectionsPage::saveLog(), TrayIcon::set_tooltip(), ConnectionsPage::setLastVerdict(), setStatus(), AlertInfo::text, AlertInfo::type, StatsPage::updateStats(), and AlertInfo::what.

onDaemonConnected()

void MainWindow::onDaemonConnected ( )

private

Definition at line 779 of file MainWindow.cpp.

{
    setStatus(_("✅ Daemon connesso"));
    if (m_daemonLabel)
        m_daemonLabel->set_text(_("⚙ Daemon: connesso"));
    m_tray.set_tooltip("BastionGuard™ SC — Daemon connesso");
 
    // Allineamento immediato: il daemon parte "idle" per sicurezza finché
    // la UI non conferma che il desktop è attivo.
    pollDesktopActivity();
    sendDesktopActivityState(m_desktopActiveSent, true);
}

References _, m_daemonLabel, m_desktopActiveSent, m_tray, pollDesktopActivity(), sendDesktopActivityState(), TrayIcon::set_tooltip(), and setStatus().

onDaemonDisconnected()

void MainWindow::onDaemonDisconnected ( )

private

Definition at line 792 of file MainWindow.cpp.

{
    setStatus(_("⚠ Daemon disconnesso — in attesa..."));
    if (m_daemonLabel)
        m_daemonLabel->set_text(_("⚙ Daemon: in attesa..."));
    m_tray.set_tooltip("BastionGuard™ SC — Daemon disconnesso");
}

References _, m_daemonLabel, m_tray, TrayIcon::set_tooltip(), and setStatus().

onNewConnection()

void MainWindow::onNewConnection ( const ConnectionInfo & info )

private

Definition at line 815 of file MainWindow.cpp.

{
    // ── Controlla la cache dei verdetti "always" ─────────────────────────
    // Se questa combinazione app+host+ip è già stata decisa con ALLOW_ALWAYS
    // o DENY_ALWAYS, rispondi immediatamente senza mostrare il popup.
    const std::string key = cacheKey(!info.app_path.empty() ? info.app_path : info.app_comm, info.dest_host, info.dest_ip);
    auto it = m_verdictCache.find(key);
    if (it != m_verdictCache.end()) {
        const bool allowed = (it->second == ReplyAction::ALLOW_ALWAYS);
        const std::string esito = allowed
        ? std::string{"✅ "} + _("Consentito (sempre)")
        : std::string{"❌ "} + _("Negato (sempre)");
 
        m_uiServer.sendReply(it->second);
        m_connectionsPage.onNewConnection(info, /*pending=*/false);
        m_connectionsPage.setLastVerdict(esito);
 
        // Anche i verdetti ricavati da cache devono aggiornare le
        // viste aggregate e la mappa, altrimenti dopo il primo "allow
        // always" una app scompare dai grafici.
        m_appsPage.noteConnection(info, esito);
        m_networkPage.noteConnection(info);
 
        if (allowed) ++m_statAllowed; else ++m_statDenied;
        m_statsPage.updateStats(m_statAllowed, m_statDenied,
                                m_statAllowed + m_statDenied);
        setStatus(esito + " — " + displayNameForStatus(info));
        return;
    }
 
    // ── Nessuna regola in cache: mostra il popup ─────────────────────────
    m_connectionsPage.onNewConnection(info, /*pending=*/true);
    m_connectionsPage.saveLog();
 
    if (m_alertDialog && m_alertDialog->is_visible())
        return;
 
    m_alertDialog = std::make_unique<AlertDialog>(
        info.app_comm, info.app_path, info.app_args, info.dest_host, info.dest_ip, info.dest_port);
 
    // IMPORTANTE: NON rendere l'AlertDialog transient_for della main window.
    // Se lo fosse:
    //   - su X11/Wayland, presentarlo presenterebbe anche la main window
    //   - la main window in tray verrebbe forzata visibile
    // Qui vogliamo che l'alert sia una finestra completamente indipendente:
    // il tray resta nel tray, il dialog appare sopra al desktop.
 
    m_alertDialog->signal_verdict.connect(
        [this, info](Verdict v) {
            onVerdict(v, info);
        });
 
    // IMPORTANTE: NON chiamare present() sulla main window.
    // Prima c'era `if (!is_visible()) present()` che apriva la finestra
    // principale ogni volta che arrivava un alert — comportamento sbagliato:
    // l'utente viene disturbato abbastanza dal popup, la main window deve
    // restare discreta nel tray.
    m_alertDialog->present();
}

References _, ALLOW_ALWAYS, ConnectionInfo::app_args, ConnectionInfo::app_comm, ConnectionInfo::app_path, cacheKey(), ConnectionInfo::dest_host, ConnectionInfo::dest_ip, ConnectionInfo::dest_port, m_alertDialog, m_appsPage, m_connectionsPage, m_networkPage, m_statAllowed, m_statDenied, m_statsPage, m_uiServer, m_verdictCache, AppsPage::noteConnection(), NetworkPage::noteConnection(), ConnectionsPage::onNewConnection(), onVerdict(), ConnectionsPage::saveLog(), UIServer::sendReply(), ConnectionsPage::setLastVerdict(), setStatus(), and StatsPage::updateStats().

onVerdict()

void MainWindow::onVerdict ( Verdict v, const ConnectionInfo & info )

private

Definition at line 916 of file MainWindow.cpp.

{
    ReplyAction action = ReplyAction::DENY_ONCE;
    std::string esito;
 
    switch (v) {
        case Verdict::ALLOW_ONCE:
            action = ReplyAction::ALLOW_ONCE;
            esito  = std::string{"✅ "} + _("Consentito (una volta)");
            ++m_statAllowed;
            break;
 
        case Verdict::ALLOW_ALWAYS:
            action = ReplyAction::ALLOW_ALWAYS;
            esito  = std::string{"✅ "} + _("Consentito (sempre)");
            ++m_statAllowed;
            break;
 
        case Verdict::DENY_ONCE:
            action = ReplyAction::DENY_ONCE;
            esito  = std::string{"❌ "} + _("Negato (una volta)");
            ++m_statDenied;
            break;
 
        case Verdict::DENY_ALWAYS:
            action = ReplyAction::DENY_ALWAYS;
            esito  = std::string{"❌ "} + _("Negato (sempre)");
            ++m_statDenied;
            break;
    }
 
    m_uiServer.sendReply(action);
 
    // Memorizza in cache solo le regole "always"
    if (v == Verdict::ALLOW_ALWAYS || v == Verdict::DENY_ALWAYS)
        m_verdictCache[cacheKey(!info.app_path.empty() ? info.app_path : info.app_comm, info.dest_host, info.dest_ip)] = action;
 
    // Aggiorna la riga nella pagina Connessioni e salva il log
    m_connectionsPage.setLastVerdict(esito);
    m_connectionsPage.saveLog();
 
    // Aggiorna vista per-applicazione
    m_appsPage.noteConnection(info, esito);
 
    // Aggiorna Monitor di rete (geo lookup async)
    m_networkPage.noteConnection(info);
 
    m_statsPage.updateStats(
        m_statAllowed,
        m_statDenied,
        m_statAllowed + m_statDenied);
 
    setStatus(esito + " — " + displayNameForStatus(info));
}

References _, ALLOW_ALWAYS, ALLOW_ONCE, ConnectionInfo::app_comm, ConnectionInfo::app_path, cacheKey(), DENY_ALWAYS, DENY_ONCE, ConnectionInfo::dest_host, ConnectionInfo::dest_ip, m_appsPage, m_connectionsPage, m_networkPage, m_statAllowed, m_statDenied, m_statsPage, m_uiServer, m_verdictCache, AppsPage::noteConnection(), NetworkPage::noteConnection(), ConnectionsPage::saveLog(), UIServer::sendReply(), ConnectionsPage::setLastVerdict(), setStatus(), and StatsPage::updateStats().

Referenced by onNewConnection().

open_backup_flow()

void MainWindow.open_backup_flow ( )

inlineprivate

Definition at line 762 of file MainWindow.vala.

                                    {
        var embedded = new BackupWindow(true);
        embedded.request_close.connect(() => {
            refresh_all();
            ui_sensitive(true);
            show_snapshots_page();
        });
        set_dynamic_page("backup_flow", ref backup_page_widget, embedded.detach_root_widget());
    }

References backup_page_widget, BackupWindow.BackupWindow(), refresh_all(), set_dynamic_page(), show_snapshots_page(), and ui_sensitive().

Referenced by create_snapshot().

open_delete_flow()

void MainWindow.open_delete_flow ( )

inlineprivate

Definition at line 772 of file MainWindow.vala.

                                    {
        var embedded = new DeleteWindow(true);
        embedded.request_close.connect(() => {
            refresh_all();
            ui_sensitive(true);
            show_snapshots_page();
        });
        set_dynamic_page("delete_flow", ref delete_page_widget, embedded.detach_root_widget());
    }

References delete_page_widget, DeleteWindow.DeleteWindow(), refresh_all(), set_dynamic_page(), show_snapshots_page(), and ui_sensitive().

Referenced by check_if_deletion_running(), and delete_selected().

open_restore_flow()

void MainWindow.open_restore_flow ( )

inlineprivate

Definition at line 782 of file MainWindow.vala.

                                     {
        var embedded = new RestoreWindow(true);
        embedded.request_close.connect(() => {
            App.dry_run = false;
            App.repo.load_snapshots();
            refresh_all();
            show_snapshots_page();
        });
        set_dynamic_page("restore_flow", ref restore_page_widget, embedded.detach_root_widget());
    }

References App, SnapshotRepo.load_snapshots(), refresh_all(), Main.repo, restore_page_widget, RestoreWindow.RestoreWindow(), set_dynamic_page(), and show_snapshots_page().

Referenced by restore().

open_rsync_log_page()

void MainWindow.open_rsync_log_page ( string log_file )

inlineprivate

Definition at line 793 of file MainWindow.vala.

                                                      {
        var embedded = new RsyncLogWindow(log_file, true);
        embedded.request_close.connect(() => {
            show_snapshots_page();
        });
        set_dynamic_page("rsync_log", ref rsync_log_page_widget, embedded.detach_root_widget());
    }

References rsync_log_page_widget, RsyncLogWindow.RsyncLogWindow(), set_dynamic_page(), and show_snapshots_page().

Referenced by view_snapshot_log().

open_settings_window()

void MainWindow::open_settings_window

(

)

Definition at line 493 of file MainWindow.cpp.

{
    if (settings_window_) {
        settings_window_->present();
        return;
    }
 
    settings_window_ = new SettingsWindow(clamdConfig_);
    settings_window_->set_transient_for(*this);
    settings_window_->set_modal(true);
 
    settings_window_->signal_close_request().connect(
        [this]() -> bool {
            settings_window_->hide();
            return true;
        },
        false
    );
 
    settings_window_->present();
}

References clamdConfig_, settings_window_, and SettingsWindow::SettingsWindow().

Referenced by build_sidebar(), and ClamApp::launch_main_window().

page_requires_expanded_window()

bool MainWindow.page_requires_expanded_window ( string page )

inlineprivate

Definition at line 683 of file MainWindow.vala.

                                                            {
        switch (page) {
            case "settings_page":
            case "wizard":
            case "backup_flow":
            case "restore_flow":
            case "delete_flow":
            case "rsync_log":
                return true;
            default:
                return false;
        }
    }

Referenced by apply_window_mode_for_page().

pollDesktopActivity()

bool MainWindow::pollDesktopActivity ( )

private

Definition at line 751 of file MainWindow.cpp.

{
    const auto screensaver_active = queryScreensaverActive();
 
    // Se il DE non espone lo stato screen saver/lock, restiamo attivi:
    // meglio non spegnere il monitoraggio mentre l’utente sta lavorando.
    const bool desktop_active = screensaver_active ? !*screensaver_active : true;
    sendDesktopActivityState(desktop_active);
    return true;
}

References sendDesktopActivityState().

Referenced by onDaemonConnected(), and startDesktopActivityMonitor().

populate_device_lists()

void MainWindow::populate_device_lists ( )

private

Definition at line 650 of file main_window.cpp.

                                       {
    while (auto* child = devices_list_.get_first_child()) devices_list_.remove(*child);
    while (auto* child = recovery_devices_list_.get_first_child()) recovery_devices_list_.remove(*child);
 
    int selected_index = -1;
 
    for (size_t i = 0; i < devices_.size(); ++i) {
        const auto& d = devices_[i];
 
        auto make_row = [&](bool include_path_first) -> Gtk::ListBoxRow* {
            auto* row_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 4);
            row_box->set_margin_top(10);
            row_box->set_margin_bottom(10);
            row_box->set_margin_start(12);
            row_box->set_margin_end(12);
 
            std::ostringstream title;
            if (include_path_first)
                title << d.path << "  •  " << human_size(d.size_bytes);
            else
                title << d.name << "  •  " << human_size(d.size_bytes);
 
            std::ostringstream subtitle;
            subtitle << (d.model.empty() ? tr("Disk") : d.model) << "  •  "
            << (d.transport.empty() ? tr("Block") : d.transport);
 
            if (d.removable) subtitle << trs("  •  removable");
            if (!PrivilegeUtils::can_read_source(d.path) && !PrivilegeUtils::is_running_as_root())
                subtitle << trs("  •  needs elevation");
 
            auto* lbl1 = Gtk::make_managed<Gtk::Label>(title.str());
            auto* lbl2 = Gtk::make_managed<Gtk::Label>(subtitle.str());
            lbl1->set_halign(Gtk::Align::START);
            lbl2->set_halign(Gtk::Align::START);
            lbl1->set_xalign(0.0f);
            lbl2->set_xalign(0.0f);
            lbl1->add_css_class("subtitle");
            lbl2->add_css_class("small-label");
            row_box->append(*lbl1);
            row_box->append(*lbl2);
 
            auto* row = Gtk::make_managed<Gtk::ListBoxRow>();
            row->set_child(*row_box);
            return row;
        };
 
        devices_list_.append(*make_row(true));
        recovery_devices_list_.append(*make_row(true));
 
        if (!selected_source_path_.empty() && d.path == selected_source_path_) {
            selected_index = static_cast<int>(i);
        }
    }
 
    devices_list_.unselect_all();
    recovery_devices_list_.unselect_all();
 
    if (selected_index >= 0) {
        if (auto* row = devices_list_.get_row_at_index(selected_index))
            devices_list_.select_row(*row);
        if (auto* row = recovery_devices_list_.get_row_at_index(selected_index))
            recovery_devices_list_.select_row(*row);
    }
}

References PrivilegeUtils::can_read_source(), devices_, devices_list_, human_size(), PrivilegeUtils::is_running_as_root(), recovery_devices_list_, selected_source_path_, tr(), and trs().

Referenced by activate_sidebar_button(), and refresh_devices().

populate_scan_results()

void MainWindow::populate_scan_results ( const ScanReport & report )

private

Definition at line 1109 of file main_window.cpp.

                                                               {
    while (auto* child = results_tree_box_.get_first_child())
        results_tree_box_.remove(*child);
 
    result_selection_.assign(report.results.size(), false);
    result_check_buttons_.assign(report.results.size(), nullptr);
 
    std::map<std::string, std::vector<size_t>> subgroups;
    size_t count = 0;
 
    for (size_t report_index = 0; report_index < report.results.size(); ++report_index) {
        const auto& r = report.results[report_index];
        if (r.kind == ResultKind::Info || r.kind == ResultKind::Warning || r.kind == ResultKind::Error)
            continue;
        ++count;
        result_selection_[report_index] = true;
        subgroups[result_subgroup_label(r)].push_back(report_index);
    }
 
    const std::string scan_root_name = !selected_source_label_.empty()
        ? selected_source_label_
        : (!report.input_path.empty() ? report.input_path : std::string(trs("Scanned source")));
 
    auto* root_expander = Gtk::make_managed<Gtk::Expander>();
    root_expander->set_label(scan_root_name + " (" + std::to_string(count) + ")");
    root_expander->set_expanded(true);
 
    auto* root_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 6);
    root_box->set_margin_top(6);
    root_box->set_margin_bottom(6);
    root_box->set_margin_start(6);
    root_box->set_margin_end(6);
 
    if (count == 0) {
        auto* empty = Gtk::make_managed<Gtk::Label>(trs("No recoverable items found in this scan result."));
        empty->set_halign(Gtk::Align::START);
        empty->set_xalign(0.0f);
        empty->add_css_class("small-label");
        root_box->append(*empty);
    }
 
    for (const auto& subgroup_entry : subgroups) {
        const auto& subgroup_name = subgroup_entry.first;
        const auto& indices = subgroup_entry.second;
 
        auto* sub_expander = Gtk::make_managed<Gtk::Expander>();
        sub_expander->set_label(subgroup_name + " (" + std::to_string(indices.size()) + ")");
        sub_expander->set_expanded(true);
 
        auto* subgroup_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 4);
        subgroup_box->set_margin_top(4);
        subgroup_box->set_margin_bottom(4);
        subgroup_box->set_margin_start(8);
        subgroup_box->set_margin_end(4);
 
        for (size_t report_index : indices) {
            const auto& r = report.results[report_index];
 
            auto* row_layout = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 10);
            row_layout->set_margin_top(6);
            row_layout->set_margin_bottom(6);
            row_layout->set_margin_start(10);
            row_layout->set_margin_end(10);
 
            auto* check = Gtk::make_managed<Gtk::CheckButton>();
            check->set_active(true);
            check->set_valign(Gtk::Align::START);
            check->signal_toggled().connect([this, report_index, check]() {
                if (report_index < result_selection_.size()) {
                    result_selection_[report_index] = check->get_active();
                    update_selected_results_state();
                }
            });
            if (report_index < result_check_buttons_.size()) result_check_buttons_[report_index] = check;
            row_layout->append(*check);
 
            auto* row_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 3);
            row_box->set_hexpand(true);
 
            std::ostringstream title;
            title << r.type;
            if (r.size_bytes > 0)
                title << "  •  " << human_size(r.size_bytes);
 
            std::ostringstream sub;
            sub << trs("Offset: ") << r.offset_bytes
                << " (0x" << std::hex << std::uppercase << r.offset_bytes << std::dec << ")";
            if (r.confidence > 0.0) {
                std::ostringstream conf;
                conf << std::fixed << std::setprecision(0) << (r.confidence * 100.0) << "%";
                sub << trs("  •  Confidence: ") << conf.str();
            }
            if (!r.source.empty())
                sub << "  •  " << r.source;
 
            auto* lbl_title = Gtk::make_managed<Gtk::Label>(title.str());
            lbl_title->set_halign(Gtk::Align::START);
            lbl_title->set_xalign(0.0f);
            lbl_title->add_css_class("subtitle");
 
            auto* lbl_sub = Gtk::make_managed<Gtk::Label>(sub.str());
            lbl_sub->set_halign(Gtk::Align::START);
            lbl_sub->set_xalign(0.0f);
            lbl_sub->add_css_class("small-label");
            lbl_sub->set_ellipsize(Pango::EllipsizeMode::END);
 
            row_box->append(*lbl_title);
            row_box->append(*lbl_sub);
 
            if (!r.detail.empty()) {
                auto* lbl_detail = Gtk::make_managed<Gtk::Label>(r.detail);
                lbl_detail->set_halign(Gtk::Align::START);
                lbl_detail->set_xalign(0.0f);
                lbl_detail->add_css_class("small-label");
                lbl_detail->set_wrap(true);
                lbl_detail->set_wrap_mode(Pango::WrapMode::WORD_CHAR);
                row_box->append(*lbl_detail);
            }
 
            row_layout->append(*row_box);
            subgroup_box->append(*row_layout);
        }
 
        sub_expander->set_child(*subgroup_box);
        root_box->append(*sub_expander);
    }
 
    root_expander->set_child(*root_box);
    results_tree_box_.append(*root_expander);
 
    std::ostringstream cnt;
    if (count == 0) {
        cnt << trs("No recoverable items found.");
    } else if (count == 1) {
        cnt << count << trs(" recoverable item detected in this scan.");
    } else {
        cnt << count << trs(" recoverable items detected in this scan.");
    }
    results_count_label_.set_text(cnt.str());
 
    std::ostringstream rec_msg;
    rec_msg << trs("Destination: ")
    << (output_dir_.empty() ? std::string(trs("not selected")) : output_dir_)
    << "\n"
    << trs("Scan result: ") << scan_root_name
    << "\n"
    << trs("This tree belongs to the current scan result. Select all items or only the entries you want to recover, then click \"Start recovery\".");
 
    recover_step_label_.set_text(rec_msg.str());
    update_selected_results_state();
}

References Error, human_size(), Info, ScanReport::input_path, output_dir_, recover_step_label_, result_check_buttons_, result_selection_, result_subgroup_label(), ScanReport::results, results_count_label_, results_tree_box_, selected_source_label_, trs(), update_selected_results_state(), and Warning.

Referenced by on_language_changed(), and on_scan_completed().

read_language()

std::string MainWindow::read_language ( )

staticprivate

Definition at line 1441 of file main_window.cpp.

                                    {
    const std::string path =
    Glib::get_home_dir() + "/.config/bastionguard-recovery-data/lang.conf";
 
    std::ifstream f(path);
    if (!f.is_open()) return "en";
 
    std::string val;
    f >> val;
 
    static const std::unordered_set<std::string> supported = {
        "en", "it", "de", "es", "fr", "ja", "nl", "pl", "pt", "ru", "ar"
    };
 
    return supported.count(val) ? val : "en";
}

Referenced by build_sidebar(), and on_language_changed().

read_theme()

std::string MainWindow::read_theme ( )

staticprivate

Definition at line 1467 of file main_window.cpp.

                                 {
    const std::string path =
    Glib::get_home_dir() + "/.config/bastionguard-recovery-data/theme.conf";
 
    std::ifstream f(path);
    if (!f.is_open()) return "dark";
 
    std::string val;
    f >> val;
 
    if (val == "dark" || val == "light")
        return val;
 
    return "dark";
}

Referenced by on_language_changed().

refresh_all()

bool MainWindow.refresh_all ( )

inlineprivate

Definition at line 1114 of file MainWindow.vala.

                               {
        ui_sensitive(false);
        snapshot_list_box.refresh();
        update_statusbar();
        ui_sensitive(true);
        return false;
    }

References SnapshotListBox.refresh(), snapshot_list_box, ui_sensitive(), and update_statusbar().

Referenced by init_delayed(), open_backup_flow(), open_delete_flow(), open_restore_flow(), and settings_changed().

refresh_devices()

void MainWindow::refresh_devices ( )

private

Definition at line 641 of file main_window.cpp.

                                 {
    devices_ = DeviceEnumerator::enumerate_linux_block_devices();
    populate_device_lists();
 
    std::ostringstream ss;
    ss << trs("Detected devices: ") << devices_.size();
    update_card_label_.set_text(ss.str());
}

References devices_, DeviceEnumerator::enumerate_linux_block_devices(), populate_device_lists(), trs(), and update_card_label_.

Referenced by activate_sidebar_button(), and on_refresh_devices().

refreshSystemIntegrationStatus()

void MainWindow::refreshSystemIntegrationStatus ( )

private

Definition at line 1048 of file MainWindow.cpp.

{
    const bool serviceEnabled = runCommand(
        shellQuote(kServiceCtlPath) + " --system is-enabled " +
        shellQuote(kServiceName) + " >/dev/null 2>&1");
    const bool autostartPresent = std::filesystem::exists(kSystemAutostartDesktop) ||
                                  std::filesystem::exists(kFallbackSystemAutostartDesktop);
    std::string text;
    if (m_protectionEnabled) {
        text = _("Protezione attiva nelle impostazioni utente.");
    } else {
        text = _("Protezione disattivata nelle impostazioni utente.");
    }
    text += std::string(" ") + (serviceEnabled ? _("Servizio di sistema abilitato.") : _("Servizio di sistema disabilitato."));
    text += std::string(" ") + (autostartPresent ? _("Avvio automatico presente.") : _("Avvio automatico assente."));
    if (!m_autostartBackupFile.empty() && std::filesystem::exists(m_autostartBackupFile)) {
        text += std::string(" ") + _("Backup autostart disponibile.");
    }
    m_settingsPage.refreshState();
    m_settingsPage.setProtectionEnabled(m_protectionEnabled);
    m_settingsPage.setSystemIntegrationStatus(text);
}

References _, m_autostartBackupFile, m_protectionEnabled, m_settingsPage, SettingsPage::refreshState(), SettingsPage::setProtectionEnabled(), and SettingsPage::setSystemIntegrationStatus().

reload_themed_icons()

void MainWindow.reload_themed_icons ( )

inlineprivate

Definition at line 1387 of file MainWindow.vala.

                                       {
        if (embedded_settings != null) embedded_settings.reload_themed_icons();
        if (embedded_wizard   != null) embedded_wizard.reload_themed_icons();
        for (int i = 0; i < themed_img_list.size; i++) {
            var img  = themed_img_list[i];
            var name = themed_img_name[i];
            var sz   = themed_img_size[i];
            var pix  = IconManager.lookup(name, sz);
            if (pix != null) {
                img.set_from_pixbuf(pix);
            } else {
                img.set_from_icon_name(name);
            }
        }
    }

References embedded_settings, embedded_wizard, IconManager.lookup(), SettingsWindow.reload_themed_icons(), SetupWizardWindow.reload_themed_icons(), themed_img_list, themed_img_name, and themed_img_size.

Referenced by load_css().

remember_compact_window_size()

void MainWindow.remember_compact_window_size ( )

inlineprivate

Definition at line 697 of file MainWindow.vala.

                                                {
        if (window_in_expanded_mode)
            return;
 
        int current_width = this.get_width();
        int current_height = this.get_height();
 
        if (current_width > 0)
            compact_window_width = current_width;
        if (current_height > 0)
            compact_window_height = current_height;
    }

References compact_window_height, compact_window_width, and window_in_expanded_mode.

Referenced by apply_window_mode_for_page().

resize_main_window()

void MainWindow.resize_main_window ( int width, int height )

inlineprivate

Definition at line 710 of file MainWindow.vala.

                                                           {
        this.set_default_size(width, height);
        this.set_size_request(width, height);
        Idle.add(() => {
            this.set_size_request(-1, -1);
            return false;
        });
    }

References Idle.

Referenced by apply_window_mode_for_page().

restart_application()

void MainWindow.restart_application ( )

inlineprivate

Spawns a fresh instance of the application and exits the current one. The new process reads language.json at startup and loads the correct locale before any _() call — this is the only reliable way to switch gettext locale.

Definition at line 399 of file MainWindow.vala.

                                       {
        string exe_path = "";
        try {
            exe_path = GLib.FileUtils.read_link("/proc/self/exe");
        } catch (Error e) {
            log_error("restart: cannot read /proc/self/exe: " + e.message);
            App.exit_app(0);
            return;
        }
 
        string[] argv = { exe_path };
 
        try {
            GLib.Process.spawn_async(
                null,
                argv,
                null,
                GLib.SpawnFlags.SEARCH_PATH | GLib.SpawnFlags.DO_NOT_REAP_CHILD,
                null,
                null
            );
        } catch (Error e) {
            log_error("restart: spawn failed: " + e.message);
            App.exit_app(0);
            return;
        }
 
        App.exit_app(0);
    }

References App, Error, Main.exit_app(), and TeeJee.Logging.log_error().

Referenced by on_language_changed().

restore()

void MainWindow.restore ( )

inlineprivate

Definition at line 1259 of file MainWindow.vala.

                           {
        if (!App.mirror_system) {
            var selected = snapshot_list_box.selected_snapshots();
            if (selected.size == 0) {
                gtk_messagebox(_("No snapshots selected"), _("Select the snapshot to restore"), this, false);
                return;
            }
            if (selected.size > 1) {
                gtk_messagebox(_("Multiple snapshots selected"), _("Select a single snapshot"), this, false);
                return;
            }
            Snapshot snap = selected[0];
            if ((snap != null) && snap.marked_for_deletion) {
                gtk_messagebox(_("Invalid snapshot"),
                               _("Selected snapshot is marked for deletion"), this, false);
                return;
            }
            App.snapshot_to_restore = snap;
        } else {
            App.snapshot_to_restore = null;
        }
        App.init_mount_list();
        open_restore_flow();
    }

References _, App, Main.init_mount_list(), Snapshot.marked_for_deletion, Main.mirror_system, open_restore_flow(), SnapshotListBox.selected_snapshots(), and snapshot_list_box.

Referenced by btn_restore_clicked().

result_group_label()

std::string MainWindow::result_group_label ( const ScanResult & result )

staticprivate

Definition at line 1085 of file main_window.cpp.

                                                                 {
    if (result.type.find("NTFS") != std::string::npos) return "NTFS";
    if (result.type.find("ext4") != std::string::npos || result.type.find("EXT4") != std::string::npos) return "ext4";
    if (result.type.find("Btrfs") != std::string::npos || result.type.find("BTRFS") != std::string::npos) return "Btrfs";
    if (result.type.find("exFAT") != std::string::npos) return "exFAT";
    if (result.type.find("FAT32") != std::string::npos) return "FAT32";
    if (result.kind == ResultKind::Partition || result.kind == ResultKind::LostPartitionCandidate) return "Partitions";
    return "Other detected items";
}

References ScanResult::kind, LostPartitionCandidate, Partition, and ScanResult::type.

Referenced by on_language_changed().

result_subgroup_label()

std::string MainWindow::result_subgroup_label ( const ScanResult & result )

staticprivate

Definition at line 1095 of file main_window.cpp.

                                                                    {
    switch (result.kind) {
        case ResultKind::Partition: return "Partitions";
        case ResultKind::LostPartitionCandidate: return "Lost partitions";
        case ResultKind::FilesystemCandidate: return "Filesystem candidates";
        case ResultKind::FilesystemVolume:
        case ResultKind::NtfsVolume: return "Volumes";
        case ResultKind::NtfsMetadata: return "Metadata";
        default: break;
    }
    if (result.type.find("$MFT") != std::string::npos) return "Metadata";
    return "Items";
}

References FilesystemCandidate, FilesystemVolume, ScanResult::kind, LostPartitionCandidate, NtfsMetadata, NtfsVolume, Partition, and ScanResult::type.

Referenced by on_language_changed(), and populate_scan_results().

save_language()

void MainWindow::save_language ( const std::string & lang_code )

staticprivate

Definition at line 1458 of file main_window.cpp.

                                                         {
    const std::string dir =
    Glib::get_home_dir() + "/.config/bastionguard-recovery-data";
 
    std::filesystem::create_directories(dir);
    std::ofstream f(dir + "/lang.conf");
    if (f.is_open()) f << lang_code << "\n";
}

Referenced by on_language_changed().

save_language_preference()

void MainWindow.save_language_preference ( string lang_code )

inlineprivate

Definition at line 310 of file MainWindow.vala.

                                                            {
        try {
            if (!FileUtils.test(THEME_CONFIG_DIR, FileTest.IS_DIR)) {
                DirUtils.create_with_parents(THEME_CONFIG_DIR, 0755);
            }
 
            string json = "{\n\t\"language\": \"%s\"\n}\n".printf(lang_code);
            FileUtils.set_contents(LANG_CONFIG_FILE, json);
 
            log_debug("Lingua salvata in " + LANG_CONFIG_FILE + ": " + lang_code);
        }
        catch (Error e) {
            log_error("Errore salvataggio language config: " + e.message);
        }
    }

References Error, LANG_CONFIG_FILE, TeeJee.Logging.log_debug(), TeeJee.Logging.log_error(), and THEME_CONFIG_DIR.

Referenced by on_language_changed().

save_theme()

void MainWindow::save_theme ( const std::string & theme_code )

staticprivate

Definition at line 1483 of file main_window.cpp.

                                                       {
    const std::string dir =
    Glib::get_home_dir() + "/.config/bastionguard-recovery-data";
 
    std::filesystem::create_directories(dir);
    std::ofstream f(dir + "/theme.conf");
    if (f.is_open()) f << theme_code << "\n";
}

Referenced by on_language_changed(), on_theme_dark(), and on_theme_light().

save_theme_preference()

void MainWindow.save_theme_preference ( bool use_dark )

inlineprivate

Definition at line 239 of file MainWindow.vala.

                                                      {
        try {
            // Crea la directory se manca
            if (!FileUtils.test(THEME_CONFIG_DIR, FileTest.IS_DIR)) {
                DirUtils.create_with_parents(THEME_CONFIG_DIR, 0755);
            }
 
            string theme = use_dark ? "dark" : "light";
            string json  = "{\n\t\"theme\": \"%s\"\n}\n".printf(theme);
 
            FileUtils.set_contents(THEME_CONFIG_FILE, json);
 
            log_debug("Theme salvato in " + THEME_CONFIG_FILE + ": " + theme);
        }
        catch (Error e) {
            log_error("Errore salvataggio theme config: " + e.message);
        }
    }

References Error, TeeJee.Logging.log_debug(), TeeJee.Logging.log_error(), THEME_CONFIG_DIR, and THEME_CONFIG_FILE.

Referenced by apply_theme().

saveConfig()

void MainWindow::saveConfig ( )

private

Definition at line 312 of file MainWindow.cpp.

{
    try {
        std::filesystem::create_directories(
            std::filesystem::path(m_configFile).parent_path());
        std::ofstream f(m_configFile);
        f << "[General]\n";
        f << "dark_mode=" << (m_darkMode ? "true" : "false") << "\n";
        if (!m_language.empty())
            f << "language=" << m_language << "\n";
        f << "protection_enabled=" << (m_protectionEnabled ? "true" : "false") << "\n";
        if (!m_autostartBackupFile.empty())
            f << "autostart_backup=" << m_autostartBackupFile << "\n";
    } catch (const std::exception& e) {
        std::cerr << "⚠ Impossibile salvare config: " << e.what() << "\n";
    }
}

References m_autostartBackupFile, m_configFile, m_darkMode, m_language, and m_protectionEnabled.

Referenced by applyProtectionEnabled(), and applyTheme().

select_source()

void MainWindow::select_source ( const std::string & path, const std::string & label )

private

Definition at line 715 of file main_window.cpp.

                                                                            {
    selected_source_path_ = path;
    selected_source_label_ = label;
    last_report_ = {};
 
    int selected_index = -1;
    for (size_t i = 0; i < devices_.size(); ++i) {
        if (devices_[i].path == path) {
            selected_index = static_cast<int>(i);
            break;
        }
    }
 
    devices_list_.unselect_all();
    recovery_devices_list_.unselect_all();
 
    if (selected_index >= 0) {
        if (auto* dashboard_row = devices_list_.get_row_at_index(selected_index))
            devices_list_.select_row(*dashboard_row);
 
        if (auto* wizard_row = recovery_devices_list_.get_row_at_index(selected_index))
            recovery_devices_list_.select_row(*wizard_row);
    }
 
    update_source_state();
    append_log(trs("Selected source: ") + label);
}

References append_log(), devices_, devices_list_, last_report_, recovery_devices_list_, selected_source_label_, selected_source_path_, trs(), and update_source_state().

Referenced by activate_sidebar_button(), on_dashboard_device_activated(), on_open_image(), and on_use_selected_device().

selected_result_indices()

std::vector< size_t > MainWindow::selected_result_indices ( ) const

private

Definition at line 1275 of file main_window.cpp.

                                                            {
    std::vector<size_t> out;
    for (size_t i = 0; i < result_selection_.size(); ++i) {
        if (result_selection_[i]) {
            const auto& r = last_report_.results[i];
            if (r.kind == ResultKind::Info || r.kind == ResultKind::Warning || r.kind == ResultKind::Error) continue;
            out.push_back(i);
        }
    }
    return out;
}

References Error, Info, last_report_, result_selection_, ScanReport::results, and Warning.

Referenced by on_language_changed(), on_recover_now(), and update_selected_results_state().

sendDesktopActivityState()

void MainWindow::sendDesktopActivityState ( bool active, bool force = false )

private

Definition at line 768 of file MainWindow.cpp.

{
    if (!force && active == m_desktopActiveSent) return;
    m_desktopActiveSent = active;
 
    m_uiServer.queueNotification(active ? kNotifDesktopActive : kNotifDesktopIdle, "{}");
    if (!active) {
        setStatus(_("⏸ Desktop inattivo: monitoraggio connessioni sospeso"));
    }
}

References _, m_desktopActiveSent, m_uiServer, UIServer::queueNotification(), and setStatus().

Referenced by noteDesktopActivity(), onDaemonConnected(), and pollDesktopActivity().

set_all_results_selected()

void MainWindow::set_all_results_selected ( bool selected )

private

Definition at line 1287 of file main_window.cpp.

                                                       {
    for (size_t i = 0; i < last_report_.results.size(); ++i) {
        const auto& r = last_report_.results[i];
        if (r.kind == ResultKind::Info || r.kind == ResultKind::Warning || r.kind == ResultKind::Error) continue;
        if (i < result_selection_.size()) result_selection_[i] = selected;
        if (i < result_check_buttons_.size() && result_check_buttons_[i]) {
            result_check_buttons_[i]->set_active(selected);
        }
    }
    update_selected_results_state();
}

References Error, Info, last_report_, result_check_buttons_, result_selection_, ScanReport::results, update_selected_results_state(), and Warning.

Referenced by on_language_changed().

set_dynamic_page()

void MainWindow.set_dynamic_page ( string name, ref Gtk.Widget? slot, Gtk.Widget widget )

inlineprivate

Definition at line 751 of file MainWindow.vala.

                                                                                        {
        if (slot != null) {
            content_stack.remove(slot);
            slot = null;
        }
        slot = widget;
        content_stack.add_named(slot, name);
        content_stack.set_visible_child_name(name);
        apply_window_mode_for_page(name);
    }

References apply_window_mode_for_page(), and content_stack.

Referenced by open_backup_flow(), open_delete_flow(), open_restore_flow(), and open_rsync_log_page().

setStatus()

void MainWindow::setStatus ( const std::string & msg )

private

Definition at line 975 of file MainWindow.cpp.

{
    m_statusbar.pop(m_statusCtx);
    m_statusbar.push(msg, m_statusCtx);
}

References m_statusbar, and m_statusCtx.

Referenced by applyProtectionEnabled(), onDaemonAlert(), onDaemonConnected(), onDaemonDisconnected(), onNewConnection(), onVerdict(), sendDesktopActivityState(), and showLanguageDialog().

settings_changed()

void MainWindow.settings_changed ( bool btrfs_mode_prev )

inlineprivate

Definition at line 1296 of file MainWindow.vala.

                                                        {
        if (btrfs_mode_prev != App.btrfs_mode) {
            if ((App.repo != null) && (App.repo.device != null) && (App.repo.device.uuid.length > 0))
                App.repo = new SnapshotRepo.from_uuid(App.repo.device.uuid, this, App.btrfs_mode);
            else if ((App.sys_root != null) && (App.sys_root.fstype == "btrfs"))
                App.repo = new SnapshotRepo.from_uuid(App.sys_root.uuid, this, App.btrfs_mode);
            else
                App.repo = new SnapshotRepo.from_null();
        }
        App.save_app_config();
        App.repo.load_snapshots();
        refresh_all();
    }

References App, Main.btrfs_mode, SnapshotRepo.device, SnapshotRepo.from_null(), SnapshotRepo.from_uuid(), Device.fstype, SnapshotRepo.load_snapshots(), refresh_all(), Main.repo, Main.save_app_config(), Main.sys_root, and Device.uuid.

show_settings()

void MainWindow.show_settings ( )

inline

Definition at line 1285 of file MainWindow.vala.

                                {
        btn_settings_clicked();
    }

References btn_settings_clicked().

show_snapshots_page()

void MainWindow.show_snapshots_page ( )

inlineprivate

Definition at line 679 of file MainWindow.vala.

                                       {
        activate_nav(btn_nav_snapshots, "snapshots");
    }

References activate_nav(), and btn_nav_snapshots.

Referenced by init_settings_page(), init_wizard_page(), open_backup_flow(), open_delete_flow(), open_restore_flow(), and open_rsync_log_page().

showDashboard()

void MainWindow::showDashboard

(

)

Definition at line 465 of file MainWindow.cpp.

                               {
    try {
        stack_.set_visible_child("dashboard");
        activate_sidebar_button(dashboard_button_);
 
        // grab_focus su un widget non ancora realized/mapped emette
        // un g_critical fatale (con G_DEBUG=fatal-criticals). Posticipalo
        // a quando la finestra è effettivamente mostrata.
        if (dashboard_page_.get_realized() && dashboard_page_.get_mapped()) {
            dashboard_page_.grab_focus();
        } else {
            Glib::signal_idle().connect_once([this]() {
                try {
                    if (dashboard_page_.get_realized() && dashboard_page_.get_mapped()) {
                        dashboard_page_.grab_focus();
                    }
                } catch (...) {}
            });
        }
 
        std::cout << _("[MainWindow] Ritorno alla Dashboard") << std::endl;
    } catch (const std::exception& e) {
        std::cerr << _("⚠ Errore durante il ritorno alla Dashboard: ") << e.what() << std::endl;
    } catch (...) {
        std::cerr << _("⚠ Errore sconosciuto durante il ritorno alla Dashboard") << std::endl;
    }
}

References _, activate_sidebar_button(), dashboard_button_, dashboard_page_, and stack_.

Referenced by ClamApp::launch_main_window().

showLanguageDialog()

void MainWindow::showLanguageDialog ( )

private

Definition at line 414 of file MainWindow.cpp.

{
    m_langDialog = std::make_unique<LanguageDialog>(m_configFile, m_language);
    m_langDialog->set_transient_for(*this);
    m_langDialog->set_modal(true);
    m_langDialog->signal_hide().connect([this]() {
        // Se la lingua è cambiata aggiorna il membro (la UI si aggiorna al prossimo avvio)
        const std::string chosen = m_langDialog->selectedLanguage();
        if (chosen != m_language) {
            m_language = chosen;
            // Il file è già stato scritto da LanguageDialog::onApply()
            setStatus(_("Lingua aggiornata — riavvia per applicare la modifica."));
        }
    });
    m_langDialog->present();
}

References _, m_configFile, m_langDialog, m_language, and setStatus().

Referenced by buildHeaderBar().

startDesktopActivityMonitor()

void MainWindow::startDesktopActivityMonitor ( )

private

Definition at line 696 of file MainWindow.cpp.

{
    m_lastUiActivity = std::chrono::steady_clock::now();
 
    auto install_activity_controller = [this](GtkEventController* controller) {
        gtk_event_controller_set_propagation_phase(controller, GTK_PHASE_CAPTURE);
        gtk_widget_add_controller(GTK_WIDGET(gobj()), controller);
    };
 
    auto* motion = gtk_event_controller_motion_new();
    g_signal_connect(
        motion,
        "motion",
        G_CALLBACK(+[](GtkEventControllerMotion*, double, double, gpointer data) {
            static_cast<MainWindow*>(data)->noteDesktopActivity();
        }),
        this);
    install_activity_controller(GTK_EVENT_CONTROLLER(motion));
 
    auto* click = gtk_gesture_click_new();
    g_signal_connect(
        click,
        "pressed",
        G_CALLBACK(+[](GtkGestureClick*, int, double, double, gpointer data) {
            static_cast<MainWindow*>(data)->noteDesktopActivity();
        }),
        this);
    install_activity_controller(GTK_EVENT_CONTROLLER(click));
 
    auto* key = gtk_event_controller_key_new();
    g_signal_connect(
        key,
        "key-pressed",
        G_CALLBACK(+[](GtkEventControllerKey*, guint, guint, GdkModifierType, gpointer data) -> gboolean {
            static_cast<MainWindow*>(data)->noteDesktopActivity();
            return GDK_EVENT_PROPAGATE;
        }),
        this);
    install_activity_controller(GTK_EVENT_CONTROLLER(key));
 
    // Il polling non usa “inattività della finestra BSC” perché la UI può
    // restare nel tray mentre l’utente lavora su altre app. Usiamo invece lo
    // stato del desktop/screen saver quando il DE lo espone via D-Bus.
    m_desktopActivityTimer = g_timeout_add_seconds(
        5,
        +[](gpointer data) -> gboolean {
            return static_cast<MainWindow*>(data)->pollDesktopActivity()
                ? G_SOURCE_CONTINUE
                : G_SOURCE_REMOVE;
        },
        this);
 
    pollDesktopActivity();
}

References m_desktopActivityTimer, m_lastUiActivity, MainWindow(), noteDesktopActivity(), and pollDesktopActivity().

themed_icon()

Gtk.Image MainWindow.themed_icon ( string icon_name, int size )

inlineprivate

Definition at line 1379 of file MainWindow.vala.

                                                              {
        var img = IconManager.lookup_image(icon_name, size);
        themed_img_list.add(img);
        themed_img_name.add(icon_name);
        themed_img_size.add(size);
        return img;
    }

References IconManager.lookup_image(), themed_img_list, themed_img_name, and themed_img_size.

Referenced by build_headerbar(), make_action_btn(), make_nav_btn(), and make_theme_btn().

ui_sensitive()

void MainWindow.ui_sensitive ( bool enable )

inlineprivate

Definition at line 1314 of file MainWindow.vala.

                                           {
        vbox_sidebar.sensitive               = enable;
        snapshot_list_box.sensitive = enable;
        gtk_set_busy(!enable, this);
    }

References TeeJee.GtkHelper.gtk_set_busy().

Referenced by check_if_deletion_running(), create_snapshot(), delete_selected(), open_backup_flow(), open_delete_flow(), and refresh_all().

update_action_controls()

void MainWindow::update_action_controls ( )

private

Definition at line 1428 of file main_window.cpp.

                                        {
    btn_scan_now_.set_sensitive(!scan_worker_.running() && !selected_source_path_.empty());
    btn_results_select_all_.set_sensitive(!last_report_.results.empty());
    btn_results_clear_.set_sensitive(!last_report_.results.empty());
    update_selected_results_state();
}

References btn_results_clear_, btn_results_select_all_, btn_scan_now_, last_report_, ScanReport::results, ScanWorker::running(), scan_worker_, selected_source_path_, and update_selected_results_state().

Referenced by build_headerbar(), on_scan_completed(), and update_source_state().

update_selected_results_state()

void MainWindow::update_selected_results_state ( )

private

Definition at line 1261 of file main_window.cpp.

                                               {
    const auto selected = selected_result_indices().size();
    size_t total = 0;
    for (const auto& r : last_report_.results) {
        if (r.kind == ResultKind::Info || r.kind == ResultKind::Warning || r.kind == ResultKind::Error) continue;
        ++total;
    }
    std::ostringstream ss;
    ss << trs("Selected items: ") << selected;
    if (total > 0) ss << " / " << total;
    results_selected_label_.set_text(ss.str());
    btn_recover_now_.set_sensitive(!selected_source_path_.empty() && !output_dir_.empty() && !last_report_.results.empty() && selected > 0 && !recovery_worker_.running());
}

References btn_recover_now_, Error, Info, last_report_, output_dir_, recovery_worker_, ScanReport::results, results_selected_label_, RecoveryWorker::running(), selected_result_indices(), selected_source_path_, trs(), and Warning.

Referenced by on_language_changed(), on_recovery_completed(), populate_scan_results(), set_all_results_selected(), and update_action_controls().

update_source_state()

void MainWindow::update_source_state ( )

private

Definition at line 743 of file main_window.cpp.

                                     {
    if (selected_source_path_.empty()) {
        source_card_label_.set_text(tr("No source selected"));
        scan_step_label_.set_text(tr("Run a read-only scan before exporting recovered data. Non si garantisce il recupero totale dei file."));
        recover_step_label_.set_text(tr("Export detected volumes, filesystem-level recoveries, and carved files. Non si garantisce il recupero totale dei file."));
        update_action_controls();
        return;
    }
 
    std::ostringstream ss;
    ss << trs("Source selected:\n") << selected_source_label_ << "\nPath: " << selected_source_path_;
 
    if (!PrivilegeUtils::can_read_source(selected_source_path_) && !PrivilegeUtils::is_running_as_root())
        ss << trs("\nAccess: needs elevation");
    else
        ss << trs("\nAccess: ready");
 
    source_card_label_.set_text(ss.str());
 
    std::ostringstream scan_msg;
    scan_msg << trs("Current source:\n") << selected_source_label_
    << trs("\n\nRun a read-only scan before continuing.");
    scan_step_label_.set_text(scan_msg.str());
 
    std::ostringstream rec_msg;
    rec_msg << trs("Destination: ")
            << (output_dir_.empty() ? std::string(trs("not selected")) : output_dir_)
            << trs("\nSource: ") << selected_source_label_
            << trs("\n\nBrowse the recovery tree, keep all items selected or choose only the branches you want, then click \"Start recovery\".");
    recover_step_label_.set_text(rec_msg.str());
    update_action_controls();
}

References PrivilegeUtils::can_read_source(), PrivilegeUtils::is_running_as_root(), output_dir_, recover_step_label_, scan_step_label_, selected_source_label_, selected_source_path_, source_card_label_, tr(), trs(), and update_action_controls().

Referenced by activate_sidebar_button(), on_choose_destination(), and select_source().

update_statusbar()

void MainWindow.update_statusbar ( )

inlineprivate

Definition at line 1320 of file MainWindow.vala.

                                    {
        App.repo.check_status();
        string message     = App.repo.status_message;
        string details     = App.repo.status_details;
        int    status_code = App.repo.status_code;
 
        switch (status_code) {
            case SnapshotLocationStatus.HAS_SNAPSHOTS_HAS_SPACE:
                img_shield.set_from_pixbuf(IconManager.lookup(
                    IconManager.SHIELD_HIGH, 48));
                break;
            case SnapshotLocationStatus.NO_SNAPSHOTS_HAS_SPACE:
            case SnapshotLocationStatus.HAS_SNAPSHOTS_NO_SPACE:
                img_shield.set_from_pixbuf(IconManager.lookup(
                    IconManager.SHIELD_MED, 48));
                break;
            default:
                img_shield.set_from_pixbuf(IconManager.lookup(
                    IconManager.SHIELD_LOW, 48));
                break;
        }
 
        lbl_status_title.set_text(message);
 
        // Evita duplicazione con le card laterali
        switch (status_code) {
            case SnapshotLocationStatus.HAS_SNAPSHOTS_HAS_SPACE:
                lbl_status_detail.set_text(_("Repository available and ready"));
                break;
 
            case SnapshotLocationStatus.NO_SNAPSHOTS_HAS_SPACE:
                lbl_status_detail.set_text(_("No snapshots yet"));
                break;
 
            case SnapshotLocationStatus.HAS_SNAPSHOTS_NO_SPACE:
                lbl_status_detail.set_text(_("Low free space on backup device"));
                break;
 
            default:
                lbl_status_detail.set_text(details);
                break;
        }
 
        lbl_snap_count.set_text("%d".printf(App.repo.snapshots.size));
 
        if ((App.repo != null) && (App.repo.device != null)) {
            lbl_free_space.set_text(format_file_size(App.repo.device.free_bytes));
            lbl_device_name.set_text(App.repo.device.device);
        } else {
            lbl_free_space.set_text("—");
            lbl_device_name.set_text("");
        }
    }

References _, App, SnapshotRepo.check_status(), Device.device, SnapshotRepo.device, TeeJee.FileSystem.format_file_size(), Device.free_bytes, img_shield, lbl_device_name, lbl_free_space, lbl_snap_count, lbl_status_detail, lbl_status_title, IconManager.lookup(), Main.repo, IconManager.SHIELD_HIGH, IconManager.SHIELD_LOW, IconManager.SHIELD_MED, SnapshotRepo.snapshots, SnapshotRepo.status_code, SnapshotRepo.status_details, and SnapshotRepo.status_message.

Referenced by refresh_all().

update_theme_buttons() [1/2]

void MainWindow.update_theme_buttons ( )

inlineprivate

Definition at line 488 of file MainWindow.vala.

                                        {
        if (btn_theme_light == null || btn_theme_dark == null)
            return;
 
        var light_btn = btn_theme_light;
        var dark_btn  = btn_theme_dark;
 
        if (dark_mode) {
            dark_btn.get_style_context().add_class("active-sidebar-button");
            light_btn.get_style_context().remove_class("active-sidebar-button");
        }
        else {
            light_btn.get_style_context().add_class("active-sidebar-button");
            dark_btn.get_style_context().remove_class("active-sidebar-button");
        }
    }

References btn_theme_dark, btn_theme_light, and dark_mode.

Referenced by apply_theme(), init_sidebar(), load_css(), and MainWindow().

update_theme_buttons() [2/2]

void MainWindow::update_theme_buttons ( )

private

update_wizard_step()

void MainWindow::update_wizard_step ( )

private

Definition at line 776 of file main_window.cpp.

                                    {
    btn_wizard_back_.set_sensitive(current_step_ != WizardStep::Source);
 
    switch (current_step_) {
        case WizardStep::Source:
            wizard_stack_.set_visible_child(source_step_box_);
            btn_wizard_next_.set_sensitive(!selected_source_path_.empty());
            break;
        case WizardStep::Destination:
            wizard_stack_.set_visible_child(destination_step_box_);
            btn_wizard_next_.set_sensitive(!output_dir_.empty());
            break;
        case WizardStep::Scan:
            wizard_stack_.set_visible_child(scan_step_box_);
            btn_wizard_next_.set_sensitive(!last_report_.results.empty());
            break;
        case WizardStep::Recover:
            wizard_stack_.set_visible_child(recover_step_box_);
            btn_wizard_next_.set_sensitive(false);
            break;
    }
}

References btn_wizard_back_, btn_wizard_next_, current_step_, Destination, destination_step_box_, last_report_, output_dir_, Recover, recover_step_box_, ScanReport::results, Scan, scan_step_box_, selected_source_path_, Source, source_step_box_, and wizard_stack_.

Referenced by activate_sidebar_button(), on_choose_destination(), on_dashboard_device_activated(), on_open_image(), on_scan_completed(), on_use_selected_device(), on_wizard_back(), and on_wizard_next().

view_snapshot_log()

void MainWindow.view_snapshot_log ( bool view_restore_log )

inline

Definition at line 1229 of file MainWindow.vala.

                                                         {
        var selected = snapshot_list_box.selected_snapshots();
        if (selected.size == 0) {
            gtk_messagebox(_("Select Snapshot"), _("Please select a snapshot"), this, false);
            return;
        }
        var bak = selected[0];
        string log_file = view_restore_log ? bak.rsync_restore_log_file : bak.rsync_log_file;
        if (file_exists(log_file) || file_exists(log_file + "-changes")) {
            open_rsync_log_page(log_file);
        }
    }

References _, TeeJee.FileSystem.file_exists(), open_rsync_log_page(), SnapshotListBox.selected_snapshots(), and snapshot_list_box.

Referenced by init_snapshots_page().

Member Data Documentation

about_button_

Gtk::Button* MainWindow::about_button_ = nullptr

private

Definition at line 116 of file main_window.hpp.

Referenced by build_sidebar(), and on_sidebar_about().

about_page_ [1/2]

AboutPage MainWindow::about_page_

private

Definition at line 68 of file MainWindow.hpp.

Referenced by build_about_page(), MainWindow(), and on_sidebar_about().

about_page_ [2/2]

Gtk::Box MainWindow::about_page_ {Gtk::Orientation::VERTICAL, 24}

private

Definition at line 92 of file main_window.hpp.

about_page_widget

Gtk.? Widget MainWindow.about_page_widget = null

private

Definition at line 33 of file MainWindow.vala.

Referenced by init_about_page().

anti_ransomware_page_

AntiRansomwarePage* MainWindow::anti_ransomware_page_ = nullptr

private

Definition at line 84 of file MainWindow.hpp.

Referenced by MainWindow().

backup_page_

BackupPage* MainWindow::backup_page_ = nullptr

private

Definition at line 89 of file MainWindow.hpp.

Referenced by MainWindow().

backup_page_widget

Gtk.? Widget MainWindow.backup_page_widget = null

private

Definition at line 34 of file MainWindow.vala.

Referenced by open_backup_flow().

bank_page_

BankPage* MainWindow::bank_page_ = nullptr

private

Definition at line 76 of file MainWindow.hpp.

Referenced by MainWindow().

brand_label_

Gtk::Label MainWindow::brand_label_

private

Definition at line 107 of file main_window.hpp.

Referenced by build_sidebar().

btn_about_

Gtk::Button MainWindow::btn_about_

private

Definition at line 110 of file main_window.hpp.

Referenced by build_sidebar().

btn_backup

Gtk.Button MainWindow.btn_backup

private

Definition at line 71 of file MainWindow.vala.

Referenced by init_snapshots_page().

btn_browse_snapshot

Gtk.Button MainWindow.btn_browse_snapshot

private

Definition at line 74 of file MainWindow.vala.

Referenced by init_snapshots_page().

btn_choose_destination_

Gtk::Button MainWindow::btn_choose_destination_

private

Definition at line 147 of file main_window.hpp.

Referenced by build_wizard().

btn_dashboard_

Gtk::Button MainWindow::btn_dashboard_

private

Definition at line 108 of file main_window.hpp.

Referenced by build_sidebar().

btn_delete_snapshot

Gtk.Button MainWindow.btn_delete_snapshot

private

Definition at line 73 of file MainWindow.vala.

Referenced by init_snapshots_page().

btn_launch_elevated_

Gtk::Button MainWindow::btn_launch_elevated_

private

Definition at line 139 of file main_window.hpp.

Referenced by build_wizard().

btn_nav_about

Gtk.Button MainWindow.btn_nav_about

private

Definition at line 43 of file MainWindow.vala.

Referenced by init_sidebar().

btn_nav_settings

Gtk.Button MainWindow.btn_nav_settings

private

Definition at line 41 of file MainWindow.vala.

Referenced by init_sidebar().

btn_nav_snapshots

Gtk.Button MainWindow.btn_nav_snapshots

private

Definition at line 40 of file MainWindow.vala.

Referenced by init_sidebar(), MainWindow(), and show_snapshots_page().

btn_nav_wizard

Gtk.Button MainWindow.btn_nav_wizard

private

Definition at line 42 of file MainWindow.vala.

Referenced by init_sidebar().

btn_open_image_

Gtk::Button MainWindow::btn_open_image_

private

Definition at line 137 of file main_window.hpp.

Referenced by build_wizard().

btn_recover_now_

Gtk::Button MainWindow::btn_recover_now_

private

Definition at line 166 of file main_window.hpp.

Referenced by build_wizard(), on_recover_now(), and update_selected_results_state().

btn_recovery_

Gtk::Button MainWindow::btn_recovery_

private

Definition at line 109 of file main_window.hpp.

Referenced by build_sidebar().

btn_refresh_

Gtk::Button MainWindow::btn_refresh_

private

Definition at line 111 of file main_window.hpp.

Referenced by build_sidebar().

btn_restore

Gtk.Button MainWindow.btn_restore

private

Definition at line 72 of file MainWindow.vala.

Referenced by init_snapshots_page().

btn_results_clear_

Gtk::Button MainWindow::btn_results_clear_

private

Definition at line 165 of file main_window.hpp.

Referenced by build_wizard(), and update_action_controls().

btn_results_select_all_

Gtk::Button MainWindow::btn_results_select_all_

private

Definition at line 164 of file main_window.hpp.

Referenced by build_wizard(), and update_action_controls().

btn_scan_now_

Gtk::Button MainWindow::btn_scan_now_

private

Definition at line 154 of file main_window.hpp.

Referenced by build_wizard(), on_scan_completed(), on_scan_now(), and update_action_controls().

btn_theme_dark

Gtk.? Button MainWindow.btn_theme_dark = null

private

Definition at line 50 of file MainWindow.vala.

Referenced by init_sidebar(), and update_theme_buttons().

btn_theme_dark_

Gtk::Button MainWindow::btn_theme_dark_

private

Definition at line 112 of file main_window.hpp.

Referenced by build_sidebar().

btn_theme_light

Gtk.? Button MainWindow.btn_theme_light = null

private

Definition at line 49 of file MainWindow.vala.

Referenced by init_sidebar(), and update_theme_buttons().

btn_theme_light_

Gtk::Button MainWindow::btn_theme_light_

private

Definition at line 113 of file main_window.hpp.

Referenced by build_sidebar().

btn_use_selected_device_

Gtk::Button MainWindow::btn_use_selected_device_

private

Definition at line 138 of file main_window.hpp.

Referenced by build_wizard().

btn_wizard_back_

Gtk::Button MainWindow::btn_wizard_back_

private

Definition at line 130 of file main_window.hpp.

Referenced by build_wizard(), and update_wizard_step().

btn_wizard_next_

Gtk::Button MainWindow::btn_wizard_next_

private

Definition at line 131 of file main_window.hpp.

Referenced by build_wizard(), and update_wizard_step().

card_source_

Gtk::Frame MainWindow::card_source_

private

Definition at line 97 of file main_window.hpp.

Referenced by build_dashboard().

card_status_

Gtk::Frame MainWindow::card_status_

private

Definition at line 96 of file main_window.hpp.

Referenced by build_dashboard().

card_update_

Gtk::Frame MainWindow::card_update_

private

Definition at line 98 of file main_window.hpp.

Referenced by build_dashboard().

cards_grid_

Gtk::Grid MainWindow::cards_grid_

private

Definition at line 95 of file main_window.hpp.

Referenced by build_dashboard().

clamdConfig_

ClamdConfig MainWindow::clamdConfig_

private

Definition at line 73 of file MainWindow.hpp.

Referenced by MainWindow(), and open_settings_window().

compact_window_height

int MainWindow.compact_window_height = 520

private

Definition at line 101 of file MainWindow.vala.

Referenced by apply_window_mode_for_page(), and remember_compact_window_size().

compact_window_width

int MainWindow.compact_window_width = 980

private

Definition at line 100 of file MainWindow.vala.

Referenced by apply_window_mode_for_page(), and remember_compact_window_size().

content_stack

Gtk.Stack MainWindow.content_stack

private

Definition at line 30 of file MainWindow.vala.

Referenced by activate_nav(), btn_about_clicked(), btn_settings_clicked(), btn_wizard_clicked(), init_about_page(), init_content(), init_settings_page(), init_snapshots_page(), init_wizard_page(), and set_dynamic_page().

css_provider

Gtk.? CssProvider MainWindow.css_provider = null

private

Definition at line 47 of file MainWindow.vala.

Referenced by load_css().

css_provider_

Glib::RefPtr<Gtk::CssProvider> MainWindow::css_provider_

private

Definition at line 84 of file main_window.hpp.

Referenced by apply_theme().

current_lang

string MainWindow.current_lang = "en_US"

private

Definition at line 58 of file MainWindow.vala.

Referenced by init_sidebar(), MainWindow(), and on_language_changed().

current_nav_btn

Gtk.? Button MainWindow.current_nav_btn = null

private

Definition at line 44 of file MainWindow.vala.

Referenced by activate_nav().

current_step_

WizardStep MainWindow::current_step_ = WizardStep::Source

private

Definition at line 82 of file main_window.hpp.

Referenced by on_dashboard_device_activated(), on_scan_completed(), on_wizard_back(), on_wizard_next(), and update_wizard_step().

current_theme_

ThemeMode MainWindow::current_theme_ = ThemeMode::Dark

private

Definition at line 81 of file main_window.hpp.

Referenced by apply_theme(), on_theme_dark(), and on_theme_light().

dark_mode

bool MainWindow.dark_mode = false

private

Definition at line 48 of file MainWindow.vala.

Referenced by load_css(), MainWindow(), and update_theme_buttons().

dashboard_button_

Gtk::Button * MainWindow::dashboard_button_ = nullptr

private

Definition at line 93 of file MainWindow.hpp.

Referenced by build_sidebar(), build_sidebar(), MainWindow(), on_sidebar_dashboard(), and showDashboard().

dashboard_page_ [1/2]

DashboardPage MainWindow::dashboard_page_

private

Definition at line 70 of file MainWindow.hpp.

Referenced by build_dashboard(), MainWindow(), on_sidebar_dashboard(), and showDashboard().

dashboard_page_ [2/2]

Gtk::Box MainWindow::dashboard_page_ {Gtk::Orientation::VERTICAL, 16}

private

Definition at line 90 of file main_window.hpp.

def_height

int MainWindow.def_height = -1

private

Definition at line 99 of file MainWindow.vala.

def_width

int MainWindow.def_width = 500

private

Definition at line 98 of file MainWindow.vala.

delete_page_widget

Gtk.? Widget MainWindow.delete_page_widget = null

private

Definition at line 36 of file MainWindow.vala.

Referenced by open_delete_flow().

destination_button_row_

Gtk::Box MainWindow::destination_button_row_ {Gtk::Orientation::HORIZONTAL, 8}

private

Definition at line 145 of file main_window.hpp.

Referenced by build_wizard().

destination_step_box_

Gtk::Box MainWindow::destination_step_box_ {Gtk::Orientation::VERTICAL, 8}

private

Definition at line 143 of file main_window.hpp.

Referenced by build_wizard(), and update_wizard_step().

destination_step_label_

Gtk::Label MainWindow::destination_step_label_

private

Definition at line 144 of file main_window.hpp.

Referenced by build_wizard().

devices_

std::vector<DeviceInfo> MainWindow::devices_

private

Definition at line 175 of file main_window.hpp.

Referenced by on_dashboard_device_activated(), on_use_selected_device(), populate_device_lists(), refresh_devices(), and select_source().

devices_frame_

Gtk::Frame MainWindow::devices_frame_

private

Definition at line 103 of file main_window.hpp.

Referenced by build_dashboard().

devices_list_

Gtk::ListBox MainWindow::devices_list_

private

Definition at line 105 of file main_window.hpp.

Referenced by build_dashboard(), populate_device_lists(), and select_source().

devices_scroller_

Gtk::ScrolledWindow MainWindow::devices_scroller_

private

Definition at line 104 of file main_window.hpp.

Referenced by build_dashboard().

donate_page_

DonatePage MainWindow::donate_page_

private

Definition at line 69 of file MainWindow.hpp.

Referenced by MainWindow().

embedded_settings

SettingsWindow? MainWindow.embedded_settings = null

private

Definition at line 82 of file MainWindow.vala.

Referenced by init_settings_page(), and reload_themed_icons().

embedded_wizard

SetupWizardWindow? MainWindow.embedded_wizard = null

private

Definition at line 83 of file MainWindow.vala.

Referenced by init_wizard_page(), and reload_themed_icons().

entry_output_

Gtk::Entry MainWindow::entry_output_

private

Definition at line 146 of file main_window.hpp.

Referenced by build_wizard(), and on_choose_destination().

file_dialog_

Glib::RefPtr<Gtk::FileDialog> MainWindow::file_dialog_

private

Definition at line 172 of file main_window.hpp.

Referenced by on_open_image().

folder_dialog_

Glib::RefPtr<Gtk::FileDialog> MainWindow::folder_dialog_

private

Definition at line 173 of file main_window.hpp.

Referenced by on_choose_destination().

hbox_root

Gtk.Box MainWindow.hbox_root

private

Definition at line 28 of file MainWindow.vala.

Referenced by init_content(), init_sidebar(), and MainWindow().

identity_leak_page_

IdentityLeakPage* MainWindow::identity_leak_page_ = nullptr

private

Definition at line 87 of file MainWindow.hpp.

Referenced by MainWindow().

img_shield

Gtk.Image MainWindow.img_shield

private

Definition at line 89 of file MainWindow.vala.

Referenced by init_snapshots_page(), and update_statusbar().

lang_changing_

bool MainWindow::lang_changing_ = false

private

Definition at line 120 of file main_window.hpp.

LANG_CODES

string [] MainWindow.LANG_CODES

staticprivate

Initial value:

                             = {
    "en_US", "ar_SA", "de_DE", "es_ES", "fr_FR",
    "it_IT", "ja_JP", "nl_NL", "pl_PL", "pt_PT", "ru_RU"
}

Definition at line 61 of file MainWindow.vala.

Referenced by init_sidebar(), load_language_preference(), and on_language_changed().

lang_combo

Gtk.? ComboBoxText MainWindow.lang_combo = null

private

Definition at line 57 of file MainWindow.vala.

Referenced by init_sidebar(), and on_language_changed().

lang_combo_

Gtk::DropDown MainWindow::lang_combo_

private

Definition at line 119 of file main_window.hpp.

Referenced by build_sidebar().

LANG_CONFIG_FILE

const string MainWindow.LANG_CONFIG_FILE = "/etc/bastionguard-backup/language.json"

staticprivate

Definition at line 54 of file MainWindow.vala.

Referenced by load_language_preference(), and save_language_preference().

LANG_NAMES

string [] MainWindow.LANG_NAMES

staticprivate

Initial value:

                             = {
    "English", "\u0627\u0644\u0639\u0631\u0628\u064a\u0629", "Deutsch", "Espa\u00f1ol", "Fran\u00e7ais",
    "Italiano", "\u65e5\u672c\u8a9e", "Nederlands", "Polski", "Portugu\u00eas", "\u0420\u0443\u0441\u0441\u043a\u0438\u0439"
}

Definition at line 65 of file MainWindow.vala.

Referenced by init_sidebar().

last_report_

ScanReport MainWindow::last_report_

private

Definition at line 179 of file main_window.hpp.

Referenced by on_recover_now(), on_scan_completed(), on_wizard_next(), select_source(), selected_result_indices(), set_all_results_selected(), update_action_controls(), update_selected_results_state(), and update_wizard_step().

last_scan_progress_

ScanProgress MainWindow::last_scan_progress_

private

Definition at line 186 of file main_window.hpp.

Referenced by on_scan_now(), and on_scan_progress().

lbl_device_name

Gtk.Label MainWindow.lbl_device_name

private

Definition at line 94 of file MainWindow.vala.

Referenced by init_snapshots_page(), and update_statusbar().

lbl_free_space

Gtk.Label MainWindow.lbl_free_space

private

Definition at line 93 of file MainWindow.vala.

Referenced by init_snapshots_page(), and update_statusbar().

lbl_snap_count

Gtk.Label MainWindow.lbl_snap_count

private

Definition at line 92 of file MainWindow.vala.

Referenced by init_snapshots_page(), and update_statusbar().

lbl_status_detail

Gtk.Label MainWindow.lbl_status_detail

private

Definition at line 91 of file MainWindow.vala.

Referenced by init_snapshots_page(), and update_statusbar().

lbl_status_title

Gtk.Label MainWindow.lbl_status_title

private

Definition at line 90 of file MainWindow.vala.

Referenced by init_snapshots_page(), and update_statusbar().

log_buffer_

Glib::RefPtr<Gtk::TextBuffer> MainWindow::log_buffer_

private

Definition at line 170 of file main_window.hpp.

Referenced by append_log().

log_page_

LogPage MainWindow::log_page_

private

Definition at line 72 of file MainWindow.hpp.

Referenced by MainWindow().

log_scroller_

Gtk::ScrolledWindow MainWindow::log_scroller_

private

Definition at line 168 of file main_window.hpp.

Referenced by build_recovery_page().

log_view_

Gtk::TextView MainWindow::log_view_

private

Definition at line 169 of file main_window.hpp.

Referenced by build_recovery_page().

m_aboutPage

AboutPage MainWindow::m_aboutPage

private

Definition at line 48 of file MainWindow.hpp.

m_activeButton

Gtk::Button* MainWindow::m_activeButton = nullptr

private

Definition at line 69 of file MainWindow.hpp.

Referenced by activateSidebarButton().

m_alertDialog

std::unique_ptr<AlertDialog> MainWindow::m_alertDialog

private

Definition at line 55 of file MainWindow.hpp.

Referenced by onNewConnection().

m_appsPage

AppsPage MainWindow::m_appsPage

private

Definition at line 44 of file MainWindow.hpp.

Referenced by onDaemonAlert(), onNewConnection(), and onVerdict().

m_autostartBackupFile

std::string MainWindow::m_autostartBackupFile

private

Definition at line 90 of file MainWindow.hpp.

Referenced by applyProtectionEnabled(), loadConfig(), refreshSystemIntegrationStatus(), and saveConfig().

m_btnDark

Gtk::Button* MainWindow::m_btnDark = nullptr

private

Definition at line 76 of file MainWindow.hpp.

Referenced by applyTheme(), and buildHeaderBar().

m_btnLight

Gtk::Button* MainWindow::m_btnLight = nullptr

private

Definition at line 75 of file MainWindow.hpp.

Referenced by applyTheme(), and buildHeaderBar().

m_configFile

std::string MainWindow::m_configFile

private

Definition at line 87 of file MainWindow.hpp.

Referenced by applyProtectionEnabled(), loadConfig(), saveConfig(), and showLanguageDialog().

m_connectionsPage

ConnectionsPage MainWindow::m_connectionsPage { m_uiServer }

private

Definition at line 43 of file MainWindow.hpp.

Referenced by onDaemonAlert(), onNewConnection(), onVerdict(), and ~MainWindow().

m_cssProvider

Glib::RefPtr<Gtk::CssProvider> MainWindow::m_cssProvider

private

Definition at line 73 of file MainWindow.hpp.

Referenced by loadTheme().

m_daemonLabel

Gtk::Label* MainWindow::m_daemonLabel = nullptr

private

Definition at line 70 of file MainWindow.hpp.

Referenced by buildSidebar(), onDaemonConnected(), and onDaemonDisconnected().

m_darkMode

bool MainWindow::m_darkMode = false

private

Definition at line 74 of file MainWindow.hpp.

Referenced by applyTheme(), buildHeaderBar(), loadConfig(), and saveConfig().

m_desktopActiveSent

bool MainWindow::m_desktopActiveSent = true

private

Definition at line 96 of file MainWindow.hpp.

Referenced by onDaemonConnected(), and sendDesktopActivityState().

m_desktopActivityTimer

guint MainWindow::m_desktopActivityTimer = 0

private

Definition at line 95 of file MainWindow.hpp.

Referenced by startDesktopActivityMonitor(), and ~MainWindow().

m_langDialog

std::unique_ptr<LanguageDialog> MainWindow::m_langDialog

private

Definition at line 58 of file MainWindow.hpp.

Referenced by showLanguageDialog().

m_language

std::string MainWindow::m_language

private

Definition at line 88 of file MainWindow.hpp.

Referenced by loadConfig(), saveConfig(), and showLanguageDialog().

m_lastUiActivity

std::chrono::steady_clock::time_point MainWindow::m_lastUiActivity {}

private

Definition at line 97 of file MainWindow.hpp.

Referenced by noteDesktopActivity(), and startDesktopActivityMonitor().

m_mainBox

Gtk::Box MainWindow::m_mainBox { Gtk::Orientation::HORIZONTAL, 0 }

private

Definition at line 36 of file MainWindow.hpp.

Referenced by buildSidebar().

m_networkPage

NetworkPage MainWindow::m_networkPage

private

Definition at line 45 of file MainWindow.hpp.

Referenced by onDaemonAlert(), onNewConnection(), onVerdict(), and ~MainWindow().

m_protectionEnabled

bool MainWindow::m_protectionEnabled = true

private

Definition at line 89 of file MainWindow.hpp.

Referenced by applyProtectionEnabled(), loadConfig(), refreshSystemIntegrationStatus(), and saveConfig().

m_rulesPage

RulesPage MainWindow::m_rulesPage

private

Definition at line 46 of file MainWindow.hpp.

m_settingsPage

SettingsPage MainWindow::m_settingsPage

private

Definition at line 49 of file MainWindow.hpp.

Referenced by applyProtectionEnabled(), and refreshSystemIntegrationStatus().

m_sidebarButtons

std::vector<Gtk::Button*> MainWindow::m_sidebarButtons

private

Definition at line 68 of file MainWindow.hpp.

Referenced by activateSidebarButton(), and makeSidebarButton().

m_stack

Gtk::Stack MainWindow::m_stack

private

Definition at line 37 of file MainWindow.hpp.

Referenced by makeSidebarButton().

m_statAllowed

uint64_t MainWindow::m_statAllowed = 0

private

Definition at line 83 of file MainWindow.hpp.

Referenced by onDaemonAlert(), onNewConnection(), and onVerdict().

m_statDenied

uint64_t MainWindow::m_statDenied = 0

private

Definition at line 84 of file MainWindow.hpp.

Referenced by onDaemonAlert(), onNewConnection(), and onVerdict().

m_statsPage

StatsPage MainWindow::m_statsPage

private

Definition at line 47 of file MainWindow.hpp.

Referenced by onDaemonAlert(), onNewConnection(), and onVerdict().

m_statusbar

Gtk::Statusbar MainWindow::m_statusbar

private

Definition at line 79 of file MainWindow.hpp.

Referenced by setStatus().

m_statusCtx

guint MainWindow::m_statusCtx = 0

private

Definition at line 80 of file MainWindow.hpp.

Referenced by setStatus().

m_tray

TrayIcon MainWindow::m_tray

private

Definition at line 52 of file MainWindow.hpp.

Referenced by onDaemonAlert(), onDaemonConnected(), onDaemonDisconnected(), and ~MainWindow().

m_uiServer

UIServer MainWindow::m_uiServer

private

Definition at line 40 of file MainWindow.hpp.

Referenced by onNewConnection(), onVerdict(), sendDesktopActivityState(), and ~MainWindow().

m_verdictCache

std::map<std::string, ReplyAction> MainWindow::m_verdictCache

private

Definition at line 62 of file MainWindow.hpp.

Referenced by onNewConnection(), and onVerdict().

main_box_

Gtk::Box MainWindow::main_box_ {Gtk::Orientation::HORIZONTAL, 0}

private

Definition at line 86 of file main_window.hpp.

mainBox

Gtk::Box MainWindow::mainBox {Gtk::Orientation::HORIZONTAL}

private

Definition at line 64 of file MainWindow.hpp.

Referenced by build_sidebar(), and MainWindow().

output_dir_

std::string MainWindow::output_dir_

private

Definition at line 178 of file main_window.hpp.

Referenced by on_choose_destination(), on_recover_now(), on_wizard_next(), populate_scan_results(), update_selected_results_state(), update_source_state(), and update_wizard_step().

page_stack_

Gtk::Stack MainWindow::page_stack_

private

Definition at line 87 of file main_window.hpp.

Referenced by on_sidebar_about(), on_sidebar_dashboard(), and on_sidebar_recovery().

password_manager_page_

PasswordManagerPage* MainWindow::password_manager_page_ = nullptr

private

Definition at line 88 of file MainWindow.hpp.

Referenced by MainWindow().

phishing_page_

PhishingPage* MainWindow::phishing_page_ = nullptr

private

Definition at line 79 of file MainWindow.hpp.

Referenced by MainWindow().

privacy_page_

PrivacyPage* MainWindow::privacy_page_

private

Definition at line 82 of file MainWindow.hpp.

Referenced by MainWindow().

quarantine_page_

QuarantinePage MainWindow::quarantine_page_

private

Definition at line 78 of file MainWindow.hpp.

Referenced by MainWindow().

recover_step_box_

Gtk::Box MainWindow::recover_step_box_ {Gtk::Orientation::VERTICAL, 8}

private

Definition at line 156 of file main_window.hpp.

Referenced by build_wizard(), and update_wizard_step().

recover_step_label_

Gtk::Label MainWindow::recover_step_label_

private

Definition at line 157 of file main_window.hpp.

Referenced by build_wizard(), populate_scan_results(), and update_source_state().

recovery_button_

Gtk::Button* MainWindow::recovery_button_ = nullptr

private

Definition at line 115 of file main_window.hpp.

Referenced by build_sidebar(), and on_sidebar_recovery().

recovery_devices_list_

Gtk::ListBox MainWindow::recovery_devices_list_

private

Definition at line 141 of file main_window.hpp.

Referenced by build_wizard(), on_recovery_device_activated(), on_use_selected_device(), populate_device_lists(), and select_source().

recovery_devices_scroller_

Gtk::ScrolledWindow MainWindow::recovery_devices_scroller_

private

Definition at line 140 of file main_window.hpp.

Referenced by build_wizard().

recovery_header_

Gtk::Box MainWindow::recovery_header_ {Gtk::Orientation::VERTICAL, 8}

private

Definition at line 122 of file main_window.hpp.

Referenced by build_recovery_page().

recovery_page_

Gtk::Box MainWindow::recovery_page_ {Gtk::Orientation::VERTICAL, 16}

private

Definition at line 91 of file main_window.hpp.

Referenced by build_recovery_page(), and on_sidebar_recovery().

recovery_subtitle_

Gtk::Label MainWindow::recovery_subtitle_

private

Definition at line 124 of file main_window.hpp.

Referenced by build_recovery_page().

recovery_title_

Gtk::Label MainWindow::recovery_title_

private

Definition at line 123 of file main_window.hpp.

Referenced by build_recovery_page().

recovery_worker_

RecoveryWorker MainWindow::recovery_worker_

private

Definition at line 184 of file main_window.hpp.

Referenced by on_recover_now(), and update_selected_results_state().

restore_page_widget

Gtk.? Widget MainWindow.restore_page_widget = null

private

Definition at line 35 of file MainWindow.vala.

Referenced by open_restore_flow().

result_check_buttons_

std::vector<Gtk::CheckButton*> MainWindow::result_check_buttons_

private

Definition at line 181 of file main_window.hpp.

Referenced by populate_scan_results(), and set_all_results_selected().

result_selection_

std::vector<bool> MainWindow::result_selection_

private

Definition at line 180 of file main_window.hpp.

Referenced by populate_scan_results(), selected_result_indices(), and set_all_results_selected().

results_actions_row_

Gtk::Box MainWindow::results_actions_row_ {Gtk::Orientation::HORIZONTAL, 8}

private

Definition at line 163 of file main_window.hpp.

Referenced by build_wizard().

results_count_label_

Gtk::Label MainWindow::results_count_label_

private

Definition at line 161 of file main_window.hpp.

Referenced by build_wizard(), and populate_scan_results().

results_frame_

Gtk::Frame MainWindow::results_frame_

private

Definition at line 158 of file main_window.hpp.

Referenced by build_wizard().

results_scroller_

Gtk::ScrolledWindow MainWindow::results_scroller_

private

Definition at line 159 of file main_window.hpp.

Referenced by build_wizard().

results_selected_label_

Gtk::Label MainWindow::results_selected_label_

private

Definition at line 162 of file main_window.hpp.

Referenced by build_wizard(), and update_selected_results_state().

results_tree_box_

Gtk::Box MainWindow::results_tree_box_ {Gtk::Orientation::VERTICAL, 8}

private

Definition at line 160 of file main_window.hpp.

Referenced by build_wizard(), and populate_scan_results().

rootguard_page_

RootGuardPage* MainWindow::rootguard_page_ = nullptr

private

Definition at line 83 of file MainWindow.hpp.

Referenced by MainWindow().

rsync_log_page_widget

Gtk.? Widget MainWindow.rsync_log_page_widget = null

private

Definition at line 37 of file MainWindow.vala.

Referenced by open_rsync_log_page().

samba_page_

SambaPage* MainWindow::samba_page_ = nullptr

private

Definition at line 86 of file MainWindow.hpp.

Referenced by MainWindow().

scan_page_

ScanPage MainWindow::scan_page_ {*this}

private

Definition at line 71 of file MainWindow.hpp.

Referenced by MainWindow().

scan_progress_bar_

Gtk::ProgressBar MainWindow::scan_progress_bar_

private

Definition at line 151 of file main_window.hpp.

Referenced by build_wizard(), on_scan_completed(), on_scan_now(), and on_scan_progress().

scan_started_at_

std::chrono::steady_clock::time_point MainWindow::scan_started_at_ {}

private

Definition at line 188 of file main_window.hpp.

Referenced by on_scan_completed(), and on_scan_now().

scan_status_label_

Gtk::Label MainWindow::scan_status_label_

private

Definition at line 152 of file main_window.hpp.

Referenced by build_wizard(), on_scan_completed(), on_scan_now(), and on_scan_progress().

scan_step_box_

Gtk::Box MainWindow::scan_step_box_ {Gtk::Orientation::VERTICAL, 8}

private

Definition at line 149 of file main_window.hpp.

Referenced by build_wizard(), and update_wizard_step().

scan_step_label_

Gtk::Label MainWindow::scan_step_label_

private

Definition at line 150 of file main_window.hpp.

Referenced by build_wizard(), and update_source_state().

scan_timer_connection_

sigc::connection MainWindow::scan_timer_connection_

private

Definition at line 187 of file main_window.hpp.

Referenced by on_scan_completed(), and on_scan_now().

scan_timer_label_

Gtk::Label MainWindow::scan_timer_label_

private

Definition at line 153 of file main_window.hpp.

Referenced by build_wizard(), on_scan_completed(), and on_scan_now().

scan_worker_

ScanWorker MainWindow::scan_worker_

private

Definition at line 183 of file main_window.hpp.

Referenced by on_scan_now(), and update_action_controls().

selected_source_label_

std::string MainWindow::selected_source_label_

private

Definition at line 177 of file main_window.hpp.

Referenced by populate_scan_results(), select_source(), and update_source_state().

selected_source_path_

std::string MainWindow::selected_source_path_

private

Definition at line 176 of file main_window.hpp.

Referenced by on_scan_now(), on_wizard_next(), populate_device_lists(), select_source(), update_action_controls(), update_selected_results_state(), update_source_state(), and update_wizard_step().

settings_page_widget

Gtk.? Widget MainWindow.settings_page_widget = null

private

Definition at line 31 of file MainWindow.vala.

Referenced by init_settings_page().

settings_window_

SettingsWindow* MainWindow::settings_window_ = nullptr

private

Definition at line 74 of file MainWindow.hpp.

Referenced by open_settings_window().

sidebar_

Gtk::Box MainWindow::sidebar_ {Gtk::Orientation::VERTICAL, 10}

private

Definition at line 89 of file main_window.hpp.

Referenced by build_sidebar().

sidebar_buttons_

std::vector< Gtk::Button * > MainWindow::sidebar_buttons_

private

Definition at line 66 of file MainWindow.hpp.

Referenced by activate_sidebar_button(), build_sidebar(), and build_sidebar().

snapshot_list_box

SnapshotListBox MainWindow.snapshot_list_box

private

Definition at line 86 of file MainWindow.vala.

Referenced by browse_selected(), delete_selected(), init_snapshots_page(), mark_selected(), refresh_all(), restore(), and view_snapshot_log().

source_button_row_

Gtk::Box MainWindow::source_button_row_ {Gtk::Orientation::HORIZONTAL, 8}

private

Definition at line 136 of file main_window.hpp.

Referenced by build_wizard().

source_card_label_

Gtk::Label MainWindow::source_card_label_

private

Definition at line 100 of file main_window.hpp.

Referenced by build_dashboard(), and update_source_state().

source_step_box_

Gtk::Box MainWindow::source_step_box_ {Gtk::Orientation::VERTICAL, 8}

private

Definition at line 134 of file main_window.hpp.

Referenced by build_wizard(), and update_wizard_step().

source_step_label_

Gtk::Label MainWindow::source_step_label_

private

Definition at line 135 of file main_window.hpp.

Referenced by build_wizard().

stack_

Gtk::Stack MainWindow::stack_

private

Definition at line 65 of file MainWindow.hpp.

Referenced by build_sidebar(), MainWindow(), and showDashboard().

status_card_label_

Gtk::Label MainWindow::status_card_label_

private

Definition at line 99 of file main_window.hpp.

Referenced by build_dashboard().

THEME_CONFIG_DIR

const string MainWindow.THEME_CONFIG_DIR = "/etc/bastionguard-backup"

staticprivate

Definition at line 52 of file MainWindow.vala.

Referenced by save_language_preference(), and save_theme_preference().

THEME_CONFIG_FILE

const string MainWindow.THEME_CONFIG_FILE = "/etc/bastionguard-backup/theme.json"

staticprivate

Definition at line 53 of file MainWindow.vala.

Referenced by load_theme_preference(), and save_theme_preference().

themed_img_list

Gee.ArrayList<Gtk.Image> MainWindow.themed_img_list = new Gee.ArrayList<Gtk.Image>()

private

Definition at line 77 of file MainWindow.vala.

Referenced by reload_themed_icons(), and themed_icon().

themed_img_name

Gee.ArrayList<string> MainWindow.themed_img_name = new Gee.ArrayList<string>()

private

Definition at line 78 of file MainWindow.vala.

Referenced by reload_themed_icons(), and themed_icon().

themed_img_size

Gee.ArrayList<int> MainWindow.themed_img_size = new Gee.ArrayList<int>()

private

Definition at line 79 of file MainWindow.vala.

Referenced by reload_themed_icons(), and themed_icon().

tmr_init

uint MainWindow.tmr_init

private

Definition at line 97 of file MainWindow.vala.

Referenced by init_delayed(), and MainWindow().

update_card_label_

Gtk::Label MainWindow::update_card_label_

private

Definition at line 101 of file main_window.hpp.

Referenced by build_dashboard(), and refresh_devices().

update_page_

UpdatePage MainWindow::update_page_

private

Definition at line 81 of file MainWindow.hpp.

Referenced by MainWindow().

usb_page_

USBScanPage* MainWindow::usb_page_ = nullptr

private

Definition at line 85 of file MainWindow.hpp.

Referenced by MainWindow().

vbox_sidebar

Gtk.Box MainWindow.vbox_sidebar

private

Definition at line 29 of file MainWindow.vala.

Referenced by init_sidebar(), and make_nav_btn().

vpn_page_

VpnPage* MainWindow::vpn_page_ = nullptr

private

Definition at line 80 of file MainWindow.hpp.

Referenced by MainWindow().

window_in_expanded_mode

bool MainWindow.window_in_expanded_mode = false

private

Definition at line 102 of file MainWindow.vala.

Referenced by apply_window_mode_for_page(), and remember_compact_window_size().

wizard_frame_

Gtk::Frame MainWindow::wizard_frame_

private

Definition at line 126 of file main_window.hpp.

Referenced by build_recovery_page(), and build_wizard().

wizard_nav_

Gtk::Box MainWindow::wizard_nav_ {Gtk::Orientation::HORIZONTAL, 8}

private

Definition at line 129 of file main_window.hpp.

Referenced by build_wizard().

wizard_notice_label_

Gtk::Label MainWindow::wizard_notice_label_

private

Definition at line 132 of file main_window.hpp.

Referenced by build_wizard().

wizard_page_widget

Gtk.? Widget MainWindow.wizard_page_widget = null

private

Definition at line 32 of file MainWindow.vala.

Referenced by init_wizard_page().

wizard_root_

Gtk::Box MainWindow::wizard_root_ {Gtk::Orientation::VERTICAL, 12}

private

Definition at line 127 of file main_window.hpp.

Referenced by build_wizard().

wizard_stack_

Gtk::Stack MainWindow::wizard_stack_

private

Definition at line 128 of file main_window.hpp.

Referenced by build_wizard(), and update_wizard_step().

---

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

• BastionGuard/src/MainWindow.hpp
• BastionGuard/thirdparty/bastionguard-backup/src/Gtk/MainWindow.vala
• BastionGuard/thirdparty/bastionguard-recovery-data/src/main_window.hpp
• BastionGuard/thirdparty/bastionguard-secure-connection/ui/src/MainWindow.hpp
• BastionGuard/src/MainWindow.cpp
• BastionGuard/thirdparty/bastionguard-recovery-data/src/main_window.cpp
• BastionGuard/thirdparty/bastionguard-secure-connection/ui/src/MainWindow.cpp