/*

libluaSDL

by SWAT

*/

$#include "ds.h"

$

$

$#define SDL_MASK_RED 0x00FF0000

$#define SDL_MASK_GREEN 0x0000FF00

$#define SDL_MASK_BLUE 0x000000FF

$#define SDL_MASK_ALPHA 0xFF000000

$

$

$SDL_Event* SDL_Event_new() { return (SDL_Event*) malloc(sizeof(SDL_Event)); }

$void SDL_Event_delete(SDL_Event* e) { free(e); }

$

$#undef SDL_SaveBMP

$ int SDL_SaveBMP(SDL_Surface* surface, const char* file)

$ {

$ return SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1);

$ }

$

$ #undef SDL_LoadBMP

$ SDL_Surface* SDL_LoadBMP(const char* file) { return SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1); }

$

$SDL_Rect* SDL_Rect_new() { return (SDL_Rect*) malloc(sizeof(SDL_Rect)); }

$void SDL_Rect_delete(SDL_Rect *r) { free(r); }

$SDL_Color* SDL_Color_new() { return (SDL_Color*) malloc(sizeof(SDL_Color)); }

$void SDL_Color_delete(SDL_Color *c) { free(c); }

$SDL_Palette* SDL_Palette_new() { return (SDL_Palette*) malloc(sizeof(SDL_Palette)); }

$void SDL_Palette_delete(SDL_Palette *p) { free(p); }

$

module SDL

{

/*

lua utility

For allocate surface

*/

#define SDL_MASK_RED 0x00FF0000

#define SDL_MASK_GREEN 0x0000FF00

#define SDL_MASK_BLUE 0x000000FF

#define SDL_MASK_ALPHA 0xFF000000

/* Main include header for the SDL library */

/* Basic data types */

typedef enum {

SDL_FALSE = 0,

SDL_TRUE = 1

} SDL_bool;

typedef unsigned char Uint8;

typedef signed char Sint8;

typedef unsigned short Uint16;

typedef signed short Sint16;

typedef unsigned int Uint32;

typedef signed int Sint32;

/* General keyboard/mouse state definitions */

enum { SDL_PRESSED = 0x01, SDL_RELEASED = 0x00 };

/* Public functions */

/* not for luaswig: extern void SDL_SetError(const char *fmt); */

extern char * SDL_GetError(void);

extern void SDL_ClearError(void);

/* This is the OS scheduler timeslice, in milliseconds */

#define SDL_TIMESLICE 10

/* This is the maximum resolution of the SDL timer on all platforms */

#define TIMER_RESOLUTION 10 /* Experimentally determined */

/* Get the number of milliseconds since the SDL library initialization.

* Note that this value wraps if the program runs for more than ~49 days.

*/

extern Uint32 SDL_GetTicks(void);

/* Wait a specified number of milliseconds before returning */

extern void SDL_Delay(Uint32 ms);

/* In order to use these functions, SDL_Init() must have been called

with the SDL_INIT_JOYSTICK flag. This causes SDL to scan the system

for joysticks, and load appropriate drivers.

*/

/* The joystick structure used to identify an SDL joystick */

typedef struct SDL_Joystick {

} SDL_Joystick;

/* Function prototypes */

/*

* Count the number of joysticks attached to the system

*/

extern int SDL_NumJoysticks(void);

/*

* Get the implementation dependent name of a joystick.

* This can be called before any joysticks are opened.

* If no name can be found, this function returns NULL.

*/

extern const char *SDL_JoystickName(int device_index);

/*

* Open a joystick for use - the index passed as an argument refers to

* the N'th joystick on the system. This index is the value which will

* identify this joystick in future joystick events.

*

* This function returns a joystick identifier, or NULL if an error occurred.

*/

extern SDL_Joystick *SDL_JoystickOpen(int device_index);

/*

* Returns 1 if the joystick has been opened, or 0 if it has not.

*/

extern int SDL_JoystickOpened(int device_index);

/*

* Get the device index of an opened joystick.

*/

extern int SDL_JoystickIndex(SDL_Joystick *joystick);

/*

* Get the number of general axis controls on a joystick

*/

extern int SDL_JoystickNumAxes(SDL_Joystick *joystick);

/*

* Get the number of trackballs on a joystick

* Joystick trackballs have only relative motion events associated

* with them and their state cannot be polled.

*/

extern int SDL_JoystickNumBalls(SDL_Joystick *joystick);

/*

* Get the number of POV hats on a joystick

*/

extern int SDL_JoystickNumHats(SDL_Joystick *joystick);

/*

* Get the number of buttons on a joystick

*/

extern int SDL_JoystickNumButtons(SDL_Joystick *joystick);

/*

* Update the current state of the open joysticks.

* This is called automatically by the event loop if any joystick

* events are enabled.

*/

extern void SDL_JoystickUpdate(void);

/*

* Enable/disable joystick event polling.

* If joystick events are disabled, you must call SDL_JoystickUpdate()

* yourself and check the state of the joystick when you want joystick

* information.

* The state can be one of SDL_QUERY, SDL_ENABLE or SDL_IGNORE.

*/

extern int SDL_JoystickEventState(int state);

/*

* Get the current state of an axis control on a joystick

* The state is a value ranging from -32768 to 32767.

* The axis indices start at index 0.

*/

extern Sint16 SDL_JoystickGetAxis(SDL_Joystick *joystick, int axis);

/*

* Get the current state of a POV hat on a joystick

* The return value is one of the following positions:

*/

#define SDL_HAT_CENTERED 0x00

#define SDL_HAT_UP 0x01

#define SDL_HAT_RIGHT 0x02

#define SDL_HAT_DOWN 0x04

#define SDL_HAT_LEFT 0x08

#define SDL_HAT_RIGHTUP (SDL_HAT_RIGHT|SDL_HAT_UP)

#define SDL_HAT_RIGHTDOWN (SDL_HAT_RIGHT|SDL_HAT_DOWN)

#define SDL_HAT_LEFTUP (SDL_HAT_LEFT|SDL_HAT_UP)

#define SDL_HAT_LEFTDOWN (SDL_HAT_LEFT|SDL_HAT_DOWN)

/*

* The hat indices start at index 0.

*/

extern Uint8 SDL_JoystickGetHat(SDL_Joystick *joystick, int hat);

/*

* Get the ball axis change since the last poll

* This returns 0, or -1 if you passed it invalid parameters.

* The ball indices start at index 0.

*/

extern int SDL_JoystickGetBall(SDL_Joystick *joystick, int ball, int *dx, int *dy);

/*

* Get the current state of a button on a joystick

* The button indices start at index 0.

*/

extern Uint8 SDL_JoystickGetButton(SDL_Joystick *joystick, int button);

/*

* Close a joystick previously opened with SDL_JoystickOpen()

*/

extern void SDL_JoystickClose(SDL_Joystick *joystick);

/* What we really want is a mapping of every raw key on the keyboard.

To support international keyboards, we use the range 0xA1 - 0xFF

as international virtual keycodes. We'll follow in the footsteps of X11...

The names of the keys

*/

typedef enum {

/* The keyboard syms have been cleverly chosen to map to ASCII */

SDLK_UNKNOWN = 0,

SDLK_FIRST = 0,

SDLK_BACKSPACE = 8,

SDLK_TAB = 9,

SDLK_CLEAR = 12,

SDLK_RETURN = 13,

SDLK_PAUSE = 19,

SDLK_ESCAPE = 27,

SDLK_SPACE = 32,

SDLK_EXCLAIM = 33,

SDLK_QUOTEDBL = 34,

SDLK_HASH = 35,

SDLK_DOLLAR = 36,

SDLK_AMPERSAND = 38,

SDLK_QUOTE = 39,

SDLK_LEFTPAREN = 40,

SDLK_RIGHTPAREN = 41,

SDLK_ASTERISK = 42,

SDLK_PLUS = 43,

SDLK_COMMA = 44,

SDLK_MINUS = 45,

SDLK_PERIOD = 46,

SDLK_SLASH = 47,

SDLK_0 = 48,

SDLK_1 = 49,

SDLK_2 = 50,

SDLK_3 = 51,

SDLK_4 = 52,

SDLK_5 = 53,

SDLK_6 = 54,

SDLK_7 = 55,

SDLK_8 = 56,

SDLK_9 = 57,

SDLK_COLON = 58,

SDLK_SEMICOLON = 59,

SDLK_LESS = 60,

SDLK_EQUALS = 61,

SDLK_GREATER = 62,

SDLK_QUESTION = 63,

SDLK_AT = 64,

/*

Skip uppercase letters

*/

SDLK_LEFTBRACKET = 91,

SDLK_BACKSLASH = 92,

SDLK_RIGHTBRACKET = 93,

SDLK_CARET = 94,

SDLK_UNDERSCORE = 95,

SDLK_BACKQUOTE = 96,

SDLK_a = 97,

SDLK_b = 98,

SDLK_c = 99,

SDLK_d = 100,

SDLK_e = 101,

SDLK_f = 102,

SDLK_g = 103,

SDLK_h = 104,

SDLK_i = 105,

SDLK_j = 106,

SDLK_k = 107,

SDLK_l = 108,

SDLK_m = 109,

SDLK_n = 110,

SDLK_o = 111,

SDLK_p = 112,

SDLK_q = 113,

SDLK_r = 114,

SDLK_s = 115,

SDLK_t = 116,

SDLK_u = 117,

SDLK_v = 118,

SDLK_w = 119,

SDLK_x = 120,

SDLK_y = 121,

SDLK_z = 122,

SDLK_DELETE = 127,

/* End of ASCII mapped keysyms */

/* International keyboard syms */

SDLK_WORLD_0 = 160, /* 0xA0 */

SDLK_WORLD_1 = 161,

SDLK_WORLD_2 = 162,

SDLK_WORLD_3 = 163,

SDLK_WORLD_4 = 164,

SDLK_WORLD_5 = 165,

SDLK_WORLD_6 = 166,

SDLK_WORLD_7 = 167,

SDLK_WORLD_8 = 168,

SDLK_WORLD_9 = 169,

SDLK_WORLD_10 = 170,

SDLK_WORLD_11 = 171,

SDLK_WORLD_12 = 172,

SDLK_WORLD_13 = 173,

SDLK_WORLD_14 = 174,

SDLK_WORLD_15 = 175,

SDLK_WORLD_16 = 176,

SDLK_WORLD_17 = 177,

SDLK_WORLD_18 = 178,

SDLK_WORLD_19 = 179,

SDLK_WORLD_20 = 180,

SDLK_WORLD_21 = 181,

SDLK_WORLD_22 = 182,

SDLK_WORLD_23 = 183,

SDLK_WORLD_24 = 184,

SDLK_WORLD_25 = 185,

SDLK_WORLD_26 = 186,

SDLK_WORLD_27 = 187,

SDLK_WORLD_28 = 188,

SDLK_WORLD_29 = 189,

SDLK_WORLD_30 = 190,

SDLK_WORLD_31 = 191,

SDLK_WORLD_32 = 192,

SDLK_WORLD_33 = 193,

SDLK_WORLD_34 = 194,

SDLK_WORLD_35 = 195,

SDLK_WORLD_36 = 196,

SDLK_WORLD_37 = 197,

SDLK_WORLD_38 = 198,

SDLK_WORLD_39 = 199,

SDLK_WORLD_40 = 200,

SDLK_WORLD_41 = 201,

SDLK_WORLD_42 = 202,

SDLK_WORLD_43 = 203,

SDLK_WORLD_44 = 204,

SDLK_WORLD_45 = 205,

SDLK_WORLD_46 = 206,

SDLK_WORLD_47 = 207,

SDLK_WORLD_48 = 208,

SDLK_WORLD_49 = 209,

SDLK_WORLD_50 = 210,

SDLK_WORLD_51 = 211,

SDLK_WORLD_52 = 212,

SDLK_WORLD_53 = 213,

SDLK_WORLD_54 = 214,

SDLK_WORLD_55 = 215,

SDLK_WORLD_56 = 216,

SDLK_WORLD_57 = 217,

SDLK_WORLD_58 = 218,

SDLK_WORLD_59 = 219,

SDLK_WORLD_60 = 220,

SDLK_WORLD_61 = 221,

SDLK_WORLD_62 = 222,

SDLK_WORLD_63 = 223,

SDLK_WORLD_64 = 224,

SDLK_WORLD_65 = 225,

SDLK_WORLD_66 = 226,

SDLK_WORLD_67 = 227,

SDLK_WORLD_68 = 228,

SDLK_WORLD_69 = 229,

SDLK_WORLD_70 = 230,

SDLK_WORLD_71 = 231,

SDLK_WORLD_72 = 232,

SDLK_WORLD_73 = 233,

SDLK_WORLD_74 = 234,

SDLK_WORLD_75 = 235,

SDLK_WORLD_76 = 236,

SDLK_WORLD_77 = 237,

SDLK_WORLD_78 = 238,

SDLK_WORLD_79 = 239,

SDLK_WORLD_80 = 240,

SDLK_WORLD_81 = 241,

SDLK_WORLD_82 = 242,

SDLK_WORLD_83 = 243,

SDLK_WORLD_84 = 244,

SDLK_WORLD_85 = 245,

SDLK_WORLD_86 = 246,

SDLK_WORLD_87 = 247,

SDLK_WORLD_88 = 248,

SDLK_WORLD_89 = 249,

SDLK_WORLD_90 = 250,

SDLK_WORLD_91 = 251,

SDLK_WORLD_92 = 252,

SDLK_WORLD_93 = 253,

SDLK_WORLD_94 = 254,

SDLK_WORLD_95 = 255, /* 0xFF */

/* Numeric keypad */

SDLK_KP0 = 256,

SDLK_KP1 = 257,

SDLK_KP2 = 258,

SDLK_KP3 = 259,

SDLK_KP4 = 260,

SDLK_KP5 = 261,

SDLK_KP6 = 262,

SDLK_KP7 = 263,

SDLK_KP8 = 264,

SDLK_KP9 = 265,

SDLK_KP_PERIOD = 266,

SDLK_KP_DIVIDE = 267,

SDLK_KP_MULTIPLY = 268,

SDLK_KP_MINUS = 269,

SDLK_KP_PLUS = 270,

SDLK_KP_ENTER = 271,

SDLK_KP_EQUALS = 272,

/* Arrows + Home/End pad */

SDLK_UP = 273,

SDLK_DOWN = 274,

SDLK_RIGHT = 275,

SDLK_LEFT = 276,

SDLK_INSERT = 277,

SDLK_HOME = 278,

SDLK_END = 279,

SDLK_PAGEUP = 280,

SDLK_PAGEDOWN = 281,

/* Function keys */

SDLK_F1 = 282,

SDLK_F2 = 283,

SDLK_F3 = 284,

SDLK_F4 = 285,

SDLK_F5 = 286,

SDLK_F6 = 287,

SDLK_F7 = 288,

SDLK_F8 = 289,

SDLK_F9 = 290,

SDLK_F10 = 291,

SDLK_F11 = 292,

SDLK_F12 = 293,

SDLK_F13 = 294,

SDLK_F14 = 295,

SDLK_F15 = 296,

/* Key state modifier keys */

SDLK_NUMLOCK = 300,

SDLK_CAPSLOCK = 301,

SDLK_SCROLLOCK = 302,

SDLK_RSHIFT = 303,

SDLK_LSHIFT = 304,

SDLK_RCTRL = 305,

SDLK_LCTRL = 306,

SDLK_RALT = 307,

SDLK_LALT = 308,

SDLK_RMETA = 309,

SDLK_LMETA = 310,

SDLK_LSUPER = 311, /* Left "Windows" key */

SDLK_RSUPER = 312, /* Right "Windows" key */

SDLK_MODE = 313, /* "Alt Gr" key */

SDLK_COMPOSE = 314, /* Multi-key compose key */

/* Miscellaneous function keys */

SDLK_HELP = 315,

SDLK_PRINT = 316,

SDLK_SYSREQ = 317,

SDLK_BREAK = 318,

SDLK_MENU = 319,

SDLK_POWER = 320, /* Power Macintosh power key */

SDLK_EURO = 321, /* Some european keyboards */

/* Add any other keys here */

SDLK_LAST

} SDLKey;

/* Enumeration of valid key mods (possibly OR'd together) */

typedef enum {

KMOD_NONE = 0x0000,

KMOD_LSHIFT= 0x0001,

KMOD_RSHIFT= 0x0002,

KMOD_LCTRL = 0x0040,

KMOD_RCTRL = 0x0080,

KMOD_LALT = 0x0100,

KMOD_RALT = 0x0200,

KMOD_LMETA = 0x0400,

KMOD_RMETA = 0x0800,

KMOD_NUM = 0x1000,

KMOD_CAPS = 0x2000,

KMOD_MODE = 0x4000,

KMOD_RESERVED = 0x8000

} SDLMod;

#define KMOD_CTRL (KMOD_LCTRL|KMOD_RCTRL)

#define KMOD_SHIFT (KMOD_LSHIFT|KMOD_RSHIFT)

#define KMOD_ALT (KMOD_LALT|KMOD_RALT)

#define KMOD_META (KMOD_LMETA|KMOD_RMETA)

/* Keysym structure

- The scancode is hardware dependent, and should not be used by general

applications. If no hardware scancode is available, it will be 0.

- The 'unicode' translated character is only available when character

translation is enabled by the SDL_EnableUNICODE() API. If non-zero,

this is a UNICODE character corresponding to the keypress. If the

high 9 bits of the character are 0, then this maps to the equivalent

ASCII character:

char ch;

if ( (keysym.unicode & 0xFF80) == 0 ) {

ch = keysym.unicode & 0x7F;

} else {

An international character..

}

*/

typedef struct {

Uint8 scancode; /* hardware specific scancode */

SDLKey sym; /* SDL virtual keysym */

SDLMod mod; /* current key modifiers */

Uint16 unicode; /* translated character */

} SDL_keysym;

/* This is the mask which refers to all hotkey bindings */

#define SDL_ALL_HOTKEYS 0xFFFFFFFF

/* Function prototypes */

/*

* Enable/Disable UNICODE translation of keyboard input.

* This translation has some overhead, so translation defaults off.

* If 'enable' is 1, translation is enabled.

* If 'enable' is 0, translation is disabled.

* If 'enable' is -1, the translation state is not changed.

* It returns the previous state of keyboard translation.

*/

extern int SDL_EnableUNICODE(int enable);

/*

* Enable/Disable keyboard repeat. Keyboard repeat defaults to off.

* 'delay' is the initial delay in ms between the time when a key is

* pressed, and keyboard repeat begins.

* 'interval' is the time in ms between keyboard repeat events.

*/

#define SDL_DEFAULT_REPEAT_DELAY 500

#define SDL_DEFAULT_REPEAT_INTERVAL 30

/*

* If 'delay' is set to 0, keyboard repeat is disabled.

*/

extern int SDL_EnableKeyRepeat(int delay, int interval);

extern void SDL_GetKeyRepeat(int *delay, int *interval);

/*

* Get a snapshot of the current state of the keyboard.

* Returns an array of keystates, indexed by the SDLK_* syms.

* Used:

* Uint8 *keystate = SDL_GetKeyState(NULL);

* if ( keystate[SDLK_RETURN] ) ... <RETURN> is pressed.

*/

/* not for tolua: extern Uint8 * SDL_GetKeyState(int *numkeys); */

/*

* Get the current key modifier state

*/

extern SDLMod SDL_GetModState(void);

/*

* Set the current key modifier state

* This does not change the keyboard state, only the key modifier flags.

*/

extern void SDL_SetModState(SDLMod modstate);

/*

* Get the name of an SDL virtual keysym

*/

extern char * SDL_GetKeyName(SDLKey key);

typedef struct WMcursor {

} WMcursor; /* Implementation dependent */

typedef struct {

// #ifdef NOT_FOR_LUASWIG

// SDL_Rect area; /* The area of the mouse cursor */

// Sint16 hot_x, hot_y; /* The "tip" of the cursor */

// Uint8 *data; /* B/W cursor data */

// Uint8 *mask; /* B/W cursor mask */

// Uint8 *save[2]; /* Place to save cursor area */

// WMcursor *wm_cursor; /* Window-manager cursor */

// #endif // NOT_FOR_LUASWIG

} SDL_Cursor;

/* Function prototypes */

/*

* Retrieve the current state of the mouse.

* The current button state is returned as a button bitmask, which can

* be tested using the SDL_BUTTON(X) macros, and x and y are set to the

* current mouse cursor position. You can pass NULL for either x or y.

*/

extern Uint8 SDL_GetMouseState(int *x, int *y);

/*

* Retrieve the current state of the mouse.

* The current button state is returned as a button bitmask, which can

* be tested using the SDL_BUTTON(X) macros, and x and y are set to the

* mouse deltas since the last call to SDL_GetRelativeMouseState().

*/

extern Uint8 SDL_GetRelativeMouseState(int *x, int *y);

/*

* Set the position of the mouse cursor (generates a mouse motion event)

*/

extern void SDL_WarpMouse(Uint16 x, Uint16 y);

/*

* Create a cursor using the specified data and mask (in MSB format).

* The cursor width must be a multiple of 8 bits.

*

* The cursor is created in black and white according to the following:

* data mask resulting pixel on screen

* 0 1 White

* 1 1 Black

* 0 0 Transparent

* 1 0 Inverted color if possible, black if not.

*

* Cursors created with this function must be freed with SDL_FreeCursor().

*/

extern SDL_Cursor *SDL_CreateCursor

(Uint8 *data, Uint8 *mask, int w, int h, int hot_x, int hot_y);

/*

* Set the currently active cursor to the specified one.

* If the cursor is currently visible, the change will be immediately

* represented on the display.

*/

extern void SDL_SetCursor(SDL_Cursor *cursor);

/*

* Returns the currently active cursor.

*/

extern SDL_Cursor * SDL_GetCursor(void);

/*

* Deallocates a cursor created with SDL_CreateCursor().

*/

extern void SDL_FreeCursor(SDL_Cursor *cursor);

/*

* Toggle whether or not the cursor is shown on the screen.

* The cursor start off displayed, but can be turned off.

* SDL_ShowCursor() returns 1 if the cursor was being displayed

* before the call, or 0 if it was not. You can query the current

* state by passing a 'toggle' value of -1.

*/

extern int SDL_ShowCursor(int toggle);

/* Used as a mask when testing buttons in buttonstate

Button 1: Left mouse button

Button 2: Middle mouse button

Button 3: Right mouse button

*/

// #define SDL_BUTTON(X) (SDL_PRESSED<<(X-1))

#define SDL_BUTTON_LEFT 1

#define SDL_BUTTON_MIDDLE 2

#define SDL_BUTTON_RIGHT 3

#define SDL_BUTTON_LMASK SDL_BUTTON(SDL_BUTTON_LEFT)

#define SDL_BUTTON_MMASK SDL_BUTTON(SDL_BUTTON_MIDDLE)

#define SDL_BUTTON_RMASK SDL_BUTTON(SDL_BUTTON_RIGHT)

/* Event enumerations */

enum { SDL_NOEVENT = 0, /* Unused (do not remove) */

SDL_ACTIVEEVENT, /* Application loses/gains visibility */

SDL_KEYDOWN, /* Keys pressed */

SDL_KEYUP, /* Keys released */

SDL_MOUSEMOTION, /* Mouse moved */

SDL_MOUSEBUTTONDOWN, /* Mouse button pressed */

SDL_MOUSEBUTTONUP, /* Mouse button released */

SDL_JOYAXISMOTION, /* Joystick axis motion */

SDL_JOYBALLMOTION, /* Joystick trackball motion */

SDL_JOYHATMOTION, /* Joystick hat position change */

SDL_JOYBUTTONDOWN, /* Joystick button pressed */

SDL_JOYBUTTONUP, /* Joystick button released */

SDL_QUIT, /* User-requested quit */

SDL_SYSWMEVENT, /* System specific event */

SDL_EVENT_RESERVEDA, /* Reserved for future use.. */

SDL_EVENT_RESERVEDB, /* Reserved for future use.. */

SDL_VIDEORESIZE, /* User resized video mode */

SDL_VIDEOEXPOSE, /* Screen needs to be redrawn */

SDL_EVENT_RESERVED2, /* Reserved for future use.. */

SDL_EVENT_RESERVED3, /* Reserved for future use.. */

SDL_EVENT_RESERVED4, /* Reserved for future use.. */

SDL_EVENT_RESERVED5, /* Reserved for future use.. */

SDL_EVENT_RESERVED6, /* Reserved for future use.. */

SDL_EVENT_RESERVED7, /* Reserved for future use.. */

/* Events SDL_USEREVENT through SDL_MAXEVENTS-1 are for your use */

SDL_USEREVENT = 24,

/* This last event is only for bounding internal arrays

It is the number of bits in the event mask datatype -- Uint32

*/

SDL_NUMEVENTS = 32

};

/* Predefined event masks */

// #define SDL_EVENTMASK(X) (1<<(X))

enum {

SDL_ACTIVEEVENTMASK = (1<<(SDL_ACTIVEEVENT)),

SDL_KEYDOWNMASK = (1<<(SDL_KEYDOWN)),

SDL_KEYUPMASK = (1<<(SDL_KEYUP)),

SDL_MOUSEMOTIONMASK = (1<<(SDL_MOUSEMOTION)),

SDL_MOUSEBUTTONDOWNMASK = (1<<(SDL_MOUSEBUTTONDOWN)),

SDL_MOUSEBUTTONUPMASK = (1<<(SDL_MOUSEBUTTONUP)),

SDL_MOUSEEVENTMASK = (1<<(SDL_MOUSEMOTION))|

(1<<(SDL_MOUSEBUTTONDOWN))|

(1<<(SDL_MOUSEBUTTONUP)),

SDL_JOYAXISMOTIONMASK = (1<<(SDL_JOYAXISMOTION)),

SDL_JOYBALLMOTIONMASK = (1<<(SDL_JOYBALLMOTION)),

SDL_JOYHATMOTIONMASK = (1<<(SDL_JOYHATMOTION)),

SDL_JOYBUTTONDOWNMASK = (1<<(SDL_JOYBUTTONDOWN)),

SDL_JOYBUTTONUPMASK = (1<<(SDL_JOYBUTTONUP)),

SDL_JOYEVENTMASK = (1<<(SDL_JOYAXISMOTION))|

(1<<(SDL_JOYBALLMOTION))|

(1<<(SDL_JOYHATMOTION))|

(1<<(SDL_JOYBUTTONDOWN))|

(1<<(SDL_JOYBUTTONUP)),

SDL_VIDEORESIZEMASK = (1<<(SDL_VIDEORESIZE)),

SDL_VIDEOEXPOSEMASK = (1<<(SDL_VIDEOEXPOSE)),

SDL_QUITMASK = (1<<(SDL_QUIT)),

SDL_SYSWMEVENTMASK = (1<<(SDL_SYSWMEVENT))

};

#define SDL_ALLEVENTS 0xFFFFFFFF

/* Application visibility event structure */

typedef struct {

Uint8 type; /* SDL_ACTIVEEVENT */

Uint8 gain; /* Whether given states were gained or lost (1/0) */

Uint8 state; /* A mask of the focus states */

} SDL_ActiveEvent;

/* Keyboard event structure */

typedef struct {

Uint8 type; /* SDL_KEYDOWN or SDL_KEYUP */

Uint8 which; /* The keyboard device index */

Uint8 state; /* SDL_PRESSED or SDL_RELEASED */

SDL_keysym keysym;

} SDL_KeyboardEvent;

/* Mouse motion event structure */

typedef struct {

Uint8 type; /* SDL_MOUSEMOTION */

Uint8 which; /* The mouse device index */

Uint8 state; /* The current button state */

Uint16 x;

Uint16 y; /* The X/Y coordinates of the mouse */

Sint16 xrel; /* The relative motion in the X direction */

Sint16 yrel; /* The relative motion in the Y direction */

} SDL_MouseMotionEvent;

/* Mouse button event structure */

typedef struct {

Uint8 type; /* SDL_MOUSEBUTTONDOWN or SDL_MOUSEBUTTONUP */

Uint8 which; /* The mouse device index */

Uint8 button; /* The mouse button index */

Uint8 state; /* SDL_PRESSED or SDL_RELEASED */

Uint16 x;

Uint16 y; /* The X/Y coordinates of the mouse at press time */

} SDL_MouseButtonEvent;

/* Joystick axis motion event structure */

typedef struct {

Uint8 type; /* SDL_JOYAXISMOTION */

Uint8 which; /* The joystick device index */

Uint8 axis; /* The joystick axis index */

Sint16 value; /* The axis value (range: -32768 to 32767) */

} SDL_JoyAxisEvent;

/* Joystick trackball motion event structure */

typedef struct {

Uint8 type; /* SDL_JOYBALLMOTION */

Uint8 which; /* The joystick device index */

Uint8 ball; /* The joystick trackball index */

Sint16 xrel; /* The relative motion in the X direction */

Sint16 yrel; /* The relative motion in the Y direction */

} SDL_JoyBallEvent;

/* Joystick hat position change event structure */

typedef struct {

Uint8 type; /* SDL_JOYHATMOTION */

Uint8 which; /* The joystick device index */

Uint8 hat; /* The joystick hat index */

Uint8 value; /* The hat position value:

8 1 2

7 0 3

6 5 4

Note that zero means the POV is centered.

*/

} SDL_JoyHatEvent;

/* Joystick button event structure */

typedef struct {

Uint8 type; /* SDL_JOYBUTTONDOWN or SDL_JOYBUTTONUP */

Uint8 which; /* The joystick device index */

Uint8 button; /* The joystick button index */

Uint8 state; /* SDL_PRESSED or SDL_RELEASED */

} SDL_JoyButtonEvent;

/* The "window resized" event

When you get this event, you are responsible for setting a new video

mode with the new width and height.

*/

typedef struct {

Uint8 type; /* SDL_VIDEORESIZE */

int w; /* New width */

int h; /* New height */

} SDL_ResizeEvent;

/* The "screen redraw" event */

typedef struct {

Uint8 type; /* SDL_VIDEOEXPOSE */

} SDL_ExposeEvent;

/* The "quit requested" event */

typedef struct {

Uint8 type; /* SDL_QUIT */

} SDL_QuitEvent;

/* A user-defined event type */

typedef struct {

Uint8 type; /* SDL_USEREVENT through SDL_NUMEVENTS-1 */

int code; /* User defined event code */

void *data1; /* User defined data pointer */

void *data2; /* User defined data pointer */

} SDL_UserEvent;

// #ifdef NOT_FOR_LUASWIG

// /* If you want to use this event, you should include SDL_syswm.h */

// struct SDL_SysWMmsg;

// typedef struct SDL_SysWMmsg SDL_SysWMmsg;

// #endif // NOT_FOR_LUASWIG

typedef struct {

// #ifdef NOT_FOR_LUASWIG

// Uint8 type;

// SDL_SysWMmsg *msg;

// #endif // NOT_FOR_LUASWIG

} SDL_SysWMEvent;

/* General event structure */

// #ifdef NOT_FOR_TOLUA

// typedef union {

// #else

typedef struct {

// #endif

Uint8 type;

SDL_ActiveEvent active;

SDL_KeyboardEvent key;

SDL_MouseMotionEvent motion;

SDL_MouseButtonEvent button;

SDL_JoyAxisEvent jaxis;

SDL_JoyBallEvent jball;

SDL_JoyHatEvent jhat;

SDL_JoyButtonEvent jbutton;

SDL_ResizeEvent resize;

SDL_ExposeEvent expose;

SDL_QuitEvent quit;

SDL_UserEvent user;

SDL_SysWMEvent syswm;

} SDL_Event;

SDL_Event* SDL_Event_new();

void SDL_Event_delete(SDL_Event* e);

/* Function prototypes */

/* Pumps the event loop, gathering events from the input devices.

This function updates the event queue and internal input device state.

This should only be run in the thread that sets the video mode.

*/

extern void SDL_PumpEvents(void);

/* Checks the event queue for messages and optionally returns them.

If 'action' is SDL_ADDEVENT, up to 'numevents' events will be added to

the back of the event queue.

If 'action' is SDL_PEEKEVENT, up to 'numevents' events at the front

of the event queue, matching 'mask', will be returned and will not

be removed from the queue.

If 'action' is SDL_GETEVENT, up to 'numevents' events at the front

of the event queue, matching 'mask', will be returned and will be

removed from the queue.

This function returns the number of events actually stored, or -1

if there was an error. This function is thread-safe.

*/

typedef enum {

SDL_ADDEVENT,

SDL_PEEKEVENT,

SDL_GETEVENT

} SDL_eventaction;

/* */

extern int SDL_PeepEvents(SDL_Event *events, int numevents,

SDL_eventaction action, Uint32 mask);

/* Polls for currently pending events, and returns 1 if there are any pending

events, or 0 if there are none available. If 'event' is not NULL, the next

event is removed from the queue and stored in that area.

*/

extern int SDL_PollEvent(SDL_Event *event);

/* Waits indefinitely for the next available event, returning 1, or 0 if there

was an error while waiting for events. If 'event' is not NULL, the next

event is removed from the queue and stored in that area.

*/

extern int SDL_WaitEvent(SDL_Event *event);

/* Add an event to the event queue.

This function returns 0, or -1 if the event couldn't be added to

the event queue. If the event queue is full, this function fails.

*/

extern int SDL_PushEvent(SDL_Event *event);

// #ifdef NOT_FOR_LUASWIG

// /*

// This function sets up a filter to process all events before they

// change internal state and are posted to the internal event queue.

// The filter is protypted as:

// */

// typedef int (*SDL_EventFilter)(const SDL_Event *event);

// /*

// If the filter returns 1, then the event will be added to the internal queue.

// If it returns 0, then the event will be dropped from the queue, but the

// internal state will still be updated. This allows selective filtering of

// dynamically arriving events.

// WARNING: Be very careful of what you do in the event filter function, as

// it may run in a different thread!

// There is one caveat when dealing with the SDL_QUITEVENT event type. The

// event filter is only called when the window manager desires to close the

// application window. If the event filter returns 1, then the window will

// be closed, otherwise the window will remain open if possible.

// If the quit event is generated by an interrupt signal, it will bypass the

// internal queue and be delivered to the application at the next event poll.

// */

// extern void SDL_SetEventFilter(SDL_EventFilter filter);

// /*

// Return the current event filter - can be used to "chain" filters.

// If there is no event filter set, this function returns NULL.

// */

// extern SDL_EventFilter SDL_GetEventFilter(void);

// #endif // NOT_FOR_LUASWIG

/*

This function allows you to set the state of processing certain events.

If 'state' is set to SDL_IGNORE, that event will be automatically dropped

from the event queue and will not event be filtered.

If 'state' is set to SDL_ENABLE, that event will be processed normally.

If 'state' is set to SDL_QUERY, SDL_EventState() will return the

current processing state of the specified event.

*/

#define SDL_QUERY -1

#define SDL_IGNORE 0

#define SDL_DISABLE 0

#define SDL_ENABLE 1

extern Uint8 SDL_EventState(Uint8 type, int state);

/* Transparency definitions: These define alpha as the opacity of a surface */

#define SDL_ALPHA_OPAQUE 255

#define SDL_ALPHA_TRANSPARENT 0

/* Useful data types */

typedef struct {

Sint16 x;

Sint16 y;

Uint16 w;

Uint16 h;