SDL_events.h

Go to the documentation of this file.

/*
  Simple DirectMedia Layer
  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>

  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.
*/

#ifndef _SDL_events_h
#define _SDL_events_h

#include "SDL_stdinc.h"
#include "SDL_error.h"
#include "SDL_video.h"
#include "SDL_keyboard.h"
#include "SDL_mouse.h"
#include "SDL_joystick.h"
#include "SDL_gamecontroller.h"
#include "SDL_quit.h"
#include "SDL_gesture.h"
#include "SDL_touch.h"

#include "begin_code.h"
/* Set up for C function definitions, even when using C++ */
#ifdef __cplusplus
extern "C" {
#endif

/* General keyboard/mouse state definitions */
#define SDL_RELEASED    0
#define SDL_PRESSED 1

typedef enum
{
    SDL_FIRSTEVENT     = 0,     
    /* Application events */
    SDL_QUIT           = 0x100, 
    /* These application events have special meaning on iOS, see README-ios.txt for details */
    SDL_APP_TERMINATING,        
    SDL_APP_LOWMEMORY,          
    SDL_APP_WILLENTERBACKGROUND, 
    SDL_APP_DIDENTERBACKGROUND, 
    SDL_APP_WILLENTERFOREGROUND, 
    SDL_APP_DIDENTERFOREGROUND, 
    /* Window events */
    SDL_WINDOWEVENT    = 0x200, 
    SDL_SYSWMEVENT,             
    /* Keyboard events */
    SDL_KEYDOWN        = 0x300, 
    SDL_KEYUP,                  
    SDL_TEXTEDITING,            
    SDL_TEXTINPUT,              
    /* Mouse events */
    SDL_MOUSEMOTION    = 0x400, 
    SDL_MOUSEBUTTONDOWN,        
    SDL_MOUSEBUTTONUP,          
    SDL_MOUSEWHEEL,             
    /* Joystick events */
    SDL_JOYAXISMOTION  = 0x600, 
    SDL_JOYBALLMOTION,          
    SDL_JOYHATMOTION,           
    SDL_JOYBUTTONDOWN,          
    SDL_JOYBUTTONUP,            
    SDL_JOYDEVICEADDED,         
    SDL_JOYDEVICEREMOVED,       
    /* Game controller events */
    SDL_CONTROLLERAXISMOTION  = 0x650, 
    SDL_CONTROLLERBUTTONDOWN,          
    SDL_CONTROLLERBUTTONUP,            
    SDL_CONTROLLERDEVICEADDED,         
    SDL_CONTROLLERDEVICEREMOVED,       
    SDL_CONTROLLERDEVICEREMAPPED,      
    /* Touch events */
    SDL_FINGERDOWN      = 0x700,
    SDL_FINGERUP,
    SDL_FINGERMOTION,

    /* Gesture events */
    SDL_DOLLARGESTURE   = 0x800,
    SDL_DOLLARRECORD,
    SDL_MULTIGESTURE,

    /* Clipboard events */
    SDL_CLIPBOARDUPDATE = 0x900, 
    /* Drag and drop events */
    SDL_DROPFILE        = 0x1000, 
    SDL_USEREVENT    = 0x8000,

    SDL_LASTEVENT    = 0xFFFF
} SDL_EventType;

typedef struct SDL_CommonEvent
{
    Uint32 type;
    Uint32 timestamp;
} SDL_CommonEvent;

typedef struct SDL_WindowEvent
{
    Uint32 type;        
    Uint32 timestamp;
    Uint32 windowID;    
    Uint8 event;        
    Uint8 padding1;
    Uint8 padding2;
    Uint8 padding3;
    Sint32 data1;       
    Sint32 data2;       
} SDL_WindowEvent;

typedef struct SDL_KeyboardEvent
{
    Uint32 type;        
    Uint32 timestamp;
    Uint32 windowID;    
    Uint8 state;        
    Uint8 repeat;       
    Uint8 padding2;
    Uint8 padding3;
    SDL_Keysym keysym;  
} SDL_KeyboardEvent;

#define SDL_TEXTEDITINGEVENT_TEXT_SIZE (32)

typedef struct SDL_TextEditingEvent
{
    Uint32 type;                                
    Uint32 timestamp;
    Uint32 windowID;                            
    char text[SDL_TEXTEDITINGEVENT_TEXT_SIZE];  
    Sint32 start;                               
    Sint32 length;                              
} SDL_TextEditingEvent;


#define SDL_TEXTINPUTEVENT_TEXT_SIZE (32)

typedef struct SDL_TextInputEvent
{
    Uint32 type;                              
    Uint32 timestamp;
    Uint32 windowID;                          
    char text[SDL_TEXTINPUTEVENT_TEXT_SIZE];  
} SDL_TextInputEvent;

typedef struct SDL_MouseMotionEvent
{
    Uint32 type;        
    Uint32 timestamp;
    Uint32 windowID;    
    Uint32 which;       
    Uint32 state;       
    Sint32 x;           
    Sint32 y;           
    Sint32 xrel;        
    Sint32 yrel;        
} SDL_MouseMotionEvent;

typedef struct SDL_MouseButtonEvent
{
    Uint32 type;        
    Uint32 timestamp;
    Uint32 windowID;    
    Uint32 which;       
    Uint8 button;       
    Uint8 state;        
    Uint8 padding1;
    Uint8 padding2;
    Sint32 x;           
    Sint32 y;           
} SDL_MouseButtonEvent;

typedef struct SDL_MouseWheelEvent
{
    Uint32 type;        
    Uint32 timestamp;
    Uint32 windowID;    
    Uint32 which;       
    Sint32 x;           
    Sint32 y;           
} SDL_MouseWheelEvent;

typedef struct SDL_JoyAxisEvent
{
    Uint32 type;        
    Uint32 timestamp;
    SDL_JoystickID which; 
    Uint8 axis;         
    Uint8 padding1;
    Uint8 padding2;
    Uint8 padding3;
    Sint16 value;       
    Uint16 padding4;
} SDL_JoyAxisEvent;

typedef struct SDL_JoyBallEvent
{
    Uint32 type;        
    Uint32 timestamp;
    SDL_JoystickID which; 
    Uint8 ball;         
    Uint8 padding1;
    Uint8 padding2;
    Uint8 padding3;
    Sint16 xrel;        
    Sint16 yrel;        
} SDL_JoyBallEvent;

typedef struct SDL_JoyHatEvent
{
    Uint32 type;        
    Uint32 timestamp;
    SDL_JoystickID which; 
    Uint8 hat;          
    Uint8 value;        
    Uint8 padding1;
    Uint8 padding2;
} SDL_JoyHatEvent;

typedef struct SDL_JoyButtonEvent
{
    Uint32 type;        
    Uint32 timestamp;
    SDL_JoystickID which; 
    Uint8 button;       
    Uint8 state;        
    Uint8 padding1;
    Uint8 padding2;
} SDL_JoyButtonEvent;

typedef struct SDL_JoyDeviceEvent
{
    Uint32 type;        
    Uint32 timestamp;
    Sint32 which;       
} SDL_JoyDeviceEvent;


typedef struct SDL_ControllerAxisEvent
{
    Uint32 type;        
    Uint32 timestamp;
    SDL_JoystickID which; 
    Uint8 axis;         
    Uint8 padding1;
    Uint8 padding2;
    Uint8 padding3;
    Sint16 value;       
    Uint16 padding4;
} SDL_ControllerAxisEvent;


typedef struct SDL_ControllerButtonEvent
{
    Uint32 type;        
    Uint32 timestamp;
    SDL_JoystickID which; 
    Uint8 button;       
    Uint8 state;        
    Uint8 padding1;
    Uint8 padding2;
} SDL_ControllerButtonEvent;


typedef struct SDL_ControllerDeviceEvent
{
    Uint32 type;        
    Uint32 timestamp;
    Sint32 which;       
} SDL_ControllerDeviceEvent;


typedef struct SDL_TouchFingerEvent
{
    Uint32 type;        
    Uint32 timestamp;
    SDL_TouchID touchId; 
    SDL_FingerID fingerId;
    float x;            
    float y;            
    float dx;           
    float dy;           
    float pressure;     
} SDL_TouchFingerEvent;


typedef struct SDL_MultiGestureEvent
{
    Uint32 type;        
    Uint32 timestamp;
    SDL_TouchID touchId; 
    float dTheta;
    float dDist;
    float x;
    float y;
    Uint16 numFingers;
    Uint16 padding;
} SDL_MultiGestureEvent;


typedef struct SDL_DollarGestureEvent
{
    Uint32 type;        
    Uint32 timestamp;
    SDL_TouchID touchId; 
    SDL_GestureID gestureId;
    Uint32 numFingers;
    float error;
    float x;            
    float y;            
} SDL_DollarGestureEvent;


typedef struct SDL_DropEvent
{
    Uint32 type;        
    Uint32 timestamp;
    char *file;         
} SDL_DropEvent;


typedef struct SDL_QuitEvent
{
    Uint32 type;        
    Uint32 timestamp;
} SDL_QuitEvent;

typedef struct SDL_OSEvent
{
    Uint32 type;        
    Uint32 timestamp;
} SDL_OSEvent;

typedef struct SDL_UserEvent
{
    Uint32 type;        
    Uint32 timestamp;
    Uint32 windowID;    
    Sint32 code;        
    void *data1;        
    void *data2;        
} SDL_UserEvent;


struct SDL_SysWMmsg;
typedef struct SDL_SysWMmsg SDL_SysWMmsg;

typedef struct SDL_SysWMEvent
{
    Uint32 type;        
    Uint32 timestamp;
    SDL_SysWMmsg *msg;  
} SDL_SysWMEvent;

typedef union SDL_Event
{
    Uint32 type;                    
    SDL_CommonEvent common;         
    SDL_WindowEvent window;         
    SDL_KeyboardEvent key;          
    SDL_TextEditingEvent edit;      
    SDL_TextInputEvent text;        
    SDL_MouseMotionEvent motion;    
    SDL_MouseButtonEvent button;    
    SDL_MouseWheelEvent wheel;      
    SDL_JoyAxisEvent jaxis;         
    SDL_JoyBallEvent jball;         
    SDL_JoyHatEvent jhat;           
    SDL_JoyButtonEvent jbutton;     
    SDL_JoyDeviceEvent jdevice;     
    SDL_ControllerAxisEvent caxis;      
    SDL_ControllerButtonEvent cbutton;  
    SDL_ControllerDeviceEvent cdevice;  
    SDL_QuitEvent quit;             
    SDL_UserEvent user;             
    SDL_SysWMEvent syswm;           
    SDL_TouchFingerEvent tfinger;   
    SDL_MultiGestureEvent mgesture; 
    SDL_DollarGestureEvent dgesture; 
    SDL_DropEvent drop;             
    /* This is necessary for ABI compatibility between Visual C++ and GCC
       Visual C++ will respect the push pack pragma and use 52 bytes for
       this structure, and GCC will use the alignment of the largest datatype
       within the union, which is 8 bytes.

       So... we'll add padding to force the size to be 56 bytes for both.
    */
    Uint8 padding[56];
} SDL_Event;


/* Function prototypes */

extern DECLSPEC void SDLCALL SDL_PumpEvents(void);

/* @{ */
typedef enum
{
    SDL_ADDEVENT,
    SDL_PEEKEVENT,
    SDL_GETEVENT
} SDL_eventaction;

extern DECLSPEC int SDLCALL SDL_PeepEvents(SDL_Event * events, int numevents,
                                           SDL_eventaction action,
                                           Uint32 minType, Uint32 maxType);
/* @} */

extern DECLSPEC SDL_bool SDLCALL SDL_HasEvent(Uint32 type);
extern DECLSPEC SDL_bool SDLCALL SDL_HasEvents(Uint32 minType, Uint32 maxType);

extern DECLSPEC void SDLCALL SDL_FlushEvent(Uint32 type);
extern DECLSPEC void SDLCALL SDL_FlushEvents(Uint32 minType, Uint32 maxType);

extern DECLSPEC int SDLCALL SDL_PollEvent(SDL_Event * event);

extern DECLSPEC int SDLCALL SDL_WaitEvent(SDL_Event * event);

extern DECLSPEC int SDLCALL SDL_WaitEventTimeout(SDL_Event * event,
                                                 int timeout);

extern DECLSPEC int SDLCALL SDL_PushEvent(SDL_Event * event);

typedef int (SDLCALL * SDL_EventFilter) (void *userdata, SDL_Event * event);

extern DECLSPEC void SDLCALL SDL_SetEventFilter(SDL_EventFilter filter,
                                                void *userdata);

extern DECLSPEC SDL_bool SDLCALL SDL_GetEventFilter(SDL_EventFilter * filter,
                                                    void **userdata);

extern DECLSPEC void SDLCALL SDL_AddEventWatch(SDL_EventFilter filter,
                                               void *userdata);

extern DECLSPEC void SDLCALL SDL_DelEventWatch(SDL_EventFilter filter,
                                               void *userdata);

extern DECLSPEC void SDLCALL SDL_FilterEvents(SDL_EventFilter filter,
                                              void *userdata);

/* @{ */
#define SDL_QUERY   -1
#define SDL_IGNORE   0
#define SDL_DISABLE  0
#define SDL_ENABLE   1

extern DECLSPEC Uint8 SDLCALL SDL_EventState(Uint32 type, int state);
/* @} */
#define SDL_GetEventState(type) SDL_EventState(type, SDL_QUERY)

extern DECLSPEC Uint32 SDLCALL SDL_RegisterEvents(int numevents);

/* Ends C function definitions when using C++ */
#ifdef __cplusplus
}
#endif
#include "close_code.h"

#endif /* _SDL_events_h */

/* vi: set ts=4 sw=4 expandtab: */