Expose severity to display

See https://github.com/EFForg/rayhunter/issues/334

Severity levels low, medium, high are now exposed to the UI in form of
dotted, dashed and solid lines. The line on the UI represents the
highest-so-far severity seen.

Originally this was intended to be represented by Yellow/Orange/Red, but
this would mean yet another divergence for colorblind mode. This is
colorblind-friendly by default (I think...)

As part of this, simplify EventType so that it becomes a flat "level"
enum without nested variants.

There is also a new debug endpoint that allows one to overwrite the
display level directly for testing.

daemon/src/display/generic_framebuffer.rs

@@ -5,6 +5,7 @@ use std::time::Duration;
 
 use crate::config;
 use crate::display::DisplayState;
+use rayhunter::analysis::analyzer::EventType;
 
 use log::{error, info};
 use tokio::sync::mpsc::Receiver;
@@ -20,6 +21,13 @@ pub struct Dimensions {
     pub width: u32,
 }
 
+#[derive(Copy, Clone)]
+pub enum LinePattern {
+    Solid,
+    Dashed, // _ _ _ _
+    Dotted, // . . . .
+}
+
 #[allow(dead_code)]
 #[derive(Copy, Clone)]
 pub enum Color {
@@ -48,18 +56,36 @@ impl Color {
     }
 }
 
-impl Color {
-    fn from_state(state: DisplayState, colorblind_mode: bool) -> Self {
-        match state {
-            DisplayState::Paused => Color::White,
-            DisplayState::Recording => {
-                if colorblind_mode {
-                    Color::Blue
-                } else {
-                    Color::Green
-                }
+fn display_style_from_state(state: DisplayState, colorblind_mode: bool) -> (Color, LinePattern) {
+    match state {
+        DisplayState::Paused => (Color::White, LinePattern::Solid),
+        DisplayState::Recording => {
+            if colorblind_mode {
+                (Color::Blue, LinePattern::Solid)
+            } else {
+                (Color::Green, LinePattern::Solid)
             }
-            DisplayState::WarningDetected => Color::Red,
+        }
+        DisplayState::WarningDetected { event_type } => {
+            let pattern = match event_type {
+                EventType::Informational => LinePattern::Solid,
+                EventType::Low => LinePattern::Dotted,
+                EventType::Medium => LinePattern::Dashed,
+                EventType::High => LinePattern::Solid,
+            };
+
+            let color = match event_type {
+                EventType::Informational => {
+                    if colorblind_mode {
+                        Color::Blue
+                    } else {
+                        Color::Green
+                    }
+                }
+                _ => Color::Red,
+            };
+
+            (color, pattern)
         }
     }
 }
@@ -120,11 +146,28 @@ pub trait GenericFramebuffer: Send + 'static {
     }
 
     async fn draw_line(&mut self, color: Color, height: u32) {
+        self.draw_patterned_line(color, height, LinePattern::Solid)
+            .await
+    }
+
+    async fn draw_patterned_line(&mut self, color: Color, height: u32, pattern: LinePattern) {
         let width = self.dimensions().width;
-        let px_num = height * width;
         let mut buffer = Vec::new();
-        for _ in 0..px_num {
-            buffer.push(color.rgb());
+
+        for _row in 0..height {
+            for col in 0..width {
+                let should_draw = match pattern {
+                    LinePattern::Solid => true,
+                    LinePattern::Dashed => (col / 4) % 2 == 0, // 4 pixels on, 4 pixels off
+                    LinePattern::Dotted => col % 4 == 0,       // 1 pixel on, 3 pixels off
+                };
+
+                if should_draw {
+                    buffer.push(color.rgb());
+                } else {
+                    buffer.push((0, 0, 0)); // Black background
+                }
+            }
         }
 
         self.write_buffer(buffer).await
@@ -145,7 +188,7 @@ pub fn update_ui(
     }
 
     let colorblind_mode = config.colorblind_mode;
-    let mut display_color = Color::from_state(DisplayState::Recording, colorblind_mode);
+    let mut display_style = display_style_from_state(DisplayState::Recording, colorblind_mode);
 
     task_tracker.spawn(async move {
         // this feels wrong, is there a more rusty way to do this?
@@ -176,7 +219,7 @@ pub fn update_ui(
             }
             match ui_update_rx.try_recv() {
                 Ok(state) => {
-                    display_color = Color::from_state(state, colorblind_mode);
+                    display_style = display_style_from_state(state, colorblind_mode);
                 }
                 Err(tokio::sync::mpsc::error::TryRecvError::Empty) => {}
                 Err(e) => error!("error receiving framebuffer update message: {e}"),
@@ -196,7 +239,8 @@ pub fn update_ui(
                 // unknown value is used
                 _ => {}
             };
-            fb.draw_line(display_color, 2).await;
+            let (color, pattern) = display_style;
+            fb.draw_patterned_line(color, 2, pattern).await;
             tokio::time::sleep(Duration::from_millis(1000)).await;
         }
     });