#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"
#include "close_code.h"

Include dependency graph for SDL_events.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	SDL_CommonEvent
	Fields shared by every event. More...
struct	SDL_DisplayEvent
	Display state change event data (event.display.*) More...
struct	SDL_WindowEvent
	Window state change event data (event.window.*) More...
struct	SDL_KeyboardEvent
	Keyboard button event structure (event.key.*) More...
struct	SDL_TextEditingEvent
	Keyboard text editing event structure (event.edit.*) More...
struct	SDL_TextInputEvent
	Keyboard text input event structure (event.text.*) More...
struct	SDL_MouseMotionEvent
	Mouse motion event structure (event.motion.*) More...
struct	SDL_MouseButtonEvent
	Mouse button event structure (event.button.*) More...
struct	SDL_MouseWheelEvent
	Mouse wheel event structure (event.wheel.*) More...
struct	SDL_JoyAxisEvent
	Joystick axis motion event structure (event.jaxis.*) More...
struct	SDL_JoyBallEvent
	Joystick trackball motion event structure (event.jball.*) More...
struct	SDL_JoyHatEvent
	Joystick hat position change event structure (event.jhat.*) More...
struct	SDL_JoyButtonEvent
	Joystick button event structure (event.jbutton.*) More...
struct	SDL_JoyDeviceEvent
	Joystick device event structure (event.jdevice.*) More...
struct	SDL_ControllerAxisEvent
	Game controller axis motion event structure (event.caxis.*) More...
struct	SDL_ControllerButtonEvent
	Game controller button event structure (event.cbutton.*) More...
struct	SDL_ControllerDeviceEvent
	Controller device event structure (event.cdevice.*) More...
struct	SDL_AudioDeviceEvent
	Audio device event structure (event.adevice.*) More...
struct	SDL_TouchFingerEvent
	Touch finger event structure (event.tfinger.*) More...
struct	SDL_MultiGestureEvent
	Multiple Finger Gesture Event (event.mgesture.*) More...
struct	SDL_DollarGestureEvent
	Dollar Gesture Event (event.dgesture.*) More...
struct	SDL_DropEvent
	An event used to request a file open by the system (event.drop.*) This event is enabled by default, you can disable it with SDL_EventState(). More...
struct	SDL_SensorEvent
	Sensor event structure (event.sensor.*) More...
struct	SDL_QuitEvent
	The "quit requested" event. More...
struct	SDL_OSEvent
	OS Specific event. More...
struct	SDL_UserEvent
	A user-defined event type (event.user.*) More...
struct	SDL_SysWMEvent
	A video driver dependent system event (event.syswm.*) This event is disabled by default, you can enable it with SDL_EventState() More...
union	SDL_Event
	General event structure. More...

Macros
#define	SDL_RELEASED 0
#define	SDL_PRESSED 1
#define	SDL_TEXTEDITINGEVENT_TEXT_SIZE (32)
#define	SDL_TEXTINPUTEVENT_TEXT_SIZE (32)
#define	SDL_GetEventState(type) SDL_EventState(type, SDL_QUERY)

Typedefs
typedef int(*	SDL_EventFilter )(void userdata, SDL_Event event)

Enumerations
enum	SDL_EventType { SDL_FIRSTEVENT = 0, SDL_QUIT = 0x100, SDL_APP_TERMINATING, SDL_APP_LOWMEMORY, SDL_APP_WILLENTERBACKGROUND, SDL_APP_DIDENTERBACKGROUND, SDL_APP_WILLENTERFOREGROUND, SDL_APP_DIDENTERFOREGROUND, SDL_DISPLAYEVENT = 0x150, SDL_WINDOWEVENT = 0x200, SDL_SYSWMEVENT, SDL_KEYDOWN = 0x300, SDL_KEYUP, SDL_TEXTEDITING, SDL_TEXTINPUT, SDL_KEYMAPCHANGED, SDL_MOUSEMOTION = 0x400, SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP, SDL_MOUSEWHEEL, SDL_JOYAXISMOTION = 0x600, SDL_JOYBALLMOTION, SDL_JOYHATMOTION, SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP, SDL_JOYDEVICEADDED, SDL_JOYDEVICEREMOVED, SDL_CONTROLLERAXISMOTION = 0x650, SDL_CONTROLLERBUTTONDOWN, SDL_CONTROLLERBUTTONUP, SDL_CONTROLLERDEVICEADDED, SDL_CONTROLLERDEVICEREMOVED, SDL_CONTROLLERDEVICEREMAPPED, SDL_FINGERDOWN = 0x700, SDL_FINGERUP, SDL_FINGERMOTION, SDL_DOLLARGESTURE = 0x800, SDL_DOLLARRECORD, SDL_MULTIGESTURE, SDL_CLIPBOARDUPDATE = 0x900, SDL_DROPFILE = 0x1000, SDL_DROPTEXT, SDL_DROPBEGIN, SDL_DROPCOMPLETE, SDL_AUDIODEVICEADDED = 0x1100, SDL_AUDIODEVICEREMOVED, SDL_SENSORUPDATE = 0x1200, SDL_RENDER_TARGETS_RESET = 0x2000, SDL_RENDER_DEVICE_RESET, SDL_USEREVENT = 0x8000, SDL_LASTEVENT = 0xFFFF }
	The types of events that can be delivered. More...

Functions
void	SDL_PumpEvents (void)
SDL_bool	SDL_HasEvent (Uint32 type)
SDL_bool	SDL_HasEvents (Uint32 minType, Uint32 maxType)
void	SDL_FlushEvent (Uint32 type)
void	SDL_FlushEvents (Uint32 minType, Uint32 maxType)
int	SDL_PollEvent (SDL_Event *event)
	Polls for currently pending events.
int	SDL_WaitEvent (SDL_Event *event)
	Waits indefinitely for the next available event.
int	SDL_WaitEventTimeout (SDL_Event *event, int timeout)
	Waits until the specified timeout (in milliseconds) for the next available event.
int	SDL_PushEvent (SDL_Event *event)
	Add an event to the event queue.
void	SDL_SetEventFilter (SDL_EventFilter filter, void *userdata)
SDL_bool	SDL_GetEventFilter (SDL_EventFilter filter, void *userdata)
void	SDL_AddEventWatch (SDL_EventFilter filter, void *userdata)
void	SDL_DelEventWatch (SDL_EventFilter filter, void *userdata)
void	SDL_FilterEvents (SDL_EventFilter filter, void *userdata)
Uint32	SDL_RegisterEvents (int numevents)
enum	SDL_eventaction { SDL_ADDEVENT, SDL_PEEKEVENT, SDL_GETEVENT }
int	SDL_PeepEvents (SDL_Event *events, int numevents, SDL_eventaction action, Uint32 minType, Uint32 maxType)
#define	SDL_QUERY -1
#define	SDL_IGNORE 0
#define	SDL_DISABLE 0
#define	SDL_ENABLE 1
Uint8	SDL_EventState (Uint32 type, int state)

Detailed Description

Include file for SDL event handling.

Definition in file SDL_events.h.

Macro Definition Documentation

#define SDL_DISABLE 0

Definition at line 755 of file SDL_events.h.

Referenced by mouse_showCursor(), SDL_EventState(), SDL_JoystickEventState(), SDL_StartEventLoop(), and SDL_StopTextInput().

#define SDL_ENABLE 1

Definition at line 756 of file SDL_events.h.

Referenced by _changeCursorVisibility(), IsAcceptingDragAndDrop(), main(), mouse_showCursor(), SDL_AddAudioDevice(), SDL_EventState(), SDL_GameControllerEventState(), SDL_IsTextInputActive(), SDL_JoystickEventState(), SDL_OpenedAudioDeviceDisconnected(), SDL_PrivateGameControllerAxis(), SDL_PrivateGameControllerButton(), SDL_PrivateJoystickAdded(), SDL_PrivateJoystickAxis(), SDL_PrivateJoystickBall(), SDL_PrivateJoystickButton(), SDL_PrivateJoystickHat(), SDL_PrivateJoystickRemoved(), SDL_PrivateSendMouseButton(), SDL_PrivateSendMouseMotion(), SDL_PrivateSensorUpdate(), SDL_SendAppEvent(), SDL_SendClipboardUpdate(), SDL_SendDisplayEvent(), SDL_SendDrop(), SDL_SendEditingText(), SDL_SendKeyboardKey(), SDL_SendKeyboardText(), SDL_SendMouseWheel(), SDL_SendSysWMEvent(), SDL_SendTouch(), SDL_SendTouchMotion(), SDL_SendWindowEvent(), and SDL_StartTextInput().

#define SDL_GetEventState ( type ) SDL_EventState(type, SDL_QUERY)

#define SDL_IGNORE 0

Definition at line 754 of file SDL_events.h.

Referenced by main(), and SDL_GameControllerEventState().

#define SDL_PRESSED 1

Definition at line 50 of file SDL_events.h.

Referenced by SDL_BApp::_HandleKey(), SDL_BWin::DispatchMessage(), HandleJoystickAxis(), HandleJoystickHat(), handleKeyboardEvent(), IOS_MFIJoystickUpdate(), loop(), SDL_GameControllerGetAxis(), SDL_GameControllerGetButton(), SDL_PrivateGameControllerButton(), SDL_PrivateJoystickButton(), SDL_PrivateSendMouseButton(), SDL_ResetKeyboard(), SDL_SendKeyboardKey(), and WINRT_OnBackButtonPressed().

#define SDL_QUERY -1

Definition at line 753 of file SDL_events.h.

Referenced by _changeCursorVisibility(), SDL_BApp::_HandleKey(), mouse_showCursor(), SDL_GameControllerEventState(), SDL_JoystickEventState(), SDL_PumpEvents(), and SDL_SetKeyboardFocus().

#define SDL_RELEASED 0

Definition at line 49 of file SDL_events.h.

Referenced by SDL_BWin::DispatchMessage(), HandleJoystickAxis(), handleKeyboardEvent(), IOS_MFIJoystickUpdate(), ResetOutput(), SDL_GameControllerGetButton(), SDL_GameControllerHandleDelayedGuideButton(), SDL_PrivateGameControllerButton(), SDL_PrivateJoystickButton(), SDL_PrivateSendMouseButton(), SDL_ResetKeyboard(), SDL_SendKeyboardKey(), and WINRT_OnBackButtonPressed().

#define SDL_TEXTEDITINGEVENT_TEXT_SIZE (32)

Definition at line 223 of file SDL_events.h.

Referenced by main().

#define SDL_TEXTINPUTEVENT_TEXT_SIZE (32)

Definition at line 238 of file SDL_events.h.

Referenced by SDL_BApp::_HandleKey().

Typedef Documentation

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

Definition at line 696 of file SDL_events.h.

Enumeration Type Documentation

enum SDL_eventaction

Enumerator:

SDL_ADDEVENT
SDL_PEEKEVENT
SDL_GETEVENT

Definition at line 610 of file SDL_events.h.

{
    SDL_ADDEVENT,
    SDL_PEEKEVENT,
    SDL_GETEVENT
} SDL_eventaction;

enum SDL_EventType

The types of events that can be delivered.

Enumerator:

SDL_FIRSTEVENT	Unused (do not remove)
SDL_QUIT	User-requested quit
SDL_APP_TERMINATING	The application is being terminated by the OS Called on iOS in applicationWillTerminate() Called on Android in onDestroy()
SDL_APP_LOWMEMORY	The application is low on memory, free memory if possible. Called on iOS in applicationDidReceiveMemoryWarning() Called on Android in onLowMemory()
SDL_APP_WILLENTERBACKGROUND	The application is about to enter the background Called on iOS in applicationWillResignActive() Called on Android in onPause()
SDL_APP_DIDENTERBACKGROUND	The application did enter the background and may not get CPU for some time Called on iOS in applicationDidEnterBackground() Called on Android in onPause()
SDL_APP_WILLENTERFOREGROUND	The application is about to enter the foreground Called on iOS in applicationWillEnterForeground() Called on Android in onResume()
SDL_APP_DIDENTERFOREGROUND	The application is now interactive Called on iOS in applicationDidBecomeActive() Called on Android in onResume()
SDL_DISPLAYEVENT	Display state change
SDL_WINDOWEVENT	Window state change
SDL_SYSWMEVENT	System specific event
SDL_KEYDOWN	Key pressed
SDL_KEYUP	Key released
SDL_TEXTEDITING	Keyboard text editing (composition)
SDL_TEXTINPUT	Keyboard text input
SDL_KEYMAPCHANGED	Keymap changed due to a system event such as an input language or keyboard layout change.
SDL_MOUSEMOTION	Mouse moved
SDL_MOUSEBUTTONDOWN	Mouse button pressed
SDL_MOUSEBUTTONUP	Mouse button released
SDL_MOUSEWHEEL	Mouse wheel motion
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_JOYDEVICEADDED	A new joystick has been inserted into the system
SDL_JOYDEVICEREMOVED	An opened joystick has been removed
SDL_CONTROLLERAXISMOTION	Game controller axis motion
SDL_CONTROLLERBUTTONDOWN	Game controller button pressed
SDL_CONTROLLERBUTTONUP	Game controller button released
SDL_CONTROLLERDEVICEADDED	A new Game controller has been inserted into the system
SDL_CONTROLLERDEVICEREMOVED	An opened Game controller has been removed
SDL_CONTROLLERDEVICEREMAPPED	The controller mapping was updated
SDL_FINGERDOWN
SDL_FINGERUP
SDL_FINGERMOTION
SDL_DOLLARGESTURE
SDL_DOLLARRECORD
SDL_MULTIGESTURE
SDL_CLIPBOARDUPDATE	The clipboard changed
SDL_DROPFILE	The system requests a file open
SDL_DROPTEXT	text/plain drag-and-drop event
SDL_DROPBEGIN	A new set of drops is beginning (NULL filename)
SDL_DROPCOMPLETE	Current set of drops is now complete (NULL filename)
SDL_AUDIODEVICEADDED	A new audio device is available
SDL_AUDIODEVICEREMOVED	An audio device has been removed.
SDL_SENSORUPDATE	A sensor was updated
SDL_RENDER_TARGETS_RESET	The render targets have been reset and their contents need to be updated
SDL_RENDER_DEVICE_RESET	The device has been reset and all textures need to be recreated
SDL_USEREVENT	Events SDL_USEREVENT through SDL_LASTEVENT are for your use, and should be allocated with SDL_RegisterEvents()
SDL_LASTEVENT	This last event is only for bounding internal arrays

Definition at line 55 of file SDL_events.h.

{
    SDL_FIRSTEVENT     = 0,     /**< Unused (do not remove) */
    /* Application events */
    SDL_QUIT           = 0x100, /**< User-requested quit */
    /* These application events have special meaning on iOS, see README-ios.md for details */
    SDL_APP_TERMINATING,        /**< The application is being terminated by the OS
                                     Called on iOS in applicationWillTerminate()
                                     Called on Android in onDestroy()
                                */
    SDL_APP_LOWMEMORY,          /**< The application is low on memory, free memory if possible.
                                     Called on iOS in applicationDidReceiveMemoryWarning()
                                     Called on Android in onLowMemory()
                                */
    SDL_APP_WILLENTERBACKGROUND, /**< The application is about to enter the background
                                     Called on iOS in applicationWillResignActive()
                                     Called on Android in onPause()
                                */
    SDL_APP_DIDENTERBACKGROUND, /**< The application did enter the background and may not get CPU for some time
                                     Called on iOS in applicationDidEnterBackground()
                                     Called on Android in onPause()
                                */
    SDL_APP_WILLENTERFOREGROUND, /**< The application is about to enter the foreground
                                     Called on iOS in applicationWillEnterForeground()
                                     Called on Android in onResume()
                                */
    SDL_APP_DIDENTERFOREGROUND, /**< The application is now interactive
                                     Called on iOS in applicationDidBecomeActive()
                                     Called on Android in onResume()
                                */
    /* Display events */
    SDL_DISPLAYEVENT   = 0x150,  /**< Display state change */
    /* Window events */
    SDL_WINDOWEVENT    = 0x200, /**< Window state change */
    SDL_SYSWMEVENT,             /**< System specific event */
    /* Keyboard events */
    SDL_KEYDOWN        = 0x300, /**< Key pressed */
    SDL_KEYUP,                  /**< Key released */
    SDL_TEXTEDITING,            /**< Keyboard text editing (composition) */
    SDL_TEXTINPUT,              /**< Keyboard text input */
    SDL_KEYMAPCHANGED,          /**< Keymap changed due to a system event such as an
                                     input language or keyboard layout change.
                                */
    /* Mouse events */
    SDL_MOUSEMOTION    = 0x400, /**< Mouse moved */
    SDL_MOUSEBUTTONDOWN,        /**< Mouse button pressed */
    SDL_MOUSEBUTTONUP,          /**< Mouse button released */
    SDL_MOUSEWHEEL,             /**< Mouse wheel motion */
    /* Joystick events */
    SDL_JOYAXISMOTION  = 0x600, /**< 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_JOYDEVICEADDED,         /**< A new joystick has been inserted into the system */
    SDL_JOYDEVICEREMOVED,       /**< An opened joystick has been removed */
    /* Game controller events */
    SDL_CONTROLLERAXISMOTION  = 0x650, /**< Game controller axis motion */
    SDL_CONTROLLERBUTTONDOWN,          /**< Game controller button pressed */
    SDL_CONTROLLERBUTTONUP,            /**< Game controller button released */
    SDL_CONTROLLERDEVICEADDED,         /**< A new Game controller has been inserted into the system */
    SDL_CONTROLLERDEVICEREMOVED,       /**< An opened Game controller has been removed */
    SDL_CONTROLLERDEVICEREMAPPED,      /**< The controller mapping was updated */
    /* Touch events */
    SDL_FINGERDOWN      = 0x700,
    SDL_FINGERUP,
    SDL_FINGERMOTION,
    /* Gesture events */
    SDL_DOLLARGESTURE   = 0x800,
    SDL_DOLLARRECORD,
    SDL_MULTIGESTURE,
    /* Clipboard events */
    SDL_CLIPBOARDUPDATE = 0x900, /**< The clipboard changed */
    /* Drag and drop events */
    SDL_DROPFILE        = 0x1000, /**< The system requests a file open */
    SDL_DROPTEXT,                 /**< text/plain drag-and-drop event */
    SDL_DROPBEGIN,                /**< A new set of drops is beginning (NULL filename) */
    SDL_DROPCOMPLETE,             /**< Current set of drops is now complete (NULL filename) */
    /* Audio hotplug events */
    SDL_AUDIODEVICEADDED = 0x1100, /**< A new audio device is available */
    SDL_AUDIODEVICEREMOVED,        /**< An audio device has been removed. */
    /* Sensor events */
    SDL_SENSORUPDATE = 0x1200,     /**< A sensor was updated */
    /* Render events */
    SDL_RENDER_TARGETS_RESET = 0x2000, /**< The render targets have been reset and their contents need to be updated */
    SDL_RENDER_DEVICE_RESET, /**< The device has been reset and all textures need to be recreated */
    /** Events ::SDL_USEREVENT through ::SDL_LASTEVENT are for your use,
     *  and should be allocated with SDL_RegisterEvents()
     */
    SDL_USEREVENT    = 0x8000,
    /**
     *  This last event is only for bounding internal arrays
     */
    SDL_LASTEVENT    = 0xFFFF
} SDL_EventType;

Function Documentation

void SDL_AddEventWatch	(	SDL_EventFilter	filter,
		void *	userdata
	)

Add a function which is called when an event is added to the queue.

Definition at line 811 of file SDL_events.c.

References SDL_EventWatcher::callback, SDL_EventWatcher::removed, SDL_event_watchers_count, SDL_FALSE, SDL_LockMutex, SDL_realloc, SDL_UnlockMutex, and SDL_EventWatcher::userdata.

{
    if (!SDL_event_watchers_lock || SDL_LockMutex(SDL_event_watchers_lock) == 0) {
        SDL_EventWatcher *event_watchers;
        event_watchers = SDL_realloc(SDL_event_watchers, (SDL_event_watchers_count + 1) * sizeof(*event_watchers));
        if (event_watchers) {
            SDL_EventWatcher *watcher;
            SDL_event_watchers = event_watchers;
            watcher = &SDL_event_watchers[SDL_event_watchers_count];
            watcher->callback = filter;
            watcher->userdata = userdata;
            watcher->removed = SDL_FALSE;
            ++SDL_event_watchers_count;
        }
        if (SDL_event_watchers_lock) {
            SDL_UnlockMutex(SDL_event_watchers_lock);
        }
    }
}

void SDL_DelEventWatch	(	SDL_EventFilter	filter,
		void *	userdata
	)

Remove an event watch function added with SDL_AddEventWatch()

Definition at line 835 of file SDL_events.c.

References callback(), i, SDL_EventWatcher::removed, SDL_event_watchers_count, SDL_event_watchers_dispatching, SDL_event_watchers_removed, SDL_LockMutex, SDL_memmove, SDL_TRUE, and SDL_UnlockMutex.

{
    if (!SDL_event_watchers_lock || SDL_LockMutex(SDL_event_watchers_lock) == 0) {
        int i;
        for (i = 0; i < SDL_event_watchers_count; ++i) {
            if (SDL_event_watchers[i].callback == filter && SDL_event_watchers[i].userdata == userdata) {
                if (SDL_event_watchers_dispatching) {
                    SDL_event_watchers[i].removed = SDL_TRUE;
                    SDL_event_watchers_removed = SDL_TRUE;
                } else {
                    --SDL_event_watchers_count;
                    if (i < SDL_event_watchers_count) {
                        SDL_memmove(&SDL_event_watchers[i], &SDL_event_watchers[i+1], (SDL_event_watchers_count - i) * sizeof(SDL_event_watchers[i]));
                    }
                }
                break;
            }
        }
        if (SDL_event_watchers_lock) {
            SDL_UnlockMutex(SDL_event_watchers_lock);
        }
    }
}

Uint8 SDL_EventState	(	Uint32	type,
		int	state
	)

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

Definition at line 879 of file SDL_events.c.

References SDL_DisabledEventBlock::bits, SDL_calloc, SDL_DISABLE, SDL_DROPFILE, SDL_DROPTEXT, SDL_ENABLE, SDL_FlushEvent, and SDL_ToggleDragAndDropSupport().

{
    const SDL_bool isdnd = ((state == SDL_DISABLE) || (state == SDL_ENABLE)) &&
                           ((type == SDL_DROPFILE) || (type == SDL_DROPTEXT));
    Uint8 current_state;
    Uint8 hi = ((type >> 8) & 0xff);
    Uint8 lo = (type & 0xff);
    if (SDL_disabled_events[hi] &&
        (SDL_disabled_events[hi]->bits[lo/32] & (1 << (lo&31)))) {
        current_state = SDL_DISABLE;
    } else {
        current_state = SDL_ENABLE;
    }
    if (state != current_state)
    {
        switch (state) {
        case SDL_DISABLE:
            /* Disable this event type and discard pending events */
            if (!SDL_disabled_events[hi]) {
                SDL_disabled_events[hi] = (SDL_DisabledEventBlock*) SDL_calloc(1, sizeof(SDL_DisabledEventBlock));
                if (!SDL_disabled_events[hi]) {
                    /* Out of memory, nothing we can do... */
                    break;
                }
            }
            SDL_disabled_events[hi]->bits[lo/32] |= (1 << (lo&31));
            SDL_FlushEvent(type);
            break;
        case SDL_ENABLE:
            SDL_disabled_events[hi]->bits[lo/32] &= ~(1 << (lo&31));
            break;
        default:
            /* Querying state... */
            break;
        }
    }
    /* turn off drag'n'drop support if we've disabled the events.
       This might change some UI details at the OS level. */
    if (isdnd) {
        SDL_ToggleDragAndDropSupport();
    }
    return current_state;
}

void SDL_FilterEvents	(	SDL_EventFilter	filter,
		void *	userdata
	)

Run the filter function on the current event queue, removing any events for which the filter returns 0.

Definition at line 862 of file SDL_events.c.

References SDL_EventEntry::event, SDL_EventEntry::next, SDL_CutEvent(), SDL_EventQ, SDL_LockMutex, and SDL_UnlockMutex.

{
    if (!SDL_EventQ.lock || SDL_LockMutex(SDL_EventQ.lock) == 0) {
        SDL_EventEntry *entry, *next;
        for (entry = SDL_EventQ.head; entry; entry = next) {
            next = entry->next;
            if (!filter(userdata, &entry->event)) {
                SDL_CutEvent(entry);
            }
        }
        if (SDL_EventQ.lock) {
            SDL_UnlockMutex(SDL_EventQ.lock);
        }
    }
}

void SDL_FlushEvent ( Uint32 type )

This function clears events from the event queue This function only affects currently queued events. If you want to make sure that all pending OS events are flushed, you can call SDL_PumpEvents() on the main thread immediately before the flush call.

Definition at line 603 of file SDL_events.c.

References SDL_FlushEvents.

{
    SDL_FlushEvents(type, type);
}

void SDL_FlushEvents	(	Uint32	minType,
		Uint32	maxType
	)

Definition at line 609 of file SDL_events.c.

References SDL_EventEntry::event, SDL_EventEntry::next, SDL_AtomicGet, SDL_CutEvent(), SDL_EventQ, SDL_LockMutex, SDL_PumpEvents, SDL_UnlockMutex, and SDL_Event::type.

{
    /* !!! FIXME: we need to manually SDL_free() the strings in TEXTINPUT and
       drag'n'drop events if we're flushing them without passing them to the
       app, but I don't know if this is the right place to do that. */
    /* Don't look after we've quit */
    if (!SDL_AtomicGet(&SDL_EventQ.active)) {
        return;
    }
    /* Make sure the events are current */
#if 0
    /* Actually, we can't do this since we might be flushing while processing
       a resize event, and calling this might trigger further resize events.
    */
    SDL_PumpEvents();
#endif
    /* Lock the event queue */
    if (!SDL_EventQ.lock || SDL_LockMutex(SDL_EventQ.lock) == 0) {
        SDL_EventEntry *entry, *next;
        Uint32 type;
        for (entry = SDL_EventQ.head; entry; entry = next) {
            next = entry->next;
            type = entry->event.type;
            if (minType <= type && type <= maxType) {
                SDL_CutEvent(entry);
            }
        }
        if (SDL_EventQ.lock) {
            SDL_UnlockMutex(SDL_EventQ.lock);
        }
    }
}

SDL_bool SDL_GetEventFilter	(	SDL_EventFilter *	filter,
		void **	userdata
	)

Return the current event filter - can be used to "chain" filters. If there is no event filter set, this function returns SDL_FALSE.

Definition at line 787 of file SDL_events.c.

References SDL_EventWatcher::callback, SDL_EventOK, SDL_FALSE, SDL_LockMutex, SDL_TRUE, SDL_UnlockMutex, SDL_zero, and SDL_EventWatcher::userdata.

{
    SDL_EventWatcher event_ok;
    if (!SDL_event_watchers_lock || SDL_LockMutex(SDL_event_watchers_lock) == 0) {
        event_ok = SDL_EventOK;
        if (SDL_event_watchers_lock) {
            SDL_UnlockMutex(SDL_event_watchers_lock);
        }
    } else {
        SDL_zero(event_ok);
    }
    if (filter) {
        *filter = event_ok.callback;
    }
    if (userdata) {
        *userdata = event_ok.userdata;
    }
    return event_ok.callback ? SDL_TRUE : SDL_FALSE;
}

SDL_bool SDL_HasEvent ( Uint32 type )

Checks to see if certain event types are in the event queue.

Definition at line 591 of file SDL_events.c.

References NULL, SDL_PEEKEVENT, and SDL_PeepEvents.

{
    return (SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, type, type) > 0);
}

SDL_bool SDL_HasEvents	(	Uint32	minType,
		Uint32	maxType
	)

Definition at line 597 of file SDL_events.c.

References NULL, SDL_PEEKEVENT, and SDL_PeepEvents.

{
    return (SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, minType, maxType) > 0);
}

int SDL_PeepEvents	(	SDL_Event *	events,
		int	numevents,
		SDL_eventaction	action,
		Uint32	minType,
		Uint32	maxType
	)

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, within the specified minimum and maximum type, 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, within the specified minimum and maximum type, will be returned and will be removed from the queue.

Returns: The number of events actually stored, or -1 if there was an error.

This function is thread-safe.

Definition at line 513 of file SDL_events.c.

References SDL_EventEntry::event, i, SDL_SysWMEntry::msg, SDL_SysWMEvent::msg, SDL_EventEntry::next, SDL_SysWMEntry::next, NULL, SDL_AddEvent(), SDL_ADDEVENT, SDL_AtomicGet, SDL_CutEvent(), SDL_EventQ, SDL_GETEVENT, SDL_LockMutex, SDL_malloc, SDL_SetError, SDL_SYSWMEVENT, SDL_UnlockMutex, SDL_Event::syswm, and SDL_Event::type.

{
    int i, used;
    /* Don't look after we've quit */
    if (!SDL_AtomicGet(&SDL_EventQ.active)) {
        /* We get a few spurious events at shutdown, so don't warn then */
        if (action != SDL_ADDEVENT) {
            SDL_SetError("The event system has been shut down");
        }
        return (-1);
    }
    /* Lock the event queue */
    used = 0;
    if (!SDL_EventQ.lock || SDL_LockMutex(SDL_EventQ.lock) == 0) {
        if (action == SDL_ADDEVENT) {
            for (i = 0; i < numevents; ++i) {
                used += SDL_AddEvent(&events[i]);
            }
        } else {
            SDL_EventEntry *entry, *next;
            SDL_SysWMEntry *wmmsg, *wmmsg_next;
            Uint32 type;
            if (action == SDL_GETEVENT) {
                /* Clean out any used wmmsg data
                   FIXME: Do we want to retain the data for some period of time?
                 */
                for (wmmsg = SDL_EventQ.wmmsg_used; wmmsg; wmmsg = wmmsg_next) {
                    wmmsg_next = wmmsg->next;
                    wmmsg->next = SDL_EventQ.wmmsg_free;
                    SDL_EventQ.wmmsg_free = wmmsg;
                }
                SDL_EventQ.wmmsg_used = NULL;
            }
            for (entry = SDL_EventQ.head; entry && (!events || used < numevents); entry = next) {
                next = entry->next;
                type = entry->event.type;
                if (minType <= type && type <= maxType) {
                    if (events) {
                        events[used] = entry->event;
                        if (entry->event.type == SDL_SYSWMEVENT) {
                            /* We need to copy the wmmsg somewhere safe.
                               For now we'll guarantee it's valid at least until
                               the next call to SDL_PeepEvents()
                             */
                            if (SDL_EventQ.wmmsg_free) {
                                wmmsg = SDL_EventQ.wmmsg_free;
                                SDL_EventQ.wmmsg_free = wmmsg->next;
                            } else {
                                wmmsg = (SDL_SysWMEntry *)SDL_malloc(sizeof(*wmmsg));
                            }
                            wmmsg->msg = *entry->event.syswm.msg;
                            wmmsg->next = SDL_EventQ.wmmsg_used;
                            SDL_EventQ.wmmsg_used = wmmsg;
                            events[used].syswm.msg = &wmmsg->msg;
                        }
                        if (action == SDL_GETEVENT) {
                            SDL_CutEvent(entry);
                        }
                    }
                    ++used;
                }
            }
        }
        if (SDL_EventQ.lock) {
            SDL_UnlockMutex(SDL_EventQ.lock);
        }
    } else {
        return SDL_SetError("Couldn't lock event queue");
    }
    return (used);
}

int SDL_PollEvent ( SDL_Event * event )

Polls for currently pending events.

Returns: 1 if there are any pending events, or 0 if there are none available.

Parameters

event If not NULL, the next event is removed from the queue and stored in that area.

Definition at line 675 of file SDL_events.c.

References SDL_WaitEventTimeout.

{
    return SDL_WaitEventTimeout(event, 0);
}

void SDL_PumpEvents ( void )

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.

Definition at line 647 of file SDL_events.c.

References _this, SDL_VideoDevice::PumpEvents, SDL_GetVideoDevice(), SDL_JOYAXISMOTION, SDL_JoystickEventState, SDL_JoystickUpdate, SDL_QUERY, SDL_SendPendingQuit(), SDL_SENSORUPDATE, and SDL_SensorUpdate.

{
    SDL_VideoDevice *_this = SDL_GetVideoDevice();
    /* Get events from the video subsystem */
    if (_this) {
        _this->PumpEvents(_this);
    }
#if !SDL_JOYSTICK_DISABLED
    /* Check for joystick state change */
    if ((!SDL_disabled_events[SDL_JOYAXISMOTION >> 8] || SDL_JoystickEventState(SDL_QUERY))) {
        SDL_JoystickUpdate();
    }
#endif
#if !SDL_SENSOR_DISABLED
    /* Check for sensor state change */
    if (!SDL_disabled_events[SDL_SENSORUPDATE >> 8]) {
        SDL_SensorUpdate();
    }
#endif
    SDL_SendPendingQuit();  /* in case we had a signal handler fire, etc. */
}

int SDL_PushEvent ( SDL_Event * event )

Add an event to the event queue.

Returns: 1 on success, 0 if the event was filtered, or -1 if the event queue was full or there was some other error.

Definition at line 718 of file SDL_events.c.

References SDL_EventWatcher::callback, i, SDL_ADDEVENT, SDL_event_watchers_count, SDL_event_watchers_dispatching, SDL_event_watchers_removed, SDL_FALSE, SDL_GestureProcessEvent(), SDL_GetTicks(), SDL_LockMutex, SDL_memmove, SDL_PeepEvents, SDL_TRUE, SDL_UnlockMutex, and SDL_EventWatcher::userdata.

{
    event->common.timestamp = SDL_GetTicks();
    if (SDL_EventOK.callback || SDL_event_watchers_count > 0) {
        if (!SDL_event_watchers_lock || SDL_LockMutex(SDL_event_watchers_lock) == 0) {
            if (SDL_EventOK.callback && !SDL_EventOK.callback(SDL_EventOK.userdata, event)) {
                if (SDL_event_watchers_lock) {
                    SDL_UnlockMutex(SDL_event_watchers_lock);
                }
                return 0;
            }
            if (SDL_event_watchers_count > 0) {
                /* Make sure we only dispatch the current watcher list */
                int i, event_watchers_count = SDL_event_watchers_count;
                SDL_event_watchers_dispatching = SDL_TRUE;
                for (i = 0; i < event_watchers_count; ++i) {
                    if (!SDL_event_watchers[i].removed) {
                        SDL_event_watchers[i].callback(SDL_event_watchers[i].userdata, event);
                    }
                }
                SDL_event_watchers_dispatching = SDL_FALSE;
                if (SDL_event_watchers_removed) {
                    for (i = SDL_event_watchers_count; i--; ) {
                        if (SDL_event_watchers[i].removed) {
                            --SDL_event_watchers_count;
                            if (i < SDL_event_watchers_count) {
                                SDL_memmove(&SDL_event_watchers[i], &SDL_event_watchers[i+1], (SDL_event_watchers_count - i) * sizeof(SDL_event_watchers[i]));
                            }
                        }
                    }
                    SDL_event_watchers_removed = SDL_FALSE;
                }
            }
            if (SDL_event_watchers_lock) {
                SDL_UnlockMutex(SDL_event_watchers_lock);
            }
        }
    }
    if (SDL_PeepEvents(event, 1, SDL_ADDEVENT, 0, 0) <= 0) {
        return -1;
    }
    SDL_GestureProcessEvent(event);
    return 1;
}

Uint32 SDL_RegisterEvents ( int numevents )

This function allocates a set of user-defined events, and returns the beginning event number for that set of events.

If there aren't enough user-defined events left, this function returns (Uint32)-1

Definition at line 928 of file SDL_events.c.

References SDL_LASTEVENT, and SDL_userevents.

{
    Uint32 event_base;
    if ((numevents > 0) && (SDL_userevents+numevents <= SDL_LASTEVENT)) {
        event_base = SDL_userevents;
        SDL_userevents += numevents;
    } else {
        event_base = (Uint32)-1;
    }
    return event_base;
}

void SDL_SetEventFilter	(	SDL_EventFilter	filter,
		void *	userdata
	)

Sets up a filter to process all events before they change internal state and are posted to the internal event queue.

The filter is prototyped as:

int SDL_EventFilter(void *userdata, 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.

Definition at line 772 of file SDL_events.c.

References SDL_EventWatcher::callback, SDL_FIRSTEVENT, SDL_FlushEvents, SDL_LASTEVENT, SDL_LockMutex, SDL_UnlockMutex, and SDL_EventWatcher::userdata.

{
    if (!SDL_event_watchers_lock || SDL_LockMutex(SDL_event_watchers_lock) == 0) {
        /* Set filter and discard pending events */
        SDL_EventOK.callback = filter;
        SDL_EventOK.userdata = userdata;
        SDL_FlushEvents(SDL_FIRSTEVENT, SDL_LASTEVENT);
        if (SDL_event_watchers_lock) {
            SDL_UnlockMutex(SDL_event_watchers_lock);
        }
    }
}

int SDL_WaitEvent ( SDL_Event * event )

Waits indefinitely for the next available event.

Returns: 1, or 0 if there was an error while waiting for events.

Parameters

event If not NULL, the next event is removed from the queue and stored in that area.

Definition at line 681 of file SDL_events.c.

References SDL_WaitEventTimeout.

{
    return SDL_WaitEventTimeout(event, -1);
}

int SDL_WaitEventTimeout	(	SDL_Event *	event,
		int	timeout
	)

Waits until the specified timeout (in milliseconds) for the next available event.

Returns: 1, or 0 if there was an error while waiting for events.

Parameters

event	If not NULL, the next event is removed from the queue and stored in that area.
timeout	The timeout (in milliseconds) to wait for next event.

Definition at line 687 of file SDL_events.c.

References SDL_Delay, SDL_FIRSTEVENT, SDL_GETEVENT, SDL_GetTicks(), SDL_LASTEVENT, SDL_PeepEvents, SDL_PumpEvents, and SDL_TICKS_PASSED.

{
    Uint32 expiration = 0;
    if (timeout > 0)
        expiration = SDL_GetTicks() + timeout;
    for (;;) {
        SDL_PumpEvents();
        switch (SDL_PeepEvents(event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LASTEVENT)) {
        case -1:
            return 0;
        case 0:
            if (timeout == 0) {
                /* Polling and no events, just return */
                return 0;
            }
            if (timeout > 0 && SDL_TICKS_PASSED(SDL_GetTicks(), expiration)) {
                /* Timeout expired and no events */
                return 0;
            }
            SDL_Delay(10);
            break;
        default:
            /* Has events */
            return 1;
        }
    }
}

Data Structures

Macros

Typedefs

Enumerations

Functions

Detailed Description

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation