1 files changed, 98 insertions, 98 deletions

diff --git a/src/input.rs b/src/input.rs
index 28a2356c..c2523aa2 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -3,13 +3,13 @@ use anyhow::Result;
 use crossbeam_channel::{unbounded, Receiver, Sender};
 use crossterm::event::{self, Event};
 use std::{
-    process,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc,
-    },
-    thread,
-    time::Duration,
+	process,
+	sync::{
+		atomic::{AtomicBool, Ordering},
+		Arc,
+	},
+	thread,
+	time::Duration,
 };
 
 static POLL_DURATION: Duration = Duration::from_millis(1000);
@@ -17,107 +17,107 @@ static POLL_DURATION: Duration = Duration::from_millis(1000);
 ///
 #[derive(Clone, Copy, Debug)]
 pub enum InputState {
-    Paused,
-    Polling,
+	Paused,
+	Polling,
 }
 
 ///
 #[derive(Clone, Copy, Debug)]
 pub enum InputEvent {
-    Input(Event),
-    State(InputState),
+	Input(Event),
+	State(InputState),
 }
 
 ///
 pub struct Input {
-    desired_state: Arc<NotifyableMutex<bool>>,
-    current_state: Arc<AtomicBool>,
-    receiver: Receiver<InputEvent>,
+	desired_state: Arc<NotifyableMutex<bool>>,
+	current_state: Arc<AtomicBool>,
+	receiver: Receiver<InputEvent>,
 }
 
 impl Input {
-    ///
-    pub fn new() -> Self {
-        let (tx, rx) = unbounded();
-
-        let desired_state = Arc::new(NotifyableMutex::new(true));
-        let current_state = Arc::new(AtomicBool::new(true));
-
-        let arc_desired = Arc::clone(&desired_state);
-        let arc_current = Arc::clone(&current_state);
-
-        thread::spawn(move || {
-            if let Err(e) =
-                Self::input_loop(&arc_desired, &arc_current, &tx)
-            {
-                log::error!("input thread error: {}", e);
-                process::abort();
-            }
-        });
-
-        Self {
-            receiver: rx,
-            desired_state,
-            current_state,
-        }
-    }
-
-    ///
-    pub fn receiver(&self) -> Receiver<InputEvent> {
-        self.receiver.clone()
-    }
-
-    ///
-    pub fn set_polling(&mut self, enabled: bool) {
-        self.desired_state.set_and_notify(enabled);
-    }
-
-    fn shall_poll(&self) -> bool {
-        self.desired_state.get()
-    }
-
-    ///
-    pub fn is_state_changing(&self) -> bool {
-        self.shall_poll()
-            != self.current_state.load(Ordering::Relaxed)
-    }
-
-    fn poll(dur: Duration) -> anyhow::Result<Option<Event>> {
-        if event::poll(dur)? {
-            Ok(Some(event::read()?))
-        } else {
-            Ok(None)
-        }
-    }
-
-    fn input_loop(
-        arc_desired: &Arc<NotifyableMutex<bool>>,
-        arc_current: &Arc<AtomicBool>,
-        tx: &Sender<InputEvent>,
-    ) -> Result<()> {
-        loop {
-            if arc_desired.get() {
-                if !arc_current.load(Ordering::Relaxed) {
-                    log::info!("input polling resumed");
-
-                    tx.send(InputEvent::State(InputState::Polling))?;
-                }
-                arc_current.store(true, Ordering::Relaxed);
-
-                if let Some(e) = Self::poll(POLL_DURATION)? {
-                    tx.send(InputEvent::Input(e))?;
-                }
-            } else {
-                if arc_current.load(Ordering::Relaxed) {
-                    log::info!("input polling suspended");
-
-                    tx.send(InputEvent::State(InputState::Paused))?;
-                }
-
-                arc_current.store(false, Ordering::Relaxed);
-
-                arc_desired.wait(true);
-            }
-        }
-    }
+	///
+	pub fn new() -> Self {
+		let (tx, rx) = unbounded();
+
+		let desired_state = Arc::new(NotifyableMutex::new(true));
+		let current_state = Arc::new(AtomicBool::new(true));
+
+		let arc_desired = Arc::clone(&desired_state);
+		let arc_current = Arc::clone(&current_state);
+
+		thread::spawn(move || {
+			if let Err(e) =
+				Self::input_loop(&arc_desired, &arc_current, &tx)
+			{
+				log::error!("input thread error: {}", e);
+				process::abort();
+			}
+		});
+
+		Self {
+			receiver: rx,
+			desired_state,
+			current_state,
+		}
+	}
+
+	///
+	pub fn receiver(&self) -> Receiver<InputEvent> {
+		self.receiver.clone()
+	}
+
+	///
+	pub fn set_polling(&mut self, enabled: bool) {
+		self.desired_state.set_and_notify(enabled);
+	}
+
+	fn shall_poll(&self) -> bool {
+		self.desired_state.get()
+	}
+
+	///
+	pub fn is_state_changing(&self) -> bool {
+		self.shall_poll()
+			!= self.current_state.load(Ordering::Relaxed)
+	}
+
+	fn poll(dur: Duration) -> anyhow::Result<Option<Event>> {
+		if event::poll(dur)? {
+			Ok(Some(event::read()?))
+		} else {
+			Ok(None)
+		}
+	}
+
+	fn input_loop(
+		arc_desired: &Arc<NotifyableMutex<bool>>,
+		arc_current: &Arc<AtomicBool>,
+		tx: &Sender<InputEvent>,
+	) -> Result<()> {
+		loop {
+			if arc_desired.get() {
+				if !arc_current.load(Ordering::Relaxed) {
+					log::info!("input polling resumed");
+
+					tx.send(InputEvent::State(InputState::Polling))?;
+				}
+				arc_current.store(true, Ordering::Relaxed);
+
+				if let Some(e) = Self::poll(POLL_DURATION)? {
+					tx.send(InputEvent::Input(e))?;
+				}
+			} else {
+				if arc_current.load(Ordering::Relaxed) {
+					log::info!("input polling suspended");
+
+					tx.send(InputEvent::State(InputState::Paused))?;
+				}
+
+				arc_current.store(false, Ordering::Relaxed);
+
+				arc_desired.wait(true);
+			}
+		}
+	}
 }