fnox 1.23.1

A flexible secret management tool supporting multiple providers and encryption methods
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

//! Event handling for TUI
//!
//! Handles keyboard input, mouse input, and async events using tokio channels.

use std::time::Duration;

use crossterm::event::{self, Event as CrosstermEvent, KeyEvent, MouseEvent};
use tokio::sync::mpsc;

use crate::tui::app::Message;

/// Events that can occur in the TUI
#[derive(Debug)]
pub enum Event {
    /// Keyboard input event
    Key(KeyEvent),
    /// Mouse input event
    Mouse(MouseEvent),
    /// Periodic tick for UI updates
    Tick,
    /// Async message from background tasks
    Message(Message),
}

/// Handles event collection from multiple sources
pub struct EventHandler {
    rx: mpsc::UnboundedReceiver<Event>,
    tx: mpsc::UnboundedSender<Event>,
}

impl EventHandler {
    /// Create a new event handler with the specified tick rate
    pub fn new(tick_rate: Duration) -> Self {
        let (tx, rx) = mpsc::unbounded_channel();

        // Spawn keyboard event handler
        let tx_clone = tx.clone();
        tokio::spawn(async move {
            loop {
                // Poll for events with tick rate as timeout
                if event::poll(tick_rate).unwrap_or(false) {
                    if let Ok(evt) = event::read() {
                        match evt {
                            CrosstermEvent::Key(key)
                                if tx_clone.send(Event::Key(key)).is_err() => {
                                    break;
                                }
                            CrosstermEvent::Mouse(mouse)
                                if tx_clone.send(Event::Mouse(mouse)).is_err() => {
                                    break;
                                }
                            CrosstermEvent::Resize(_, _)
                                // Terminal resize - send tick to trigger redraw
                                if tx_clone.send(Event::Tick).is_err() => {
                                    break;
                                }
                            _ => {}
                        }
                    }
                } else {
                    // Timeout - send tick
                    if tx_clone.send(Event::Tick).is_err() {
                        break;
                    }
                }
            }
        });

        Self { rx, tx }
    }

    /// Get a sender for sending messages from async tasks
    pub fn message_tx(&self) -> mpsc::UnboundedSender<Event> {
        self.tx.clone()
    }

    /// Wait for the next event
    pub async fn next(&mut self) -> Option<Event> {
        self.rx.recv().await
    }
}