split input into two methods for key_up and key_down

6 files changed, 53 insertions, 64 deletions

diff --git a/example/src/main.rs b/example/src/main.rs
index 66ff9e5..c24270d 100644
--- a/example/src/main.rs
+++ b/example/src/main.rs
@@ -16,7 +16,7 @@ extern crate gate;
 
 use gate::{App, AppContext};
 use gate::app_info::AppInfo;
-use gate::input::{KeyEvent, KeyCode};
+use gate::input::KeyCode;
 use gate::renderer::{Renderer, Affine};
 
 mod asset_id { include!(concat!(env!("OUT_DIR"), "/asset_id.rs")); }
@@ -62,33 +62,31 @@ impl App<AssetId> for TowerGame {
         }
     }
 
-    fn input(&mut self, evt: KeyEvent, key: KeyCode, ctx: &mut AppContext<AssetId>) {
-        if evt == KeyEvent::Pressed {
-            let index = match key {
-                KeyCode::Num1 => Some(0),
-                KeyCode::Num2 => Some(1),
-                KeyCode::Num3 => Some(2),
-                KeyCode::MouseLeft => pillar_for_cursor(ctx.cursor()),
-                _ => None,
-            };
-            if let Some(index) = index {
-                let pillar = &mut self.pillars[index];
-                if let Some(held) = self.held.take() {
-                    if pillar.last().map_or(true, |&v| v > held.value) {
-                        pillar.push(held.value);
-                        ctx.audio.play_sound(SoundId::Shuffle);
-                    } else {
-                        self.held = Some(held);
-                        ctx.audio.play_sound(SoundId::Error);
-                    }
+    fn key_down(&mut self, key: KeyCode, ctx: &mut AppContext<AssetId>) {
+        let index = match key {
+            KeyCode::Num1 => Some(0),
+            KeyCode::Num2 => Some(1),
+            KeyCode::Num3 => Some(2),
+            KeyCode::MouseLeft => pillar_for_cursor(ctx.cursor()),
+            _ => None,
+        };
+        if let Some(index) = index {
+            let pillar = &mut self.pillars[index];
+            if let Some(held) = self.held.take() {
+                if pillar.last().map_or(true, |&v| v > held.value) {
+                    pillar.push(held.value);
+                    ctx.audio.play_sound(SoundId::Shuffle);
                 } else {
-                    if let Some(value) = pillar.pop() {
-                        let pos = disc_pos(index, pillar.len());
-                        self.held = Some(HeldDisc { value, pos });
-                        ctx.audio.play_sound(SoundId::Shuffle);
-                    } else {
-                        ctx.audio.play_sound(SoundId::Error);
-                    }
+                    self.held = Some(held);
+                    ctx.audio.play_sound(SoundId::Error);
+                }
+            } else {
+                if let Some(value) = pillar.pop() {
+                    let pos = disc_pos(index, pillar.len());
+                    self.held = Some(HeldDisc { value, pos });
+                    ctx.audio.play_sound(SoundId::Shuffle);
+                } else {
+                    ctx.audio.play_sound(SoundId::Error);
                 }
             }
         }
diff --git a/gate/src/core/sdl/event_handler.rs b/gate/src/core/sdl/event_handler.rs
index 7f82d5e..6af04b8 100644
--- a/gate/src/core/sdl/event_handler.rs
+++ b/gate/src/core/sdl/event_handler.rs
@@ -23,7 +23,7 @@ use sdl2::{
 
 use ::{App, AppContext};
 use asset_id::AppAssetId;
-use input::{KeyEvent, KeyCode};
+use input::KeyCode;
 use renderer::Renderer;
 
 pub struct EventHandler {
@@ -44,14 +44,14 @@ impl EventHandler {
                 Event::KeyDown { keycode: Some(keycode), .. } => {
                     if let Some(keycode) = sdl_to_gate_key(keycode) {
                         if self.held_keys.insert(keycode) {
-                            app.input(KeyEvent::Pressed, keycode, ctx);
+                            app.key_down(keycode, ctx);
                         }
                     }
                 },
                 Event::KeyUp { keycode: Some(keycode), .. } => {
                     if let Some(keycode) = sdl_to_gate_key(keycode) {
                         if self.held_keys.remove(&keycode) {
-                            app.input(KeyEvent::Released, keycode, ctx);
+                            app.key_up(keycode, ctx);
                         }
                     }
                 },
@@ -60,7 +60,7 @@ impl EventHandler {
                     ctx.cursor = renderer.to_app_pos(x, y);
                     if let Some(keycode) = mouse_button_to_gate_key(mouse_btn) {
                         if self.held_keys.insert(keycode) {
-                            app.input(KeyEvent::Pressed, keycode, ctx);
+                            app.key_down(keycode, ctx);
                         }
                     }
                 },
@@ -68,7 +68,7 @@ impl EventHandler {
                     ctx.cursor = renderer.to_app_pos(x, y);
                     if let Some(keycode) = mouse_button_to_gate_key(mouse_btn) {
                         if self.held_keys.remove(&keycode) {
-                            app.input(KeyEvent::Released, keycode, ctx);
+                            app.key_up(keycode, ctx);
                         }
                     }
                 },
diff --git a/gate/src/core/wasm/mod.rs b/gate/src/core/wasm/mod.rs
index 6a9ee4f..8ea3773 100644
--- a/gate/src/core/wasm/mod.rs
+++ b/gate/src/core/wasm/mod.rs
@@ -22,13 +22,13 @@ use std::io::Cursor;
 use std::os::raw::c_int;
 
 use ::{App, AppContext};
-use ::asset_id::{AppAssetId, IdU16};
-use ::renderer::Renderer;
-use ::app_info::AppInfo;
-use ::input::{KeyEvent, KeyCode};
-use ::renderer::atlas::Atlas;
-use ::renderer::render_buffer::RenderBuffer;
-use ::renderer::core_renderer::CoreRenderer;
+use asset_id::{AppAssetId, IdU16};
+use renderer::Renderer;
+use app_info::AppInfo;
+use input::KeyCode;
+use renderer::atlas::Atlas;
+use renderer::render_buffer::RenderBuffer;
+use renderer::core_renderer::CoreRenderer;
 use self::wasm_imports::*;
 use super::mark_app_created_flag;
 
@@ -57,7 +57,7 @@ trait TraitAppRunner {
     fn resize(&mut self, dims: (u32, u32));
     fn update_and_draw(&mut self, time_sec: f64);
     fn update_cursor(&mut self, cursor_x: i32, cursor_y: i32);
-    fn input(&mut self, event: KeyEvent, key: KeyCode);
+    fn input(&mut self, key: KeyCode, down: bool);
     fn music_count(&self) -> u16;
     fn sound_count(&self) -> u16;
 }
@@ -137,14 +137,15 @@ impl<AS: AppAssetId, AP: App<AS>> TraitAppRunner for AppRunner<AS, AP> {
         self.ctx.cursor = self.renderer.as_ref().unwrap().to_app_pos(cursor_x, cursor_y);
     }
 
-    fn input(&mut self, event: KeyEvent, key: KeyCode) {
-        let success = if event == KeyEvent::Pressed {
-            self.held_keys.insert(key)
+    fn input(&mut self, key: KeyCode, down: bool) {
+        if down {
+            if self.held_keys.insert(key) {
+                self.app.key_down(key, &mut self.ctx);
+            }
         } else {
-            self.held_keys.remove(&key)
-        };
-        if success {
-            self.app.input(event, key, &mut self.ctx);
+            if self.held_keys.remove(&key) {
+                self.app.key_up(key, &mut self.ctx);
+            }
         }
     }
 
diff --git a/gate/src/core/wasm/wasm_exports.rs b/gate/src/core/wasm/wasm_exports.rs
index f8cdca4..42716af 100644
--- a/gate/src/core/wasm/wasm_exports.rs
+++ b/gate/src/core/wasm/wasm_exports.rs
@@ -17,7 +17,7 @@
 
 use std::os::raw::{c_int, c_char};
 
-use ::input::{KeyEvent, KeyCode};
+use ::input::KeyCode;
 use ::renderer::shaders;
 use super::{app_runner_is_defined, app_runner_borrow, app_runner_borrow_mut};
 
@@ -41,8 +41,7 @@ pub unsafe extern "C" fn gateWasmUpdateAndDraw(time_millis: f64, cursor_x: c_int
 pub unsafe extern "C" fn gateWasmKeyEvent(code: c_int, down: bool) {
     assert!(code >= 0 && code <= 255);
     let code = KeyCode::from_u8(code as u8).unwrap();
-    let event = if down { KeyEvent::Pressed } else { KeyEvent::Released };
-    app_runner_borrow_mut().input(event, code);
+    app_runner_borrow_mut().input(code, down);
 }
 
 #[no_mangle]
@@ -55,8 +54,7 @@ pub unsafe extern "C" fn gateWasmMouseEvent(cursor_x: c_int, cursor_y: c_int, bu
         _ => None,
     };
     if let Some(code) = code {
-        let event = if down { KeyEvent::Pressed } else { KeyEvent::Released };
-        app_runner_borrow_mut().input(event, code);
+        app_runner_borrow_mut().input(code, down);
     }
 }
 
diff --git a/gate/src/input.rs b/gate/src/input.rs
index 60e5da0..2a05aba 100644
--- a/gate/src/input.rs
+++ b/gate/src/input.rs
@@ -16,15 +16,6 @@
 
 #[cfg(target_arch = "wasm32")] use std::mem;
 
-/// Events related to a keyboard key or similar button.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub enum KeyEvent {
-    /// Key is pressed down.
-    Pressed,
-    /// A pressed down key is released.
-    Released,
-}
-
 /// Enum for keyboard keys and mouse buttons.
 #[repr(u8)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
diff --git a/gate/src/lib.rs b/gate/src/lib.rs
index cf0a7e9..0a1657d 100644
--- a/gate/src/lib.rs
+++ b/gate/src/lib.rs
@@ -68,7 +68,7 @@ use std::marker::PhantomData;
 
 use core::CoreAudio;
 use ::asset_id::{AppAssetId, IdU16};
-use ::input::{KeyEvent, KeyCode};
+use ::input::KeyCode;
 use ::renderer::Renderer;
 use ::app_info::AppInfo;
 
@@ -86,8 +86,9 @@ pub trait App<A: AppAssetId> {
     /// Advances the app state by a given amount of `seconds` (usually a fraction of a second).
     fn advance(&mut self, seconds: f64, ctx: &mut AppContext<A>);
 
-    /// Invoked when user input is received (currently only keyboard presses/releases).
-    fn input(&mut self, event: KeyEvent, key: KeyCode, ctx: &mut AppContext<A>);
+    fn key_down(&mut self, key: KeyCode, ctx: &mut AppContext<A>);
+
+    fn key_up(&mut self, _key: KeyCode, _ctx: &mut AppContext<A>) {}
 
     /// Render the app in its current state.
     fn render(&mut self, renderer: &mut Renderer<A>, ctx: &AppContext<A>);