LOVE/love
1
0
Fork 0
mirror of https://github.com/love2d/love.git synced 2026-08-17 11:00:31 +02:00
Code Issues Packages Projects Releases Wiki Activity

Finally abstracted constants properly. Changed how the event module works; wasn't really abstract before. Removed libs we're not going to use: native, signal.

Browse Source
This commit is contained in:
rude
2009-10-10 11:11:04 +02:00
parent 0a2ae705dd
commit 87e3c4131c
101 changed files with 3225 additions and 33496 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/modules/keyboard/Keyboard.cpp
+187
View File
@@ -0,0 +1,187 @@
/**
* Copyright (c) 2006-2009 LOVE Development Team
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
**/
#include "Keyboard.h"
namespace love
{
namespace keyboard
{
bool Keyboard::getConstant(const char * in, Keyboard::Key & out)
{
return keys.find(in, out);
}
bool Keyboard::getConstant(Keyboard::Key in, const char *& out)
{
return keys.find(in, out);
}
StringMap<Keyboard::Key, Keyboard::KEY_MAX_ENUM>::Entry Keyboard::keyEntries[] =
{
{"backspace", Keyboard::KEY_BACKSPACE},
{"tab", Keyboard::KEY_TAB},
{"clear", Keyboard::KEY_CLEAR},
{"return", Keyboard::KEY_RETURN},
{"pause", Keyboard::KEY_PAUSE},
{"escape", Keyboard::KEY_ESCAPE},
{" ", Keyboard::KEY_SPACE},
{"!", Keyboard::KEY_EXCLAIM},
{"\"", Keyboard::KEY_QUOTEDBL},
{"#", Keyboard::KEY_HASH},
{"$", Keyboard::KEY_DOLLAR},
{"&", Keyboard::KEY_AMPERSAND},
{"'", Keyboard::KEY_QUOTE},
{"(", Keyboard::KEY_LEFTPAREN},
{")", Keyboard::KEY_RIGHTPAREN},
{"*", Keyboard::KEY_ASTERISK},
{"+", Keyboard::KEY_PLUS},
{",", Keyboard::KEY_COMMA},
{"-", Keyboard::KEY_MINUS},
{".", Keyboard::KEY_PERIOD},
{"/", Keyboard::KEY_SLASH},
{"0", Keyboard::KEY_0},
{"1", Keyboard::KEY_1},
{"2", Keyboard::KEY_2},
{"3", Keyboard::KEY_3},
{"4", Keyboard::KEY_4},
{"5", Keyboard::KEY_5},
{"6", Keyboard::KEY_6},
{"7", Keyboard::KEY_7},
{"8", Keyboard::KEY_8},
{"9", Keyboard::KEY_9},
{":", Keyboard::KEY_COLON},
{";", Keyboard::KEY_SEMICOLON},
{"<", Keyboard::KEY_LESS},
{"=", Keyboard::KEY_EQUALS},
{">", Keyboard::KEY_GREATER},
{"?", Keyboard::KEY_QUESTION},
{"@", Keyboard::KEY_AT},
{"[", Keyboard::KEY_LEFTBRACKET},
{"\\", Keyboard::KEY_BACKSLASH},
{"]", Keyboard::KEY_RIGHTBRACKET},
{"^", Keyboard::KEY_CARET},
{"_", Keyboard::KEY_UNDERSCORE},
{"`", Keyboard::KEY_BACKQUOTE},
{"a", Keyboard::KEY_A},
{"b", Keyboard::KEY_B},
{"c", Keyboard::KEY_C},
{"d", Keyboard::KEY_D},
{"e", Keyboard::KEY_E},
{"f", Keyboard::KEY_F},
{"g", Keyboard::KEY_G},
{"h", Keyboard::KEY_H},
{"i", Keyboard::KEY_I},
{"j", Keyboard::KEY_J},
{"k", Keyboard::KEY_K},
{"l", Keyboard::KEY_L},
{"m", Keyboard::KEY_M},
{"n", Keyboard::KEY_N},
{"o", Keyboard::KEY_O},
{"p", Keyboard::KEY_P},
{"q", Keyboard::KEY_Q},
{"r", Keyboard::KEY_R},
{"s", Keyboard::KEY_S},
{"t", Keyboard::KEY_T},
{"u", Keyboard::KEY_U},
{"v", Keyboard::KEY_V},
{"w", Keyboard::KEY_W},
{"x", Keyboard::KEY_X},
{"y", Keyboard::KEY_Y},
{"z", Keyboard::KEY_Z},
{"delete", Keyboard::KEY_DELETE},
{"kp0", Keyboard::KEY_KP0},
{"kp1", Keyboard::KEY_KP1},
{"kp2", Keyboard::KEY_KP2},
{"kp3", Keyboard::KEY_KP3},
{"kp4", Keyboard::KEY_KP4},
{"kp5", Keyboard::KEY_KP5},
{"kp6", Keyboard::KEY_KP6},
{"kp7", Keyboard::KEY_KP7},
{"kp8", Keyboard::KEY_KP8},
{"kp9", Keyboard::KEY_KP9},
{"kp.", Keyboard::KEY_KP_PERIOD},
{"kp/", Keyboard::KEY_KP_DIVIDE},
{"kp*", Keyboard::KEY_KP_MULTIPLY},
{"kp-", Keyboard::KEY_KP_MINUS},
{"kp+", Keyboard::KEY_KP_PLUS},
{"kpenter", Keyboard::KEY_KP_ENTER},
{"kp=", Keyboard::KEY_KP_EQUALS},
{"kpup", Keyboard::KEY_UP},
{"kpdown", Keyboard::KEY_DOWN},
{"kpright", Keyboard::KEY_RIGHT},
{"kpleft", Keyboard::KEY_LEFT},
{"kpinsert", Keyboard::KEY_INSERT},
{"kphome", Keyboard::KEY_HOME},
{"kpend", Keyboard::KEY_END},
{"kppageup", Keyboard::KEY_PAGEUP},
{"kppagedown", Keyboard::KEY_PAGEDOWN},
{"f1", Keyboard::KEY_F1},
{"f2", Keyboard::KEY_F2},
{"f3", Keyboard::KEY_F3},
{"f4", Keyboard::KEY_F4},
{"f5", Keyboard::KEY_F5},
{"f6", Keyboard::KEY_F6},
{"f7", Keyboard::KEY_F7},
{"f8", Keyboard::KEY_F8},
{"f9", Keyboard::KEY_F9},
{"f10", Keyboard::KEY_F10},
{"f11", Keyboard::KEY_F11},
{"f12", Keyboard::KEY_F12},
{"f13", Keyboard::KEY_F13},
{"f14", Keyboard::KEY_F14},
{"f15", Keyboard::KEY_F15},
{"numlock", Keyboard::KEY_NUMLOCK},
{"capslock", Keyboard::KEY_CAPSLOCK},
{"scrollock", Keyboard::KEY_SCROLLOCK},
{"rshift", Keyboard::KEY_RSHIFT},
{"lshift", Keyboard::KEY_LSHIFT},
{"rctrl", Keyboard::KEY_RCTRL},
{"lctrl", Keyboard::KEY_LCTRL},
{"ralt", Keyboard::KEY_RALT},
{"lalt", Keyboard::KEY_LALT},
{"rmeta", Keyboard::KEY_RMETA},
{"lmeta", Keyboard::KEY_LMETA},
{"lsuper", Keyboard::KEY_LSUPER},
{"rsuper", Keyboard::KEY_RSUPER},
{"mode", Keyboard::KEY_MODE},
{"compose", Keyboard::KEY_COMPOSE},
{"help", Keyboard::KEY_HELP},
{"print", Keyboard::KEY_PRINT},
{"sysreq", Keyboard::KEY_SYSREQ},
{"break", Keyboard::KEY_BREAK},
{"menu", Keyboard::KEY_MENU},
{"power", Keyboard::KEY_POWER},
{"euro", Keyboard::KEY_EURO},
{"undo", Keyboard::KEY_UNDO},
};
StringMap<Keyboard::Key, Keyboard::KEY_MAX_ENUM> Keyboard::keys(Keyboard::keyEntries, sizeof(Keyboard::keyEntries));
} // keyboard
} // love
src/modules/keyboard/Keyboard.h
+157 -2
View File
@@ -23,6 +23,7 @@
// LOVE
#include <common/Module.h>
#include <common/StringMap.h>
namespace love
{
@@ -32,11 +33,165 @@ namespace keyboard
{
public:
static const int KEY_REPEAT_DELAY = -1;
static const int KEY_REPEAT_INTERVAL = -2;
enum Key
{
KEY_UNKNOWN,
KEY_BACKSPACE,
KEY_TAB,
KEY_CLEAR,
KEY_RETURN,
KEY_PAUSE,
KEY_ESCAPE,
KEY_SPACE,
KEY_EXCLAIM,
KEY_QUOTEDBL,
KEY_HASH,
KEY_DOLLAR,
KEY_AMPERSAND,
KEY_QUOTE,
KEY_LEFTPAREN,
KEY_RIGHTPAREN,
KEY_ASTERISK,
KEY_PLUS,
KEY_COMMA,
KEY_MINUS,
KEY_PERIOD,
KEY_SLASH,
KEY_0,
KEY_1,
KEY_2,
KEY_3,
KEY_4,
KEY_5,
KEY_6,
KEY_7,
KEY_8,
KEY_9,
KEY_COLON,
KEY_SEMICOLON,
KEY_LESS,
KEY_EQUALS,
KEY_GREATER,
KEY_QUESTION,
KEY_AT,
KEY_LEFTBRACKET,
KEY_BACKSLASH,
KEY_RIGHTBRACKET,
KEY_CARET,
KEY_UNDERSCORE,
KEY_BACKQUOTE,
KEY_A,
KEY_B,
KEY_C,
KEY_D,
KEY_E,
KEY_F,
KEY_G,
KEY_H,
KEY_I,
KEY_J,
KEY_K,
KEY_L,
KEY_M,
KEY_N,
KEY_O,
KEY_P,
KEY_Q,
KEY_R,
KEY_S,
KEY_T,
KEY_U,
KEY_V,
KEY_W,
KEY_X,
KEY_Y,
KEY_Z,
KEY_DELETE,
KEY_KP0,
KEY_KP1,
KEY_KP2,
KEY_KP3,
KEY_KP4,
KEY_KP5,
KEY_KP6,
KEY_KP7,
KEY_KP8,
KEY_KP9,
KEY_KP_PERIOD,
KEY_KP_DIVIDE,
KEY_KP_MULTIPLY,
KEY_KP_MINUS,
KEY_KP_PLUS,
KEY_KP_ENTER,
KEY_KP_EQUALS,
KEY_UP,
KEY_DOWN,
KEY_RIGHT,
KEY_LEFT,
KEY_INSERT,
KEY_HOME,
KEY_END,
KEY_PAGEUP,
KEY_PAGEDOWN,
KEY_F1,
KEY_F2,
KEY_F3,
KEY_F4,
KEY_F5,
KEY_F6,
KEY_F7,
KEY_F8,
KEY_F9,
KEY_F10,
KEY_F11,
KEY_F12,
KEY_F13,
KEY_F14,
KEY_F15,
KEY_NUMLOCK,
KEY_CAPSLOCK,
KEY_SCROLLOCK,
KEY_RSHIFT,
KEY_LSHIFT,
KEY_RCTRL,
KEY_LCTRL,
KEY_RALT,
KEY_LALT,
KEY_RMETA,
KEY_LMETA,
KEY_LSUPER,
KEY_RSUPER,
KEY_MODE,
KEY_COMPOSE,
KEY_HELP,
KEY_PRINT,
KEY_SYSREQ,
KEY_BREAK,
KEY_MENU,
KEY_POWER,
KEY_EURO,
KEY_UNDO,
KEY_MAX_ENUM = 512
};
static const int DEFAULT = 0;
virtual ~Keyboard(){}
static bool getConstant(const char * in, Key & out);
static bool getConstant(Key in, const char *& out);
private:
static StringMap<Key, KEY_MAX_ENUM>::Entry keyEntries[];
static StringMap<Key, KEY_MAX_ENUM> keys;
}; // Keyboard
} // keyboard
src/modules/keyboard/sdl/Keyboard.cpp
+160 -11
View File
@@ -20,9 +20,6 @@
#include "Keyboard.h"
// SDL
#include <SDL.h>
namespace love
{
namespace keyboard
@@ -34,22 +31,26 @@ namespace sdl
return "love.keyboard.sdl";
}
bool Keyboard::isDown(int key) const
bool Keyboard::isDown(Key key) const
{
Uint8 * keystate = SDL_GetKeyState(0);
return keystate[key] == 1;
SDLKey k;
if(keys.find(key, k))
{
Uint8 * keystate = SDL_GetKeyState(0);
return keystate[(unsigned)k] == 1;
}
return false;
}
void Keyboard::setKeyRepeat(int delay, int interval) const
{
if(delay == KEY_REPEAT_DELAY)
if(delay == DEFAULT)
delay = SDL_DEFAULT_REPEAT_DELAY;
if(interval == KEY_REPEAT_INTERVAL)
if(interval == DEFAULT)
interval = SDL_DEFAULT_REPEAT_INTERVAL;
if(SDL_EnableKeyRepeat(delay, interval) == -1)
throw new Exception("[Keyboard::enableKeyRepeat] Unable to enable key repeat");
}
int Keyboard::getKeyRepeatDelay() const
@@ -66,6 +67,154 @@ namespace sdl
return interval;
}
EnumMap<Keyboard::Key, SDLKey, Keyboard::KEY_MAX_ENUM>::Entry Keyboard::keyEntries[] =
{
{ Keyboard::KEY_BACKSPACE, SDLK_BACKSPACE},
{ Keyboard::KEY_TAB, SDLK_TAB},
{ Keyboard::KEY_CLEAR, SDLK_CLEAR},
{ Keyboard::KEY_RETURN, SDLK_RETURN},
{ Keyboard::KEY_PAUSE, SDLK_PAUSE},
{ Keyboard::KEY_ESCAPE, SDLK_ESCAPE },
{ Keyboard::KEY_SPACE, SDLK_SPACE },
{ Keyboard::KEY_EXCLAIM, SDLK_EXCLAIM },
{ Keyboard::KEY_QUOTEDBL, SDLK_QUOTEDBL },
{ Keyboard::KEY_HASH, SDLK_HASH },
{ Keyboard::KEY_DOLLAR, SDLK_DOLLAR },
{ Keyboard::KEY_AMPERSAND, SDLK_AMPERSAND },
{ Keyboard::KEY_QUOTE, SDLK_QUOTE },
{ Keyboard::KEY_LEFTPAREN, SDLK_LEFTPAREN },
{ Keyboard::KEY_RIGHTPAREN, SDLK_RIGHTPAREN },
{ Keyboard::KEY_ASTERISK, SDLK_ASTERISK },
{ Keyboard::KEY_PLUS, SDLK_PLUS },
{ Keyboard::KEY_COMMA, SDLK_COMMA },
{ Keyboard::KEY_MINUS, SDLK_MINUS },
{ Keyboard::KEY_PERIOD, SDLK_PERIOD },
{ Keyboard::KEY_SLASH, SDLK_SLASH },
{ Keyboard::KEY_0, SDLK_0 },
{ Keyboard::KEY_1, SDLK_1 },
{ Keyboard::KEY_2, SDLK_2 },
{ Keyboard::KEY_3, SDLK_3 },
{ Keyboard::KEY_4, SDLK_4 },
{ Keyboard::KEY_5, SDLK_5 },
{ Keyboard::KEY_6, SDLK_6 },
{ Keyboard::KEY_7, SDLK_7 },
{ Keyboard::KEY_8, SDLK_8 },
{ Keyboard::KEY_9, SDLK_9 },
{ Keyboard::KEY_COLON, SDLK_COLON },
{ Keyboard::KEY_SEMICOLON, SDLK_SEMICOLON },
{ Keyboard::KEY_LESS, SDLK_LESS },
{ Keyboard::KEY_EQUALS, SDLK_EQUALS },
{ Keyboard::KEY_GREATER, SDLK_GREATER },
{ Keyboard::KEY_QUESTION, SDLK_QUESTION },
{ Keyboard::KEY_AT, SDLK_AT },
{ Keyboard::KEY_LEFTBRACKET, SDLK_LEFTBRACKET },
{ Keyboard::KEY_BACKSLASH, SDLK_BACKSLASH },
{ Keyboard::KEY_RIGHTBRACKET, SDLK_RIGHTBRACKET },
{ Keyboard::KEY_CARET, SDLK_CARET },
{ Keyboard::KEY_UNDERSCORE, SDLK_UNDERSCORE },
{ Keyboard::KEY_BACKQUOTE, SDLK_BACKQUOTE },
{ Keyboard::KEY_A, SDLK_a },
{ Keyboard::KEY_B, SDLK_b },
{ Keyboard::KEY_C, SDLK_c },
{ Keyboard::KEY_D, SDLK_d },
{ Keyboard::KEY_E, SDLK_e },
{ Keyboard::KEY_F, SDLK_f },
{ Keyboard::KEY_G, SDLK_g },
{ Keyboard::KEY_H, SDLK_h },
{ Keyboard::KEY_I, SDLK_i },
{ Keyboard::KEY_J, SDLK_j },
{ Keyboard::KEY_K, SDLK_k },
{ Keyboard::KEY_L, SDLK_l },
{ Keyboard::KEY_M, SDLK_m },
{ Keyboard::KEY_N, SDLK_n },
{ Keyboard::KEY_O, SDLK_o },
{ Keyboard::KEY_P, SDLK_p },
{ Keyboard::KEY_Q, SDLK_q },
{ Keyboard::KEY_R, SDLK_r },
{ Keyboard::KEY_S, SDLK_s },
{ Keyboard::KEY_T, SDLK_t },
{ Keyboard::KEY_U, SDLK_u },
{ Keyboard::KEY_V, SDLK_v },
{ Keyboard::KEY_W, SDLK_w },
{ Keyboard::KEY_X, SDLK_x },
{ Keyboard::KEY_Y, SDLK_y },
{ Keyboard::KEY_Z, SDLK_z },
{ Keyboard::KEY_DELETE, SDLK_DELETE },
{ Keyboard::KEY_KP0, SDLK_KP0 },
{ Keyboard::KEY_KP1, SDLK_KP1 },
{ Keyboard::KEY_KP2, SDLK_KP2 },
{ Keyboard::KEY_KP3, SDLK_KP3 },
{ Keyboard::KEY_KP4, SDLK_KP4 },
{ Keyboard::KEY_KP5, SDLK_KP5 },
{ Keyboard::KEY_KP6, SDLK_KP6 },
{ Keyboard::KEY_KP7, SDLK_KP7 },
{ Keyboard::KEY_KP8, SDLK_KP8 },
{ Keyboard::KEY_KP9, SDLK_KP9 },
{ Keyboard::KEY_KP_PERIOD, SDLK_KP_PERIOD },
{ Keyboard::KEY_KP_DIVIDE, SDLK_KP_DIVIDE },
{ Keyboard::KEY_KP_MULTIPLY, SDLK_KP_MULTIPLY},
{ Keyboard::KEY_KP_MINUS, SDLK_KP_MINUS },
{ Keyboard::KEY_KP_PLUS, SDLK_KP_PLUS },
{ Keyboard::KEY_KP_ENTER, SDLK_KP_ENTER },
{ Keyboard::KEY_KP_EQUALS, SDLK_KP_EQUALS },
{ Keyboard::KEY_UP, SDLK_UP },
{ Keyboard::KEY_DOWN, SDLK_DOWN },
{ Keyboard::KEY_RIGHT, SDLK_RIGHT },
{ Keyboard::KEY_LEFT, SDLK_LEFT },
{ Keyboard::KEY_INSERT, SDLK_INSERT },
{ Keyboard::KEY_HOME, SDLK_HOME },
{ Keyboard::KEY_END, SDLK_END },
{ Keyboard::KEY_PAGEUP, SDLK_PAGEUP },
{ Keyboard::KEY_PAGEDOWN, SDLK_PAGEDOWN },
{ Keyboard::KEY_F1, SDLK_F1 },
{ Keyboard::KEY_F2, SDLK_F2 },
{ Keyboard::KEY_F3, SDLK_F3 },
{ Keyboard::KEY_F4, SDLK_F4 },
{ Keyboard::KEY_F5, SDLK_F5 },
{ Keyboard::KEY_F6, SDLK_F6 },
{ Keyboard::KEY_F7, SDLK_F7 },
{ Keyboard::KEY_F8, SDLK_F8 },
{ Keyboard::KEY_F9, SDLK_F9 },
{ Keyboard::KEY_F10, SDLK_F10 },
{ Keyboard::KEY_F11, SDLK_F11 },
{ Keyboard::KEY_F12, SDLK_F12 },
{ Keyboard::KEY_F13, SDLK_F13 },
{ Keyboard::KEY_F14, SDLK_F14 },
{ Keyboard::KEY_F15, SDLK_F15 },
{ Keyboard::KEY_NUMLOCK, SDLK_NUMLOCK },
{ Keyboard::KEY_CAPSLOCK, SDLK_CAPSLOCK },
{ Keyboard::KEY_SCROLLOCK, SDLK_SCROLLOCK },
{ Keyboard::KEY_RSHIFT, SDLK_RSHIFT },
{ Keyboard::KEY_LSHIFT, SDLK_LSHIFT },
{ Keyboard::KEY_RCTRL, SDLK_RCTRL },
{ Keyboard::KEY_LCTRL, SDLK_LCTRL },
{ Keyboard::KEY_RALT, SDLK_RALT },
{ Keyboard::KEY_LALT, SDLK_LALT },
{ Keyboard::KEY_RMETA, SDLK_RMETA },
{ Keyboard::KEY_LMETA, SDLK_LMETA },
{ Keyboard::KEY_LSUPER, SDLK_LSUPER },
{ Keyboard::KEY_RSUPER, SDLK_RSUPER },
{ Keyboard::KEY_MODE, SDLK_MODE },
{ Keyboard::KEY_COMPOSE, SDLK_COMPOSE },
{ Keyboard::KEY_HELP, SDLK_HELP },
{ Keyboard::KEY_PRINT, SDLK_PRINT },
{ Keyboard::KEY_SYSREQ, SDLK_SYSREQ },
{ Keyboard::KEY_BREAK, SDLK_BREAK },
{ Keyboard::KEY_MENU, SDLK_MENU },
{ Keyboard::KEY_POWER, SDLK_POWER },
{ Keyboard::KEY_EURO, SDLK_EURO },
{ Keyboard::KEY_UNDO, SDLK_UNDO },
};
EnumMap<Keyboard::Key, SDLKey, Keyboard::KEY_MAX_ENUM> Keyboard::keys(Keyboard::keyEntries, sizeof(Keyboard::keyEntries));
} // sdl
} // keyboard
} // love
src/modules/keyboard/sdl/Keyboard.h
+11 -2
View File
@@ -23,6 +23,10 @@
// LOVE
#include <keyboard/Keyboard.h>
#include <common/EnumMap.h>
// SDL
#include <SDL.h>
namespace love
{
@@ -42,14 +46,14 @@ namespace sdl
* @param key A key identifier.
* @return boolean
**/
bool isDown(int key) const;
bool isDown(Key key) const;
/**
* Enables key repeating.
* @param delay The amount of delay before repeating the key (in milliseconds)
* @param interval Specifies the amount of time between repeats (in milliseconds)
**/
void setKeyRepeat(int delay = 0, int interval = 0) const;
void setKeyRepeat(int delay, int interval) const;
/**
* Gets the specified delay for the key repeat.
@@ -63,6 +67,11 @@ namespace sdl
**/
int getKeyRepeatInterval() const;
private:
static EnumMap<Key, SDLKey, Keyboard::KEY_MAX_ENUM>::Entry keyEntries[];
static EnumMap<Key, SDLKey, Keyboard::KEY_MAX_ENUM> keys;
}; // Keyboard
} // sdl
src/modules/keyboard/sdl/wrap_Keyboard.cpp
+14 -162
View File
@@ -26,12 +26,21 @@ namespace keyboard
{
namespace sdl
{
static Keyboard * instance = 0;
static Keyboard * instance;
int w_isDown(lua_State * L)
{
int b = luaL_checkint(L, 1);
luax_pushboolean(L, instance->isDown(b));
Keyboard::Key k;
if(Keyboard::getConstant(luaL_checkstring(L, 1), k))
{
luax_pushboolean(L, instance->isDown(k));
}
else
{
luax_pushboolean(L, false);
}
return 1;
}
@@ -39,13 +48,11 @@ namespace sdl
{
if(lua_gettop(L) == 0)
{
instance->setKeyRepeat();
instance->setKeyRepeat(0, 0);
return 0;
}
int a = luaL_checkint(L, 1);
int b = luaL_checkint(L, 2);
instance->setKeyRepeat(a, b);
instance->setKeyRepeat(luaL_checkint(L, 1), luaL_checkint(L, 2));
return 0;
}
@@ -64,160 +71,6 @@ namespace sdl
{ 0, 0 }
};
// List of constants.
static const Constant constants[] = {
{ "key_unknown", 0 },
{ "key_first", 0 },
{ "key_backspace", 8 },
{ "key_tab", 9 },
{ "key_clear", 12 },
{ "key_return", 13 },
{ "key_pause", 19 },
{ "key_escape", 27 },
{ "key_space", 32 },
{ "key_exclaim", 33 },
{ "key_quotedbl", 34 },
{ "key_hash", 35 },
{ "key_dollar", 36 },
{ "key_ampersand", 38 },
{ "key_quote", 39 },
{ "key_leftparen", 40 },
{ "key_rightparen", 41 },
{ "key_asterisk", 42 },
{ "key_plus", 43 },
{ "key_comma", 44 },
{ "key_minus", 45 },
{ "key_period", 46 },
{ "key_slash", 47 },
{ "key_0", 48 },
{ "key_1", 49 },
{ "key_2", 50 },
{ "key_3", 51 },
{ "key_4", 52 },
{ "key_5", 53 },
{ "key_6", 54 },
{ "key_7", 55 },
{ "key_8", 56 },
{ "key_9", 57 },
{ "key_colon", 58 },
{ "key_semicolon", 59 },
{ "key_less", 60 },
{ "key_equals", 61 },
{ "key_greater", 62 },
{ "key_question", 63 },
{ "key_at", 64 },
{ "key_leftbracket", 91 },
{ "key_backslash", 92 },
{ "key_rightbracket", 93 },
{ "key_caret", 94 },
{ "key_underscore", 95 },
{ "key_backquote", 96 },
{ "key_a", 97 },
{ "key_b", 98 },
{ "key_c", 99 },
{ "key_d", 100 },
{ "key_e", 101 },
{ "key_f", 102 },
{ "key_g", 103 },
{ "key_h", 104 },
{ "key_i", 105 },
{ "key_j", 106 },
{ "key_k", 107 },
{ "key_l", 108 },
{ "key_m", 109 },
{ "key_n", 110 },
{ "key_o", 111 },
{ "key_p", 112 },
{ "key_q", 113 },
{ "key_r", 114 },
{ "key_s", 115 },
{ "key_t", 116 },
{ "key_u", 117 },
{ "key_v", 118 },
{ "key_w", 119 },
{ "key_x", 120 },
{ "key_y", 121 },
{ "key_z", 122 },
{ "key_delete", 127 },
{ "key_kp0", 256 },
{ "key_kp1", 257 },
{ "key_kp2", 258 },
{ "key_kp3", 259 },
{ "key_kp4", 260 },
{ "key_kp5", 261 },
{ "key_kp6", 262 },
{ "key_kp7", 263 },
{ "key_kp8", 264 },
{ "key_kp9", 265 },
{ "key_kp_period", 266 },
{ "key_kp_divide", 267 },
{ "key_kp_multiply", 268 },
{ "key_kp_minus", 269 },
{ "key_kp_plus", 270 },
{ "key_kp_enter", 271 },
{ "key_kp_equals", 272 },
{ "key_up", 273 },
{ "key_down", 274 },
{ "key_right", 275 },
{ "key_left", 276 },
{ "key_insert", 277 },
{ "key_home", 278 },
{ "key_end", 279 },
{ "key_pageup", 280 },
{ "key_pagedown", 281 },
{ "key_f1", 282 },
{ "key_f2", 283 },
{ "key_f3", 284 },
{ "key_f4", 285 },
{ "key_f5", 286 },
{ "key_f6", 287 },
{ "key_f7", 288 },
{ "key_f8", 289 },
{ "key_f9", 290 },
{ "key_f10", 291 },
{ "key_f11", 292 },
{ "key_f12", 293 },
{ "key_f13", 294 },
{ "key_f14", 295 },
{ "key_f15", 296 },
{ "key_numlock", 300 },
{ "key_capslock", 301 },
{ "key_scrollock", 302 },
{ "key_rshift", 303 },
{ "key_lshift", 304 },
{ "key_rctrl", 305 },
{ "key_lctrl", 306 },
{ "key_ralt", 307 },
{ "key_lalt", 308 },
{ "key_rmeta", 309 },
{ "key_lmeta", 310 },
{ "key_lsuper", 311 },
{ "key_rsuper", 312 },
{ "key_mode", 313 },
{ "key_compose", 314 },
{ "key_help", 315 },
{ "key_print", 316 },
{ "key_sysreq", 317 },
{ "key_break", 318 },
{ "key_menu", 319 },
{ "key_power", 320 },
{ "key_euro", 321 },
{ "key_undo", 322 },
{ "key_repeat_delay", Keyboard::KEY_REPEAT_DELAY },
{ "key_repeat_interval", Keyboard::KEY_REPEAT_INTERVAL },
{ 0, 0 }
};
int luaopen_love_keyboard(lua_State * L)
{
if(instance == 0)
@@ -238,7 +91,6 @@ namespace sdl
w.flags = MODULE_T;
w.functions = functions;
w.types = 0;
w.constants = constants;
return luax_register_module(L, w);
}
src/modules/keyboard/sdl/wrap_Keyboard.h
+3
View File
@@ -25,6 +25,9 @@
#include <common/config.h>
#include "Keyboard.h"
// SDL
#include <SDL.h>
namespace love
{
namespace keyboard