threshold notifications: expand / collapse

Author: GyulyVGC

resources/fonts/subset/icons.ttf

@@ -7,19 +7,19 @@ use iced::widget::{Space, button, vertical_space};
 use iced::{Alignment, Font, Length, Padding};
 
 use crate::chart::types::chart_type::ChartType;
-use crate::countries::country_utils::get_computer_tooltip;
+use crate::countries::flags_pictures::FLAGS_WIDTH_BIG;
 use crate::gui::components::header::get_button_settings;
 use crate::gui::components::tab::get_pages_tabs;
 use crate::gui::components::types::my_modal::MyModal;
 use crate::gui::pages::overview_page::{get_bars, get_bars_length, host_bar};
 use crate::gui::pages::types::settings_page::SettingsPage;
+use crate::gui::styles::button::ButtonType;
 use crate::gui::styles::container::ContainerType;
 use crate::gui::styles::scrollbar::ScrollbarType;
 use crate::gui::styles::style_constants::FONT_SIZE_FOOTER;
 use crate::gui::styles::text::TextType;
 use crate::gui::types::message::Message;
 use crate::networking::types::data_info::DataInfo;
-use crate::networking::types::traffic_type::TrafficType;
 use crate::notifications::types::logged_notification::{
     DataThresholdExceeded, FavoriteTransmitted, LoggedNotification,
 };
@@ -61,11 +61,11 @@ pub fn notifications_page(sniffer: &Sniffer) -> Container<Message, StyleType> {
     if notifications.packets_notification.threshold.is_none()
         && notifications.bytes_notification.threshold.is_none()
         && !notifications.favorite_notification.notify_on_favorite
-        && sniffer.logged_notifications.is_empty()
+        && sniffer.logged_notifications.0.is_empty()
     {
         let body = body_no_notifications_set(font, language);
         tab_and_body = tab_and_body.push(body);
-    } else if sniffer.logged_notifications.is_empty() {
+    } else if sniffer.logged_notifications.0.is_empty() {
         let body = body_no_notifications_received(font, language, &sniffer.dots_pulse.0);
         tab_and_body = tab_and_body.push(body);
     } else {
@@ -74,7 +74,7 @@ pub fn notifications_page(sniffer: &Sniffer) -> Container<Message, StyleType> {
             .spacing(10)
             .padding(Padding::new(10.0).bottom(0))
             .push(
-                Container::new(if sniffer.logged_notifications.len() < 30 {
+                Container::new(if sniffer.logged_notifications.0.len() < 30 {
                     Text::new("")
                 } else {
                     Text::new(only_last_30_translation(language)).font(font)
@@ -168,7 +168,6 @@ fn data_notification_log<'a>(
     );
     let content = Row::new()
         .align_y(Alignment::Center)
-        .height(Length::Fill)
         .spacing(30)
         .push(icon)
         .push(
@@ -179,7 +178,7 @@ fn data_notification_log<'a>(
                     Row::new()
                         .spacing(8)
                         .push(Icon::Clock.to_text())
-                        .push(Text::new(logged_notification.timestamp).font(font)),
+                        .push(Text::new(logged_notification.timestamp.clone()).font(font)),
                 )
                 .push(
                     Text::new(if chart_type == ChartType::Bytes {
@@ -198,16 +197,21 @@ fn data_notification_log<'a>(
                 ),
         )
         .push(threshold_bar(
-            logged_notification.data_info,
+            &logged_notification,
             chart_type,
             first_entry_data_info,
             font,
-            language,
         ));
-    Container::new(content)
-        .height(120)
+    let content_and_extra = Column::new()
+        .push(content)
+        .push(if logged_notification.is_expanded {
+            Row::new().push(get_button_clear_all(font, language))
+        } else {
+            Row::new()
+        });
+    Container::new(content_and_extra)
         .width(Length::Fill)
-        .padding(10)
+        .padding(15)
         .class(ContainerType::BorderedRound)
 }
 
@@ -230,7 +234,6 @@ fn favorite_notification_log<'a>(
     let content = Row::new()
         .spacing(30)
         .align_y(Alignment::Center)
-        .height(Length::Fill)
         .push(
             Icon::Star
                 .to_text()
@@ -257,9 +260,8 @@ fn favorite_notification_log<'a>(
         .push(host_bar);
 
     Container::new(content)
-        .height(120)
         .width(Length::Fill)
-        .padding(10)
+        .padding(15)
         .class(ContainerType::BorderedRound)
 }
 
@@ -298,12 +300,13 @@ fn logged_notifications<'a>(sniffer: &Sniffer) -> Column<'a, Message, StyleType>
 
     let first_entry_data_info = sniffer
         .logged_notifications
+        .0
         .iter()
         .map(LoggedNotification::data_info)
         .max_by(|d1, d2| d1.compare(d2, SortType::Ascending, chart_type))
         .unwrap_or_default();
 
-    for logged_notification in &sniffer.logged_notifications {
+    for logged_notification in &sniffer.logged_notifications.0 {
         ret_val = ret_val.push(match logged_notification {
             LoggedNotification::DataThresholdExceeded(data_threshold_exceeded) => {
                 data_notification_log(
@@ -328,26 +331,22 @@ fn logged_notifications<'a>(sniffer: &Sniffer) -> Column<'a, Message, StyleType>
 }
 
 fn threshold_bar<'a>(
-    data_info: DataInfo,
+    logged_notification: &DataThresholdExceeded,
     chart_type: ChartType,
     first_entry_data_info: DataInfo,
     font: Font,
-    language: Language,
 ) -> Row<'a, Message, StyleType> {
+    let data_info = logged_notification.data_info;
+    let id = logged_notification.id;
+    let is_expanded = logged_notification.is_expanded;
+
     let (incoming_bar_len, outgoing_bar_len) =
         get_bars_length(chart_type, &first_entry_data_info, &data_info);
 
     Row::new()
         .align_y(Alignment::Center)
         .spacing(5)
-        .push(get_computer_tooltip(
-            true,
-            true,
-            None,
-            TrafficType::Unicast,
-            language,
-            font,
-        ))
+        .push(button_expand(id, is_expanded))
         .push(
             Column::new()
                 .spacing(1)
@@ -364,3 +363,28 @@ fn threshold_bar<'a>(
                 .push(get_bars(incoming_bar_len, outgoing_bar_len)),
         )
 }
+
+fn button_expand<'a>(
+    notification_id: usize,
+    is_expanded: bool,
+) -> Container<'a, Message, StyleType> {
+    let button = button(
+        if is_expanded {
+            Icon::Collapse
+        } else {
+            Icon::Expand
+        }
+        .to_text()
+        .size(25)
+        .align_x(Alignment::Center)
+        .align_y(Alignment::Center),
+    )
+    .width(FLAGS_WIDTH_BIG)
+    .padding(Padding::ZERO)
+    .class(ButtonType::SortArrows)
+    .on_press(Message::ExpandNotification(notification_id, !is_expanded));
+
+    Container::new(button)
+        .align_x(Alignment::Center)
+        .align_y(Alignment::Center)
+}

src/gui/pages/notifications_page.rs

@@ -87,8 +87,8 @@ pub struct Sniffer {
     pub addresses_resolved: HashMap<IpAddr, (String, Host)>,
     /// Collection of the favorite hosts
     pub favorite_hosts: HashSet<Host>,
-    /// Log of the received notifications
-    pub logged_notifications: VecDeque<LoggedNotification>,
+    /// Log of the displayed notifications, with the total number of notifications for this capture
+    pub logged_notifications: (VecDeque<LoggedNotification>, usize),
     /// Reports if a newer release of the software is available on GitHub
     pub newer_release_available: Option<bool>,
     /// Network device to be analyzed, or PCAP file to be imported
@@ -155,7 +155,7 @@ impl Sniffer {
             info_traffic: InfoTraffic::default(),
             addresses_resolved: HashMap::new(),
             favorite_hosts: HashSet::new(),
-            logged_notifications: VecDeque::new(),
+            logged_notifications: (VecDeque::new(), 0),
             newer_release_available: None,
             capture_source: CaptureSource::Device(device),
             my_devices: Vec::new(),
@@ -364,7 +364,7 @@ impl Sniffer {
                 self.configs.settings.notifications.volume = volume;
             }
             Message::ClearAllNotifications => {
-                self.logged_notifications = VecDeque::new();
+                self.logged_notifications.0 = VecDeque::new();
                 self.modal = None;
             }
             Message::SwitchPage(next) => {
@@ -552,6 +552,16 @@ impl Sniffer {
                 self.update_waiting_dots();
                 self.fetch_devices();
             }
+            Message::ExpandNotification(id, expand) => {
+                if let Some(n) = self
+                    .logged_notifications
+                    .0
+                    .iter_mut()
+                    .find(|n| n.id() == id)
+                {
+                    n.expand(expand);
+                }
+            }
         }
         Task::none()
     }
@@ -798,7 +808,7 @@ impl Sniffer {
         self.info_traffic = InfoTraffic::default();
         self.addresses_resolved = HashMap::new();
         self.favorite_hosts = HashSet::new();
-        self.logged_notifications = VecDeque::new();
+        self.logged_notifications = (VecDeque::new(), 0);
         self.pcap_error = None;
         self.traffic_chart = TrafficChart::new(style, language);
         self.report_sort_type = ReportSortType::default();
@@ -1058,7 +1068,7 @@ impl Sniffer {
 
     fn shortcut_ctrl_d(&mut self) -> Task<Message> {
         if self.running_page.eq(&RunningPage::Notifications)
-            && !self.logged_notifications.is_empty()
+            && !self.logged_notifications.0.is_empty()
         {
             return Task::done(Message::ShowModal(MyModal::ClearAll));
         }

src/gui/sniffer.rs

@@ -133,4 +133,6 @@ pub enum Message {
     OfflineGap(usize, u32),
     /// Emitted every second to repeat certain tasks (such as fetching the network devices)
     Periodic,
+    /// Expand or collapse the given logged notification
+    ExpandNotification(usize, bool),
 }

src/gui/types/message.rs

@@ -15,32 +15,36 @@ use std::collections::{HashSet, VecDeque};
 ///
 /// It returns the number of new notifications emitted
 pub fn notify_and_log(
-    logged_notifications: &mut VecDeque<LoggedNotification>,
+    logged_notifications: &mut (VecDeque<LoggedNotification>, usize),
     notifications: Notifications,
     info_traffic_msg: &InfoTraffic,
     favorites: &HashSet<Host>,
     cs: &CaptureSource,
 ) -> usize {
     let mut sound_to_play = Sound::None;
-    let mut emitted_notifications = 0;
+    let emitted_notifications_prev = logged_notifications.1;
     let timestamp = info_traffic_msg.last_packet_timestamp;
     let data_info = info_traffic_msg.tot_data_info;
     // packets threshold
     if let Some(threshold) = notifications.packets_notification.threshold {
         if data_info.tot_packets() > u128::from(threshold) {
             // log this notification
-            emitted_notifications += 1;
-            if logged_notifications.len() >= 30 {
-                logged_notifications.pop_back();
+            logged_notifications.1 += 1;
+            if logged_notifications.0.len() >= 30 {
+                logged_notifications.0.pop_back();
             }
-            logged_notifications.push_front(LoggedNotification::DataThresholdExceeded(
-                DataThresholdExceeded {
-                    chart_type: ChartType::Packets,
-                    threshold: notifications.packets_notification.previous_threshold,
-                    data_info,
-                    timestamp: get_formatted_timestamp(timestamp),
-                },
-            ));
+            logged_notifications
+                .0
+                .push_front(LoggedNotification::DataThresholdExceeded(
+                    DataThresholdExceeded {
+                        id: logged_notifications.1,
+                        chart_type: ChartType::Packets,
+                        threshold: notifications.packets_notification.previous_threshold,
+                        data_info,
+                        timestamp: get_formatted_timestamp(timestamp),
+                        is_expanded: false,
+                    },
+                ));
             if sound_to_play.eq(&Sound::None) {
                 sound_to_play = notifications.packets_notification.sound;
             }
@@ -50,18 +54,22 @@ pub fn notify_and_log(
     if let Some(threshold) = notifications.bytes_notification.threshold {
         if data_info.tot_bytes() > u128::from(threshold) {
             //log this notification
-            emitted_notifications += 1;
-            if logged_notifications.len() >= 30 {
-                logged_notifications.pop_back();
+            logged_notifications.1 += 1;
+            if logged_notifications.0.len() >= 30 {
+                logged_notifications.0.pop_back();
             }
-            logged_notifications.push_front(LoggedNotification::DataThresholdExceeded(
-                DataThresholdExceeded {
-                    chart_type: ChartType::Bytes,
-                    threshold: notifications.bytes_notification.previous_threshold,
-                    data_info,
-                    timestamp: get_formatted_timestamp(timestamp),
-                },
-            ));
+            logged_notifications
+                .0
+                .push_front(LoggedNotification::DataThresholdExceeded(
+                    DataThresholdExceeded {
+                        id: logged_notifications.1,
+                        chart_type: ChartType::Bytes,
+                        threshold: notifications.bytes_notification.previous_threshold,
+                        data_info,
+                        timestamp: get_formatted_timestamp(timestamp),
+                        is_expanded: false,
+                    },
+                ));
             if sound_to_play.eq(&Sound::None) {
                 sound_to_play = notifications.bytes_notification.sound;
             }
@@ -78,18 +86,21 @@ pub fn notify_and_log(
         if !favorites_last_interval.is_empty() {
             for (host, data_info_host) in favorites_last_interval {
                 //log this notification
-                emitted_notifications += 1;
-                if logged_notifications.len() >= 30 {
-                    logged_notifications.pop_back();
+                logged_notifications.1 += 1;
+                if logged_notifications.0.len() >= 30 {
+                    logged_notifications.0.pop_back();
                 }
 
-                logged_notifications.push_front(LoggedNotification::FavoriteTransmitted(
-                    FavoriteTransmitted {
-                        host,
-                        data_info_host,
-                        timestamp: get_formatted_timestamp(timestamp),
-                    },
-                ));
+                logged_notifications
+                    .0
+                    .push_front(LoggedNotification::FavoriteTransmitted(
+                        FavoriteTransmitted {
+                            id: logged_notifications.1,
+                            host,
+                            data_info_host,
+                            timestamp: get_formatted_timestamp(timestamp),
+                        },
+                    ));
             }
             if sound_to_play.eq(&Sound::None) {
                 sound_to_play = notifications.favorite_notification.sound;
@@ -102,5 +113,5 @@ pub fn notify_and_log(
         play(sound_to_play, notifications.volume);
     }
 
-    emitted_notifications
+    logged_notifications.1 - emitted_notifications_prev
 }