include/SDL_events.h
author Manuel Alfayate Corchete <redwindwanderer@gmail.com>
Mon, 03 Aug 2020 22:24:49 +0200
changeset 13974 c47a91919b1e
parent 13797 55ec5ae4aa0b
permissions -rw-r--r--
kmsdrm: update SwapWindow fn, moving it to triple-buffer.
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
     4 
     5   This software is provided 'as-is', without any express or implied
     6   warranty.  In no event will the authors be held liable for any damages
     7   arising from the use of this software.
     8 
     9   Permission is granted to anyone to use this software for any purpose,
    10   including commercial applications, and to alter it and redistribute it
    11   freely, subject to the following restrictions:
    12 
    13   1. The origin of this software must not be misrepresented; you must not
    14      claim that you wrote the original software. If you use this software
    15      in a product, an acknowledgment in the product documentation would be
    16      appreciated but is not required.
    17   2. Altered source versions must be plainly marked as such, and must not be
    18      misrepresented as being the original software.
    19   3. This notice may not be removed or altered from any source distribution.
    20 */
    21 
    22 /**
    23  *  \file SDL_events.h
    24  *
    25  *  Include file for SDL event handling.
    26  */
    27 
    28 #ifndef SDL_events_h_
    29 #define SDL_events_h_
    30 
    31 #include "SDL_stdinc.h"
    32 #include "SDL_error.h"
    33 #include "SDL_video.h"
    34 #include "SDL_keyboard.h"
    35 #include "SDL_mouse.h"
    36 #include "SDL_joystick.h"
    37 #include "SDL_gamecontroller.h"
    38 #include "SDL_quit.h"
    39 #include "SDL_gesture.h"
    40 #include "SDL_touch.h"
    41 
    42 #include "begin_code.h"
    43 /* Set up for C function definitions, even when using C++ */
    44 #ifdef __cplusplus
    45 extern "C" {
    46 #endif
    47 
    48 /* General keyboard/mouse state definitions */
    49 #define SDL_RELEASED    0
    50 #define SDL_PRESSED 1
    51 
    52 /**
    53  * \brief The types of events that can be delivered.
    54  */
    55 typedef enum
    56 {
    57     SDL_FIRSTEVENT     = 0,     /**< Unused (do not remove) */
    58 
    59     /* Application events */
    60     SDL_QUIT           = 0x100, /**< User-requested quit */
    61 
    62     /* These application events have special meaning on iOS, see README-ios.md for details */
    63     SDL_APP_TERMINATING,        /**< The application is being terminated by the OS
    64                                      Called on iOS in applicationWillTerminate()
    65                                      Called on Android in onDestroy()
    66                                 */
    67     SDL_APP_LOWMEMORY,          /**< The application is low on memory, free memory if possible.
    68                                      Called on iOS in applicationDidReceiveMemoryWarning()
    69                                      Called on Android in onLowMemory()
    70                                 */
    71     SDL_APP_WILLENTERBACKGROUND, /**< The application is about to enter the background
    72                                      Called on iOS in applicationWillResignActive()
    73                                      Called on Android in onPause()
    74                                 */
    75     SDL_APP_DIDENTERBACKGROUND, /**< The application did enter the background and may not get CPU for some time
    76                                      Called on iOS in applicationDidEnterBackground()
    77                                      Called on Android in onPause()
    78                                 */
    79     SDL_APP_WILLENTERFOREGROUND, /**< The application is about to enter the foreground
    80                                      Called on iOS in applicationWillEnterForeground()
    81                                      Called on Android in onResume()
    82                                 */
    83     SDL_APP_DIDENTERFOREGROUND, /**< The application is now interactive
    84                                      Called on iOS in applicationDidBecomeActive()
    85                                      Called on Android in onResume()
    86                                 */
    87 
    88     SDL_LOCALECHANGED,  /**< The user's locale preferences have changed. */
    89 
    90     /* Display events */
    91     SDL_DISPLAYEVENT   = 0x150,  /**< Display state change */
    92 
    93     /* Window events */
    94     SDL_WINDOWEVENT    = 0x200, /**< Window state change */
    95     SDL_SYSWMEVENT,             /**< System specific event */
    96 
    97     /* Keyboard events */
    98     SDL_KEYDOWN        = 0x300, /**< Key pressed */
    99     SDL_KEYUP,                  /**< Key released */
   100     SDL_TEXTEDITING,            /**< Keyboard text editing (composition) */
   101     SDL_TEXTINPUT,              /**< Keyboard text input */
   102     SDL_KEYMAPCHANGED,          /**< Keymap changed due to a system event such as an
   103                                      input language or keyboard layout change.
   104                                 */
   105 
   106     /* Mouse events */
   107     SDL_MOUSEMOTION    = 0x400, /**< Mouse moved */
   108     SDL_MOUSEBUTTONDOWN,        /**< Mouse button pressed */
   109     SDL_MOUSEBUTTONUP,          /**< Mouse button released */
   110     SDL_MOUSEWHEEL,             /**< Mouse wheel motion */
   111 
   112     /* Joystick events */
   113     SDL_JOYAXISMOTION  = 0x600, /**< Joystick axis motion */
   114     SDL_JOYBALLMOTION,          /**< Joystick trackball motion */
   115     SDL_JOYHATMOTION,           /**< Joystick hat position change */
   116     SDL_JOYBUTTONDOWN,          /**< Joystick button pressed */
   117     SDL_JOYBUTTONUP,            /**< Joystick button released */
   118     SDL_JOYDEVICEADDED,         /**< A new joystick has been inserted into the system */
   119     SDL_JOYDEVICEREMOVED,       /**< An opened joystick has been removed */
   120 
   121     /* Game controller events */
   122     SDL_CONTROLLERAXISMOTION  = 0x650, /**< Game controller axis motion */
   123     SDL_CONTROLLERBUTTONDOWN,          /**< Game controller button pressed */
   124     SDL_CONTROLLERBUTTONUP,            /**< Game controller button released */
   125     SDL_CONTROLLERDEVICEADDED,         /**< A new Game controller has been inserted into the system */
   126     SDL_CONTROLLERDEVICEREMOVED,       /**< An opened Game controller has been removed */
   127     SDL_CONTROLLERDEVICEREMAPPED,      /**< The controller mapping was updated */
   128 
   129     /* Touch events */
   130     SDL_FINGERDOWN      = 0x700,
   131     SDL_FINGERUP,
   132     SDL_FINGERMOTION,
   133 
   134     /* Gesture events */
   135     SDL_DOLLARGESTURE   = 0x800,
   136     SDL_DOLLARRECORD,
   137     SDL_MULTIGESTURE,
   138 
   139     /* Clipboard events */
   140     SDL_CLIPBOARDUPDATE = 0x900, /**< The clipboard changed */
   141 
   142     /* Drag and drop events */
   143     SDL_DROPFILE        = 0x1000, /**< The system requests a file open */
   144     SDL_DROPTEXT,                 /**< text/plain drag-and-drop event */
   145     SDL_DROPBEGIN,                /**< A new set of drops is beginning (NULL filename) */
   146     SDL_DROPCOMPLETE,             /**< Current set of drops is now complete (NULL filename) */
   147 
   148     /* Audio hotplug events */
   149     SDL_AUDIODEVICEADDED = 0x1100, /**< A new audio device is available */
   150     SDL_AUDIODEVICEREMOVED,        /**< An audio device has been removed. */
   151 
   152     /* Sensor events */
   153     SDL_SENSORUPDATE = 0x1200,     /**< A sensor was updated */
   154 
   155     /* Render events */
   156     SDL_RENDER_TARGETS_RESET = 0x2000, /**< The render targets have been reset and their contents need to be updated */
   157     SDL_RENDER_DEVICE_RESET, /**< The device has been reset and all textures need to be recreated */
   158 
   159     /** Events ::SDL_USEREVENT through ::SDL_LASTEVENT are for your use,
   160      *  and should be allocated with SDL_RegisterEvents()
   161      */
   162     SDL_USEREVENT    = 0x8000,
   163 
   164     /**
   165      *  This last event is only for bounding internal arrays
   166      */
   167     SDL_LASTEVENT    = 0xFFFF
   168 } SDL_EventType;
   169 
   170 /**
   171  *  \brief Fields shared by every event
   172  */
   173 typedef struct SDL_CommonEvent
   174 {
   175     Uint32 type;
   176     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   177 } SDL_CommonEvent;
   178 
   179 /**
   180  *  \brief Display state change event data (event.display.*)
   181  */
   182 typedef struct SDL_DisplayEvent
   183 {
   184     Uint32 type;        /**< ::SDL_DISPLAYEVENT */
   185     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   186     Uint32 display;     /**< The associated display index */
   187     Uint8 event;        /**< ::SDL_DisplayEventID */
   188     Uint8 padding1;
   189     Uint8 padding2;
   190     Uint8 padding3;
   191     Sint32 data1;       /**< event dependent data */
   192 } SDL_DisplayEvent;
   193 
   194 /**
   195  *  \brief Window state change event data (event.window.*)
   196  */
   197 typedef struct SDL_WindowEvent
   198 {
   199     Uint32 type;        /**< ::SDL_WINDOWEVENT */
   200     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   201     Uint32 windowID;    /**< The associated window */
   202     Uint8 event;        /**< ::SDL_WindowEventID */
   203     Uint8 padding1;
   204     Uint8 padding2;
   205     Uint8 padding3;
   206     Sint32 data1;       /**< event dependent data */
   207     Sint32 data2;       /**< event dependent data */
   208 } SDL_WindowEvent;
   209 
   210 /**
   211  *  \brief Keyboard button event structure (event.key.*)
   212  */
   213 typedef struct SDL_KeyboardEvent
   214 {
   215     Uint32 type;        /**< ::SDL_KEYDOWN or ::SDL_KEYUP */
   216     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   217     Uint32 windowID;    /**< The window with keyboard focus, if any */
   218     Uint8 state;        /**< ::SDL_PRESSED or ::SDL_RELEASED */
   219     Uint8 repeat;       /**< Non-zero if this is a key repeat */
   220     Uint8 padding2;
   221     Uint8 padding3;
   222     SDL_Keysym keysym;  /**< The key that was pressed or released */
   223 } SDL_KeyboardEvent;
   224 
   225 #define SDL_TEXTEDITINGEVENT_TEXT_SIZE (32)
   226 /**
   227  *  \brief Keyboard text editing event structure (event.edit.*)
   228  */
   229 typedef struct SDL_TextEditingEvent
   230 {
   231     Uint32 type;                                /**< ::SDL_TEXTEDITING */
   232     Uint32 timestamp;                           /**< In milliseconds, populated using SDL_GetTicks() */
   233     Uint32 windowID;                            /**< The window with keyboard focus, if any */
   234     char text[SDL_TEXTEDITINGEVENT_TEXT_SIZE];  /**< The editing text */
   235     Sint32 start;                               /**< The start cursor of selected editing text */
   236     Sint32 length;                              /**< The length of selected editing text */
   237 } SDL_TextEditingEvent;
   238 
   239 
   240 #define SDL_TEXTINPUTEVENT_TEXT_SIZE (32)
   241 /**
   242  *  \brief Keyboard text input event structure (event.text.*)
   243  */
   244 typedef struct SDL_TextInputEvent
   245 {
   246     Uint32 type;                              /**< ::SDL_TEXTINPUT */
   247     Uint32 timestamp;                         /**< In milliseconds, populated using SDL_GetTicks() */
   248     Uint32 windowID;                          /**< The window with keyboard focus, if any */
   249     char text[SDL_TEXTINPUTEVENT_TEXT_SIZE];  /**< The input text */
   250 } SDL_TextInputEvent;
   251 
   252 /**
   253  *  \brief Mouse motion event structure (event.motion.*)
   254  */
   255 typedef struct SDL_MouseMotionEvent
   256 {
   257     Uint32 type;        /**< ::SDL_MOUSEMOTION */
   258     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   259     Uint32 windowID;    /**< The window with mouse focus, if any */
   260     Uint32 which;       /**< The mouse instance id, or SDL_TOUCH_MOUSEID */
   261     Uint32 state;       /**< The current button state */
   262     Sint32 x;           /**< X coordinate, relative to window */
   263     Sint32 y;           /**< Y coordinate, relative to window */
   264     Sint32 xrel;        /**< The relative motion in the X direction */
   265     Sint32 yrel;        /**< The relative motion in the Y direction */
   266 } SDL_MouseMotionEvent;
   267 
   268 /**
   269  *  \brief Mouse button event structure (event.button.*)
   270  */
   271 typedef struct SDL_MouseButtonEvent
   272 {
   273     Uint32 type;        /**< ::SDL_MOUSEBUTTONDOWN or ::SDL_MOUSEBUTTONUP */
   274     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   275     Uint32 windowID;    /**< The window with mouse focus, if any */
   276     Uint32 which;       /**< The mouse instance id, or SDL_TOUCH_MOUSEID */
   277     Uint8 button;       /**< The mouse button index */
   278     Uint8 state;        /**< ::SDL_PRESSED or ::SDL_RELEASED */
   279     Uint8 clicks;       /**< 1 for single-click, 2 for double-click, etc. */
   280     Uint8 padding1;
   281     Sint32 x;           /**< X coordinate, relative to window */
   282     Sint32 y;           /**< Y coordinate, relative to window */
   283 } SDL_MouseButtonEvent;
   284 
   285 /**
   286  *  \brief Mouse wheel event structure (event.wheel.*)
   287  */
   288 typedef struct SDL_MouseWheelEvent
   289 {
   290     Uint32 type;        /**< ::SDL_MOUSEWHEEL */
   291     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   292     Uint32 windowID;    /**< The window with mouse focus, if any */
   293     Uint32 which;       /**< The mouse instance id, or SDL_TOUCH_MOUSEID */
   294     Sint32 x;           /**< The amount scrolled horizontally, positive to the right and negative to the left */
   295     Sint32 y;           /**< The amount scrolled vertically, positive away from the user and negative toward the user */
   296     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 */
   297 } SDL_MouseWheelEvent;
   298 
   299 /**
   300  *  \brief Joystick axis motion event structure (event.jaxis.*)
   301  */
   302 typedef struct SDL_JoyAxisEvent
   303 {
   304     Uint32 type;        /**< ::SDL_JOYAXISMOTION */
   305     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   306     SDL_JoystickID which; /**< The joystick instance id */
   307     Uint8 axis;         /**< The joystick axis index */
   308     Uint8 padding1;
   309     Uint8 padding2;
   310     Uint8 padding3;
   311     Sint16 value;       /**< The axis value (range: -32768 to 32767) */
   312     Uint16 padding4;
   313 } SDL_JoyAxisEvent;
   314 
   315 /**
   316  *  \brief Joystick trackball motion event structure (event.jball.*)
   317  */
   318 typedef struct SDL_JoyBallEvent
   319 {
   320     Uint32 type;        /**< ::SDL_JOYBALLMOTION */
   321     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   322     SDL_JoystickID which; /**< The joystick instance id */
   323     Uint8 ball;         /**< The joystick trackball index */
   324     Uint8 padding1;
   325     Uint8 padding2;
   326     Uint8 padding3;
   327     Sint16 xrel;        /**< The relative motion in the X direction */
   328     Sint16 yrel;        /**< The relative motion in the Y direction */
   329 } SDL_JoyBallEvent;
   330 
   331 /**
   332  *  \brief Joystick hat position change event structure (event.jhat.*)
   333  */
   334 typedef struct SDL_JoyHatEvent
   335 {
   336     Uint32 type;        /**< ::SDL_JOYHATMOTION */
   337     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   338     SDL_JoystickID which; /**< The joystick instance id */
   339     Uint8 hat;          /**< The joystick hat index */
   340     Uint8 value;        /**< The hat position value.
   341                          *   \sa ::SDL_HAT_LEFTUP ::SDL_HAT_UP ::SDL_HAT_RIGHTUP
   342                          *   \sa ::SDL_HAT_LEFT ::SDL_HAT_CENTERED ::SDL_HAT_RIGHT
   343                          *   \sa ::SDL_HAT_LEFTDOWN ::SDL_HAT_DOWN ::SDL_HAT_RIGHTDOWN
   344                          *
   345                          *   Note that zero means the POV is centered.
   346                          */
   347     Uint8 padding1;
   348     Uint8 padding2;
   349 } SDL_JoyHatEvent;
   350 
   351 /**
   352  *  \brief Joystick button event structure (event.jbutton.*)
   353  */
   354 typedef struct SDL_JoyButtonEvent
   355 {
   356     Uint32 type;        /**< ::SDL_JOYBUTTONDOWN or ::SDL_JOYBUTTONUP */
   357     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   358     SDL_JoystickID which; /**< The joystick instance id */
   359     Uint8 button;       /**< The joystick button index */
   360     Uint8 state;        /**< ::SDL_PRESSED or ::SDL_RELEASED */
   361     Uint8 padding1;
   362     Uint8 padding2;
   363 } SDL_JoyButtonEvent;
   364 
   365 /**
   366  *  \brief Joystick device event structure (event.jdevice.*)
   367  */
   368 typedef struct SDL_JoyDeviceEvent
   369 {
   370     Uint32 type;        /**< ::SDL_JOYDEVICEADDED or ::SDL_JOYDEVICEREMOVED */
   371     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   372     Sint32 which;       /**< The joystick device index for the ADDED event, instance id for the REMOVED event */
   373 } SDL_JoyDeviceEvent;
   374 
   375 
   376 /**
   377  *  \brief Game controller axis motion event structure (event.caxis.*)
   378  */
   379 typedef struct SDL_ControllerAxisEvent
   380 {
   381     Uint32 type;        /**< ::SDL_CONTROLLERAXISMOTION */
   382     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   383     SDL_JoystickID which; /**< The joystick instance id */
   384     Uint8 axis;         /**< The controller axis (SDL_GameControllerAxis) */
   385     Uint8 padding1;
   386     Uint8 padding2;
   387     Uint8 padding3;
   388     Sint16 value;       /**< The axis value (range: -32768 to 32767) */
   389     Uint16 padding4;
   390 } SDL_ControllerAxisEvent;
   391 
   392 
   393 /**
   394  *  \brief Game controller button event structure (event.cbutton.*)
   395  */
   396 typedef struct SDL_ControllerButtonEvent
   397 {
   398     Uint32 type;        /**< ::SDL_CONTROLLERBUTTONDOWN or ::SDL_CONTROLLERBUTTONUP */
   399     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   400     SDL_JoystickID which; /**< The joystick instance id */
   401     Uint8 button;       /**< The controller button (SDL_GameControllerButton) */
   402     Uint8 state;        /**< ::SDL_PRESSED or ::SDL_RELEASED */
   403     Uint8 padding1;
   404     Uint8 padding2;
   405 } SDL_ControllerButtonEvent;
   406 
   407 
   408 /**
   409  *  \brief Controller device event structure (event.cdevice.*)
   410  */
   411 typedef struct SDL_ControllerDeviceEvent
   412 {
   413     Uint32 type;        /**< ::SDL_CONTROLLERDEVICEADDED, ::SDL_CONTROLLERDEVICEREMOVED, or ::SDL_CONTROLLERDEVICEREMAPPED */
   414     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   415     Sint32 which;       /**< The joystick device index for the ADDED event, instance id for the REMOVED or REMAPPED event */
   416 } SDL_ControllerDeviceEvent;
   417 
   418 /**
   419  *  \brief Audio device event structure (event.adevice.*)
   420  */
   421 typedef struct SDL_AudioDeviceEvent
   422 {
   423     Uint32 type;        /**< ::SDL_AUDIODEVICEADDED, or ::SDL_AUDIODEVICEREMOVED */
   424     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   425     Uint32 which;       /**< The audio device index for the ADDED event (valid until next SDL_GetNumAudioDevices() call), SDL_AudioDeviceID for the REMOVED event */
   426     Uint8 iscapture;    /**< zero if an output device, non-zero if a capture device. */
   427     Uint8 padding1;
   428     Uint8 padding2;
   429     Uint8 padding3;
   430 } SDL_AudioDeviceEvent;
   431 
   432 
   433 /**
   434  *  \brief Touch finger event structure (event.tfinger.*)
   435  */
   436 typedef struct SDL_TouchFingerEvent
   437 {
   438     Uint32 type;        /**< ::SDL_FINGERMOTION or ::SDL_FINGERDOWN or ::SDL_FINGERUP */
   439     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   440     SDL_TouchID touchId; /**< The touch device id */
   441     SDL_FingerID fingerId;
   442     float x;            /**< Normalized in the range 0...1 */
   443     float y;            /**< Normalized in the range 0...1 */
   444     float dx;           /**< Normalized in the range -1...1 */
   445     float dy;           /**< Normalized in the range -1...1 */
   446     float pressure;     /**< Normalized in the range 0...1 */
   447     Uint32 windowID;    /**< The window underneath the finger, if any */
   448 } SDL_TouchFingerEvent;
   449 
   450 
   451 /**
   452  *  \brief Multiple Finger Gesture Event (event.mgesture.*)
   453  */
   454 typedef struct SDL_MultiGestureEvent
   455 {
   456     Uint32 type;        /**< ::SDL_MULTIGESTURE */
   457     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   458     SDL_TouchID touchId; /**< The touch device id */
   459     float dTheta;
   460     float dDist;
   461     float x;
   462     float y;
   463     Uint16 numFingers;
   464     Uint16 padding;
   465 } SDL_MultiGestureEvent;
   466 
   467 
   468 /**
   469  * \brief Dollar Gesture Event (event.dgesture.*)
   470  */
   471 typedef struct SDL_DollarGestureEvent
   472 {
   473     Uint32 type;        /**< ::SDL_DOLLARGESTURE or ::SDL_DOLLARRECORD */
   474     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   475     SDL_TouchID touchId; /**< The touch device id */
   476     SDL_GestureID gestureId;
   477     Uint32 numFingers;
   478     float error;
   479     float x;            /**< Normalized center of gesture */
   480     float y;            /**< Normalized center of gesture */
   481 } SDL_DollarGestureEvent;
   482 
   483 
   484 /**
   485  *  \brief An event used to request a file open by the system (event.drop.*)
   486  *         This event is enabled by default, you can disable it with SDL_EventState().
   487  *  \note If this event is enabled, you must free the filename in the event.
   488  */
   489 typedef struct SDL_DropEvent
   490 {
   491     Uint32 type;        /**< ::SDL_DROPBEGIN or ::SDL_DROPFILE or ::SDL_DROPTEXT or ::SDL_DROPCOMPLETE */
   492     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   493     char *file;         /**< The file name, which should be freed with SDL_free(), is NULL on begin/complete */
   494     Uint32 windowID;    /**< The window that was dropped on, if any */
   495 } SDL_DropEvent;
   496 
   497 
   498 /**
   499  *  \brief Sensor event structure (event.sensor.*)
   500  */
   501 typedef struct SDL_SensorEvent
   502 {
   503     Uint32 type;        /**< ::SDL_SENSORUPDATE */
   504     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   505     Sint32 which;       /**< The instance ID of the sensor */
   506     float data[6];      /**< Up to 6 values from the sensor - additional values can be queried using SDL_SensorGetData() */
   507 } SDL_SensorEvent;
   508 
   509 /**
   510  *  \brief The "quit requested" event
   511  */
   512 typedef struct SDL_QuitEvent
   513 {
   514     Uint32 type;        /**< ::SDL_QUIT */
   515     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   516 } SDL_QuitEvent;
   517 
   518 /**
   519  *  \brief OS Specific event
   520  */
   521 typedef struct SDL_OSEvent
   522 {
   523     Uint32 type;        /**< ::SDL_QUIT */
   524     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   525 } SDL_OSEvent;
   526 
   527 /**
   528  *  \brief A user-defined event type (event.user.*)
   529  */
   530 typedef struct SDL_UserEvent
   531 {
   532     Uint32 type;        /**< ::SDL_USEREVENT through ::SDL_LASTEVENT-1 */
   533     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   534     Uint32 windowID;    /**< The associated window if any */
   535     Sint32 code;        /**< User defined event code */
   536     void *data1;        /**< User defined data pointer */
   537     void *data2;        /**< User defined data pointer */
   538 } SDL_UserEvent;
   539 
   540 
   541 struct SDL_SysWMmsg;
   542 typedef struct SDL_SysWMmsg SDL_SysWMmsg;
   543 
   544 /**
   545  *  \brief A video driver dependent system event (event.syswm.*)
   546  *         This event is disabled by default, you can enable it with SDL_EventState()
   547  *
   548  *  \note If you want to use this event, you should include SDL_syswm.h.
   549  */
   550 typedef struct SDL_SysWMEvent
   551 {
   552     Uint32 type;        /**< ::SDL_SYSWMEVENT */
   553     Uint32 timestamp;   /**< In milliseconds, populated using SDL_GetTicks() */
   554     SDL_SysWMmsg *msg;  /**< driver dependent data, defined in SDL_syswm.h */
   555 } SDL_SysWMEvent;
   556 
   557 /**
   558  *  \brief General event structure
   559  */
   560 typedef union SDL_Event
   561 {
   562     Uint32 type;                    /**< Event type, shared with all events */
   563     SDL_CommonEvent common;         /**< Common event data */
   564     SDL_DisplayEvent display;       /**< Display event data */
   565     SDL_WindowEvent window;         /**< Window event data */
   566     SDL_KeyboardEvent key;          /**< Keyboard event data */
   567     SDL_TextEditingEvent edit;      /**< Text editing event data */
   568     SDL_TextInputEvent text;        /**< Text input event data */
   569     SDL_MouseMotionEvent motion;    /**< Mouse motion event data */
   570     SDL_MouseButtonEvent button;    /**< Mouse button event data */
   571     SDL_MouseWheelEvent wheel;      /**< Mouse wheel event data */
   572     SDL_JoyAxisEvent jaxis;         /**< Joystick axis event data */
   573     SDL_JoyBallEvent jball;         /**< Joystick ball event data */
   574     SDL_JoyHatEvent jhat;           /**< Joystick hat event data */
   575     SDL_JoyButtonEvent jbutton;     /**< Joystick button event data */
   576     SDL_JoyDeviceEvent jdevice;     /**< Joystick device change event data */
   577     SDL_ControllerAxisEvent caxis;      /**< Game Controller axis event data */
   578     SDL_ControllerButtonEvent cbutton;  /**< Game Controller button event data */
   579     SDL_ControllerDeviceEvent cdevice;  /**< Game Controller device event data */
   580     SDL_AudioDeviceEvent adevice;   /**< Audio device event data */
   581     SDL_SensorEvent sensor;         /**< Sensor event data */
   582     SDL_QuitEvent quit;             /**< Quit request event data */
   583     SDL_UserEvent user;             /**< Custom event data */
   584     SDL_SysWMEvent syswm;           /**< System dependent window event data */
   585     SDL_TouchFingerEvent tfinger;   /**< Touch finger event data */
   586     SDL_MultiGestureEvent mgesture; /**< Gesture event data */
   587     SDL_DollarGestureEvent dgesture; /**< Gesture event data */
   588     SDL_DropEvent drop;             /**< Drag and drop event data */
   589 
   590     /* This is necessary for ABI compatibility between Visual C++ and GCC
   591        Visual C++ will respect the push pack pragma and use 52 bytes for
   592        this structure, and GCC will use the alignment of the largest datatype
   593        within the union, which is 8 bytes.
   594 
   595        So... we'll add padding to force the size to be 56 bytes for both.
   596     */
   597     Uint8 padding[56];
   598 } SDL_Event;
   599 
   600 /* Make sure we haven't broken binary compatibility */
   601 SDL_COMPILE_TIME_ASSERT(SDL_Event, sizeof(SDL_Event) == 56);
   602 
   603 
   604 /* Function prototypes */
   605 
   606 /**
   607  *  Pumps the event loop, gathering events from the input devices.
   608  *
   609  *  This function updates the event queue and internal input device state.
   610  *
   611  *  This should only be run in the thread that sets the video mode.
   612  */
   613 extern DECLSPEC void SDLCALL SDL_PumpEvents(void);
   614 
   615 /* @{ */
   616 typedef enum
   617 {
   618     SDL_ADDEVENT,
   619     SDL_PEEKEVENT,
   620     SDL_GETEVENT
   621 } SDL_eventaction;
   622 
   623 /**
   624  *  Checks the event queue for messages and optionally returns them.
   625  *
   626  *  If \c action is ::SDL_ADDEVENT, up to \c numevents events will be added to
   627  *  the back of the event queue.
   628  *
   629  *  If \c action is ::SDL_PEEKEVENT, up to \c numevents events at the front
   630  *  of the event queue, within the specified minimum and maximum type,
   631  *  will be returned and will not be removed from the queue.
   632  *
   633  *  If \c action is ::SDL_GETEVENT, up to \c numevents events at the front
   634  *  of the event queue, within the specified minimum and maximum type,
   635  *  will be returned and will be removed from the queue.
   636  *
   637  *  \return The number of events actually stored, or -1 if there was an error.
   638  *
   639  *  This function is thread-safe.
   640  */
   641 extern DECLSPEC int SDLCALL SDL_PeepEvents(SDL_Event * events, int numevents,
   642                                            SDL_eventaction action,
   643                                            Uint32 minType, Uint32 maxType);
   644 /* @} */
   645 
   646 /**
   647  *  Checks to see if certain event types are in the event queue.
   648  */
   649 extern DECLSPEC SDL_bool SDLCALL SDL_HasEvent(Uint32 type);
   650 extern DECLSPEC SDL_bool SDLCALL SDL_HasEvents(Uint32 minType, Uint32 maxType);
   651 
   652 /**
   653  *  This function clears events from the event queue
   654  *  This function only affects currently queued events. If you want to make
   655  *  sure that all pending OS events are flushed, you can call SDL_PumpEvents()
   656  *  on the main thread immediately before the flush call.
   657  */
   658 extern DECLSPEC void SDLCALL SDL_FlushEvent(Uint32 type);
   659 extern DECLSPEC void SDLCALL SDL_FlushEvents(Uint32 minType, Uint32 maxType);
   660 
   661 /**
   662  *  \brief Polls for currently pending events.
   663  *
   664  *  \return 1 if there are any pending events, or 0 if there are none available.
   665  *
   666  *  \param event If not NULL, the next event is removed from the queue and
   667  *               stored in that area.
   668  */
   669 extern DECLSPEC int SDLCALL SDL_PollEvent(SDL_Event * event);
   670 
   671 /**
   672  *  \brief Waits indefinitely for the next available event.
   673  *
   674  *  \return 1, or 0 if there was an error while waiting for events.
   675  *
   676  *  \param event If not NULL, the next event is removed from the queue and
   677  *               stored in that area.
   678  */
   679 extern DECLSPEC int SDLCALL SDL_WaitEvent(SDL_Event * event);
   680 
   681 /**
   682  *  \brief Waits until the specified timeout (in milliseconds) for the next
   683  *         available event.
   684  *
   685  *  \return 1, or 0 if there was an error while waiting for events.
   686  *
   687  *  \param event If not NULL, the next event is removed from the queue and
   688  *               stored in that area.
   689  *  \param timeout The timeout (in milliseconds) to wait for next event.
   690  */
   691 extern DECLSPEC int SDLCALL SDL_WaitEventTimeout(SDL_Event * event,
   692                                                  int timeout);
   693 
   694 /**
   695  *  \brief Add an event to the event queue.
   696  *
   697  *  \return 1 on success, 0 if the event was filtered, or -1 if the event queue
   698  *          was full or there was some other error.
   699  */
   700 extern DECLSPEC int SDLCALL SDL_PushEvent(SDL_Event * event);
   701 
   702 typedef int (SDLCALL * SDL_EventFilter) (void *userdata, SDL_Event * event);
   703 
   704 /**
   705  *  Sets up a filter to process all events before they change internal state and
   706  *  are posted to the internal event queue.
   707  *
   708  *  The filter is prototyped as:
   709  *  \code
   710  *      int SDL_EventFilter(void *userdata, SDL_Event * event);
   711  *  \endcode
   712  *
   713  *  If the filter returns 1, then the event will be added to the internal queue.
   714  *  If it returns 0, then the event will be dropped from the queue, but the
   715  *  internal state will still be updated.  This allows selective filtering of
   716  *  dynamically arriving events.
   717  *
   718  *  \warning  Be very careful of what you do in the event filter function, as
   719  *            it may run in a different thread!
   720  *
   721  *  There is one caveat when dealing with the ::SDL_QuitEvent event type.  The
   722  *  event filter is only called when the window manager desires to close the
   723  *  application window.  If the event filter returns 1, then the window will
   724  *  be closed, otherwise the window will remain open if possible.
   725  *
   726  *  If the quit event is generated by an interrupt signal, it will bypass the
   727  *  internal queue and be delivered to the application at the next event poll.
   728  */
   729 extern DECLSPEC void SDLCALL SDL_SetEventFilter(SDL_EventFilter filter,
   730                                                 void *userdata);
   731 
   732 /**
   733  *  Return the current event filter - can be used to "chain" filters.
   734  *  If there is no event filter set, this function returns SDL_FALSE.
   735  */
   736 extern DECLSPEC SDL_bool SDLCALL SDL_GetEventFilter(SDL_EventFilter * filter,
   737                                                     void **userdata);
   738 
   739 /**
   740  *  Add a function which is called when an event is added to the queue.
   741  */
   742 extern DECLSPEC void SDLCALL SDL_AddEventWatch(SDL_EventFilter filter,
   743                                                void *userdata);
   744 
   745 /**
   746  *  Remove an event watch function added with SDL_AddEventWatch()
   747  */
   748 extern DECLSPEC void SDLCALL SDL_DelEventWatch(SDL_EventFilter filter,
   749                                                void *userdata);
   750 
   751 /**
   752  *  Run the filter function on the current event queue, removing any
   753  *  events for which the filter returns 0.
   754  */
   755 extern DECLSPEC void SDLCALL SDL_FilterEvents(SDL_EventFilter filter,
   756                                               void *userdata);
   757 
   758 /* @{ */
   759 #define SDL_QUERY   -1
   760 #define SDL_IGNORE   0
   761 #define SDL_DISABLE  0
   762 #define SDL_ENABLE   1
   763 
   764 /**
   765  *  This function allows you to set the state of processing certain events.
   766  *   - If \c state is set to ::SDL_IGNORE, that event will be automatically
   767  *     dropped from the event queue and will not be filtered.
   768  *   - If \c state is set to ::SDL_ENABLE, that event will be processed
   769  *     normally.
   770  *   - If \c state is set to ::SDL_QUERY, SDL_EventState() will return the
   771  *     current processing state of the specified event.
   772  */
   773 extern DECLSPEC Uint8 SDLCALL SDL_EventState(Uint32 type, int state);
   774 /* @} */
   775 #define SDL_GetEventState(type) SDL_EventState(type, SDL_QUERY)
   776 
   777 /**
   778  *  This function allocates a set of user-defined events, and returns
   779  *  the beginning event number for that set of events.
   780  *
   781  *  If there aren't enough user-defined events left, this function
   782  *  returns (Uint32)-1
   783  */
   784 extern DECLSPEC Uint32 SDLCALL SDL_RegisterEvents(int numevents);
   785 
   786 /* Ends C function definitions when using C++ */
   787 #ifdef __cplusplus
   788 }
   789 #endif
   790 #include "close_code.h"
   791 
   792 #endif /* SDL_events_h_ */
   793 
   794 /* vi: set ts=4 sw=4 expandtab: */