refactor input to use new table construction function

2 files changed, 1565 insertions, 0 deletions

diff --git a/src/input.c b/src/input.c
new file mode 100644
index 0000000..576adf5
--- /dev/null
+++ b/src/input.c
@@ -0,0 +1,1336 @@
+#include "input.h"
+
+int honey_mouse_movement_callback_ref = LUA_NOREF;
+int honey_mouse_movement_callback_data_ref = LUA_NOREF;
+
+static void honey_glfw_mouse_movement_callback(honey_window window,
+                                               double x_pos, double y_pos);
+static void honey_glfw_keyboard_callback(honey_window window,
+                                         int key, int scancode,
+                                         int action, int mods);
+
+void honey_setup_keyboard()
+{
+    memset(honey_key_states, 0, sizeof(honey_key_states));
+    memset(honey_key_callbacks, LUA_NOREF, sizeof(honey_key_callbacks));
+    memset(honey_key_callbacks_data, LUA_NOREF, sizeof(honey_key_callbacks_data));
+}
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+void honey_setup_input(lua_State* L)
+{
+    honey_setup_keyboard();
+
+    lua_rawgeti(L, LUA_REGISTRYINDEX, honey_window_info_ref);
+    honey_window_information* info = lua_touserdata(L, -1);
+    lua_pop(L, 1);
+
+    glfwSetKeyCallback(info->window, honey_glfw_keyboard_callback);
+    glfwSetCursorPosCallback(info->window, honey_glfw_mouse_movement_callback);
+    
+    honey_lua_create_table(L, 2,
+			   HONEY_TABLE, "key", HONEY_N_KEYS+4,
+
+			   /* key table */
+			   HONEY_INTEGER, "unknown", HONEY_KEY_UNKNOWN,
+			   HONEY_INTEGER, "space", HONEY_KEY_SPACE,
+			   HONEY_INTEGER, "apostrophe", HONEY_KEY_APOSTROPHE,
+			   HONEY_INTEGER, "comma", HONEY_KEY_COMMA,
+			   HONEY_INTEGER, "minus", HONEY_KEY_MINUS,
+			   HONEY_INTEGER, "period", HONEY_KEY_PERIOD,
+			   HONEY_INTEGER, "slash", HONEY_KEY_SLASH,
+			   HONEY_INTEGER, "0", HONEY_KEY_0,
+			   HONEY_INTEGER, "1", HONEY_KEY_1,
+			   HONEY_INTEGER, "2", HONEY_KEY_2,
+			   HONEY_INTEGER, "3", HONEY_KEY_3,
+			   HONEY_INTEGER, "4", HONEY_KEY_4,
+			   HONEY_INTEGER, "5", HONEY_KEY_5,
+			   HONEY_INTEGER, "6", HONEY_KEY_6,
+			   HONEY_INTEGER, "7", HONEY_KEY_7,
+			   HONEY_INTEGER, "8", HONEY_KEY_8,
+			   HONEY_INTEGER, "9", HONEY_KEY_9,
+			   HONEY_INTEGER, "semicolon", HONEY_KEY_SEMICOLON,
+			   HONEY_INTEGER, "equal", HONEY_KEY_EQUAL,
+			   HONEY_INTEGER, "a", HONEY_KEY_A,
+			   HONEY_INTEGER, "b", HONEY_KEY_B,
+			   HONEY_INTEGER, "c", HONEY_KEY_C,
+			   HONEY_INTEGER, "d", HONEY_KEY_D,
+			   HONEY_INTEGER, "e", HONEY_KEY_E,
+			   HONEY_INTEGER, "f", HONEY_KEY_F,
+			   HONEY_INTEGER, "g", HONEY_KEY_G,
+			   HONEY_INTEGER, "h", HONEY_KEY_H,
+			   HONEY_INTEGER, "i", HONEY_KEY_I,
+			   HONEY_INTEGER, "j", HONEY_KEY_J,
+			   HONEY_INTEGER, "k", HONEY_KEY_K,
+			   HONEY_INTEGER, "l", HONEY_KEY_L,
+			   HONEY_INTEGER, "m", HONEY_KEY_M,
+			   HONEY_INTEGER, "n", HONEY_KEY_N,
+			   HONEY_INTEGER, "o", HONEY_KEY_O,
+			   HONEY_INTEGER, "p", HONEY_KEY_P,
+			   HONEY_INTEGER, "q", HONEY_KEY_Q,
+			   HONEY_INTEGER, "r", HONEY_KEY_R,
+			   HONEY_INTEGER, "s", HONEY_KEY_S,
+			   HONEY_INTEGER, "t", HONEY_KEY_T,
+			   HONEY_INTEGER, "u", HONEY_KEY_U,
+			   HONEY_INTEGER, "v", HONEY_KEY_V,
+			   HONEY_INTEGER, "w", HONEY_KEY_W,
+			   HONEY_INTEGER, "x", HONEY_KEY_X,
+			   HONEY_INTEGER, "y", HONEY_KEY_Y,
+			   HONEY_INTEGER, "z", HONEY_KEY_Z,
+			   HONEY_INTEGER, "left_bracket",  HONEY_KEY_LEFT_BRACKET,
+			   HONEY_INTEGER, "backslash",  HONEY_KEY_BACKSLASH,
+			   HONEY_INTEGER, "right_bracket",  HONEY_KEY_RIGHT_BRACKET,
+			   HONEY_INTEGER, "grave_accent",  HONEY_KEY_GRAVE_ACCENT,
+			   HONEY_INTEGER, "world_1",  HONEY_KEY_WORLD_1,
+			   HONEY_INTEGER, "world_2",  HONEY_KEY_WORLD_2,
+			   HONEY_INTEGER, "escape",  HONEY_KEY_ESCAPE,
+			   HONEY_INTEGER, "enter",  HONEY_KEY_ENTER,
+			   HONEY_INTEGER, "tab",  HONEY_KEY_TAB,
+			   HONEY_INTEGER, "backspace",  HONEY_KEY_BACKSPACE,
+			   HONEY_INTEGER, "insert",  HONEY_KEY_INSERT,
+			   HONEY_INTEGER, "delete",  HONEY_KEY_DELETE,
+			   HONEY_INTEGER, "right",  HONEY_KEY_RIGHT,
+			   HONEY_INTEGER, "left",  HONEY_KEY_LEFT,
+			   HONEY_INTEGER, "down",  HONEY_KEY_DOWN,
+			   HONEY_INTEGER, "up",  HONEY_KEY_UP,
+			   HONEY_INTEGER, "page_up",  HONEY_KEY_PAGE_UP,
+			   HONEY_INTEGER, "page_down",  HONEY_KEY_PAGE_DOWN,
+			   HONEY_INTEGER, "home",  HONEY_KEY_HOME,
+			   HONEY_INTEGER, "end",  HONEY_KEY_END,
+			   HONEY_INTEGER, "caps_lock",  HONEY_KEY_CAPS_LOCK,
+			   HONEY_INTEGER, "scroll_lock",  HONEY_KEY_SCROLL_LOCK,
+			   HONEY_INTEGER, "num_lock",  HONEY_KEY_NUM_LOCK,
+			   HONEY_INTEGER, "print_screen",  HONEY_KEY_PRINT_SCREEN,
+			   HONEY_INTEGER, "pause",  HONEY_KEY_PAUSE,
+			   HONEY_INTEGER, "f1",  HONEY_KEY_F1,
+			   HONEY_INTEGER, "f2",  HONEY_KEY_F2,
+			   HONEY_INTEGER, "f3",  HONEY_KEY_F3,
+			   HONEY_INTEGER, "f4",  HONEY_KEY_F4,
+			   HONEY_INTEGER, "f5",  HONEY_KEY_F5,
+			   HONEY_INTEGER, "f6",  HONEY_KEY_F6,
+			   HONEY_INTEGER, "f7",  HONEY_KEY_F7,
+			   HONEY_INTEGER, "f8",  HONEY_KEY_F8,
+			   HONEY_INTEGER, "f9",  HONEY_KEY_F9,
+			   HONEY_INTEGER, "f10",  HONEY_KEY_F10,
+			   HONEY_INTEGER, "f11",  HONEY_KEY_F11,
+			   HONEY_INTEGER, "f12",  HONEY_KEY_F12,
+			   HONEY_INTEGER, "f13",  HONEY_KEY_F13,
+			   HONEY_INTEGER, "f14",  HONEY_KEY_F14,
+			   HONEY_INTEGER, "f15",  HONEY_KEY_F15,
+			   HONEY_INTEGER, "f16",  HONEY_KEY_F16,
+			   HONEY_INTEGER, "f17",  HONEY_KEY_F17,
+			   HONEY_INTEGER, "f18",  HONEY_KEY_F18,
+			   HONEY_INTEGER, "f19",  HONEY_KEY_F19,
+			   HONEY_INTEGER, "f20",  HONEY_KEY_F20,
+			   HONEY_INTEGER, "f21",  HONEY_KEY_F21,
+			   HONEY_INTEGER, "f22",  HONEY_KEY_F22,
+			   HONEY_INTEGER, "f23",  HONEY_KEY_F23,
+			   HONEY_INTEGER, "f24",  HONEY_KEY_F24,
+			   HONEY_INTEGER, "f25",  HONEY_KEY_F25,
+			   HONEY_INTEGER, "kp_0",  HONEY_KEY_KP_0,
+			   HONEY_INTEGER, "kp_1",  HONEY_KEY_KP_1,
+			   HONEY_INTEGER, "kp_2",  HONEY_KEY_KP_2,
+			   HONEY_INTEGER, "kp_3",  HONEY_KEY_KP_3,
+			   HONEY_INTEGER, "kp_4",  HONEY_KEY_KP_4,
+			   HONEY_INTEGER, "kp_5",  HONEY_KEY_KP_5,
+			   HONEY_INTEGER, "kp_6",  HONEY_KEY_KP_6,
+			   HONEY_INTEGER, "kp_7",  HONEY_KEY_KP_7,
+			   HONEY_INTEGER, "kp_8",  HONEY_KEY_KP_8,
+			   HONEY_INTEGER, "kp_9",  HONEY_KEY_KP_9,
+			   HONEY_INTEGER, "kp_decimal",  HONEY_KEY_KP_DECIMAL,
+			   HONEY_INTEGER, "kp_divide",  HONEY_KEY_KP_DIVIDE,
+			   HONEY_INTEGER, "kp_multiply",  HONEY_KEY_KP_MULTIPLY,
+			   HONEY_INTEGER, "kp_subtract",  HONEY_KEY_KP_SUBTRACT,
+			   HONEY_INTEGER, "kp_add",  HONEY_KEY_KP_ADD,
+			   HONEY_INTEGER, "kp_enter",  HONEY_KEY_KP_ENTER,
+			   HONEY_INTEGER, "kp_equal",  HONEY_KEY_KP_EQUAL,
+			   HONEY_INTEGER, "left_shift",  HONEY_KEY_LEFT_SHIFT,
+			   HONEY_INTEGER, "left_control",  HONEY_KEY_LEFT_CONTROL,
+			   HONEY_INTEGER, "left_alt",  HONEY_KEY_LEFT_ALT,
+			   HONEY_INTEGER, "left_super",  HONEY_KEY_LEFT_SUPER,
+			   HONEY_INTEGER, "right_shift",  HONEY_KEY_RIGHT_SHIFT,
+			   HONEY_INTEGER, "right_control",  HONEY_KEY_RIGHT_CONTROL,
+			   HONEY_INTEGER, "right_alt",  HONEY_KEY_RIGHT_ALT,
+			   HONEY_INTEGER, "right_super",  HONEY_KEY_RIGHT_SUPER,
+			   HONEY_INTEGER, "menu",  HONEY_KEY_MENU,
+			   HONEY_FUNCTION, "is_down",  .function = honey_key_down,
+			   HONEY_FUNCTION, "bind",  .function = honey_key_bind,
+			   HONEY_FUNCTION, "unbind",  .function = honey_key_unbind,
+			   HONEY_FUNCTION, "unbind_all",  .function = honey_key_unbind_all,
+
+			   HONEY_TABLE, "mouse", 4,
+
+			   /* mouse table */
+			   HONEY_TABLE, "mode", 3,
+			   HONEY_INTEGER, "normal", HONEY_MOUSE_MODE_NORMAL,
+			   HONEY_INTEGER, "hidden", HONEY_MOUSE_MODE_HIDDEN,
+			   HONEY_INTEGER, "captured", HONEY_MOUSE_MODE_CAPTURED,
+			   HONEY_FUNCTION, "set_mode", honey_mouse_set_mode,
+			   HONEY_FUNCTION, "bind_movement", honey_mouse_movement_bind,
+			   HONEY_FUNCTION, "unbind_movement", honey_mouse_movement_unbind);
+}
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+int honey_key_down(lua_State* L)
+{
+    int key;
+    honey_lua_parse_arguments(L, 1, 1, HONEY_INTEGER, &key);
+
+    if (key < 0 || key >= HONEY_N_KEYS)
+        lua_pushboolean(L, false);
+    else
+        lua_pushboolean(L, honey_key_states[key]);
+
+    return 1;
+}
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+int honey_key_bind(lua_State* L)
+{
+    int key;
+
+    int choice = honey_lua_parse_arguments
+	(L, 2,
+	 2, HONEY_INTEGER, &key, HONEY_FUNCTION,
+	 3, HONEY_INTEGER, &key, HONEY_FUNCTION, HONEY_ANY);
+
+    lua_pushvalue(L, 2);
+    int callback = luaL_ref(L, LUA_REGISTRYINDEX);
+    int data = LUA_NOREF;
+    if (choice == 1) { /* callback data provided */
+	lua_pushvalue(L, 3);
+	data = luaL_ref(L, LUA_REGISTRYINDEX);
+    }
+
+    /* avoid potential memory leak */
+    lua_pushcfunction(L, honey_key_unbind);
+    lua_pushinteger(L, key);
+    honey_lua_pcall(L, 1, 0);
+
+    if (key >= 0 && key < HONEY_N_KEYS) {
+        honey_key_callbacks[key] = callback;
+        honey_key_callbacks_data[key] = data;
+    }
+
+    return 0;
+}
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+int honey_key_unbind(lua_State* L)
+{
+    int key;
+    honey_lua_parse_arguments
+	(L, 1,
+	 1, HONEY_INTEGER, &key);
+        
+    if (key >=0 && key < HONEY_N_KEYS) {
+	luaL_unref(L, LUA_REGISTRYINDEX, honey_key_callbacks[key]);
+	luaL_unref(L, LUA_REGISTRYINDEX, honey_key_callbacks_data[key]);
+		   
+        honey_key_callbacks[key] = LUA_NOREF;
+        honey_key_callbacks_data[key] = LUA_NOREF;
+    }
+    else
+	honey_lua_throw_error(L,
+			      "'%d' is not a valid keycode",
+			      key);
+    return 0;
+}
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+int honey_key_unbind_all(lua_State* L)
+{
+    for (int i=0; i<HONEY_N_KEYS; i++) {
+	luaL_unref(L, LUA_REGISTRYINDEX, honey_key_callbacks[i]);
+	luaL_unref(L, LUA_REGISTRYINDEX, honey_key_callbacks_data[i]);
+	
+        honey_key_callbacks[i] = LUA_NOREF;
+        honey_key_callbacks_data[i] = LUA_NOREF;
+    }
+}
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+int honey_mouse_set_mode(lua_State* L)
+{
+    int cursor_mode;
+
+    honey_lua_parse_arguments
+	(L, 1,
+	 1, HONEY_INTEGER, &cursor_mode);
+
+    if (honey_window_info_ref == LUA_NOREF ||
+        honey_window_info_ref == LUA_REFNIL) {
+        lua_pushstring(L, "ERROR: no window set!");
+        lua_error(L);
+    }
+    
+    lua_rawgeti(L, LUA_REGISTRYINDEX, honey_window_info_ref);
+    honey_window_information* info = lua_touserdata(L, -1);
+
+    glfwSetInputMode(info->window, GLFW_CURSOR, cursor_mode);
+
+    return 0;
+}
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+int honey_mouse_movement_bind(lua_State* L)
+{
+    honey_lua_parse_arguments
+	(L, 1,
+	 2, HONEY_FUNCTION, HONEY_ANY);
+
+    honey_mouse_movement_unbind(L); /* avoid memory leaks! */
+    
+    lua_pushvalue(L, 1);
+    honey_mouse_movement_callback_ref = luaL_ref(L, LUA_REGISTRYINDEX);
+    lua_pushvalue(L, 2);
+    honey_mouse_movement_callback_data_ref = luaL_ref(L, LUA_REGISTRYINDEX);
+    return 0;
+}
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+int honey_mouse_movement_unbind(lua_State* L)
+{
+    int callback = honey_mouse_movement_callback_ref;
+    int data = honey_mouse_movement_callback_data_ref;
+
+    if (callback != LUA_NOREF || callback != LUA_REFNIL)
+	luaL_unref(L, LUA_REGISTRYINDEX, callback);
+
+    if (data != LUA_NOREF || data != LUA_REFNIL)
+	luaL_unref(L, LUA_REGISTRYINDEX, data);
+
+    honey_mouse_movement_callback_ref = LUA_NOREF;
+    honey_mouse_movement_callback_data_ref = LUA_NOREF;
+    return 0;
+}
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+static void honey_glfw_mouse_movement_callback(honey_window window,
+                                               double x_pos, double y_pos)
+{
+    int callback = honey_mouse_movement_callback_ref;
+    int data = honey_mouse_movement_callback_data_ref;
+    lua_State* L = glfwGetWindowUserPointer(window);
+    
+    if (callback == LUA_NOREF || callback == LUA_REFNIL)
+        return;
+
+    lua_rawgeti(L, LUA_REGISTRYINDEX, callback);
+    lua_pushnumber(L, x_pos);
+    lua_pushnumber(L, y_pos);
+
+    if (data == LUA_NOREF || data == LUA_REFNIL)
+        lua_pushnil(L);
+    else
+        lua_rawgeti(L, LUA_REGISTRYINDEX, data);
+
+    honey_lua_pcall(L, 3, 0);
+}
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+static void execute_lua_key_callback(lua_State* L, int callback, int action, int data)
+{
+    if (callback != LUA_NOREF) {
+        lua_rawgeti(L, LUA_REGISTRYINDEX, callback);
+        lua_pushinteger(L, action);
+        if (data != LUA_REFNIL)
+            lua_rawgeti(L, LUA_REGISTRYINDEX, data);
+        else
+            lua_pushnil(L);
+        honey_lua_pcall(L, 2, 0);
+    }
+}
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
+
+static void honey_glfw_keyboard_callback(honey_window window,
+                                         int key, int scancode,
+                                         int action, int mods)
+{
+    int callback, data;
+    lua_State* L = glfwGetWindowUserPointer(window);
+    switch (key) {
+    case GLFW_KEY_UNKNOWN:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_UNKNOWN] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_UNKNOWN] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_UNKNOWN];
+        data = honey_key_callbacks_data[HONEY_KEY_UNKNOWN];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_SPACE:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_SPACE] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_SPACE] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_SPACE];
+        data = honey_key_callbacks_data[HONEY_KEY_SPACE];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_APOSTROPHE:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_APOSTROPHE] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_APOSTROPHE] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_APOSTROPHE];
+        data = honey_key_callbacks_data[HONEY_KEY_APOSTROPHE];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_COMMA:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_COMMA] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_COMMA] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_COMMA];
+        data = honey_key_callbacks_data[HONEY_KEY_COMMA];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_MINUS:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_MINUS] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_MINUS] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_MINUS];
+        data = honey_key_callbacks_data[HONEY_KEY_MINUS];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_PERIOD:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_PERIOD] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_PERIOD] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_PERIOD];
+        data = honey_key_callbacks_data[HONEY_KEY_PERIOD];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_SLASH:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_SLASH] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_SLASH] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_SLASH];
+        data = honey_key_callbacks_data[HONEY_KEY_SLASH];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_0:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_0] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_0] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_0];
+        data = honey_key_callbacks_data[HONEY_KEY_0];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_1:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_1] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_1] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_1];
+        data = honey_key_callbacks_data[HONEY_KEY_1];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_2:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_2] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_2] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_2];
+        data = honey_key_callbacks_data[HONEY_KEY_2];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_3:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_3] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_3] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_3];
+        data = honey_key_callbacks_data[HONEY_KEY_3];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_4:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_4] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_4] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_4];
+        data = honey_key_callbacks_data[HONEY_KEY_4];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_5:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_5] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_5] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_5];
+        data = honey_key_callbacks_data[HONEY_KEY_5];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_6:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_6] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_6] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_6];
+        data = honey_key_callbacks_data[HONEY_KEY_6];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_7:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_7] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_7] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_7];
+        data = honey_key_callbacks_data[HONEY_KEY_7];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_8:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_8] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_8] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_8];
+        data = honey_key_callbacks_data[HONEY_KEY_8];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_9:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_9] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_9] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_9];
+        data = honey_key_callbacks_data[HONEY_KEY_9];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_SEMICOLON:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_SEMICOLON] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_SEMICOLON] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_SEMICOLON];
+        data = honey_key_callbacks_data[HONEY_KEY_SEMICOLON];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_EQUAL:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_EQUAL] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_EQUAL] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_EQUAL];
+        data = honey_key_callbacks_data[HONEY_KEY_EQUAL];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_A:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_A] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_A] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_A];
+        data = honey_key_callbacks_data[HONEY_KEY_A];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_B:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_B] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_B] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_B];
+        data = honey_key_callbacks_data[HONEY_KEY_B];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_C:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_C] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_C] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_C];
+        data = honey_key_callbacks_data[HONEY_KEY_C];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_D:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_D] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_D] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_D];
+        data = honey_key_callbacks_data[HONEY_KEY_D];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_E:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_E] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_E] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_E];
+        data = honey_key_callbacks_data[HONEY_KEY_E];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F];
+        data = honey_key_callbacks_data[HONEY_KEY_F];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_G:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_G] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_G] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_G];
+        data = honey_key_callbacks_data[HONEY_KEY_G];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_H:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_H] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_H] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_H];
+        data = honey_key_callbacks_data[HONEY_KEY_H];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_I:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_I] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_I] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_I];
+        data = honey_key_callbacks_data[HONEY_KEY_I];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_J:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_J] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_J] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_J];
+        data = honey_key_callbacks_data[HONEY_KEY_J];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_K:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_K] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_K] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_K];
+        data = honey_key_callbacks_data[HONEY_KEY_K];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_L:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_L] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_L] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_L];
+        data = honey_key_callbacks_data[HONEY_KEY_L];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_M:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_M] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_M] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_M];
+        data = honey_key_callbacks_data[HONEY_KEY_M];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_N:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_N] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_N] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_N];
+        data = honey_key_callbacks_data[HONEY_KEY_N];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_O:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_O] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_O] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_O];
+        data = honey_key_callbacks_data[HONEY_KEY_O];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_P:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_P] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_P] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_P];
+        data = honey_key_callbacks_data[HONEY_KEY_P];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_Q:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_Q] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_Q] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_Q];
+        data = honey_key_callbacks_data[HONEY_KEY_Q];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_R:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_R] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_R] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_R];
+        data = honey_key_callbacks_data[HONEY_KEY_R];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_S:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_S] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_S] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_S];
+        data = honey_key_callbacks_data[HONEY_KEY_S];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_T:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_T] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_T] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_T];
+        data = honey_key_callbacks_data[HONEY_KEY_T];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_U:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_U] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_U] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_U];
+        data = honey_key_callbacks_data[HONEY_KEY_U];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_V:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_V] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_V] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_V];
+        data = honey_key_callbacks_data[HONEY_KEY_V];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_W:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_W] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_W] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_W];
+        data = honey_key_callbacks_data[HONEY_KEY_W];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_X:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_X] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_X] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_X];
+        data = honey_key_callbacks_data[HONEY_KEY_X];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_Y:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_Y] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_Y] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_Y];
+        data = honey_key_callbacks_data[HONEY_KEY_Y];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_Z:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_Z] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_Z] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_Z];
+        data = honey_key_callbacks_data[HONEY_KEY_Z];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_LEFT_BRACKET:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_LEFT_BRACKET] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_LEFT_BRACKET] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_LEFT_BRACKET];
+        data = honey_key_callbacks_data[HONEY_KEY_LEFT_BRACKET];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_BACKSLASH:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_BACKSLASH] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_BACKSLASH] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_BACKSLASH];
+        data = honey_key_callbacks_data[HONEY_KEY_BACKSLASH];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_RIGHT_BRACKET:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_RIGHT_BRACKET] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_RIGHT_BRACKET] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_RIGHT_BRACKET];
+        data = honey_key_callbacks_data[HONEY_KEY_RIGHT_BRACKET];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_GRAVE_ACCENT:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_GRAVE_ACCENT] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_GRAVE_ACCENT] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_GRAVE_ACCENT];
+        data = honey_key_callbacks_data[HONEY_KEY_GRAVE_ACCENT];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_WORLD_1:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_WORLD_1] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_WORLD_1] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_WORLD_1];
+        data = honey_key_callbacks_data[HONEY_KEY_WORLD_1];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_WORLD_2:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_WORLD_2] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_WORLD_2] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_WORLD_2];
+        data = honey_key_callbacks_data[HONEY_KEY_WORLD_2];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_ESCAPE:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_ESCAPE] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_ESCAPE] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_ESCAPE];
+        data = honey_key_callbacks_data[HONEY_KEY_ESCAPE];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_ENTER:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_ENTER] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_ENTER] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_ENTER];
+        data = honey_key_callbacks_data[HONEY_KEY_ENTER];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_TAB:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_TAB] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_TAB] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_TAB];
+        data = honey_key_callbacks_data[HONEY_KEY_TAB];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_BACKSPACE:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_BACKSPACE] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_BACKSPACE] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_BACKSPACE];
+        data = honey_key_callbacks_data[HONEY_KEY_BACKSPACE];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_INSERT:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_INSERT] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_INSERT] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_INSERT];
+        data = honey_key_callbacks_data[HONEY_KEY_INSERT];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_DELETE:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_DELETE] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_DELETE] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_DELETE];
+        data = honey_key_callbacks_data[HONEY_KEY_DELETE];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_RIGHT:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_RIGHT] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_RIGHT] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_RIGHT];
+        data = honey_key_callbacks_data[HONEY_KEY_RIGHT];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_LEFT:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_LEFT] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_LEFT] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_LEFT];
+        data = honey_key_callbacks_data[HONEY_KEY_LEFT];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_DOWN:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_DOWN] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_DOWN] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_DOWN];
+        data = honey_key_callbacks_data[HONEY_KEY_DOWN];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_UP:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_UP] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_UP] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_UP];
+        data = honey_key_callbacks_data[HONEY_KEY_UP];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_PAGE_UP:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_PAGE_UP] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_PAGE_UP] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_PAGE_UP];
+        data = honey_key_callbacks_data[HONEY_KEY_PAGE_UP];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_PAGE_DOWN:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_PAGE_DOWN] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_PAGE_DOWN] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_PAGE_DOWN];
+        data = honey_key_callbacks_data[HONEY_KEY_PAGE_DOWN];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_HOME:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_HOME] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_HOME] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_HOME];
+        data = honey_key_callbacks_data[HONEY_KEY_HOME];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_END:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_END] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_END] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_END];
+        data = honey_key_callbacks_data[HONEY_KEY_END];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_CAPS_LOCK:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_CAPS_LOCK] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_CAPS_LOCK] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_CAPS_LOCK];
+        data = honey_key_callbacks_data[HONEY_KEY_CAPS_LOCK];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_SCROLL_LOCK:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_SCROLL_LOCK] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_SCROLL_LOCK] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_SCROLL_LOCK];
+        data = honey_key_callbacks_data[HONEY_KEY_SCROLL_LOCK];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_NUM_LOCK:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_NUM_LOCK] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_NUM_LOCK] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_NUM_LOCK];
+        data = honey_key_callbacks_data[HONEY_KEY_NUM_LOCK];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_PRINT_SCREEN:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_PRINT_SCREEN] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_PRINT_SCREEN] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_PRINT_SCREEN];
+        data = honey_key_callbacks_data[HONEY_KEY_PRINT_SCREEN];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_PAUSE:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_PAUSE] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_PAUSE] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_PAUSE];
+        data = honey_key_callbacks_data[HONEY_KEY_PAUSE];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F1:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F1] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F1] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F1];
+        data = honey_key_callbacks_data[HONEY_KEY_F1];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F2:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F2] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F2] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F2];
+        data = honey_key_callbacks_data[HONEY_KEY_F2];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F3:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F3] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F3] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F3];
+        data = honey_key_callbacks_data[HONEY_KEY_F3];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F4:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F4] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F4] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F4];
+        data = honey_key_callbacks_data[HONEY_KEY_F4];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F5:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F5] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F5] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F5];
+        data = honey_key_callbacks_data[HONEY_KEY_F5];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F6:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F6] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F6] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F6];
+        data = honey_key_callbacks_data[HONEY_KEY_F6];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F7:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F7] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F7] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F7];
+        data = honey_key_callbacks_data[HONEY_KEY_F7];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F8:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F8] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F8] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F8];
+        data = honey_key_callbacks_data[HONEY_KEY_F8];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F9:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F9] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F9] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F9];
+        data = honey_key_callbacks_data[HONEY_KEY_F9];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F10:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F10] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F10] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F10];
+        data = honey_key_callbacks_data[HONEY_KEY_F10];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F11:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F11] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F11] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F11];
+        data = honey_key_callbacks_data[HONEY_KEY_F11];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F12:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F12] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F12] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F12];
+        data = honey_key_callbacks_data[HONEY_KEY_F12];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F13:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F13] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F13] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F13];
+        data = honey_key_callbacks_data[HONEY_KEY_F13];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F14:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F14] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F14] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F14];
+        data = honey_key_callbacks_data[HONEY_KEY_F14];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F15:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F15] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F15] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F15];
+        data = honey_key_callbacks_data[HONEY_KEY_F15];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F16:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F16] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F16] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F16];
+        data = honey_key_callbacks_data[HONEY_KEY_F16];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F17:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F17] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F17] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F17];
+        data = honey_key_callbacks_data[HONEY_KEY_F17];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F18:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F18] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F18] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F18];
+        data = honey_key_callbacks_data[HONEY_KEY_F18];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F19:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F19] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F19] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F19];
+        data = honey_key_callbacks_data[HONEY_KEY_F19];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F20:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F20] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F20] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F20];
+        data = honey_key_callbacks_data[HONEY_KEY_F20];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F21:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F21] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F21] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F21];
+        data = honey_key_callbacks_data[HONEY_KEY_F21];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F22:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F22] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F22] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F22];
+        data = honey_key_callbacks_data[HONEY_KEY_F22];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F23:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F23] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F23] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F23];
+        data = honey_key_callbacks_data[HONEY_KEY_F23];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F24:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F24] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F24] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F24];
+        data = honey_key_callbacks_data[HONEY_KEY_F24];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_F25:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_F25] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_F25] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_F25];
+        data = honey_key_callbacks_data[HONEY_KEY_F25];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_0:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_0] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_0] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_0];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_0];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_1:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_1] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_1] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_1];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_1];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_2:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_2] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_2] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_2];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_2];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_3:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_3] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_3] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_3];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_3];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_4:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_4] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_4] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_4];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_4];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_5:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_5] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_5] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_5];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_5];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_6:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_6] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_6] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_6];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_6];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_7:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_7] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_7] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_7];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_7];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_8:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_8] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_8] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_8];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_8];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_9:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_9] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_9] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_9];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_9];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_DECIMAL:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_DECIMAL] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_DECIMAL] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_DECIMAL];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_DECIMAL];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_DIVIDE:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_DIVIDE] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_DIVIDE] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_DIVIDE];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_DIVIDE];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_MULTIPLY:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_MULTIPLY] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_MULTIPLY] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_MULTIPLY];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_MULTIPLY];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_SUBTRACT:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_SUBTRACT] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_SUBTRACT] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_SUBTRACT];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_SUBTRACT];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_ADD:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_ADD] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_ADD] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_ADD];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_ADD];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_ENTER:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_ENTER] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_ENTER] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_ENTER];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_ENTER];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_KP_EQUAL:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_KP_EQUAL] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_KP_EQUAL] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_KP_EQUAL];
+        data = honey_key_callbacks_data[HONEY_KEY_KP_EQUAL];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_LEFT_SHIFT:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_LEFT_SHIFT] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_LEFT_SHIFT] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_LEFT_SHIFT];
+        data = honey_key_callbacks_data[HONEY_KEY_LEFT_SHIFT];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_LEFT_CONTROL:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_LEFT_CONTROL] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_LEFT_CONTROL] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_LEFT_CONTROL];
+        data = honey_key_callbacks_data[HONEY_KEY_LEFT_CONTROL];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_LEFT_ALT:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_LEFT_ALT] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_LEFT_ALT] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_LEFT_ALT];
+        data = honey_key_callbacks_data[HONEY_KEY_LEFT_ALT];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_LEFT_SUPER:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_LEFT_SUPER] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_LEFT_SUPER] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_LEFT_SUPER];
+        data = honey_key_callbacks_data[HONEY_KEY_LEFT_SUPER];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_RIGHT_SHIFT:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_RIGHT_SHIFT] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_RIGHT_SHIFT] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_RIGHT_SHIFT];
+        data = honey_key_callbacks_data[HONEY_KEY_RIGHT_SHIFT];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_RIGHT_CONTROL:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_RIGHT_CONTROL] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_RIGHT_CONTROL] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_RIGHT_CONTROL];
+        data = honey_key_callbacks_data[HONEY_KEY_RIGHT_CONTROL];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_RIGHT_ALT:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_RIGHT_ALT] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_RIGHT_ALT] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_RIGHT_ALT];
+        data = honey_key_callbacks_data[HONEY_KEY_RIGHT_ALT];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_RIGHT_SUPER:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_RIGHT_SUPER] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_RIGHT_SUPER] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_RIGHT_SUPER];
+        data = honey_key_callbacks_data[HONEY_KEY_RIGHT_SUPER];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    case GLFW_KEY_MENU:
+        if (action == HONEY_KEY_PRESS)   { honey_key_states[HONEY_KEY_MENU] = 1; }
+        if (action == HONEY_KEY_RELEASE) { honey_key_states[HONEY_KEY_MENU] = 0; }
+        callback = honey_key_callbacks[HONEY_KEY_MENU];
+        data = honey_key_callbacks_data[HONEY_KEY_MENU];
+        execute_lua_key_callback(L, callback, action, data);
+        break;
+        
+    default:
+        /* do nothing */
+        break;
+    }
+}
diff --git a/src/input.h b/src/input.h
new file mode 100644
index 0000000..7fd3293
--- /dev/null
+++ b/src/input.h
@@ -0,0 +1,229 @@
+#ifndef HONEY_INPUT_H
+#define HONEY_INPUT_H
+
+/** @file input.h
+ *
+ * @brief Wrap GLFW input functions for honey.
+ */
+
+#include "../common.h"
+
+#define HONEY_KEY_UNKNOWN 0
+#define HONEY_KEY_SPACE 1
+#define HONEY_KEY_APOSTROPHE 2
+#define HONEY_KEY_COMMA 3
+#define HONEY_KEY_MINUS 4
+#define HONEY_KEY_PERIOD 5
+#define HONEY_KEY_SLASH 6
+#define HONEY_KEY_0 7
+#define HONEY_KEY_1 8
+#define HONEY_KEY_2 9
+#define HONEY_KEY_3 10
+#define HONEY_KEY_4 11
+#define HONEY_KEY_5 12
+#define HONEY_KEY_6 13
+#define HONEY_KEY_7 14
+#define HONEY_KEY_8 15
+#define HONEY_KEY_9 16
+#define HONEY_KEY_SEMICOLON 17
+#define HONEY_KEY_EQUAL 18
+#define HONEY_KEY_A 19
+#define HONEY_KEY_B 20
+#define HONEY_KEY_C 21
+#define HONEY_KEY_D 22
+#define HONEY_KEY_E 23
+#define HONEY_KEY_F 24
+#define HONEY_KEY_G 25
+#define HONEY_KEY_H 26
+#define HONEY_KEY_I 27
+#define HONEY_KEY_J 28
+#define HONEY_KEY_K 29
+#define HONEY_KEY_L 30
+#define HONEY_KEY_M 31
+#define HONEY_KEY_N 32
+#define HONEY_KEY_O 33
+#define HONEY_KEY_P 34
+#define HONEY_KEY_Q 35
+#define HONEY_KEY_R 36
+#define HONEY_KEY_S 37
+#define HONEY_KEY_T 38
+#define HONEY_KEY_U 39
+#define HONEY_KEY_V 40
+#define HONEY_KEY_W 41
+#define HONEY_KEY_X 42
+#define HONEY_KEY_Y 43
+#define HONEY_KEY_Z 44
+#define HONEY_KEY_LEFT_BRACKET 45
+#define HONEY_KEY_BACKSLASH 46
+#define HONEY_KEY_RIGHT_BRACKET 47
+#define HONEY_KEY_GRAVE_ACCENT 48
+#define HONEY_KEY_WORLD_1 49
+#define HONEY_KEY_WORLD_2 50
+#define HONEY_KEY_ESCAPE 51
+#define HONEY_KEY_ENTER 52
+#define HONEY_KEY_TAB 53
+#define HONEY_KEY_BACKSPACE 54
+#define HONEY_KEY_INSERT 55
+#define HONEY_KEY_DELETE 56
+#define HONEY_KEY_RIGHT 57
+#define HONEY_KEY_LEFT 58
+#define HONEY_KEY_DOWN 59
+#define HONEY_KEY_UP 60
+#define HONEY_KEY_PAGE_UP 61
+#define HONEY_KEY_PAGE_DOWN 62
+#define HONEY_KEY_HOME 63
+#define HONEY_KEY_END 64
+#define HONEY_KEY_CAPS_LOCK 65
+#define HONEY_KEY_SCROLL_LOCK 66
+#define HONEY_KEY_NUM_LOCK 67
+#define HONEY_KEY_PRINT_SCREEN 68
+#define HONEY_KEY_PAUSE 69
+#define HONEY_KEY_F1 70
+#define HONEY_KEY_F2 71
+#define HONEY_KEY_F3 72
+#define HONEY_KEY_F4 73
+#define HONEY_KEY_F5 74
+#define HONEY_KEY_F6 75
+#define HONEY_KEY_F7 76
+#define HONEY_KEY_F8 77
+#define HONEY_KEY_F9 78
+#define HONEY_KEY_F10 79
+#define HONEY_KEY_F11 80
+#define HONEY_KEY_F12 81
+#define HONEY_KEY_F13 82
+#define HONEY_KEY_F14 83
+#define HONEY_KEY_F15 84
+#define HONEY_KEY_F16 85
+#define HONEY_KEY_F17 86
+#define HONEY_KEY_F18 87
+#define HONEY_KEY_F19 88
+#define HONEY_KEY_F20 89
+#define HONEY_KEY_F21 90
+#define HONEY_KEY_F22 91
+#define HONEY_KEY_F23 92
+#define HONEY_KEY_F24 93
+#define HONEY_KEY_F25 94
+#define HONEY_KEY_KP_0 95
+#define HONEY_KEY_KP_1 96
+#define HONEY_KEY_KP_2 97
+#define HONEY_KEY_KP_3 98
+#define HONEY_KEY_KP_4 99
+#define HONEY_KEY_KP_5 100
+#define HONEY_KEY_KP_6 101
+#define HONEY_KEY_KP_7 102
+#define HONEY_KEY_KP_8 103
+#define HONEY_KEY_KP_9 104
+#define HONEY_KEY_KP_DECIMAL 105
+#define HONEY_KEY_KP_DIVIDE 106
+#define HONEY_KEY_KP_MULTIPLY 107
+#define HONEY_KEY_KP_SUBTRACT 108
+#define HONEY_KEY_KP_ADD 109
+#define HONEY_KEY_KP_ENTER 110
+#define HONEY_KEY_KP_EQUAL 111
+#define HONEY_KEY_LEFT_SHIFT 112
+#define HONEY_KEY_LEFT_CONTROL 113
+#define HONEY_KEY_LEFT_ALT 114
+#define HONEY_KEY_LEFT_SUPER 115
+#define HONEY_KEY_RIGHT_SHIFT 116
+#define HONEY_KEY_RIGHT_CONTROL 117
+#define HONEY_KEY_RIGHT_ALT 118
+#define HONEY_KEY_RIGHT_SUPER 119
+#define HONEY_KEY_MENU 120
+
+#define HONEY_N_KEYS 121
+
+#define HONEY_KEY_PRESS GLFW_PRESS
+#define HONEY_KEY_RELEASE GLFW_RELEASE
+
+#define HONEY_MOUSE_MODE_NORMAL GLFW_CURSOR_NORMAL
+#define HONEY_MOUSE_MODE_HIDDEN GLFW_CURSOR_HIDDEN
+#define HONEY_MOUSE_MODE_DISABLED GLFW_CURSOR_DISABLED
+
+unsigned int honey_key_states[HONEY_N_KEYS];
+static int honey_key_callbacks[HONEY_N_KEYS];
+static int honey_key_callbacks_data[HONEY_N_KEYS];
+
+extern int honey_mouse_movement_callback_ref;
+extern int honey_mouse_movement_callback_data_ref;
+
+/** @brief Initializes Honey's internal keyboard states.
+ * 
+ * This function is called by honey_setup, so you shouldn't need
+ * to manually call it in most cases.
+ */
+void honey_setup_keyboard();
+
+/* @brief Place a lua table containing the enum values for GLFW keys on the stack. 
+ * 
+ * @param L The lua state to place the table on the top of the stack.
+ *
+ * @returns Nothing.
+ */
+void honey_setup_input(lua_State* L);
+
+/** @brief Check if a key is down.
+ *
+ * This function accepts a single integer as input and returns TRUE if the integer
+ * refers to a valid key and is pressed down, and false otherwise.
+ *
+ * @param[in] L The lua state.
+ * 
+ * @return 1 on success and 0 on failure.
+ */
+int honey_key_down(lua_State* L);
+
+/** @brief Bind a callback to a key.
+ *
+ * The callback must have signature (void*, int), where the first argument is supplied by the 
+ * void* supplied with this function, and the int is one of HONEY_KEY_PRESS or HONEY_KEY_RELEASE,
+ * depending on the action that triggered the callback.
+ *
+ * @param[in] key The key to bind the callback to.
+ * @param[in] callback The callback function to bind.
+ * @param[in] data Data to pass to the callback function upon triggering.
+ */
+int honey_key_bind(lua_State* L);
+
+/** @brief Unbind a key callback.
+ *
+ * THIS FUNCTION DOES NOT FREE MEMORY! If you allocated any, be sure to free it yourself!
+ *
+ * @param[in] key The key to unbind a callback from.
+ */
+int honey_key_unbind(lua_State* L);
+
+/** @brief Unbind all key callbacks.
+ *
+ * THIS FUNCTION DOES NOT FREE MEMORY! If you allocated any, be sure to free it yourself!
+ */
+int honey_key_unbind_all(lua_State* L);
+
+/** @brief Set the cursor mode.
+ *
+ * @param[in] mode The mouse mode (from honey.input.mouse.mode) to use.
+ *
+ * @returns Nothing.
+ */
+int honey_mouse_set_mode(lua_State* L);
+
+/** Bind a callback to mouse movement.
+ *
+ * The callback should be of the form cb(xpos, ypos, data),
+ * where xpos and ypos are the coordinates of the mouse relative to the
+ * upper left corner of the window, and data is the data parameter passed
+ * to this function.
+ *
+ * @param[in] callback A callback as described above.
+ * @param[in] data Auxilliary data to pass to the callback.
+ *
+ * @returns Nothing.
+ */
+int honey_mouse_movement_bind(lua_State* L);
+
+/** Unbind any callback that may be attached to mouse movement.
+ *
+ * @returns Nothing.
+ */
+int honey_mouse_movement_unbind(lua_State* L);
+
+#endif