data threshold notifications: represent amounts with bars

Author: GyulyVGC

src/gui/pages/notifications_page.rs

@@ -2,30 +2,32 @@ use iced::Length::FillPortion;
 use iced::widget::scrollable::Direction;
 use iced::widget::text::LineHeight;
 use iced::widget::tooltip::Position;
-use iced::widget::{Column, Container, Row, Scrollable, Text, Tooltip};
+use iced::widget::{Column, Container, Row, Scrollable, Text, Tooltip, horizontal_space};
 use iced::widget::{Space, button, vertical_space};
 use iced::{Alignment, Font, Length, Padding};
 use std::fmt::Write;
 
 use crate::chart::types::chart_type::ChartType;
+use crate::countries::country_utils::get_computer_tooltip;
 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::host_bar;
+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::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::{
-    BytesThresholdExceeded, FavoriteTransmitted, LoggedNotification, PacketsThresholdExceeded,
+    DataThresholdExceeded, FavoriteTransmitted, LoggedNotification,
 };
 use crate::translations::translations::{
-    bytes_exceeded_translation, bytes_exceeded_value_translation, clear_all_translation,
-    favorite_transmitted_translation, incoming_translation, no_notifications_received_translation,
-    no_notifications_set_translation, only_last_30_translation, outgoing_translation,
-    packets_exceeded_translation, packets_exceeded_value_translation, per_second_translation,
+    bytes_exceeded_translation, clear_all_translation, favorite_transmitted_translation,
+    no_notifications_received_translation, no_notifications_set_translation,
+    only_last_30_translation, packets_exceeded_translation, per_second_translation,
     threshold_translation,
 };
 use crate::utils::types::icon::Icon;
@@ -140,7 +142,7 @@ fn body_no_notifications_received(
 }
 
 fn packets_notification_log<'a>(
-    logged_notification: PacketsThresholdExceeded,
+    logged_notification: DataThresholdExceeded,
     language: Language,
     font: Font,
 ) -> Container<'a, Message, StyleType> {
@@ -150,14 +152,6 @@ fn packets_notification_log<'a>(
         logged_notification.threshold,
         per_second_translation(language)
     );
-    let mut incoming_str = " - ".to_string();
-    incoming_str.push_str(incoming_translation(language));
-    incoming_str.push_str(": ");
-    incoming_str.push_str(&logged_notification.incoming.to_string());
-    let mut outgoing_str = " - ".to_string();
-    outgoing_str.push_str(outgoing_translation(language));
-    outgoing_str.push_str(": ");
-    outgoing_str.push_str(&logged_notification.outgoing.to_string());
     let content = Row::new()
         .align_y(Alignment::Center)
         .height(Length::Fill)
@@ -190,19 +184,13 @@ fn packets_notification_log<'a>(
                         .font(font),
                 ),
         )
-        .push(
-            Column::new()
-                .spacing(7)
-                .push(
-                    Text::new(packets_exceeded_value_translation(
-                        language,
-                        logged_notification.incoming + logged_notification.outgoing,
-                    ))
-                    .font(font),
-                )
-                .push(Text::new(incoming_str).font(font))
-                .push(Text::new(outgoing_str).font(font)),
-        );
+        .push(threshold_bar(
+            logged_notification.data_info,
+            ChartType::Packets,
+            logged_notification.data_info,
+            font,
+            language,
+        ));
     Container::new(content)
         .height(120)
         .width(Length::Fill)
@@ -211,7 +199,7 @@ fn packets_notification_log<'a>(
 }
 
 fn bytes_notification_log<'a>(
-    logged_notification: BytesThresholdExceeded,
+    logged_notification: DataThresholdExceeded,
     language: Language,
     font: Font,
 ) -> Container<'a, Message, StyleType> {
@@ -220,20 +208,7 @@ fn bytes_notification_log<'a>(
     threshold_str.push_str(&ByteMultiple::formatted_string(
         (logged_notification.threshold).into(),
     ));
-
     let _ = write!(threshold_str, " {}", per_second_translation(language));
-    let mut incoming_str = " - ".to_string();
-    incoming_str.push_str(incoming_translation(language));
-    incoming_str.push_str(": ");
-    incoming_str.push_str(&ByteMultiple::formatted_string(u128::from(
-        logged_notification.incoming,
-    )));
-    let mut outgoing_str = " - ".to_string();
-    outgoing_str.push_str(outgoing_translation(language));
-    outgoing_str.push_str(": ");
-    outgoing_str.push_str(&ByteMultiple::formatted_string(u128::from(
-        logged_notification.outgoing,
-    )));
     let content = Row::new()
         .spacing(30)
         .align_y(Alignment::Center)
@@ -266,21 +241,13 @@ fn bytes_notification_log<'a>(
                         .font(font),
                 ),
         )
-        .push(
-            Column::new()
-                .spacing(7)
-                .push(
-                    Text::new(bytes_exceeded_value_translation(
-                        language,
-                        &ByteMultiple::formatted_string(u128::from(
-                            logged_notification.incoming + logged_notification.outgoing,
-                        )),
-                    ))
-                    .font(font),
-                )
-                .push(Text::new(incoming_str).font(font))
-                .push(Text::new(outgoing_str).font(font)),
-        );
+        .push(threshold_bar(
+            logged_notification.data_info,
+            ChartType::Bytes,
+            logged_notification.data_info,
+            font,
+            language,
+        ));
     Container::new(content)
         .height(120)
         .width(Length::Fill)
@@ -330,7 +297,7 @@ fn favorite_notification_log<'a>(
                         .font(font),
                 ),
         )
-        .push(Column::new().spacing(7).push(host_bar));
+        .push(host_bar);
 
     Container::new(content)
         .height(120)
@@ -387,3 +354,41 @@ fn logged_notifications<'a>(sniffer: &Sniffer) -> Column<'a, Message, StyleType>
     }
     ret_val
 }
+
+fn threshold_bar<'a>(
+    data_info: DataInfo,
+    chart_type: ChartType,
+    first_entry_data_info: DataInfo,
+    font: Font,
+    language: Language,
+) -> Row<'a, Message, StyleType> {
+    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(
+            Column::new()
+                .spacing(1)
+                .push(
+                    Row::new().push(horizontal_space()).push(
+                        Text::new(if chart_type.eq(&ChartType::Packets) {
+                            data_info.tot_packets().to_string()
+                        } else {
+                            ByteMultiple::formatted_string(data_info.tot_bytes())
+                        })
+                        .font(font),
+                    ),
+                )
+                .push(get_bars(incoming_bar_len, outgoing_bar_len)),
+        )
+}

src/gui/sniffer.rs

@@ -1158,11 +1158,12 @@ mod tests {
     use crate::gui::styles::types::gradient_type::GradientType;
     use crate::gui::types::message::Message;
     use crate::gui::types::timing_events::TimingEvents;
+    use crate::networking::types::data_info::DataInfo;
     use crate::networking::types::host::Host;
     use crate::networking::types::info_traffic::InfoTrafficMessage;
     use crate::networking::types::traffic_direction::TrafficDirection;
     use crate::notifications::types::logged_notification::{
-        LoggedNotification, PacketsThresholdExceeded,
+        DataThresholdExceeded, LoggedNotification,
     };
     use crate::notifications::types::notifications::{
         BytesNotification, FavoriteNotification, Notification, Notifications, PacketsNotification,
@@ -1922,10 +1923,9 @@ mod tests {
         let mut sniffer = Sniffer::new(Configs::default());
         sniffer.logged_notifications =
             VecDeque::from([LoggedNotification::PacketsThresholdExceeded(
-                PacketsThresholdExceeded {
+                DataThresholdExceeded {
                     threshold: 0,
-                    incoming: 0,
-                    outgoing: 0,
+                    data_info: DataInfo::default(),
                     timestamp: "".to_string(),
                 },
             )]);

src/networking/types/data_info.rs

@@ -96,6 +96,13 @@ impl DataInfo {
         self.final_instant = rhs.final_instant;
     }
 
+    pub fn subtract(&mut self, rhs: Self) {
+        self.incoming_packets -= rhs.incoming_packets;
+        self.outgoing_packets -= rhs.outgoing_packets;
+        self.incoming_bytes -= rhs.incoming_bytes;
+        self.outgoing_bytes -= rhs.outgoing_bytes;
+    }
+
     pub fn compare(&self, other: &Self, sort_type: SortType, chart_type: ChartType) -> Ordering {
         match chart_type {
             ChartType::Packets => match sort_type {

src/notifications/notify_and_log.rs

@@ -1,7 +1,7 @@
 use crate::InfoTraffic;
 use crate::networking::types::capture_context::CaptureSource;
 use crate::notifications::types::logged_notification::{
-    BytesThresholdExceeded, FavoriteTransmitted, LoggedNotification, PacketsThresholdExceeded,
+    DataThresholdExceeded, FavoriteTransmitted, LoggedNotification,
 };
 use crate::notifications::types::notifications::Notifications;
 use crate::notifications::types::sound::{Sound, play};
@@ -20,23 +20,20 @@ pub fn notify_and_log(
     let mut sound_to_play = Sound::None;
     let mut emitted_notifications = 0;
     let timestamp = info_traffic.last_packet_timestamp;
+    let mut data_info_delta = info_traffic.tot_data_info;
+    data_info_delta.subtract(info_traffic.tot_data_info_prev);
     // packets threshold
     if let Some(threshold) = notifications.packets_notification.threshold {
-        let sent_packets_entry = info_traffic.tot_data_info.outgoing_packets()
-            - info_traffic.tot_data_info_prev.outgoing_packets();
-        let received_packets_entry = info_traffic.tot_data_info.incoming_packets()
-            - info_traffic.tot_data_info_prev.incoming_packets();
-        if received_packets_entry + sent_packets_entry > u128::from(threshold) {
+        if data_info_delta.tot_packets() > u128::from(threshold) {
             // log this notification
             emitted_notifications += 1;
             if logged_notifications.len() >= 30 {
                 logged_notifications.pop_back();
             }
             logged_notifications.push_front(LoggedNotification::PacketsThresholdExceeded(
-                PacketsThresholdExceeded {
+                DataThresholdExceeded {
                     threshold: notifications.packets_notification.previous_threshold,
-                    incoming: received_packets_entry.try_into().unwrap_or_default(),
-                    outgoing: sent_packets_entry.try_into().unwrap_or_default(),
+                    data_info: data_info_delta,
                     timestamp: get_formatted_timestamp(timestamp),
                 },
             ));
@@ -47,21 +44,16 @@ pub fn notify_and_log(
     }
     // bytes threshold
     if let Some(threshold) = notifications.bytes_notification.threshold {
-        let sent_bytes_entry = info_traffic.tot_data_info.outgoing_bytes()
-            - info_traffic.tot_data_info_prev.outgoing_bytes();
-        let received_bytes_entry = info_traffic.tot_data_info.incoming_bytes()
-            - info_traffic.tot_data_info_prev.incoming_bytes();
-        if received_bytes_entry + sent_bytes_entry > u128::from(threshold) {
+        if data_info_delta.tot_bytes() > u128::from(threshold) {
             //log this notification
             emitted_notifications += 1;
             if logged_notifications.len() >= 30 {
                 logged_notifications.pop_back();
             }
             logged_notifications.push_front(LoggedNotification::BytesThresholdExceeded(
-                BytesThresholdExceeded {
+                DataThresholdExceeded {
                     threshold: notifications.bytes_notification.previous_threshold,
-                    incoming: received_bytes_entry.try_into().unwrap_or_default(),
-                    outgoing: sent_bytes_entry.try_into().unwrap_or_default(),
+                    data_info: data_info_delta,
                     timestamp: get_formatted_timestamp(timestamp),
                 },
             ));

src/notifications/types/logged_notification.rs

@@ -1,29 +1,21 @@
+use crate::networking::types::data_info::DataInfo;
 use crate::networking::types::data_info_host::DataInfoHost;
 use crate::networking::types::host::Host;
 
 /// Enum representing the possible notification events.
 pub enum LoggedNotification {
     /// Packets threshold exceeded
-    PacketsThresholdExceeded(PacketsThresholdExceeded),
+    PacketsThresholdExceeded(DataThresholdExceeded),
     /// Byte threshold exceeded
-    BytesThresholdExceeded(BytesThresholdExceeded),
+    BytesThresholdExceeded(DataThresholdExceeded),
     /// Favorite connection exchanged data
     FavoriteTransmitted(FavoriteTransmitted),
 }
 
 #[derive(Clone)]
-pub struct PacketsThresholdExceeded {
-    pub(crate) threshold: u32,
-    pub(crate) incoming: u32,
-    pub(crate) outgoing: u32,
-    pub(crate) timestamp: String,
-}
-
-#[derive(Clone)]
-pub struct BytesThresholdExceeded {
+pub struct DataThresholdExceeded {
     pub(crate) threshold: u64,
-    pub(crate) incoming: u32,
-    pub(crate) outgoing: u32,
+    pub(crate) data_info: DataInfo,
     pub(crate) timestamp: String,
 }
 

src/notifications/types/notifications.rs

@@ -37,11 +37,11 @@ pub enum Notification {
 #[derive(Clone, Eq, PartialEq, Serialize, Deserialize, Debug, Copy)]
 pub struct PacketsNotification {
     /// Threshold of received + sent packets; if exceeded a notification is emitted
-    pub threshold: Option<u32>,
+    pub threshold: Option<u64>,
     /// The sound to emit
     pub sound: Sound,
     /// The last used Some value for the threshold field
-    pub previous_threshold: u32,
+    pub previous_threshold: u64,
 }
 
 impl Default for PacketsNotification {