From b7fc6bc1a70da169f80afdc790c1a8ccf853d319 Mon Sep 17 00:00:00 2001
From: krolxon <krolyxon@tutanota.com>
Date: Wed, 1 May 2024 23:45:05 +0530
Subject: move the keymaps to thier individual files

---
 src/event.rs | 79 ------------------------------------------------------------
 1 file changed, 79 deletions(-)
 delete mode 100755 src/event.rs

(limited to 'src/event.rs')

diff --git a/src/event.rs b/src/event.rs
deleted file mode 100755
index 439c31b..0000000
--- a/src/event.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-use crate::app::AppResult;
-use crossterm::event::{self, Event as CrosstermEvent, KeyEvent, MouseEvent};
-use std::sync::mpsc;
-use std::thread;
-use std::time::{Duration, Instant};
-
-/// Terminal events.
-#[derive(Clone, Copy, Debug)]
-pub enum Event {
-    /// Terminal tick.
-    Tick,
-    /// Key press.
-    Key(KeyEvent),
-    /// Mouse click/scroll.
-    Mouse(MouseEvent),
-    /// Terminal resize.
-    Resize(u16, u16),
-}
-
-/// Terminal event handler.
-#[allow(dead_code)]
-#[derive(Debug)]
-pub struct EventHandler {
-    /// Event sender channel.
-    sender: mpsc::Sender<Event>,
-    /// Event receiver channel.
-    receiver: mpsc::Receiver<Event>,
-    /// Event handler thread.
-    handler: thread::JoinHandle<()>,
-}
-
-impl EventHandler {
-    /// Constructs a new instance of [`EventHandler`].
-    pub fn new(tick_rate: u64) -> Self {
-        let tick_rate = Duration::from_millis(tick_rate);
-        let (sender, receiver) = mpsc::channel();
-        let handler = {
-            let sender = sender.clone();
-            thread::spawn(move || {
-                let mut last_tick = Instant::now();
-                loop {
-                    let timeout = tick_rate
-                        .checked_sub(last_tick.elapsed())
-                        .unwrap_or(tick_rate);
-
-                    if event::poll(timeout).expect("failed to poll new events") {
-                        match event::read().expect("unable to read event") {
-                            CrosstermEvent::Key(e) => sender.send(Event::Key(e)),
-                            CrosstermEvent::Mouse(e) => sender.send(Event::Mouse(e)),
-                            CrosstermEvent::Resize(w, h) => sender.send(Event::Resize(w, h)),
-                            CrosstermEvent::FocusGained => Ok(()),
-                            CrosstermEvent::FocusLost => Ok(()),
-                            CrosstermEvent::Paste(_) => unimplemented!(),
-                        }
-                        .expect("failed to send terminal event")
-                    }
-
-                    if last_tick.elapsed() >= tick_rate {
-                        sender.send(Event::Tick).expect("failed to send tick event");
-                        last_tick = Instant::now();
-                    }
-                }
-            })
-        };
-        Self {
-            sender,
-            receiver,
-            handler,
-        }
-    }
-
-    /// Receive the next event from the handler thread.
-    ///
-    /// This function will always block the current thread if
-    /// there is no data available and it's possible for more data to be sent.
-    pub fn next(&self) -> AppResult<Event> {
-        Ok(self.receiver.recv()?)
-    }
-}
-- 
cgit v1.2.3