NetworkPage Class Reference

#include <NetworkPage.hpp>

Inheritance diagram for NetworkPage:

Classes
struct	Pin
struct	Columns

Public Member Functions
	NetworkPage ()
	~NetworkPage () override
void	noteConnection (const ConnectionInfo &info)
void	clear ()
void	saveLog () const
void	loadLog ()
void	drawConnectionArcs (cairo_t *cr, int width, int height)

Static Public Member Functions
static std::string	logPath ()

Private Member Functions
void	buildUI ()
void	buildMapWidget ()
void	rebuildMapMarkers ()
GtkWidget *	createMarkerWidget (const Pin &pin)
GtkWidget *	createSelfMarkerWidget ()
GtkWidget *	createHoverCard ()
void	showHoverCard (const std::string &country_code, const std::string &country_name, const std::string &city, const std::string &ip, const std::string &host, const std::string &app_name, const std::string &isp, uint32_t hits)
void	hideHoverCard ()
void	maybeRecenterMap (const std::vector< Pin > &pins)
void	onGeoResolved ()
void	updateSummary ()
void	updateRow (const Pin &pin)
void	noteUserViewportInteraction ()
bool	shouldHoldUserViewport () const
void	requestSelfLocation ()
void	triggerFxRedraw ()

Private Attributes
Columns	m_columns
Glib::RefPtr< Gtk::ListStore >	m_store
Gtk::TreeView	m_treeView
Gtk::ScrolledWindow	m_scroll
Gtk::Box	m_mapHost {Gtk::Orientation::VERTICAL, 0}
Gtk::Label	m_headerLabel
Gtk::Label	m_summaryLabel
Gtk::Button	m_clearBtn
GtkWidget *	m_simpleMap {nullptr}
ShumateViewport *	m_viewport {nullptr}
ShumateMarkerLayer *	m_markerLayer {nullptr}
GtkWidget *	m_mapOverlay {nullptr}
GtkWidget *	m_hoverCard {nullptr}
GtkWidget *	m_hoverCardTitle {nullptr}
GtkWidget *	m_hoverCardBody {nullptr}
guint	m_hoverHideSource {0}
std::chrono::steady_clock::time_point	m_lastUserViewportInteraction {}
double	m_selfLat {0.0}
double	m_selfLon {0.0}
bool	m_selfResolved {false}
GtkWidget *	m_mapFxArea {nullptr}
guint	m_pulseTimerId {0}
int	m_pulseFrame {0}
std::mutex	m_mu
std::unordered_map< std::string, Pin >	m_pins
std::unordered_map< std::string, Gtk::TreeModel::iterator >	m_rows
Glib::Dispatcher	m_geoDispatcher
std::mutex	m_pendingMu
std::vector< std::pair< std::string, bsc::ui_util::GeoEntry > >	m_pendingGeo

Static Private Attributes
static constexpr int64_t	kRetentionSeconds = 7 * 24 * 3600

Detailed Description

Pagina Rete.

Mostra una mappa reale basata su libshumate/OpenStreetMap con un marker per ogni IP contattato. La geolocalizzazione arriva da GeoResolver, mentre il rendering geografico e l'allineamento li gestisce libshumate.

Definition at line 28 of file NetworkPage.hpp.

Constructor & Destructor Documentation

NetworkPage()

NetworkPage::NetworkPage

(

)

Definition at line 177 of file NetworkPage.cpp.

: Gtk::Box(Gtk::Orientation::VERTICAL, 0)
{
    get_style_context()->add_class("bsc-page");
    get_style_context()->add_class("bsc-network-page");
 
    buildUI();
 
    m_geoDispatcher.connect([this]() { onGeoResolved(); });
 
    bsc::ui_util::GeoResolver::instance().on_resolved(
        [this](const std::string& ip, const bsc::ui_util::GeoEntry& e) {
            {
                std::lock_guard lk(m_pendingMu);
                m_pendingGeo.emplace_back(ip, e);
            }
            m_geoDispatcher.emit();
        });
 
    // Richiedi la posizione del PC in background. Il risultato arrivera'
    // via onGeoResolved() con ip="__self__".
    requestSelfLocation();
 
    // Pulse timer per animazioni (marker self + puntini destinazione +
    // cleanup pin stale). 66 ms = ~15 Hz: fluido per animazioni lente,
    // leggero sulla CPU.
    //
    // NOTA: niente cleanup periodico di pin "stale" — nella v3 l'utente
    // vuole vedere TUTTI i pin raccolti durante la sessione (e anche
    // quelli delle sessioni precedenti, fino a 7 giorni). La vecchia
    // finestra 30 s era troppo aggressiva.
    m_pulseTimerId = g_timeout_add(66, +[](gpointer data) -> gboolean {
        auto* self = static_cast<NetworkPage*>(data);
        self->m_pulseFrame = (self->m_pulseFrame + 1) % 10000;
        self->triggerFxRedraw();
        return G_SOURCE_CONTINUE;
    }, this);
}

References buildUI(), bsc::ui_util::GeoResolver::instance(), m_geoDispatcher, m_pendingGeo, m_pendingMu, m_pulseTimerId, NetworkPage(), bsc::ui_util::GeoResolver::on_resolved(), onGeoResolved(), and requestSelfLocation().

Referenced by buildMapWidget(), createMarkerWidget(), and NetworkPage().

~NetworkPage()

NetworkPage::~NetworkPage ( )

override

Definition at line 216 of file NetworkPage.cpp.

{
    if (m_pulseTimerId != 0) {
        g_source_remove(m_pulseTimerId);
        m_pulseTimerId = 0;
    }
 
    m_markerLayer = nullptr;
    m_viewport = nullptr;
    m_simpleMap = nullptr;
    m_mapFxArea = nullptr;
    m_mapOverlay = nullptr;
    m_hoverCard = nullptr;
    m_hoverCardTitle = nullptr;
    m_hoverCardBody = nullptr;
 
    if (m_hoverHideSource != 0) {
        g_source_remove(m_hoverHideSource);
        m_hoverHideSource = 0;
    }
}

References m_hoverCard, m_hoverCardBody, m_hoverCardTitle, m_hoverHideSource, m_mapFxArea, m_mapOverlay, m_markerLayer, m_pulseTimerId, m_simpleMap, and m_viewport.

Member Function Documentation

buildMapWidget()

void NetworkPage::buildMapWidget ( )

private

Definition at line 397 of file NetworkPage.cpp.

{
    m_mapOverlay = gtk_overlay_new();
 
    m_simpleMap = GTK_WIDGET(shumate_simple_map_new());
    m_viewport = shumate_simple_map_get_viewport(SHUMATE_SIMPLE_MAP(m_simpleMap));
    m_markerLayer = shumate_marker_layer_new(m_viewport);
 
    auto* registry = shumate_map_source_registry_new();
    if (registry != nullptr) {
        shumate_map_source_registry_populate_defaults(registry);
 
        auto* source =
        SHUMATE_MAP_SOURCE(g_list_model_get_object(G_LIST_MODEL(registry), 0));
        if (source != nullptr) {
            shumate_simple_map_set_map_source(SHUMATE_SIMPLE_MAP(m_simpleMap), source);
            g_object_unref(source);
        }
        g_object_unref(registry);
    }
 
    shumate_simple_map_set_show_zoom_buttons(SHUMATE_SIMPLE_MAP(m_simpleMap), TRUE);
    shumate_simple_map_add_overlay_layer(
        SHUMATE_SIMPLE_MAP(m_simpleMap),
                                         SHUMATE_LAYER(m_markerLayer));
 
    shumate_viewport_set_min_zoom_level(m_viewport, kMinZoom);
    shumate_viewport_set_max_zoom_level(m_viewport, kMaxZoom);
    shumate_location_set_location(SHUMATE_LOCATION(m_viewport), kDefaultLat, kDefaultLon);
    shumate_viewport_set_zoom_level(m_viewport, kDefaultZoom);
 
    gtk_widget_set_focusable(m_simpleMap, TRUE);
    gtk_widget_set_hexpand(m_simpleMap, TRUE);
    gtk_widget_set_vexpand(m_simpleMap, FALSE);
    gtk_widget_set_size_request(m_simpleMap, 720, 475);
    gtk_widget_add_css_class(m_simpleMap, "bsc-map-widget");
 
    gtk_overlay_set_child(GTK_OVERLAY(m_mapOverlay), m_simpleMap);
 
    // Zoom con rotella/trackpad del mouse. Il controller e' agganciato
    // all'overlay in fase CAPTURE, non solo al widget Shumate: cosi' funziona
    // anche quando il cursore e' sopra marker, hover-card o overlay grafico.
    auto* zoom_scroll = gtk_event_controller_scroll_new(
        static_cast<GtkEventControllerScrollFlags>(
            GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES | GTK_EVENT_CONTROLLER_SCROLL_DISCRETE));
    gtk_event_controller_set_propagation_phase(
        GTK_EVENT_CONTROLLER(zoom_scroll), GTK_PHASE_CAPTURE);
    g_signal_connect(
        zoom_scroll,
        "scroll",
        G_CALLBACK(+[](GtkEventControllerScroll*, double dx, double dy, gpointer data) -> gboolean {
            auto* self = static_cast<NetworkPage*>(data);
            if (!self->m_viewport) return GDK_EVENT_PROPAGATE;
            const double delta = (std::abs(dy) >= std::abs(dx)) ? dy : dx;
            if (delta == 0.0) return GDK_EVENT_PROPAGATE;
 
            self->noteUserViewportInteraction();
 
            double zoom = shumate_viewport_get_zoom_level(self->m_viewport);
            const double step = std::abs(delta) < 1.0 ? 0.25 : 0.45;
            zoom += (delta < 0.0) ? step : -step;
            zoom = std::clamp(zoom, kMinZoom, kMaxZoom);
            shumate_viewport_set_zoom_level(self->m_viewport, zoom);
            self->triggerFxRedraw();
            return GDK_EVENT_STOP;
        }),
        this
    );
    gtk_widget_add_controller(m_mapOverlay, GTK_EVENT_CONTROLLER(zoom_scroll));
 
    m_mapFxArea = gtk_drawing_area_new();
    gtk_widget_set_hexpand(m_mapFxArea, TRUE);
    gtk_widget_set_vexpand(m_mapFxArea, TRUE);
    gtk_widget_set_can_target(m_mapFxArea, FALSE);
    // Passiamo `this` come user_data cosi' map_fx_draw puo' accedere ai pin.
    gtk_drawing_area_set_draw_func(GTK_DRAWING_AREA(m_mapFxArea),
                                   map_fx_draw, this, nullptr);
    gtk_overlay_add_overlay(GTK_OVERLAY(m_mapOverlay), m_mapFxArea);
 
    m_hoverCard = createHoverCard();
    gtk_overlay_add_overlay(GTK_OVERLAY(m_mapOverlay), m_hoverCard);
 
    gtk_widget_set_focusable(m_mapOverlay, TRUE);
    gtk_widget_set_hexpand(m_mapOverlay, TRUE);
    gtk_widget_set_vexpand(m_mapOverlay, FALSE);
    gtk_widget_set_size_request(m_mapOverlay, 720, 475);
 
    gtk_box_append(GTK_BOX(m_mapHost.gobj()), m_mapOverlay);
}

References createHoverCard(), m_hoverCard, m_mapFxArea, m_mapHost, m_mapOverlay, m_markerLayer, m_simpleMap, m_viewport, and NetworkPage().

Referenced by buildUI().

buildUI()

void NetworkPage::buildUI ( )

private

Definition at line 238 of file NetworkPage.cpp.

{
    set_margin_start(12);
    set_margin_end(12);
    set_margin_top(12);
    set_margin_bottom(12);
 
    auto header = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
    header->get_style_context()->add_class("bsc-page-header");
 
    m_headerLabel.set_markup("<b>" + Glib::ustring(_("Monitor di rete")) + "</b>");
    m_headerLabel.set_halign(Gtk::Align::START);
    m_headerLabel.get_style_context()->add_class("bsc-page-title");
    header->append(m_headerLabel);
 
    m_summaryLabel.set_halign(Gtk::Align::START);
    m_summaryLabel.set_hexpand(true);
    m_summaryLabel.get_style_context()->add_class("bsc-page-subtitle");
    m_summaryLabel.set_margin_start(12);
    header->append(m_summaryLabel);
 
    m_clearBtn.set_label(_("Pulisci"));
    m_clearBtn.get_style_context()->add_class("bsc-toolbar-button");
    m_clearBtn.signal_clicked().connect([this]() { clear(); });
    header->append(m_clearBtn);
 
    append(*header);
 
    m_mapHost.set_hexpand(true);
    m_mapHost.set_vexpand(false);
    m_mapHost.set_margin_top(8);
    m_mapHost.set_margin_bottom(8);
    m_mapHost.set_size_request(-1, 475);
    m_mapHost.get_style_context()->add_class("bsc-map");
    buildMapWidget();
    append(m_mapHost);
 
    m_store = Gtk::ListStore::create(m_columns);
    m_treeView.set_model(m_store);
    m_treeView.set_headers_visible(true);
    m_treeView.set_hexpand(true);
    m_treeView.set_vexpand(true);
    m_treeView.get_style_context()->add_class("bsc-treeview");
    m_treeView.get_style_context()->add_class("bsc-network-treeview");
 
    m_treeView.append_column(_("Paese"),   m_columns.col_country);
    m_treeView.append_column(_("Città"),   m_columns.col_city);
    m_treeView.append_column(_("IP"),      m_columns.col_ip);
    m_treeView.append_column(_("Host"),    m_columns.col_host);
    m_treeView.append_column(_("App"),     m_columns.col_app);
    m_treeView.append_column(_("ISP/AS"),  m_columns.col_isp);
    m_treeView.append_column(_("Hit"),     m_columns.col_hits);
 
    for (guint i = 0; i < m_treeView.get_n_columns(); ++i) {
        if (auto* c = m_treeView.get_column(i)) {
            c->set_resizable(true);
            c->set_reorderable(false);
        }
    }
 
    m_scroll.set_child(m_treeView);
    m_scroll.set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
    m_scroll.set_hexpand(true);
    m_scroll.set_vexpand(true);
    m_scroll.get_style_context()->add_class("bsc-scrolled");
    append(m_scroll);
 
    updateSummary();
}

References _, buildMapWidget(), clear(), NetworkPage::Columns::col_app, NetworkPage::Columns::col_city, NetworkPage::Columns::col_country, NetworkPage::Columns::col_hits, NetworkPage::Columns::col_host, NetworkPage::Columns::col_ip, NetworkPage::Columns::col_isp, m_clearBtn, m_columns, m_headerLabel, m_mapHost, m_scroll, m_store, m_summaryLabel, m_treeView, and updateSummary().

Referenced by NetworkPage().

clear()

void NetworkPage::clear

(

)

Pulisci la visualizzazione.

Definition at line 1105 of file NetworkPage.cpp.

{
    {
        std::lock_guard lk(m_mu);
        m_pins.clear();
        m_rows.clear();
    }
 
    m_store->clear();
    rebuildMapMarkers();
    updateSummary();
 
    // Cancella anche il log persistente: "Pulisci" e' un reset completo.
    std::error_code ec;
    std::filesystem::remove(logPath(), ec);
}

References logPath(), m_mu, m_pins, m_rows, m_store, rebuildMapMarkers(), and updateSummary().

Referenced by buildUI().

createHoverCard()

GtkWidget * NetworkPage::createHoverCard ( )

private

Definition at line 308 of file NetworkPage.cpp.

{
    auto* frame = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
    gtk_widget_add_css_class(frame, "bsc-network-popover");
    gtk_widget_set_size_request(frame, 320, -1);
    gtk_widget_set_halign(frame, GTK_ALIGN_START);
    gtk_widget_set_valign(frame, GTK_ALIGN_START);
    gtk_widget_set_margin_start(frame, 28);
    gtk_widget_set_margin_top(frame, 28);
    gtk_widget_set_visible(frame, FALSE);
    gtk_widget_set_can_target(frame, FALSE);
 
    m_hoverCardTitle = gtk_label_new(nullptr);
    gtk_widget_add_css_class(m_hoverCardTitle, "bsc-network-popover-title");
    gtk_label_set_xalign(GTK_LABEL(m_hoverCardTitle), 0.0f);
    gtk_widget_set_can_target(m_hoverCardTitle, FALSE);
    gtk_box_append(GTK_BOX(frame), m_hoverCardTitle);
 
    m_hoverCardBody = gtk_label_new(nullptr);
    gtk_widget_add_css_class(m_hoverCardBody, "bsc-network-popover-meta");
    gtk_label_set_xalign(GTK_LABEL(m_hoverCardBody), 0.0f);
    gtk_label_set_wrap(GTK_LABEL(m_hoverCardBody), TRUE);
    gtk_widget_set_can_target(m_hoverCardBody, FALSE);
    gtk_box_append(GTK_BOX(frame), m_hoverCardBody);
 
    return frame;
}

References m_hoverCardBody, and m_hoverCardTitle.

Referenced by buildMapWidget().

createMarkerWidget()

GtkWidget * NetworkPage::createMarkerWidget ( const Pin & pin )

private

Definition at line 487 of file NetworkPage.cpp.

{
    auto* marker = shumate_marker_new();
 
    // ── Ancoraggio del marker ────────────────────────────────────────
    // Problema visto nelle screenshot utente: il cerchio rosso della
    // destinazione risultava disegnato sopra la posizione reale (dove
    // arriva l'arco arancione), creando un gap di ~20-30 px.
    //
    // Causa: il vecchio layout usava un Gtk::Box verticale [badge, dot]
    // ancorato via valign=END sulla coordinata. Ma Shumate centra il
    // widget sulla coordinata (non allinea il bordo), quindi il BOX
    // veniva centrato e il cerchio — che era META' in basso del box —
    // finiva sotto la coordinata, mentre il badge — meta' sopra —
    // finiva sopra. Risultato: i due elementi stavano AI LATI della
    // coordinata, con l'arco che puntava al punto medio tra i due.
    //
    // Fix: usiamo Gtk::Overlay col cerchio come widget base CENTRATO
    // (cosi' il suo centro coincide con la coordinata geografica), e
    // il badge paese come OVERLAY posizionato con margin-bottom positivo
    // per galleggiare sopra il cerchio senza spostarlo.
    auto* overlay = gtk_overlay_new();
    auto* dot = create_animated_dot_widget(pin.hits);
    gtk_widget_set_halign(dot, GTK_ALIGN_CENTER);
    gtk_widget_set_valign(dot, GTK_ALIGN_CENTER);
    gtk_overlay_set_child(GTK_OVERLAY(overlay), dot);
 
    if (!pin.country_code.empty()) {
        auto* badge = gtk_label_new(pin.country_code.c_str());
        gtk_widget_add_css_class(badge, "caption");
        gtk_widget_add_css_class(badge, "numeric");
        gtk_widget_add_css_class(badge, "bsc-network-marker-badge");
        gtk_widget_set_opacity(badge, 0.94);
 
        // Badge galleggia SOPRA il cerchio, sfalsato a destra cosi' non
        // lo copre. Con halign=START e valign=START + margin, il badge
        // si posiziona in alto-sinistra dentro l'overlay, ma sopra il
        // cerchio (dimensione overlay = dimensione cerchio centrato).
        // Per uscire dai bounds del cerchio e mostrarsi sopra/a lato,
        // usiamo margin negativi — GTK lo permette sugli overlay child.
        gtk_widget_set_halign(badge, GTK_ALIGN_CENTER);
        gtk_widget_set_valign(badge, GTK_ALIGN_START);
        gtk_widget_set_margin_top(badge, -18);
        gtk_overlay_add_overlay(GTK_OVERLAY(overlay), badge);
    }
 
    auto* payload = new HoverPayload{};
    payload->self = this;
    payload->ip = pin.ip;
    payload->host = pin.host;
    payload->app_name = pin.app_name;
    payload->country_code = pin.country_code;
    payload->country_name = pin.country_name;
    payload->city = pin.city;
    payload->isp = pin.isp;
    payload->hits = pin.hits;
 
    auto* motion = gtk_event_controller_motion_new();
 
    g_signal_connect_data(
        motion,
        "enter",
        G_CALLBACK(+[](GtkEventControllerMotion*, double, double, gpointer data) {
            auto* payload = static_cast<HoverPayload*>(data);
            payload->self->showHoverCard(
                payload->country_code,
                payload->country_name,
                payload->city,
                payload->ip,
                payload->host,
                payload->app_name,
                payload->isp,
                payload->hits
            );
        }),
        payload,
        hover_payload_destroy,
        G_CONNECT_DEFAULT
    );
 
    g_signal_connect(
        motion,
        "leave",
        G_CALLBACK(+[](GtkEventControllerMotion*, gpointer data) {
            static_cast<NetworkPage*>(data)->hideHoverCard();
        }),
        this
    );
 
    gtk_widget_add_controller(overlay, GTK_EVENT_CONTROLLER(motion));
 
    shumate_marker_set_child(marker, overlay);
    // valign CENTER (era END): con CENTER il widget viene centrato verticalmente
    // sulla coordinata. Combinato col cerchio centrato dentro l'overlay, il
    // CENTRO del cerchio coincide ora con la coordinata geografica esatta —
    // e quindi con il punto di arrivo dell'arco arancione.
    gtk_widget_set_halign(GTK_WIDGET(marker), GTK_ALIGN_CENTER);
    gtk_widget_set_valign(GTK_WIDGET(marker), GTK_ALIGN_CENTER);
    shumate_marker_set_selectable(marker, FALSE);
    shumate_location_set_location(SHUMATE_LOCATION(marker), pin.lat, pin.lon);
 
    return GTK_WIDGET(marker);
}

References NetworkPage::Pin::app_name, NetworkPage::Pin::city, NetworkPage::Pin::country_code, NetworkPage::Pin::country_name, hideHoverCard(), NetworkPage::Pin::hits, NetworkPage::Pin::host, NetworkPage::Pin::ip, NetworkPage::Pin::isp, NetworkPage::Pin::lat, NetworkPage::Pin::lon, and NetworkPage().

Referenced by rebuildMapMarkers().

createSelfMarkerWidget()

GtkWidget * NetworkPage::createSelfMarkerWidget ( )

private

Definition at line 932 of file NetworkPage.cpp.

{
    // Marker del PC locale: cerchio blu con pulse esterno.
    // Usa shumate_marker come contenitore e un Gtk::DrawingArea custom
    // per disegnare un cerchio blu con alone che pulsa.
    //
    // Questo marker e' l'ANCORA visiva della mappa — deve restare sempre
    // ben riconoscibile sotto qualunque sovrapposizione. Dimensioni e
    // colori scelti per massima visibilita' anche a zoom alti dove i
    // marker destinazione si addensano.
    auto* marker = shumate_marker_new();
    auto* area   = gtk_drawing_area_new();
 
    // Dimensione fissa — il "blob" occupa 32×32 px, piu' grande dei marker
    // destinazione (tipicamente 16-20 px). Il pulse si espande fino a 14 px
    // di raggio esterno.
    gtk_widget_set_size_request(area, 32, 32);
 
    gtk_drawing_area_set_draw_func(
        GTK_DRAWING_AREA(area),
        +[](GtkDrawingArea*, cairo_t* cr, int w, int h, gpointer) {
            const double cx = w * 0.5;
            const double cy = h * 0.5;
 
            // Pulse sinusoidale 0..1 con periodo 2 secondi
            const gint64 us = g_get_monotonic_time();
            const double t  = (us % 2000000) / 2000000.0;
            const double pulse = 0.5 * (1.0 - std::cos(t * 2.0 * M_PI));
 
            // Alone pulsante (blu molto trasparente, si espande)
            const double ring_r = 10.0 + pulse * 6.0;
            const double ring_a = 0.45 * (1.0 - pulse);
            cairo_set_source_rgba(cr, 0.20, 0.60, 1.0, ring_a);
            cairo_arc(cr, cx, cy, ring_r, 0.0, 2.0 * M_PI);
            cairo_fill(cr);
 
            // Drop shadow: cerchio nero sfumato sotto, per staccare dal
            // fondo della mappa (mare/terra mischiati).
            cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.35);
            cairo_arc(cr, cx, cy + 1.0, 9.0, 0.0, 2.0 * M_PI);
            cairo_fill(cr);
 
            // Anello bianco esterno (bordo di contrasto)
            cairo_set_source_rgba(cr, 1.0, 1.0, 1.0, 1.0);
            cairo_arc(cr, cx, cy, 9.0, 0.0, 2.0 * M_PI);
            cairo_fill(cr);
 
            // Cerchio pieno blu centrale (il vero marker)
            cairo_set_source_rgba(cr, 0.15, 0.50, 1.0, 1.0);
            cairo_arc(cr, cx, cy, 7.0, 0.0, 2.0 * M_PI);
            cairo_fill(cr);
 
            // Riflesso bianco in alto a sinistra — tocco 3D discreto
            cairo_set_source_rgba(cr, 1.0, 1.0, 1.0, 0.55);
            cairo_arc(cr, cx - 2.0, cy - 2.0, 2.2, 0.0, 2.0 * M_PI);
            cairo_fill(cr);
        },
        nullptr, nullptr);
 
    shumate_marker_set_child(SHUMATE_MARKER(marker), area);
    shumate_location_set_location(SHUMATE_LOCATION(marker),
                                  m_selfLat, m_selfLon);
    return GTK_WIDGET(marker);
}

References m_selfLat, and m_selfLon.

Referenced by rebuildMapMarkers().

drawConnectionArcs()

void NetworkPage::drawConnectionArcs	(	cairo_t *	cr,
		int	width,
		int	height )

Disegna gli archi attivi dalla posizione locale verso ogni pin attualmente aperto, piu' il puntino lampeggiante sul marker destinazione. Chiamato dall'overlay DrawingArea — pubblico perche' deve essere invocabile da una free function C-callback.

Definition at line 997 of file NetworkPage.cpp.

{
    if (!m_viewport || !m_selfResolved) return;
    if (width <= 0 || height <= 0) return;
 
    // Converte lat/lon del PC in pixel sul widget mappa.
    // NOTA: le coordinate sono relative a m_simpleMap (widget sotto);
    // l'overlay DrawingArea ha la stessa geometria — stesso sistema.
    double sx = 0.0, sy = 0.0;
    shumate_viewport_location_to_widget_coords(
        m_viewport, m_simpleMap,
        m_selfLat, m_selfLon, &sx, &sy);
 
    // Origine fuori dalla mappa visibile: non abbiamo un punto di partenza
    // valido, skippiamo tutti gli archi (altrimenti partirebbero dal bordo
    // in modo misterioso — come nella screenshot dell'utente: freccia che
    // scende "dal nulla"). Stesso criterio dei target.
    const bool self_visible =
        sx >= 0 && sx <= width && sy >= 0 && sy <= height;
 
    // Snapshot di TUTTI i pin sulla mappa (non solo gli ultimi 30 s).
    // L'utente ha chiesto di vedere tutto lo storico — al limite sparisce
    // solo oltre i 7 giorni via retention al loadLog().
    struct Arc { double tx, ty; bool visible; uint32_t hits; };
    std::vector<Arc> arcs;
    {
        std::lock_guard lk(m_mu);
        arcs.reserve(m_pins.size());
        for (const auto& [ip, p] : m_pins) {
            if (!p.geo_resolved) continue;
            // Salta pin con lat/lon degenere (geoip fallita o "Locale")
            if (p.lat == 0.0 && p.lon == 0.0) continue;
            double tx = 0.0, ty = 0.0;
            shumate_viewport_location_to_widget_coords(
                m_viewport, m_simpleMap, p.lat, p.lon, &tx, &ty);
            // Visibilita' STRETTA: il target deve essere COMPLETAMENTE dentro
            // il viewport. Nessun margin: un arco che "esce" dalla mappa
            // senza mostrare il puntino di arrivo e' confuso per l'utente.
            const bool visible =
                tx >= 0 && tx <= width &&
                ty >= 0 && ty <= height;
            arcs.push_back({tx, ty, visible, p.hits});
        }
    }
 
    // Pulse per i puntini destinazione (stessa fase per tutti — piu'
    // pulito visivamente di un pulse sfasato).
    const gint64 us = g_get_monotonic_time();
    const double t = (us % 1400000) / 1400000.0;   // periodo 1.4s
    const double pulse = 0.5 * (1.0 - std::cos(t * 2.0 * M_PI));
 
    cairo_save(cr);
 
    // Disegna ogni arco: linea curva dal PC al target, poi puntino lampeggiante.
    // Richiede entrambi i punti visibili, altrimenti l'arco "mozzato" al bordo
    // e' peggio di nessun arco.
    for (const auto& a : arcs) {
        if (!a.visible || !self_visible) continue;
 
        // Se origine e destinazione sono praticamente coincidenti (stessa
        // citta' / stesso data center) niente arco — sarebbe un cerchietto
        // illeggibile. Il puntino destinazione si vede comunque grazie al
        // marker arancione di Shumate.
        const double dx_ = a.tx - sx;
        const double dy_ = a.ty - sy;
        const double dist = std::sqrt(dx_ * dx_ + dy_ * dy_);
        if (dist < 8.0) continue;
 
        // Linea dritta con lieve curvatura ascendente (effetto "arco").
        // Il control point e' a meta' strada, spostato perpendicolarmente
        // al segmento per dare profondita'.
        const double mx = (sx + a.tx) * 0.5;
        const double my = (sy + a.ty) * 0.5;
        // Normale perpendicolare al segmento, normalizzata
        const double nx = -dy_ / dist;
        const double ny =  dx_ / dist;
        const double curve = std::min(60.0, dist * 0.18);
        const double cx = mx + nx * curve;
        const double cy = my + ny * curve;
 
        // Colore linea: arancione morbido con opacita' che cresce con hit count
        const double alpha = std::clamp(0.35 + 0.05 * std::log1p(a.hits), 0.35, 0.80);
        cairo_set_source_rgba(cr, 1.0, 0.60, 0.22, alpha);
        cairo_set_line_width(cr, 1.5);
        cairo_move_to(cr, sx, sy);
        cairo_curve_to(cr, cx, cy, cx, cy, a.tx, a.ty);
        cairo_stroke(cr);
 
        // Puntino destinazione lampeggiante (alone + cerchio pieno)
        const double ring_r = 5.0 + pulse * 5.0;
        const double ring_a = 0.55 * (1.0 - pulse);
        cairo_set_source_rgba(cr, 1.0, 0.60, 0.22, ring_a);
        cairo_arc(cr, a.tx, a.ty, ring_r, 0.0, 2.0 * M_PI);
        cairo_fill(cr);
 
        cairo_set_source_rgba(cr, 1.0, 0.70, 0.30, 1.0);
        cairo_arc(cr, a.tx, a.ty, 3.5, 0.0, 2.0 * M_PI);
        cairo_fill(cr);
    }
 
    cairo_restore(cr);
}

References m_mu, m_pins, m_selfLat, m_selfLon, m_selfResolved, m_simpleMap, and m_viewport.

Referenced by anonymous_namespace{NetworkPage.cpp}::map_fx_draw().

hideHoverCard()

void NetworkPage::hideHoverCard ( )

private

Definition at line 374 of file NetworkPage.cpp.

{
    if (!m_hoverCard) return;
 
    if (m_hoverHideSource != 0) {
        g_source_remove(m_hoverHideSource);
        m_hoverHideSource = 0;
    }
 
    m_hoverHideSource = g_timeout_add(
        static_cast<guint>(kHoverHideDelay.count()),
        +[](gpointer data) -> gboolean {
            auto* self = static_cast<NetworkPage*>(data);
            self->m_hoverHideSource = 0;
            if (self->m_hoverCard) {
                gtk_widget_set_visible(self->m_hoverCard, FALSE);
            }
            return G_SOURCE_REMOVE;
        },
        this
    );
}

References m_hoverCard, and m_hoverHideSource.

Referenced by createMarkerWidget(), and rebuildMapMarkers().

loadLog()

void NetworkPage::loadLog

(

)

Carica i pin da disco, scartando quelli piu' vecchi di 7 giorni.

Definition at line 1231 of file NetworkPage.cpp.

{
    std::ifstream f(logPath());
    if (!f.is_open()) return;
 
    const int64_t now_epoch   = static_cast<int64_t>(std::time(nullptr));
    const int64_t cutoff      = now_epoch - kRetentionSeconds;
    int loaded = 0, dropped = 0;
 
    std::string line;
    while (std::getline(f, line)) {
        if (line.empty() || line[0] != '{') continue;
 
        const int64_t ts = net_json_field_i64(line, "last_ts");
        // Retention 7 giorni: record piu' vecchi vengono scartati.
        if (ts > 0 && ts < cutoff) { ++dropped; continue; }
 
        Pin p;
        p.ip           = net_json_field_str(line, "ip");
        if (p.ip.empty()) continue;
        p.host         = net_json_field_str(line, "host");
        p.app_name     = net_json_field_str(line, "app");
        p.country_code = net_json_field_str(line, "cc");
        p.country_name = net_json_field_str(line, "country");
        p.city         = net_json_field_str(line, "city");
        p.isp          = net_json_field_str(line, "isp");
        p.lat          = net_json_field_double(line, "lat");
        p.lon          = net_json_field_double(line, "lon");
        p.hits         = static_cast<uint32_t>(net_json_field_i64(line, "hits"));
        p.last_seen_epoch = ts;
        // last_seen (steady_clock) non e' ricostruibile esattamente —
        // lo impostiamo a "adesso meno delta" cosi' le animazioni che
        // usano last_seen non impazziscono. Non piu' usato per culling.
        p.last_seen    = std::chrono::steady_clock::now();
        p.geo_resolved = !(p.lat == 0.0 && p.lon == 0.0);
 
        std::lock_guard lk(m_mu);
        m_pins[p.ip] = p;
        updateRow(m_pins[p.ip]);
        ++loaded;
    }
 
    rebuildMapMarkers();
    updateSummary();
 
    g_message("NetworkPage: caricati %d pin, scartati %d per retention 7gg",
              loaded, dropped);
}

References NetworkPage::Pin::app_name, NetworkPage::Pin::city, NetworkPage::Pin::country_code, NetworkPage::Pin::country_name, NetworkPage::Pin::geo_resolved, NetworkPage::Pin::hits, NetworkPage::Pin::host, NetworkPage::Pin::ip, NetworkPage::Pin::isp, kRetentionSeconds, NetworkPage::Pin::last_seen, NetworkPage::Pin::last_seen_epoch, NetworkPage::Pin::lat, logPath(), NetworkPage::Pin::lon, m_mu, m_pins, rebuildMapMarkers(), updateRow(), and updateSummary().

logPath()

std::string NetworkPage::logPath ( )

static

Path del file persistente (JSONL).

Definition at line 1129 of file NetworkPage.cpp.

{
    return "/tmp/bastionguard-sc-network-" +
           std::to_string(::getuid()) + ".jsonl";
}

Referenced by clear(), loadLog(), and saveLog().

maybeRecenterMap()

void NetworkPage::maybeRecenterMap ( const std::vector< Pin > & pins )

private

Definition at line 591 of file NetworkPage.cpp.

{
    if (m_viewport == nullptr) return;
    if (shouldHoldUserViewport()) return;
 
    // Raccoglie lat/lon di TUTTI i punti che devono essere visibili: pin
    // destinazione validi + la posizione del PC locale (se risolta).
    // Cosi' il fit automatico non nasconde mai il punto blu — era uno
    // dei bug nelle screenshot precedenti dove il marker blu scompariva
    // dietro altri marker o fuori viewport.
    struct LL { double lat, lon; };
    std::vector<LL> all;
    all.reserve(pins.size() + 1);
 
    for (const auto& p : pins) {
        if (p.geo_resolved && !(p.lat == 0.0 && p.lon == 0.0)) {
            all.push_back({p.lat, p.lon});
        }
    }
    if (m_selfResolved && !(m_selfLat == 0.0 && m_selfLon == 0.0)) {
        all.push_back({m_selfLat, m_selfLon});
    }
 
    if (all.empty()) {
        shumate_location_set_location(
            SHUMATE_LOCATION(m_viewport),
                                      kDefaultLat,
                                      kDefaultLon
        );
        shumate_viewport_set_zoom_level(m_viewport, kDefaultZoom);
        return;
    }
 
    double min_lat = all.front().lat;
    double max_lat = all.front().lat;
    double min_lon = all.front().lon;
    double max_lon = all.front().lon;
 
    for (const auto& q : all) {
        min_lat = std::min(min_lat, q.lat);
        max_lat = std::max(max_lat, q.lat);
        min_lon = std::min(min_lon, q.lon);
        max_lon = std::max(max_lon, q.lon);
    }
 
    const double center_lat = (min_lat + max_lat) * 0.5;
    const double center_lon = (min_lon + max_lon) * 0.5;
    const double span = std::max(max_lat - min_lat, max_lon - min_lon);
 
    // Auto-zoom "cluster aware": piu' i pin sono concentrati, piu' zoommiamo.
    // Numeri tarati sullo schermo 720×475 del map widget.
    //
    // Prima della v3 (con finestra 30s) bastava uno zoom basso perche'
    // tipicamente c'erano 2-5 pin sparsi. Ora l'utente accumula
    // connessioni per giorni: uno zoom piu' ravvicinato evidenzia meglio
    // le concentrazioni geografiche (la citta' del PC vs un singolo
    // data center all'estero) senza far sparire il contesto mondiale.
    double zoom;
    if      (span < 0.5)   zoom = 9.0;     // stessa citta'
    else if (span < 2.0)   zoom = 7.0;     // stessa regione
    else if (span < 5.0)   zoom = 6.0;     // paese piccolo
    else if (span < 12.0)  zoom = 5.0;     // paese grande
    else if (span < 25.0)  zoom = 4.2;     // multi-paese
    else if (span < 50.0)  zoom = 3.6;     // continente
    else if (span < 100.0) zoom = 3.0;     // emisfero
    else                   zoom = kDefaultZoom;  // mondo
 
    zoom = std::clamp(zoom, kMinZoom, kMaxZoom);
 
    shumate_location_set_location(
        SHUMATE_LOCATION(m_viewport),
                                  center_lat,
                                  center_lon
    );
    shumate_viewport_set_zoom_level(m_viewport, zoom);
}

References m_selfLat, m_selfLon, m_selfResolved, m_viewport, and shouldHoldUserViewport().

Referenced by rebuildMapMarkers().

noteConnection()

void NetworkPage::noteConnection

(

const ConnectionInfo &

info

)

Registra una connessione per la mappa.

Definition at line 724 of file NetworkPage.cpp.

{
    const std::string& ip = info.dest_ip;
    if (ip.empty()) return;
 
    bool need_geo = false;
    {
        std::lock_guard lk(m_mu);
        const bool safe_local = bsc::ui_util::is_safe_local_connection(info.dest_ip, info.src_ip);
        const std::string conn_app_name = bsc::ui_util::best_connection_display_name(
            info.app_comm, info.app_path, info.app_args, info.dest_ip, info.src_ip);
 
        auto& p = m_pins[ip];
        if (p.ip.empty()) {
            p.ip = ip;
            p.host = info.dest_host.empty() && safe_local
                ? std::string{"Connessione locale sicura"}
                : info.dest_host;
            p.app_name = conn_app_name;
            if (safe_local) {
                p.country_name = "Locale sicuro";
                p.city = "Loopback";
                p.isp = "Sistema locale";
                p.geo_resolved = false;
                need_geo = false;
            } else {
                need_geo = true;
            }
        } else {
            if (!conn_app_name.empty() && p.app_name.find(conn_app_name) == std::string::npos) {
                p.app_name = p.app_name.empty()
                ? conn_app_name
                : conn_app_name + ", " + p.app_name;
            }
            if (p.host.empty() && !info.dest_host.empty())
                p.host = info.dest_host;
        }
 
        ++p.hits;
        p.last_seen = std::chrono::steady_clock::now();
        p.last_seen_epoch = static_cast<int64_t>(std::time(nullptr));
    }
 
    if (need_geo) {
        if (auto geo = bsc::ui_util::GeoResolver::instance().resolve(ip)) {
            std::lock_guard lk(m_mu);
            auto it = m_pins.find(ip);
            if (it != m_pins.end()) {
                it->second.country_code = geo->country_code;
                it->second.country_name = geo->country_name;
                it->second.city = geo->city;
                it->second.isp = geo->isp.empty() ? geo->asn : geo->isp;
                it->second.lat = geo->lat;
                it->second.lon = geo->lon;
                it->second.geo_resolved = true;
            }
        }
    }
 
    {
        std::lock_guard lk(m_mu);
        auto it = m_pins.find(ip);
        if (it != m_pins.end()) {
            updateRow(it->second);
        }
    }
 
    rebuildMapMarkers();
    updateSummary();
 
    // Salvataggio periodico (ogni 20 connessioni) per resistere a crash.
    // Il salvataggio e' fast: tipicamente < 5 ms con <100 pin, ma non
    // vogliamo farlo ad ogni singola connessione.
    static thread_local int save_counter = 0;
    if (++save_counter >= 20) {
        save_counter = 0;
        saveLog();
    }
}

References ConnectionInfo::app_args, ConnectionInfo::app_comm, ConnectionInfo::app_path, bsc::ui_util::best_connection_display_name(), ConnectionInfo::dest_host, ConnectionInfo::dest_ip, bsc::ui_util::GeoResolver::instance(), bsc::ui_util::is_safe_local_connection(), m_mu, m_pins, rebuildMapMarkers(), saveLog(), ConnectionInfo::src_ip, updateRow(), and updateSummary().

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

noteUserViewportInteraction()

void NetworkPage::noteUserViewportInteraction ( )

private

Definition at line 713 of file NetworkPage.cpp.

{
    m_lastUserViewportInteraction = std::chrono::steady_clock::now();
}

References m_lastUserViewportInteraction.

onGeoResolved()

void NetworkPage::onGeoResolved ( )

private

Definition at line 804 of file NetworkPage.cpp.

{
    std::vector<std::pair<std::string, bsc::ui_util::GeoEntry>> pending;
    {
        std::lock_guard lk(m_pendingMu);
        pending.swap(m_pendingGeo);
    }
 
    bool self_updated = false;
    {
        std::lock_guard lk(m_mu);
        for (const auto& [ip, geo] : pending) {
            // Risoluzione speciale: posizione del PC locale.
            if (ip == "__self__") {
                m_selfLat = geo.lat;
                m_selfLon = geo.lon;
                m_selfResolved = true;
                self_updated = true;
                continue;
            }
 
            auto it = m_pins.find(ip);
            if (it == m_pins.end()) continue;
 
            it->second.country_code = geo.country_code;
            it->second.country_name = geo.country_name;
            it->second.city = geo.city;
            it->second.isp = geo.isp.empty() ? geo.asn : geo.isp;
            it->second.lat = geo.lat;
            it->second.lon = geo.lon;
            it->second.geo_resolved = true;
 
            updateRow(it->second);
        }
    }
 
    rebuildMapMarkers();
    updateSummary();
 
    // Se la posizione locale e' appena arrivata, forza anche un redraw
    // degli archi (altrimenti restano invisibili finche' non arriva una
    // nuova connessione).
    if (self_updated) triggerFxRedraw();
}

References m_mu, m_pendingGeo, m_pendingMu, m_pins, m_selfLat, m_selfLon, m_selfResolved, rebuildMapMarkers(), triggerFxRedraw(), updateRow(), and updateSummary().

Referenced by NetworkPage().

rebuildMapMarkers()

void NetworkPage::rebuildMapMarkers ( )

private

Definition at line 668 of file NetworkPage.cpp.

{
    if (m_markerLayer == nullptr) return;
 
    hideHoverCard();
 
    std::vector<Pin> pins_copy;
    {
        std::lock_guard lk(m_mu);
        pins_copy.reserve(m_pins.size());
        for (const auto& [_, p] : m_pins) pins_copy.push_back(p);
    }
 
    std::sort(
        pins_copy.begin(),
              pins_copy.end(),
              [](const Pin& a, const Pin& b) { return a.hits < b.hits; }
    );
 
    shumate_marker_layer_remove_all(m_markerLayer);
 
    // Prima tutti i marker destinazione (arancioni)...
    for (const auto& p : pins_copy) {
        if (!p.geo_resolved || (p.lat == 0.0 && p.lon == 0.0)) continue;
 
        auto* marker_widget = createMarkerWidget(p);
        shumate_marker_layer_add_marker(
            m_markerLayer,
            SHUMATE_MARKER(marker_widget)
        );
    }
 
    // ...poi il marker PC locale per ULTIMO, cosi' sta SOPRA le destinazioni
    // anche quando coincidono spazialmente (es. connessione a localhost
    // o a un server nello stesso paese). Il punto blu e' l'ancora visiva
    // della mappa e non deve mai venire nascosto.
    if (m_selfResolved) {
        auto* self_marker = createSelfMarkerWidget();
        shumate_marker_layer_add_marker(
            m_markerLayer, SHUMATE_MARKER(self_marker));
    }
 
    maybeRecenterMap(pins_copy);
}

References _, createMarkerWidget(), createSelfMarkerWidget(), hideHoverCard(), m_markerLayer, m_mu, m_pins, m_selfResolved, and maybeRecenterMap().

Referenced by clear(), loadLog(), noteConnection(), onGeoResolved(), and requestSelfLocation().

requestSelfLocation()

void NetworkPage::requestSelfLocation ( )

private

Definition at line 917 of file NetworkPage.cpp.

{
    // Tenta subito dalla cache. Se cache miss, il worker di GeoResolver
    // fara' il fetch e chiamera' on_resolved con ip="__self__"; il nostro
    // onGeoResolved() lo riconoscera' e popolera' m_selfLat/Lon.
    if (auto maybe = bsc::ui_util::GeoResolver::instance().resolve_self()) {
        m_selfLat = maybe->lat;
        m_selfLon = maybe->lon;
        m_selfResolved = true;
        rebuildMapMarkers();
    }
    // Altrimenti: il lookup e' in corso. L'aggiornamento arrivera' via
    // onGeoResolved() al completamento.
}

References bsc::ui_util::GeoResolver::instance(), m_selfLat, m_selfLon, m_selfResolved, and rebuildMapMarkers().

Referenced by NetworkPage().

saveLog()

void NetworkPage::saveLog

(

)

const

Salva i pin su disco per retention 7 giorni.

Definition at line 1195 of file NetworkPage.cpp.

{
    std::ofstream f(logPath(), std::ios::trunc);
    if (!f.is_open()) return;
 
    // Snapshot sotto lock per non bloccare la UI durante I/O. m_mu
    // protegge m_pins.
    std::vector<Pin> snapshot;
    {
        std::lock_guard lk(m_mu);
        snapshot.reserve(m_pins.size());
        for (const auto& [ip, p] : m_pins) snapshot.push_back(p);
    }
 
    for (const auto& p : snapshot) {
        // Skippiamo pin non geo-risolti: ricostruirli al prossimo avvio
        // significherebbe rifare le chiamate a ip-api e potrebbe esaurire
        // il rate limit. Se proprio serve verranno riaggiunti alla prima
        // connessione dopo restart.
        if (!p.geo_resolved) continue;
 
        f << "{\"ip\":\""          << net_json_escape(p.ip)           << "\""
          << ",\"host\":\""        << net_json_escape(p.host)         << "\""
          << ",\"app\":\""         << net_json_escape(p.app_name)     << "\""
          << ",\"cc\":\""          << net_json_escape(p.country_code) << "\""
          << ",\"country\":\""     << net_json_escape(p.country_name) << "\""
          << ",\"city\":\""        << net_json_escape(p.city)         << "\""
          << ",\"isp\":\""         << net_json_escape(p.isp)          << "\""
          << ",\"lat\":"           << p.lat
          << ",\"lon\":"           << p.lon
          << ",\"hits\":"          << p.hits
          << ",\"last_ts\":"       << p.last_seen_epoch
          << "}\n";
    }
}

References logPath(), m_mu, and m_pins.

Referenced by noteConnection(), and MainWindow::~MainWindow().

shouldHoldUserViewport()

bool NetworkPage::shouldHoldUserViewport ( ) const

private

Definition at line 718 of file NetworkPage.cpp.

{
    if (m_lastUserViewportInteraction == std::chrono::steady_clock::time_point{}) return false;
    return (std::chrono::steady_clock::now() - m_lastUserViewportInteraction) < kUserViewportHold;
}

References m_lastUserViewportInteraction.

Referenced by maybeRecenterMap().

showHoverCard()

void NetworkPage::showHoverCard ( const std::string & country_code, const std::string & country_name, const std::string & city, const std::string & ip, const std::string & host, const std::string & app_name, const std::string & isp, uint32_t hits )

private

Definition at line 336 of file NetworkPage.cpp.

{
    if (!m_hoverCard || !m_hoverCardTitle || !m_hoverCardBody) return;
 
    if (m_hoverHideSource != 0) {
        g_source_remove(m_hoverHideSource);
        m_hoverHideSource = 0;
    }
 
    std::string title;
    if (!country_code.empty() && !country_name.empty()) {
        title = country_code + "  " + country_name;
    } else if (!country_name.empty()) {
        title = country_name;
    } else {
        title = "Connessione";
    }
 
    std::ostringstream body;
    if (!city.empty()) body << city << "\n";
    body << "IP: " << ip;
    if (!host.empty()) body << "\nHost: " << host;
    if (!app_name.empty()) body << "\nApp: " << app_name;
    if (!isp.empty()) body << "\nISP/AS: " << isp;
    body << "\nHit: " << hits;
 
    gtk_label_set_text(GTK_LABEL(m_hoverCardTitle), title.c_str());
    gtk_label_set_text(GTK_LABEL(m_hoverCardBody), body.str().c_str());
    gtk_widget_set_visible(m_hoverCard, TRUE);
}

References m_hoverCard, m_hoverCardBody, m_hoverCardTitle, and m_hoverHideSource.

triggerFxRedraw()

void NetworkPage::triggerFxRedraw ( )

private

Definition at line 1100 of file NetworkPage.cpp.

{
    if (m_mapFxArea) gtk_widget_queue_draw(m_mapFxArea);
}

References m_mapFxArea.

Referenced by onGeoResolved().

updateRow()

void NetworkPage::updateRow ( const Pin & pin )

private

Definition at line 849 of file NetworkPage.cpp.

{
    Glib::ustring country_cell;
    if (pin.country_code.empty()) {
        country_cell = pin.country_name.empty()
        ? Glib::ustring("?")
        : Glib::ustring(pin.country_name);
    } else {
        country_cell = Glib::ustring(pin.country_code + "  " + pin.country_name);
    }
 
    auto it = m_rows.find(pin.ip);
    if (it != m_rows.end()) {
        auto row = *(it->second);
        row[m_columns.col_country] = country_cell;
        row[m_columns.col_city]    = pin.city;
        row[m_columns.col_ip]      = pin.ip;
        row[m_columns.col_host]    = pin.host;
        row[m_columns.col_app]     = pin.app_name;
        row[m_columns.col_isp]     = pin.isp;
        row[m_columns.col_hits]    = pin.hits;
        return;
    }
 
    auto iter = m_store->append();
    auto row  = *iter;
    row[m_columns.col_country] = country_cell;
    row[m_columns.col_city]    = pin.city;
    row[m_columns.col_ip]      = pin.ip;
    row[m_columns.col_host]    = pin.host;
    row[m_columns.col_app]     = pin.app_name;
    row[m_columns.col_isp]     = pin.isp;
    row[m_columns.col_hits]    = pin.hits;
 
    m_rows.emplace(pin.ip, iter);
}

References NetworkPage::Pin::app_name, NetworkPage::Pin::city, NetworkPage::Columns::col_app, NetworkPage::Columns::col_city, NetworkPage::Columns::col_country, NetworkPage::Columns::col_hits, NetworkPage::Columns::col_host, NetworkPage::Columns::col_ip, NetworkPage::Columns::col_isp, NetworkPage::Pin::country_code, NetworkPage::Pin::country_name, NetworkPage::Pin::hits, NetworkPage::Pin::host, NetworkPage::Pin::ip, NetworkPage::Pin::isp, m_columns, m_rows, and m_store.

Referenced by loadLog(), noteConnection(), and onGeoResolved().

updateSummary()

void NetworkPage::updateSummary ( )

private

Definition at line 886 of file NetworkPage.cpp.

{
    std::size_t total_ips = 0;
    std::size_t total_hits = 0;
    std::size_t countries = 0;
    std::unordered_map<std::string, int> seen_countries;
 
    {
        std::lock_guard lk(m_mu);
        total_ips = m_pins.size();
 
        for (const auto& [_, p] : m_pins) {
            total_hits += p.hits;
            if (!p.country_code.empty() && !seen_countries.count(p.country_code)) {
                seen_countries[p.country_code] = 1;
            }
        }
 
        countries = seen_countries.size();
    }
 
    std::ostringstream oss;
    oss << total_ips << " IP · " << total_hits << " conn. · "
    << countries << " paesi";
    m_summaryLabel.set_text(oss.str());
}

References _, m_mu, m_pins, and m_summaryLabel.

Referenced by buildUI(), clear(), loadLog(), noteConnection(), and onGeoResolved().

Member Data Documentation

kRetentionSeconds

int64_t NetworkPage::kRetentionSeconds = 7 * 24 * 3600

staticconstexprprivate

Definition at line 141 of file NetworkPage.hpp.

Referenced by loadLog().

m_clearBtn

Gtk::Button NetworkPage::m_clearBtn

private

Definition at line 104 of file NetworkPage.hpp.

Referenced by buildUI().

m_columns

Columns NetworkPage::m_columns

private

Definition at line 97 of file NetworkPage.hpp.

Referenced by buildUI(), and updateRow().

m_geoDispatcher

Glib::Dispatcher NetworkPage::m_geoDispatcher

private

Definition at line 149 of file NetworkPage.hpp.

Referenced by NetworkPage().

m_headerLabel

Gtk::Label NetworkPage::m_headerLabel

private

Definition at line 102 of file NetworkPage.hpp.

Referenced by buildUI().

m_hoverCard

GtkWidget* NetworkPage::m_hoverCard {nullptr}

private

Definition at line 113 of file NetworkPage.hpp.

Referenced by buildMapWidget(), hideHoverCard(), showHoverCard(), and ~NetworkPage().

m_hoverCardBody

GtkWidget* NetworkPage::m_hoverCardBody {nullptr}

private

Definition at line 115 of file NetworkPage.hpp.

Referenced by createHoverCard(), showHoverCard(), and ~NetworkPage().

m_hoverCardTitle

GtkWidget* NetworkPage::m_hoverCardTitle {nullptr}

private

Definition at line 114 of file NetworkPage.hpp.

Referenced by createHoverCard(), showHoverCard(), and ~NetworkPage().

m_hoverHideSource

guint NetworkPage::m_hoverHideSource {0}

private

Definition at line 116 of file NetworkPage.hpp.

Referenced by hideHoverCard(), showHoverCard(), and ~NetworkPage().

m_lastUserViewportInteraction

std::chrono::steady_clock::time_point NetworkPage::m_lastUserViewportInteraction {}

private

Definition at line 117 of file NetworkPage.hpp.

Referenced by noteUserViewportInteraction(), and shouldHoldUserViewport().

m_mapFxArea

GtkWidget* NetworkPage::m_mapFxArea {nullptr}

private

Definition at line 127 of file NetworkPage.hpp.

Referenced by buildMapWidget(), triggerFxRedraw(), and ~NetworkPage().

m_mapHost

Gtk::Box NetworkPage::m_mapHost {Gtk::Orientation::VERTICAL, 0}

private

Definition at line 101 of file NetworkPage.hpp.

Referenced by buildMapWidget(), and buildUI().

m_mapOverlay

GtkWidget* NetworkPage::m_mapOverlay {nullptr}

private

Definition at line 112 of file NetworkPage.hpp.

Referenced by buildMapWidget(), and ~NetworkPage().

m_markerLayer

ShumateMarkerLayer* NetworkPage::m_markerLayer {nullptr}

private

Definition at line 109 of file NetworkPage.hpp.

Referenced by buildMapWidget(), rebuildMapMarkers(), and ~NetworkPage().

m_mu

std::mutex NetworkPage::m_mu

mutableprivate

Definition at line 144 of file NetworkPage.hpp.

Referenced by clear(), drawConnectionArcs(), loadLog(), noteConnection(), onGeoResolved(), rebuildMapMarkers(), saveLog(), and updateSummary().

m_pendingGeo

std::vector<std::pair<std::string, bsc::ui_util::GeoEntry> > NetworkPage::m_pendingGeo

private

Definition at line 151 of file NetworkPage.hpp.

Referenced by NetworkPage(), and onGeoResolved().

m_pendingMu

std::mutex NetworkPage::m_pendingMu

private

Definition at line 150 of file NetworkPage.hpp.

Referenced by NetworkPage(), and onGeoResolved().

m_pins

std::unordered_map<std::string, Pin> NetworkPage::m_pins

private

Definition at line 145 of file NetworkPage.hpp.

Referenced by clear(), drawConnectionArcs(), loadLog(), noteConnection(), onGeoResolved(), rebuildMapMarkers(), saveLog(), and updateSummary().

m_pulseFrame

int NetworkPage::m_pulseFrame {0}

private

Definition at line 132 of file NetworkPage.hpp.

m_pulseTimerId

guint NetworkPage::m_pulseTimerId {0}

private

Definition at line 131 of file NetworkPage.hpp.

Referenced by NetworkPage(), and ~NetworkPage().

m_rows

std::unordered_map<std::string, Gtk::TreeModel::iterator> NetworkPage::m_rows

private

Definition at line 146 of file NetworkPage.hpp.

Referenced by clear(), and updateRow().

m_scroll

Gtk::ScrolledWindow NetworkPage::m_scroll

private

Definition at line 100 of file NetworkPage.hpp.

Referenced by buildUI().

m_selfLat

double NetworkPage::m_selfLat {0.0}

private

Definition at line 124 of file NetworkPage.hpp.

Referenced by createSelfMarkerWidget(), drawConnectionArcs(), maybeRecenterMap(), onGeoResolved(), and requestSelfLocation().

m_selfLon

double NetworkPage::m_selfLon {0.0}

private

Definition at line 125 of file NetworkPage.hpp.

Referenced by createSelfMarkerWidget(), drawConnectionArcs(), maybeRecenterMap(), onGeoResolved(), and requestSelfLocation().

m_selfResolved

bool NetworkPage::m_selfResolved {false}

private

Definition at line 126 of file NetworkPage.hpp.

Referenced by drawConnectionArcs(), maybeRecenterMap(), onGeoResolved(), rebuildMapMarkers(), and requestSelfLocation().

m_simpleMap

GtkWidget* NetworkPage::m_simpleMap {nullptr}

private

Definition at line 107 of file NetworkPage.hpp.

Referenced by buildMapWidget(), drawConnectionArcs(), and ~NetworkPage().

m_store

Glib::RefPtr<Gtk::ListStore> NetworkPage::m_store

private

Definition at line 98 of file NetworkPage.hpp.

Referenced by buildUI(), clear(), and updateRow().

m_summaryLabel

Gtk::Label NetworkPage::m_summaryLabel

private

Definition at line 103 of file NetworkPage.hpp.

Referenced by buildUI(), and updateSummary().

m_treeView

Gtk::TreeView NetworkPage::m_treeView

private

Definition at line 99 of file NetworkPage.hpp.

Referenced by buildUI().

m_viewport

ShumateViewport* NetworkPage::m_viewport {nullptr}

private

Definition at line 108 of file NetworkPage.hpp.

Referenced by buildMapWidget(), drawConnectionArcs(), maybeRecenterMap(), and ~NetworkPage().

---

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

• BastionGuard/thirdparty/bastionguard-secure-connection/ui/src/pages/NetworkPage.hpp
• BastionGuard/thirdparty/bastionguard-secure-connection/ui/src/pages/NetworkPage.cpp