Added idle state before solve timer

4 files changed, 74 insertions, 16 deletions

diff --git a/src/main.rs b/src/main.rs
index 6c9d2ee..d87720a 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,9 +1,10 @@
-use std::time::SystemTime;
 use sdl2::ttf;
 use sdl2::event::Event;
 use sdl2::keyboard::Keycode;
 use sdl2::pixels::Color;
 
+pub mod time;
+
 fn main() {
     let sdl = sdl2::init().unwrap();
     let video_subsys = sdl.video().unwrap();
@@ -15,36 +16,43 @@ fn main() {
         .build()
         .unwrap();
 
-    let mut timming = false;
-    let mut time_start = SystemTime::now();
+    let mut timer = time::Timer::new();
 
     let mut canvas = window.into_canvas().build().unwrap();
     let texture_creator = canvas.texture_creator();
-
     let mut event_pump = sdl.event_pump().unwrap();
+
     'running: loop {
         for e in event_pump.poll_iter() {
             match e {
-                Event::Quit {..} | Event::KeyDown { keycode: Some(Keycode::Escape), .. } => break 'running,
+                Event::Quit {..} => break 'running,
                 Event::KeyDown { keycode: Some(Keycode::Space), .. } => {
-                    timming = !timming;
-                    if timming {
-                        time_start = SystemTime::now();
+                    match timer.state {
+                        time::State::Active   => timer.stop(),
+                        time::State::Inactive => timer.idle(),
+                        time::State::Idle     => {},
+                    }
+                }
+                Event::KeyUp   { keycode: Some(Keycode::Space), .. } => {
+                    if timer.state == time::State::Idle {
+                        timer.start();
                     }
                 },
                 _ => {}
             }
         }
-
-        canvas.set_draw_color(if !timming { Color::RGB(0, 0, 0) } else { Color::RGB(30, 150, 30) });
+        match timer.state {
+            time::State::Idle     => canvas.set_draw_color(Color::RGB(100, 100, 0)),
+            time::State::Active   => canvas.set_draw_color(Color::RGB(0, 100, 0)),
+            time::State::Inactive => canvas.set_draw_color(Color::RGB(0, 0, 0)),
+        }
         canvas.clear();
-        if timming {
-            let surface = font.render(&time_start.elapsed().unwrap().as_millis().to_string())
-                              .solid(Color::RGB(255, 255, 255))
-                              .unwrap();
-            let tex = texture_creator.create_texture_from_surface(&surface).unwrap();
-            canvas.copy(&tex, None, None).unwrap();
+
+        if timer.state != time::State::Idle {
+            canvas.copy(&timer.to_texture(&font, &texture_creator), None, None).unwrap();
         }
+
         canvas.present();
+        std::thread::sleep(std::time::Duration::new(0, 3_000_000));
     }
 }
diff --git a/src/shuffle.rs b/src/shuffle.rs
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/shuffle.rs
diff --git a/src/state.rs b/src/state.rs
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/state.rs
diff --git a/src/time.rs b/src/time.rs
new file mode 100644
index 0000000..2cdd768
--- /dev/null
+++ b/src/time.rs
@@ -0,0 +1,50 @@
+use std::time::{SystemTime, Duration};
+use sdl2::ttf;
+use sdl2::render::{Texture, TextureCreator};
+use sdl2::pixels::Color;
+
+#[derive(PartialEq)]
+pub enum State {
+    Idle,
+    Active,
+    Inactive,
+}
+
+pub struct Timer {
+    pub state: State,
+    time: SystemTime,
+    result: Duration,
+}
+
+impl Timer {
+    pub fn new() -> Timer {
+        Timer {
+            state: State::Inactive,
+            time: SystemTime::now(),
+            result: Duration::new(0, 0),
+        }
+    }
+
+    pub fn start(&mut self) {
+        self.time = SystemTime::now();
+        self.state = State::Active;
+    }
+
+    pub fn stop(&mut self) {
+        self.result = self.time.elapsed().unwrap();
+        self.state = State::Inactive;
+    }
+
+    pub fn idle(&mut self) {
+        self.state = State::Idle;
+    }
+
+    pub fn to_texture<'a, T>(&'a self, font: &ttf::Font, texture_creator: &'a TextureCreator<T>) -> Texture {
+        let rendered = if self.state == State::Active { self.time.elapsed().unwrap() } else { self.result };
+
+        let surface = font.render(&rendered.as_millis().to_string())
+                          .solid(Color::RGB(255, 255, 255))
+                          .unwrap();
+        texture_creator.create_texture_from_surface(&surface).unwrap()
+    }
+}