package sdl

/*
#include "sdl_wrapper.h"
#include "events.h"

#if !SDL_VERSION_ATLEAST(2,0,9)
#define SDL_DISPLAYEVENT (0x150)
#endif

#if !SDL_VERSION_ATLEAST(2,0,2)
#define SDL_RENDER_TARGETS_RESET (0x2000)
#endif

#if !SDL_VERSION_ATLEAST(2,0,4)

#if defined(WARN_OUTDATED)
#pragma message("SDL_KEYMAPCHANGED is not supported before SDL 2.0.4")
#endif

#define SDL_KEYMAPCHANGED (0x304)


#if defined(WARN_OUTDATED)
#pragma message("SDL_AUDIODEVICEADDED is not supported before SDL 2.0.4")
#endif

#define SDL_AUDIODEVICEADDED (0x1100)


#if defined(WARN_OUTDATED)
#pragma message("SDL_AUDIODEVICEREMOVED is not supported before SDL 2.0.4")
#endif

#define SDL_AUDIODEVICEREMOVED (0x1101)


#if defined(WARN_OUTDATED)
#pragma message("SDL_RENDER_DEVICE_RESET is not supported before SDL 2.0.4")
#endif

#define SDL_RENDER_DEVICE_RESET (0x2001)


#if defined(WARN_OUTDATED)
#pragma message("SDL_AudioDeviceEvent is not supported before SDL 2.0.4")
#endif

typedef struct SDL_AudioDeviceEvent
{
    Uint32 type;
    Uint32 timestamp;
    Uint32 which;
    Uint8  iscapture;
    Uint8  padding1;
    Uint8  padding2;
    Uint8  padding3;
} SDL_AudioDeviceEvent;
#endif

#if !SDL_VERSION_ATLEAST(2,0,5)

#if defined(WARN_OUTDATED)
#pragma message("SDL_DROPTEXT is not supported before SDL 2.0.5")
#endif

#define SDL_DROPTEXT (0x1001)


#if defined(WARN_OUTDATED)
#pragma message("SDL_DROPBEGIN is not supported before SDL 2.0.5")
#endif

#define SDL_DROPBEGIN (0x1002)


#if defined(WARN_OUTDATED)
#pragma message("SDL_DROPCOMPLETE is not supported before SDL 2.0.5")
#endif

#define SDL_DROPCOMPLETE (0x1003)
#endif

#if !SDL_VERSION_ATLEAST(2,0,9)
#define SDL_SENSORUPDATE (0x1200)

typedef struct SDL_SensorEvent {
    Uint32 type;
    Uint32 timestamp;
    Sint32 which;
    float data[6];
} SDL_SensorEvent;
#endif

#if !SDL_VERSION_ATLEAST(2,0,22)
#if defined(WARN_OUTDATED)
#pragma message("SDL_TEXTEDITING_EXT is not supported before SDL 2.0.22")
#endif

#define SDL_TEXTEDITING_EXT (0x305)
#endif

// NOTE: To prevent build from failing when using older SDL2, we create a
// structure definiton that directly maps to the SDL2 struct definition if
// using the latest SDL2. Otherwise, we copy the latest definition and paste
// it here.
#if SDL_VERSION_ATLEAST(2,0,22)
typedef SDL_MouseButtonEvent MouseButtonEvent;
typedef SDL_MouseWheelEvent MouseWheelEvent;
typedef SDL_TouchFingerEvent TouchFingerEvent;
typedef SDL_DropEvent DropEvent;
#else
typedef struct MouseButtonEvent
{
    Uint32 type;        // ::SDL_MOUSEBUTTONDOWN or ::SDL_MOUSEBUTTONUP
    Uint32 timestamp;
    Uint32 windowID;    // The window with mouse focus, if any
    Uint32 which;       // The mouse instance id, or SDL_TOUCH_MOUSEID
    Uint8 button;       // The mouse button index
    Uint8 state;        // ::SDL_PRESSED or ::SDL_RELEASED
    Uint8 clicks;       // 1 for single-click, 2 for double-click, etc.
    Uint8 padding1;
    Sint32 x;           // X coordinate, relative to window
    Sint32 y;           // Y coordinate, relative to window
} MouseButtonEvent;

typedef struct MouseWheelEvent
{
    Uint32 type;        // ::SDL_MOUSEWHEEL
    Uint32 timestamp;   // In milliseconds, populated using SDL_GetTicks()
    Uint32 windowID;    // The window with mouse focus, if any
    Uint32 which;       // The mouse instance id, or SDL_TOUCH_MOUSEID
    Sint32 x;           // The amount scrolled horizontally, positive to the right and negative to the left
    Sint32 y;           // The amount scrolled vertically, positive away from the user and negative toward the user
    Uint32 direction;   // Set to one of the SDL_MOUSEWHEEL_* defines. When FLIPPED the values in X and Y will be opposite. Multiply by -1 to change them back
    float preciseX;     // The amount scrolled horizontally, positive to the right and negative to the left, with float precision (added in 2.0.18)
    float preciseY;     // The amount scrolled vertically, positive away from the user and negative toward the user, with float precision (added in 2.0.18)
} MouseWheelEvent;

typedef struct TouchFingerEvent
{
    Uint32 type;           // ::SDL_FINGERMOTION or ::SDL_FINGERDOWN or ::SDL_FINGERUP
    Uint32 timestamp;      // In milliseconds, populated using SDL_GetTicks()
    SDL_TouchID touchId;   // The touch device id
    SDL_FingerID fingerId; //
    float x;               // Normalized in the range 0...1
    float y;               // Normalized in the range 0...1
    float dx;              // Normalized in the range -1...1
    float dy;              // Normalized in the range -1...1
    float pressure;        // Normalized in the range 0...1
    Uint32 windowID;       // The window underneath the finger, if any
} TouchFingerEvent;

typedef struct DropEvent
{
    Uint32 type;        // ::SDL_DROPBEGIN or ::SDL_DROPFILE or ::SDL_DROPTEXT or ::SDL_DROPCOMPLETE
    Uint32 timestamp;   // In milliseconds, populated using SDL_GetTicks()
    char *file;         // The file name, which should be freed with SDL_free(), is NULL on begin/complete
    Uint32 windowID;    // The window that was dropped on, if any
} DropEvent;

#endif

#if !SDL_VERSION_ATLEAST(2,24,0)
#if defined(WARN_OUTDATED)
#pragma message("SDL_JOYBATTEYUPDATED is not supported before SDL 2.24.0")
#endif

#define SDL_JOYBATTERYUPDATED (1543)

#if !SDL_VERSION_ATLEAST(2,0,4)
typedef enum
{
    SDL_JOYSTICK_POWER_UNKNOWN = -1,
    SDL_JOYSTICK_POWER_EMPTY,
    SDL_JOYSTICK_POWER_LOW,
    SDL_JOYSTICK_POWER_MEDIUM,
    SDL_JOYSTICK_POWER_FULL,
    SDL_JOYSTICK_POWER_WIRED,
    SDL_JOYSTICK_POWER_MAX
} SDL_JoystickPowerLevel;
#endif

typedef struct SDL_JoyBatteryEvent
{
    Uint32 type;
    Uint32 timestamp;
    SDL_JoystickID which;
    SDL_JoystickPowerLevel level;
} SDL_JoyBatteryEvent;

#endif
*/
import "C"
import (
	"reflect"
	"sync"
	"unsafe"
)

var (
	eventFilterCache          EventFilter
	eventWatches              = make(map[EventWatchHandle]*eventFilterCallbackContext)
	lastEventWatchHandleMutex sync.Mutex
	lastEventWatchHandle      EventWatchHandle
	cevent                    C.SDL_Event
)

// Enumeration of the types of events that can be delivered.
// (https://wiki.libsdl.org/SDL_EventType)
const (
	FIRSTEVENT = C.SDL_FIRSTEVENT // do not remove (unused)

	// Application events
	QUIT = C.SDL_QUIT // user-requested quit

	// Android, iOS and WinRT events
	APP_TERMINATING         = C.SDL_APP_TERMINATING         // OS is terminating the application
	APP_LOWMEMORY           = C.SDL_APP_LOWMEMORY           // OS is low on memory; free some
	APP_WILLENTERBACKGROUND = C.SDL_APP_WILLENTERBACKGROUND // application is entering background
	APP_DIDENTERBACKGROUND  = C.SDL_APP_DIDENTERBACKGROUND  //application entered background
	APP_WILLENTERFOREGROUND = C.SDL_APP_WILLENTERFOREGROUND // application is entering foreground
	APP_DIDENTERFOREGROUND  = C.SDL_APP_DIDENTERFOREGROUND  // application entered foreground

	// Display events
	DISPLAYEVENT = C.SDL_DISPLAYEVENT // Display state change

	// Window events
	WINDOWEVENT = C.SDL_WINDOWEVENT // window state change
	SYSWMEVENT  = C.SDL_SYSWMEVENT  // system specific event

	// Keyboard events
	KEYDOWN         = C.SDL_KEYDOWN         // key pressed
	KEYUP           = C.SDL_KEYUP           // key released
	TEXTEDITING     = C.SDL_TEXTEDITING     // keyboard text editing (composition)
	TEXTINPUT       = C.SDL_TEXTINPUT       // keyboard text input
	TEXTEDITING_EXT = C.SDL_TEXTEDITING_EXT // keyboard text editing (composition)
	KEYMAPCHANGED   = C.SDL_KEYMAPCHANGED   // keymap changed due to a system event such as an input language or keyboard layout change (>= SDL 2.0.4)

	// Mouse events
	MOUSEMOTION     = C.SDL_MOUSEMOTION     // mouse moved
	MOUSEBUTTONDOWN = C.SDL_MOUSEBUTTONDOWN // mouse button pressed
	MOUSEBUTTONUP   = C.SDL_MOUSEBUTTONUP   // mouse button released
	MOUSEWHEEL      = C.SDL_MOUSEWHEEL      // mouse wheel motion

	// Joystick events
	JOYAXISMOTION    = C.SDL_JOYAXISMOTION    // joystick axis motion
	JOYBALLMOTION    = C.SDL_JOYBALLMOTION    // joystick trackball motion
	JOYHATMOTION     = C.SDL_JOYHATMOTION     // joystick hat position change
	JOYBUTTONDOWN    = C.SDL_JOYBUTTONDOWN    // joystick button pressed
	JOYBUTTONUP      = C.SDL_JOYBUTTONUP      // joystick button released
	JOYDEVICEADDED   = C.SDL_JOYDEVICEADDED   // joystick connected
	JOYDEVICEREMOVED = C.SDL_JOYDEVICEREMOVED // joystick disconnected

	// Game controller events
	CONTROLLERAXISMOTION     = C.SDL_CONTROLLERAXISMOTION     // controller axis motion
	CONTROLLERBUTTONDOWN     = C.SDL_CONTROLLERBUTTONDOWN     // controller button pressed
	CONTROLLERBUTTONUP       = C.SDL_CONTROLLERBUTTONUP       // controller button released
	CONTROLLERDEVICEADDED    = C.SDL_CONTROLLERDEVICEADDED    // controller connected
	CONTROLLERDEVICEREMOVED  = C.SDL_CONTROLLERDEVICEREMOVED  // controller disconnected
	CONTROLLERDEVICEREMAPPED = C.SDL_CONTROLLERDEVICEREMAPPED // controller mapping updated

	// Touch events
	FINGERDOWN   = C.SDL_FINGERDOWN   // user has touched input device
	FINGERUP     = C.SDL_FINGERUP     // user stopped touching input device
	FINGERMOTION = C.SDL_FINGERMOTION // user is dragging finger on input device

	// Gesture events
	DOLLARGESTURE = C.SDL_DOLLARGESTURE
	DOLLARRECORD  = C.SDL_DOLLARRECORD
	MULTIGESTURE  = C.SDL_MULTIGESTURE

	// Clipboard events
	CLIPBOARDUPDATE = C.SDL_CLIPBOARDUPDATE // the clipboard changed

	// Drag and drop events
	DROPFILE     = C.SDL_DROPFILE     // the system requests a file open
	DROPTEXT     = C.SDL_DROPTEXT     // text/plain drag-and-drop event
	DROPBEGIN    = C.SDL_DROPBEGIN    // a new set of drops is beginning (NULL filename)
	DROPCOMPLETE = C.SDL_DROPCOMPLETE // current set of drops is now complete (NULL filename)

	// Audio hotplug events
	AUDIODEVICEADDED   = C.SDL_AUDIODEVICEADDED   // a new audio device is available (>= SDL 2.0.4)
	AUDIODEVICEREMOVED = C.SDL_AUDIODEVICEREMOVED // an audio device has been removed (>= SDL 2.0.4)

	// Sensor events
	SENSORUPDATE = C.SDL_SENSORUPDATE // a sensor was updated

	// Render events
	RENDER_TARGETS_RESET = C.SDL_RENDER_TARGETS_RESET // the render targets have been reset and their contents need to be updated (>= SDL 2.0.2)
	RENDER_DEVICE_RESET  = C.SDL_RENDER_DEVICE_RESET  // the device has been reset and all textures need to be recreated (>= SDL 2.0.4)

	// These are for your use, and should be allocated with RegisterEvents()
	USEREVENT = C.SDL_USEREVENT // a user-specified event
	LASTEVENT = C.SDL_LASTEVENT // (only for bounding internal arrays)
)

// Actions for PeepEvents().
// (https://wiki.libsdl.org/SDL_PeepEvents)
const (
	ADDEVENT  = C.SDL_ADDEVENT  // up to numevents events will be added to the back of the event queue
	PEEKEVENT = C.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
	GETEVENT  = C.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
)

// Toggles for different event state functions.
const (
	QUERY   = C.SDL_QUERY
	IGNORE  = C.SDL_IGNORE
	DISABLE = C.SDL_DISABLE
	ENABLE  = C.SDL_ENABLE
)

// Event is a union of all event structures used in SDL.
// (https://wiki.libsdl.org/SDL_Event)
type Event interface {
	GetType() uint32      // GetType returns the event type
	GetTimestamp() uint32 // GetTimestamp returns the timestamp of the event
}

// CEvent is a union of all event structures used in SDL.
// (https://wiki.libsdl.org/SDL_Event)
type CEvent struct {
	Type uint32
	_    [52]byte // padding
}

// CommonEvent contains common event data.
// (https://wiki.libsdl.org/SDL_Event)
type CommonEvent struct {
	Type      uint32 // the event type
	Timestamp uint32 // timestamp of the event
}

// GetType returns the event type.
func (e *CommonEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *CommonEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// DisplayEvent contains common event data.
// (https://wiki.libsdl.org/SDL_Event)
type DisplayEvent struct {
	Type      uint32 // the event type
	Timestamp uint32 // timestamp of the event
	Display   uint32 // the associated display index
	Event     uint8  // TODO: (https://wiki.libsdl.org/SDL_DisplayEventID)
	_         uint8  // padding
	_         uint8  // padding
	_         uint8  // padding
	Data1     int32  // event dependent data
}

// GetType returns the event type.
func (e *DisplayEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *DisplayEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// WindowEvent contains window state change event data.
// (https://wiki.libsdl.org/SDL_WindowEvent)
type WindowEvent struct {
	Type      uint32 // WINDOWEVENT
	Timestamp uint32 // timestamp of the event
	WindowID  uint32 // the associated window
	Event     uint8  // (https://wiki.libsdl.org/SDL_WindowEventID)
	_         uint8  // padding
	_         uint8  // padding
	_         uint8  // padding
	Data1     int32  // event dependent data
	Data2     int32  // event dependent data
}
type cWindowEvent C.SDL_WindowEvent

// GetType returns the event type.
func (e *WindowEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *WindowEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// KeyboardEvent contains keyboard key down event information.
// (https://wiki.libsdl.org/SDL_KeyboardEvent)
type KeyboardEvent struct {
	Type      uint32 // KEYDOWN, KEYUP
	Timestamp uint32 // timestamp of the event
	WindowID  uint32 // the window with keyboard focus, if any
	State     uint8  // PRESSED, RELEASED
	Repeat    uint8  // non-zero if this is a key repeat
	_         uint8  // padding
	_         uint8  // padding
	Keysym    Keysym // Keysym representing the key that was pressed or released
}
type cKeyboardEvent C.SDL_KeyboardEvent

// GetType returns the event type.
func (e *KeyboardEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *KeyboardEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// TextEditingEvent contains keyboard text editing event information.
// (https://wiki.libsdl.org/SDL_TextEditingEvent)
type TextEditingEvent struct {
	Type      uint32                               // TEXTEDITING
	Timestamp uint32                               // timestamp of the event
	WindowID  uint32                               // the window with keyboard focus, if any
	Text      [C.SDL_TEXTINPUTEVENT_TEXT_SIZE]byte // the null-terminated editing text in UTF-8 encoding
	Start     int32                                // the location to begin editing from
	Length    int32                                // the number of characters to edit from the start point
}
type cTextEditingEvent C.SDL_TextEditingEvent

// GetType returns the event type.
func (e *TextEditingEvent) GetType() uint32 {
	return e.Type
}

// GetText returns the text as string
func (e *TextEditingEvent) GetText() string {
	length := func(buf []byte) int {
		for i := range buf {
			if buf[i] == 0 {
				return i
			}
		}

		return 0
	}(e.Text[:])

	text := e.Text[:length]
	return string(text)
}

// GetTimestamp returns the timestamp of the event.
func (e *TextEditingEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// TextInputEvent contains keyboard text input event information.
// (https://wiki.libsdl.org/SDL_TextInputEvent)
type TextInputEvent struct {
	Type      uint32                               // TEXTINPUT
	Timestamp uint32                               // timestamp of the event
	WindowID  uint32                               // the window with keyboard focus, if any
	Text      [C.SDL_TEXTINPUTEVENT_TEXT_SIZE]byte // the null-terminated input text in UTF-8 encoding
}
type cTextInputEvent C.SDL_TextInputEvent

// GetType returns the event type.
func (e *TextInputEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *TextInputEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// GetText returns the text as string
func (e *TextInputEvent) GetText() string {
	length := func(buf []byte) int {
		for i := range buf {
			if buf[i] == 0 {
				return i
			}
		}

		return 0
	}(e.Text[:])

	text := e.Text[:length]
	return string(text)
}

// MouseMotionEvent contains mouse motion event information.
// (https://wiki.libsdl.org/SDL_MouseMotionEvent)
type MouseMotionEvent struct {
	Type      uint32 // MOUSEMOTION
	Timestamp uint32 // timestamp of the event
	WindowID  uint32 // the window with mouse focus, if any
	Which     uint32 // the mouse instance id, or TOUCH_MOUSEID
	State     uint32 // BUTTON_LEFT, BUTTON_MIDDLE, BUTTON_RIGHT, BUTTON_X1, BUTTON_X2
	X         int32  // X coordinate, relative to window
	Y         int32  // Y coordinate, relative to window
	XRel      int32  // relative motion in the X direction
	YRel      int32  // relative motion in the Y direction
}
type cMouseMotionEvent C.SDL_MouseMotionEvent

// GetType returns the event type.
func (e *MouseMotionEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *MouseMotionEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// MouseButtonEvent contains mouse button event information.
// (https://wiki.libsdl.org/SDL_MouseButtonEvent)
type MouseButtonEvent struct {
	Type      uint32 // MOUSEBUTTONDOWN, MOUSEBUTTONUP
	Timestamp uint32 // timestamp of the event
	WindowID  uint32 // the window with mouse focus, if any
	Which     uint32 // the mouse instance id, or TOUCH_MOUSEID
	Button    uint8  // BUTTON_LEFT, BUTTON_MIDDLE, BUTTON_RIGHT, BUTTON_X1, BUTTON_X2
	State     uint8  // PRESSED, RELEASED
	Clicks    uint8  // 1 for single-click, 2 for double-click, etc. (>= SDL 2.0.2)
	_         uint8  // padding
	X         int32  // X coordinate, relative to window
	Y         int32  // Y coordinate, relative to window
}
type cMouseButtonEvent C.SDL_MouseButtonEvent

// GetType returns the event type.
func (e *MouseButtonEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *MouseButtonEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// MouseWheelEvent contains mouse wheel event information.
// (https://wiki.libsdl.org/SDL_MouseWheelEvent)
type MouseWheelEvent struct {
	Type      uint32  // MOUSEWHEEL
	Timestamp uint32  // timestamp of the event
	WindowID  uint32  // the window with mouse focus, if any
	Which     uint32  // the mouse instance id, or TOUCH_MOUSEID
	X         int32   // the amount scrolled horizontally, positive to the right and negative to the left
	Y         int32   // the amount scrolled vertically, positive away from the user and negative toward the user
	Direction uint32  // MOUSEWHEEL_NORMAL, MOUSEWHEEL_FLIPPED (>= SDL 2.0.4)
	PreciseX  float32 // The amount scrolled horizontally, positive to the right and negative to the left, with float precision (added in 2.0.18)
	PreciseY  float32 // The amount scrolled vertically, positive away from the user and negative toward the user, with float precision (added in 2.0.18)
}
type cMouseWheelEvent C.SDL_MouseWheelEvent

// GetType returns the event type.
func (e *MouseWheelEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *MouseWheelEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// JoyAxisEvent contains joystick axis motion event information.
// (https://wiki.libsdl.org/SDL_JoyAxisEvent)
type JoyAxisEvent struct {
	Type      uint32     // JOYAXISMOTION
	Timestamp uint32     // timestamp of the event
	Which     JoystickID // the instance id of the joystick that reported the event
	Axis      uint8      // the index of the axis that changed
	_         uint8      // padding
	_         uint8      // padding
	_         uint8      // padding
	Value     int16      // the current position of the axis (range: -32768 to 32767)
	_         uint16     // padding
}
type cJoyAxisEvent C.SDL_JoyAxisEvent

// GetType returns the event type.
func (e *JoyAxisEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *JoyAxisEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// JoyBallEvent contains joystick trackball motion event information.
// (https://wiki.libsdl.org/SDL_JoyBallEvent)
type JoyBallEvent struct {
	Type      uint32     // JOYBALLMOTION
	Timestamp uint32     // timestamp of the event
	Which     JoystickID // the instance id of the joystick that reported the event
	Ball      uint8      // the index of the trackball that changed
	_         uint8      // padding
	_         uint8      // padding
	_         uint8      // padding
	XRel      int16      // the relative motion in the X direction
	YRel      int16      // the relative motion in the Y direction
}
type cJoyBallEvent C.SDL_JoyBallEvent

// GetType returns the event type.
func (e *JoyBallEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *JoyBallEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// JoyHatEvent contains joystick hat position change event information.
// (https://wiki.libsdl.org/SDL_JoyHatEvent)
type JoyHatEvent struct {
	Type      uint32     // JOYHATMOTION
	Timestamp uint32     // timestamp of the event
	Which     JoystickID // the instance id of the joystick that reported the event
	Hat       uint8      // the index of the hat that changed
	Value     uint8      // HAT_LEFTUP, HAT_UP, HAT_RIGHTUP, HAT_LEFT, HAT_CENTERED, HAT_RIGHT, HAT_LEFTDOWN, HAT_DOWN, HAT_RIGHTDOWN
	_         uint8      // padding
	_         uint8      // padding
}
type cJoyHatEvent C.SDL_JoyHatEvent

// GetType returns the event type.
func (e *JoyHatEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *JoyHatEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// JoyButtonEvent contains joystick button event information.
// (https://wiki.libsdl.org/SDL_JoyButtonEvent)
type JoyButtonEvent struct {
	Type      uint32     // JOYBUTTONDOWN, JOYBUTTONUP
	Timestamp uint32     // timestamp of the event
	Which     JoystickID // the instance id of the joystick that reported the event
	Button    uint8      // the index of the button that changed
	State     uint8      // PRESSED, RELEASED
	_         uint8      // padding
	_         uint8      // padding
}
type cJoyButtonEvent C.SDL_JoyButtonEvent

// GetType returns the event type.
func (e *JoyButtonEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *JoyButtonEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// JoyDeviceAddedEvent contains joystick device event information.
// (https://wiki.libsdl.org/SDL_JoyDeviceEvent)
type JoyDeviceAddedEvent struct {
	Type      uint32     // JOYDEVICEADDED
	Timestamp uint32     // the timestamp of the event
	Which     JoystickID // the joystick device index
}

// GetType returns the event type.
func (e *JoyDeviceAddedEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *JoyDeviceAddedEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// JoyDeviceRemovedEvent contains joystick device event information.
// (https://wiki.libsdl.org/SDL_JoyDeviceEvent)
type JoyDeviceRemovedEvent struct {
	Type      uint32     // JOYDEVICEREMOVED
	Timestamp uint32     // the timestamp of the event
	Which     JoystickID // the instance id
}

// GetType returns the event type.
func (e *JoyDeviceRemovedEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *JoyDeviceRemovedEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// ControllerAxisEvent contains game controller axis motion event information.
// (https://wiki.libsdl.org/SDL_ControllerAxisEvent)
type ControllerAxisEvent struct {
	Type      uint32     // CONTROLLERAXISMOTION
	Timestamp uint32     // the timestamp of the event
	Which     JoystickID // the joystick instance id
	Axis      uint8      // the controller axis (https://wiki.libsdl.org/SDL_GameControllerAxis)
	_         uint8      // padding
	_         uint8      // padding
	_         uint8      // padding
	Value     int16      // the axis value (range: -32768 to 32767)
	_         uint16     // padding
}
type cControllerAxisEvent C.SDL_ControllerAxisEvent

// GetType returns the event type.
func (e *ControllerAxisEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *ControllerAxisEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// ControllerButtonEvent contains game controller button event information.
// (https://wiki.libsdl.org/SDL_ControllerButtonEvent)
type ControllerButtonEvent struct {
	Type      uint32     // CONTROLLERBUTTONDOWN, CONTROLLERBUTTONUP
	Timestamp uint32     // the timestamp of the event
	Which     JoystickID // the joystick instance id
	Button    uint8      // the controller button (https://wiki.libsdl.org/SDL_GameControllerButton)
	State     uint8      // PRESSED, RELEASED
	_         uint8      // padding
	_         uint8      // padding
}
type cControllerButtonEvent C.SDL_ControllerButtonEvent

// GetType returns the event type.
func (e *ControllerButtonEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *ControllerButtonEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// ControllerDeviceEvent contains controller device event information.
// (https://wiki.libsdl.org/SDL_ControllerDeviceEvent)
type ControllerDeviceEvent struct {
	Type      uint32     // CONTROLLERDEVICEADDED, CONTROLLERDEVICEREMOVED, SDL_CONTROLLERDEVICEREMAPPED
	Timestamp uint32     // the timestamp of the event
	Which     JoystickID // the joystick device index for the CONTROLLERDEVICEADDED event or instance id for the CONTROLLERDEVICEREMOVED or CONTROLLERDEVICEREMAPPED event
}
type cControllerDeviceEvent C.SDL_ControllerDeviceEvent

// GetType returns the event type.
func (e *ControllerDeviceEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *ControllerDeviceEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// AudioDeviceEvent contains audio device event information.
// (https://wiki.libsdl.org/SDL_AudioDeviceEvent)
type AudioDeviceEvent struct {
	Type      uint32 // AUDIODEVICEADDED, AUDIODEVICEREMOVED
	Timestamp uint32 // the timestamp of the event
	Which     uint32 // the audio device index for the AUDIODEVICEADDED event (valid until next GetNumAudioDevices() call), AudioDeviceID for the AUDIODEVICEREMOVED event
	IsCapture uint8  // zero if an audio output device, non-zero if an audio capture device
	_         uint8  // padding
	_         uint8  // padding
	_         uint8  // padding
}
type cAudioDeviceEvent C.SDL_AudioDeviceEvent

// GetType returns the event type.
func (e *AudioDeviceEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *AudioDeviceEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// TouchFingerEvent contains finger touch event information.
// (https://wiki.libsdl.org/SDL_TouchFingerEvent)
type TouchFingerEvent struct {
	Type      uint32   // FINGERMOTION, FINGERDOWN, FINGERUP
	Timestamp uint32   // timestamp of the event
	TouchID   TouchID  // the touch device id
	FingerID  FingerID // the finger id
	X         float32  // the x-axis location of the touch event, normalized (0...1)
	Y         float32  // the y-axis location of the touch event, normalized (0...1)
	DX        float32  // the distance moved in the x-axis, normalized (-1...1)
	DY        float32  // the distance moved in the y-axis, normalized (-1...1)
	Pressure  float32  // the quantity of pressure applied, normalized (0...1)
}
type cTouchFingerEvent C.SDL_TouchFingerEvent

// GetType returns the event type.
func (e *TouchFingerEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *TouchFingerEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// MultiGestureEvent contains multiple finger gesture event information.
// (https://wiki.libsdl.org/SDL_MultiGestureEvent)
type MultiGestureEvent struct {
	Type       uint32  // MULTIGESTURE
	Timestamp  uint32  // timestamp of the event
	TouchID    TouchID // the touch device id
	DTheta     float32 // the amount that the fingers rotated during this motion
	DDist      float32 // the amount that the fingers pinched during this motion
	X          float32 // the normalized center of gesture
	Y          float32 // the normalized center of gesture
	NumFingers uint16  // the number of fingers used in the gesture
	_          uint16  // padding
}
type cMultiGestureEvent C.SDL_MultiGestureEvent

// GetType returns the event type.
func (e *MultiGestureEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *MultiGestureEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// DollarGestureEvent contains complex gesture event information.
// (https://wiki.libsdl.org/SDL_DollarGestureEvent)
type DollarGestureEvent struct {
	Type       uint32    // DOLLARGESTURE, DOLLARRECORD
	Timestamp  uint32    // timestamp of the event
	TouchID    TouchID   // the touch device id
	GestureID  GestureID // the unique id of the closest gesture to the performed stroke
	NumFingers uint32    // the number of fingers used to draw the stroke
	Error      float32   // the difference between the gesture template and the actual performed gesture (lower error is a better match)
	X          float32   // the normalized center of gesture
	Y          float32   // the normalized center of gesture
}
type cDollarGestureEvent C.SDL_DollarGestureEvent

// GetType returns the event type.
func (e *DollarGestureEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *DollarGestureEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// DropEvent contains an event used to request a file open by the system.
// (https://wiki.libsdl.org/SDL_DropEvent)
type DropEvent struct {
	Type      uint32 // DROPFILE, DROPTEXT, DROPBEGIN, DROPCOMPLETE
	Timestamp uint32 // timestamp of the event
	File      string // the file name
	WindowID  uint32 // the window that was dropped on, if any
}

type tDropEvent struct {
	Type      uint32
	Timestamp uint32
	File      unsafe.Pointer
	WindowID  uint32
}
type cDropEvent C.SDL_DropEvent

// GetType returns the event type.
func (e *DropEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *DropEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// SensorEvent contains data from sensors such as accelerometer and gyroscope
// (https://wiki.libsdl.org/SDL_SensorEvent)
type SensorEvent struct {
	Type      uint32     // SDL_SENSORUPDATE
	Timestamp uint32     // In milliseconds, populated using SDL_GetTicks()
	Which     int32      // The instance ID of the sensor
	Data      [6]float32 // Up to 6 values from the sensor - additional values can be queried using SDL_SensorGetData()
}
type cSensorEvent C.SDL_SensorEvent

// GetType returns the event type.
func (e *SensorEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *SensorEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// RenderEvent contains render event information.
// (https://wiki.libsdl.org/SDL_EventType)
type RenderEvent struct {
	Type      uint32 // the event type
	Timestamp uint32 // timestamp of the event
}

// GetType returns the event type.
func (e *RenderEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *RenderEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// QuitEvent contains the "quit requested" event.
// (https://wiki.libsdl.org/SDL_QuitEvent)
type QuitEvent struct {
	Type      uint32 // QUIT
	Timestamp uint32 // timestamp of the event
}

// GetType returns the event type.
func (e *QuitEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *QuitEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// OSEvent contains OS specific event information.
type OSEvent struct {
	Type      uint32 // the event type
	Timestamp uint32 // timestamp of the event
}

// GetType returns the event type.
func (e *OSEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *OSEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// ClipboardEvent contains clipboard event information.
// (https://wiki.libsdl.org/SDL_EventType)
type ClipboardEvent struct {
	Type      uint32 // CLIPBOARDUPDATE
	Timestamp uint32 // timestamp of the event
}

// GetType returns the event type.
func (e *ClipboardEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *ClipboardEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// UserEvent contains an application-defined event type.
// (https://wiki.libsdl.org/SDL_UserEvent)
type UserEvent struct {
	Type      uint32         // value obtained from RegisterEvents()
	Timestamp uint32         // timestamp of the event
	WindowID  uint32         // the associated window, if any
	Code      int32          // user defined event code
	Data1     unsafe.Pointer // user defined data pointer
	Data2     unsafe.Pointer // user defined data pointer
}
type cUserEvent C.SDL_UserEvent

// GetType returns the event type.
func (e *UserEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *UserEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// SysWMEvent contains a video driver dependent system event.
// (https://wiki.libsdl.org/SDL_SysWMEvent)
type SysWMEvent struct {
	Type      uint32    // SYSWMEVENT
	Timestamp uint32    // timestamp of the event
	Msg       *SysWMmsg // driver dependent data, defined in SDL_syswm.h
}
type cSysWMEvent C.SDL_SysWMEvent

// GetType returns the event type.
func (e *SysWMEvent) GetType() uint32 {
	return e.Type
}

// GetTimestamp returns the timestamp of the event.
func (e *SysWMEvent) GetTimestamp() uint32 {
	return e.Timestamp
}

// EventAction is the action to take in PeepEvents() function.
// (https://wiki.libsdl.org/SDL_PeepEvents)
type EventAction C.SDL_eventaction

// EventFilter is the function to call when an event happens.
// (https://wiki.libsdl.org/SDL_SetEventFilter)
type EventFilter interface {
	FilterEvent(e Event, userdata interface{}) bool
}

type eventFilterFunc func(Event, interface{}) bool

type eventFilterCallbackContext struct {
	filter   EventFilter
	handle   EventWatchHandle
	userdata interface{}
}

// EventWatchHandle is an event watch callback added with AddEventWatch().
type EventWatchHandle uintptr

func (action EventAction) c() C.SDL_eventaction {
	return C.SDL_eventaction(action)
}

// PumpEvents pumps the event loop, gathering events from the input devices.
// (https://wiki.libsdl.org/SDL_PumpEvents)
func PumpEvents() {
	C.SDL_PumpEvents()
}

// PeepEvents checks the event queue for messages and optionally return them.
// (https://wiki.libsdl.org/SDL_PeepEvents)
func PeepEvents(events []Event, action EventAction, minType, maxType uint32) (storedEvents int, err error) {
	if events == nil {
		return 0, nil
	}

	var _events []CEvent = make([]CEvent, len(events))

	if action == ADDEVENT { // the contents of _events matter if they are to be added
		for i := 0; i < len(events); i++ {
			_events[i] = *cEvent(events[i])
		}
	}

	_pevents := (*C.SDL_Event)(unsafe.Pointer(&_events[0]))
	storedEvents = int(C.SDL_PeepEvents(_pevents, C.int(len(events)), action.c(), C.Uint32(minType), C.Uint32(maxType)))

	if action != ADDEVENT { // put events into slice, events unchanged if action = ADDEVENT
		for i := 0; i < storedEvents; i++ {
			events[i] = goEvent(&_events[i])
		}
	}

	if storedEvents < 0 {
		err = GetError()
	}

	return
}

// HasEvent checks for the existence of certain event types in the event queue.
// (https://wiki.libsdl.org/SDL_HasEvent)
func HasEvent(type_ uint32) bool {
	return C.SDL_HasEvent(C.Uint32(type_)) != 0
}

// HasEvents checks for the existence of a range of event types in the event queue.
// (https://wiki.libsdl.org/SDL_HasEvents)
func HasEvents(minType, maxType uint32) bool {
	return C.SDL_HasEvents(C.Uint32(minType), C.Uint32(maxType)) != 0
}

// FlushEvent clears events from the event queue.
// (https://wiki.libsdl.org/SDL_FlushEvent)
func FlushEvent(type_ uint32) {
	C.SDL_FlushEvent(C.Uint32(type_))
}

// FlushEvents clears events from the event queue.
// (https://wiki.libsdl.org/SDL_FlushEvents)
func FlushEvents(minType, maxType uint32) {
	C.SDL_FlushEvents(C.Uint32(minType), C.Uint32(maxType))
}

// PollEvent polls for currently pending events.
// (https://wiki.libsdl.org/SDL_PollEvent)
func PollEvent() Event {
	ret := C.PollEvent()
	if ret == 0 {
		return nil
	}
	return goEvent((*CEvent)(unsafe.Pointer(&C.event)))
}

func goEvent(cevent *CEvent) Event {
	switch cevent.Type {
	case DISPLAYEVENT:
		return (*DisplayEvent)(unsafe.Pointer(cevent))
	case WINDOWEVENT:
		return (*WindowEvent)(unsafe.Pointer(cevent))
	case SYSWMEVENT:
		return (*SysWMEvent)(unsafe.Pointer(cevent))
	case KEYDOWN, KEYUP:
		return (*KeyboardEvent)(unsafe.Pointer(cevent))
	case TEXTEDITING:
		return (*TextEditingEvent)(unsafe.Pointer(cevent))
	case TEXTINPUT:
		return (*TextInputEvent)(unsafe.Pointer(cevent))
	case MOUSEMOTION:
		return (*MouseMotionEvent)(unsafe.Pointer(cevent))
	case MOUSEBUTTONDOWN, MOUSEBUTTONUP:
		return (*MouseButtonEvent)(unsafe.Pointer(cevent))
	case MOUSEWHEEL:
		return (*MouseWheelEvent)(unsafe.Pointer(cevent))
	case JOYAXISMOTION:
		return (*JoyAxisEvent)(unsafe.Pointer(cevent))
	case JOYBALLMOTION:
		return (*JoyBallEvent)(unsafe.Pointer(cevent))
	case JOYHATMOTION:
		return (*JoyHatEvent)(unsafe.Pointer(cevent))
	case JOYBUTTONDOWN, JOYBUTTONUP:
		return (*JoyButtonEvent)(unsafe.Pointer(cevent))
	case JOYDEVICEADDED:
		return (*JoyDeviceAddedEvent)(unsafe.Pointer(cevent))
	case JOYDEVICEREMOVED:
		return (*JoyDeviceRemovedEvent)(unsafe.Pointer(cevent))
	case CONTROLLERAXISMOTION:
		return (*ControllerAxisEvent)(unsafe.Pointer(cevent))
	case CONTROLLERBUTTONDOWN, CONTROLLERBUTTONUP:
		return (*ControllerButtonEvent)(unsafe.Pointer(cevent))
	case CONTROLLERDEVICEADDED, CONTROLLERDEVICEREMOVED, CONTROLLERDEVICEREMAPPED:
		return (*ControllerDeviceEvent)(unsafe.Pointer(cevent))
	case AUDIODEVICEADDED, AUDIODEVICEREMOVED:
		return (*AudioDeviceEvent)(unsafe.Pointer(cevent))
	case FINGERMOTION, FINGERDOWN, FINGERUP:
		return (*TouchFingerEvent)(unsafe.Pointer(cevent))
	case MULTIGESTURE:
		return (*MultiGestureEvent)(unsafe.Pointer(cevent))
	case DOLLARGESTURE, DOLLARRECORD:
		return (*DollarGestureEvent)(unsafe.Pointer(cevent))
	case DROPFILE, DROPTEXT, DROPBEGIN, DROPCOMPLETE:
		e := (*tDropEvent)(unsafe.Pointer(cevent))
		event := DropEvent{Type: e.Type, Timestamp: e.Timestamp, File: C.GoString((*C.char)(e.File)), WindowID: e.WindowID}
		C.SDL_free(e.File)
		return &event
	case SENSORUPDATE:
		return (*SensorEvent)(unsafe.Pointer(cevent))
	case RENDER_TARGETS_RESET, RENDER_DEVICE_RESET:
		return (*RenderEvent)(unsafe.Pointer(cevent))
	case QUIT:
		return (*QuitEvent)(unsafe.Pointer(cevent))
	case CLIPBOARDUPDATE:
		return (*ClipboardEvent)(unsafe.Pointer(cevent))
	default:
		if cevent.Type >= USEREVENT {
			// all events beyond USEREVENT are UserEvents to be registered with RegisterEvents
			return (*UserEvent)(unsafe.Pointer(cevent))
		}
		return (*CommonEvent)(unsafe.Pointer(cevent))
	}
}

func cEvent(event Event) *CEvent {
	evv := reflect.ValueOf(event)
	p := evv.Elem()
	return (*CEvent)(unsafe.Pointer(p.UnsafeAddr()))
}

// WaitEventTimeout waits until the specified timeout (in milliseconds) for the next available event.
// (https://wiki.libsdl.org/SDL_WaitEventTimeout)
func WaitEventTimeout(timeout int) Event {
	var cevent CEvent
	_event := (*C.SDL_Event)(unsafe.Pointer(&cevent))
	ok := int(C.SDL_WaitEventTimeout(_event, C.int(timeout)))
	if ok == 0 {
		return nil
	}
	return goEvent(&cevent)
}

// WaitEvent waits indefinitely for the next available event.
// (https://wiki.libsdl.org/SDL_WaitEvent)
func WaitEvent() Event {
	var cevent CEvent
	_event := (*C.SDL_Event)(unsafe.Pointer(&cevent))
	ok := int(C.SDL_WaitEvent(_event))
	if ok == 0 {
		return nil
	}
	return goEvent(&cevent)
}

// PushEvent adds an event to the event queue.
// (https://wiki.libsdl.org/SDL_PushEvent)
func PushEvent(event Event) (filtered bool, err error) {
	_event := (*C.SDL_Event)(unsafe.Pointer(cEvent(event)))
	if ok := int(C.SDL_PushEvent(_event)); ok < 0 {
		filtered, err = false, GetError()
	} else if ok == 0 {
		filtered, err = true, nil
	}
	return
}

func (ef eventFilterFunc) FilterEvent(e Event, userdata interface{}) bool {
	return ef(e, userdata)
}

func newEventFilterCallbackContext(filter EventFilter, userdata interface{}) *eventFilterCallbackContext {
	lastEventWatchHandleMutex.Lock()
	defer lastEventWatchHandleMutex.Unlock()
	// Look for the next available watch handle (this should be immediate
	// unless you're creating a LOT of handlers).
	for {
		if _, ok := eventWatches[lastEventWatchHandle]; !ok {
			break
		}
		lastEventWatchHandle++
	}
	e := &eventFilterCallbackContext{filter, lastEventWatchHandle, userdata}
	eventWatches[lastEventWatchHandle] = e
	lastEventWatchHandle++
	return e
}

func (e *eventFilterCallbackContext) cptr() unsafe.Pointer {
	return unsafe.Pointer(e.handle)
}

//export goSetEventFilterCallback
func goSetEventFilterCallback(data unsafe.Pointer, e *C.SDL_Event) C.int {
	// No check for eventFilterCache != nil. Why? because it should never be
	// nil since the callback is set/unset based on the last filter being nil
	// /non-nil. If there is an issue, then it should panic here so we can
	// figure out why that is.

	return wrapEventFilterCallback(eventFilterCache, e, nil)
}

//export goEventFilterCallback
func goEventFilterCallback(userdata unsafe.Pointer, e *C.SDL_Event) C.int {
	// same sort of reasoning with goSetEventFilterCallback, userdata should
	// always be non-nil and represent a valid eventFilterCallbackContext. If
	// it doesn't a panic will let us know that there something wrong and the
	// problem can be fixed.

	context := eventWatches[EventWatchHandle(userdata)]
	return wrapEventFilterCallback(context.filter, e, context.userdata)
}

func wrapEventFilterCallback(filter EventFilter, e *C.SDL_Event, userdata interface{}) C.int {
	gev := goEvent((*CEvent)(unsafe.Pointer(e)))
	result := filter.FilterEvent(gev, userdata)

	if result {
		return C.SDL_TRUE
	}
	return C.SDL_FALSE
}

// SetEventFilter sets up a filter to process all events before they change internal state and are posted to the internal event queue.
// (https://wiki.libsdl.org/SDL_SetEventFilter)
func SetEventFilter(filter EventFilter, userdata interface{}) {
	if eventFilterCache == nil && filter == nil {
		// nothing to do...
		return
	}

	if eventFilterCache == nil && filter != nil {
		// We had no event filter before and do now; lets set
		// goSetEventFilterCallback() as the event filter.
		C.setEventFilter()
	} else if eventFilterCache != nil && filter == nil {
		// We had an event filter before, but no longer do, lets clear the
		// event filter
		C.clearEventFilter()
	}

	eventFilterCache = filter
}

// SetEventFilterFunc sets up a function to process all events before they change internal state and are posted to the internal event queue.
// (https://wiki.libsdl.org/SDL_SetEventFilter)
func SetEventFilterFunc(filterFunc eventFilterFunc, userdata interface{}) {
	SetEventFilter(filterFunc, userdata)
}

// GetEventFilter queries the current event filter.
// (https://wiki.libsdl.org/SDL_GetEventFilter)
func GetEventFilter() EventFilter {
	return eventFilterCache
}

func isCEventFilterSet() bool {
	return C.SDL_GetEventFilter(nil, nil) == C.SDL_TRUE
}

// FilterEvents run a specific filter function on the current event queue, removing any events for which the filter returns 0.
// (https://wiki.libsdl.org/SDL_FilterEvents)
func FilterEvents(filter EventFilter, userdata interface{}) {
	context := newEventFilterCallbackContext(filter, userdata)
	C.filterEvents(context.cptr())
}

// FilterEventsFunc run a specific function on the current event queue, removing any events for which the filter returns 0.
// (https://wiki.libsdl.org/SDL_FilterEvents)
func FilterEventsFunc(filter eventFilterFunc, userdata interface{}) {
	FilterEvents(filter, userdata)
}

// AddEventWatch adds a callback to be triggered when an event is added to the event queue.
// (https://wiki.libsdl.org/SDL_AddEventWatch)
func AddEventWatch(filter EventFilter, userdata interface{}) EventWatchHandle {
	context := newEventFilterCallbackContext(filter, userdata)
	C.addEventWatch(context.cptr())
	return context.handle
}

// AddEventWatchFunc adds a callback function to be triggered when an event is added to the event queue.
// (https://wiki.libsdl.org/SDL_AddEventWatch)
func AddEventWatchFunc(filterFunc eventFilterFunc, userdata interface{}) EventWatchHandle {
	return AddEventWatch(filterFunc, userdata)
}

// DelEventWatch removes an event watch callback added with AddEventWatch().
// (https://wiki.libsdl.org/SDL_DelEventWatch)
func DelEventWatch(handle EventWatchHandle) {
	context, ok := eventWatches[handle]
	if !ok {
		return
	}
	delete(eventWatches, context.handle)
	C.delEventWatch(context.cptr())
}

// EventState sets the state of processing events by type.
// (https://wiki.libsdl.org/SDL_EventState)
func EventState(type_ uint32, state int) uint8 {
	return uint8(C.SDL_EventState(C.Uint32(type_), C.int(state)))
}

// GetEventState returns the current processing state of the specified event
// (https://wiki.libsdl.org/SDL_EventState)
func GetEventState(type_ uint32) uint8 {
	return uint8(C.SDL_EventState(C.Uint32(type_), QUERY))
}

// RegisterEvents allocates a set of user-defined events, and return the beginning event number for that set of events.
// (https://wiki.libsdl.org/SDL_RegisterEvents)
func RegisterEvents(numEvents int) uint32 {
	return uint32(C.SDL_RegisterEvents(C.int(numEvents)))
}