include/SDL_events.h
author Sam Lantinga <slouken@libsdl.org>
Thu, 21 Jan 2010 06:21:52 +0000
changeset 3685 64ce267332c6
parent 3572 6bb9952d5029
child 3697 f7b03b6838cb
permissions -rw-r--r--
Switched from SDL_WindowID and SDL_TextureID to SDL_Window* and SDL_Texture* for code simplicity and improved performance.
     1 /*
     2     SDL - Simple DirectMedia Layer
     3     Copyright (C) 1997-2009 Sam Lantinga
     4 
     5     This library is free software; you can redistribute it and/or
     6     modify it under the terms of the GNU Lesser General Public
     7     License as published by the Free Software Foundation; either
     8     version 2.1 of the License, or (at your option) any later version.
     9 
    10     This library is distributed in the hope that it will be useful,
    11     but WITHOUT ANY WARRANTY; without even the implied warranty of
    12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    13     Lesser General Public License for more details.
    14 
    15     You should have received a copy of the GNU Lesser General Public
    16     License along with this library; if not, write to the Free Software
    17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    18 
    19     Sam Lantinga
    20     slouken@libsdl.org
    21 */
    22 
    23 /**
    24  *  \file SDL_events.h
    25  *  
    26  *  Include file for SDL event handling.
    27  */
    28 
    29 #ifndef _SDL_events_h
    30 #define _SDL_events_h
    31 
    32 #include "SDL_stdinc.h"
    33 #include "SDL_error.h"
    34 #include "SDL_video.h"
    35 #include "SDL_keyboard.h"
    36 #include "SDL_mouse.h"
    37 #include "SDL_joystick.h"
    38 #include "SDL_quit.h"
    39 
    40 #include "begin_code.h"
    41 /* Set up for C function definitions, even when using C++ */
    42 #ifdef __cplusplus
    43 /* *INDENT-OFF* */
    44 extern "C" {
    45 /* *INDENT-ON* */
    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_NOEVENT = 0,            /**< Unused (do not remove) */
    58     SDL_WINDOWEVENT,            /**< Window state change */
    59     SDL_KEYDOWN,                /**< Keys pressed */
    60     SDL_KEYUP,                  /**< Keys released */
    61     SDL_TEXTEDITING,            /**< Keyboard text editing (composition) */
    62     SDL_TEXTINPUT,              /**< Keyboard text input */
    63     SDL_MOUSEMOTION,            /**< Mouse moved */
    64     SDL_MOUSEBUTTONDOWN,        /**< Mouse button pressed */
    65     SDL_MOUSEBUTTONUP,          /**< Mouse button released */
    66     SDL_MOUSEWHEEL,             /**< Mouse wheel motion */
    67     SDL_JOYAXISMOTION,          /**< Joystick axis motion */
    68     SDL_JOYBALLMOTION,          /**< Joystick trackball motion */
    69     SDL_JOYHATMOTION,           /**< Joystick hat position change */
    70     SDL_JOYBUTTONDOWN,          /**< Joystick button pressed */
    71     SDL_JOYBUTTONUP,            /**< Joystick button released */
    72     SDL_QUIT,                   /**< User-requested quit */
    73     SDL_SYSWMEVENT,             /**< System specific event */
    74     SDL_PROXIMITYIN,            /**< Proximity In event */
    75     SDL_PROXIMITYOUT,           /**< Proximity Out event */
    76     SDL_EVENT_RESERVED1,        /**< Reserved for future use... */
    77     SDL_EVENT_RESERVED2,        /**< Reserved for future use... */
    78     SDL_EVENT_RESERVED3,        /**< Reserved for future use... */
    79     /** Events ::SDL_USEREVENT through ::SDL_MAXEVENTS-1 are for your use */
    80     SDL_USEREVENT = 24,
    81     /**
    82      *  This last event is only for bounding internal arrays
    83      *  It is the number of bits in the event mask datatype -- Uint32
    84      */
    85     SDL_NUMEVENTS = 32
    86 } SDL_EventType;
    87 
    88 /*@{*/
    89 #define SDL_EVENTMASK(X)	(1<<(X))
    90 /**
    91  * \brief Predefined event masks
    92  */
    93 typedef enum
    94 {
    95     SDL_WINDOWEVENTMASK = SDL_EVENTMASK(SDL_WINDOWEVENT),
    96     SDL_KEYDOWNMASK = SDL_EVENTMASK(SDL_KEYDOWN),
    97     SDL_KEYUPMASK = SDL_EVENTMASK(SDL_KEYUP),
    98     SDL_KEYEVENTMASK = SDL_EVENTMASK(SDL_KEYDOWN) | SDL_EVENTMASK(SDL_KEYUP),
    99     SDL_TEXTEDITINGMASK = SDL_EVENTMASK(SDL_TEXTEDITING),
   100     SDL_TEXTINPUTMASK = SDL_EVENTMASK(SDL_TEXTINPUT),
   101     SDL_MOUSEMOTIONMASK = SDL_EVENTMASK(SDL_MOUSEMOTION),
   102     SDL_MOUSEBUTTONDOWNMASK = SDL_EVENTMASK(SDL_MOUSEBUTTONDOWN),
   103     SDL_MOUSEBUTTONUPMASK = SDL_EVENTMASK(SDL_MOUSEBUTTONUP),
   104     SDL_MOUSEWHEELMASK = SDL_EVENTMASK(SDL_MOUSEWHEEL),
   105     SDL_MOUSEEVENTMASK = SDL_EVENTMASK(SDL_MOUSEMOTION) |
   106         SDL_EVENTMASK(SDL_MOUSEBUTTONDOWN) | SDL_EVENTMASK(SDL_MOUSEBUTTONUP),
   107     SDL_JOYAXISMOTIONMASK = SDL_EVENTMASK(SDL_JOYAXISMOTION),
   108     SDL_JOYBALLMOTIONMASK = SDL_EVENTMASK(SDL_JOYBALLMOTION),
   109     SDL_JOYHATMOTIONMASK = SDL_EVENTMASK(SDL_JOYHATMOTION),
   110     SDL_JOYBUTTONDOWNMASK = SDL_EVENTMASK(SDL_JOYBUTTONDOWN),
   111     SDL_JOYBUTTONUPMASK = SDL_EVENTMASK(SDL_JOYBUTTONUP),
   112     SDL_JOYEVENTMASK = SDL_EVENTMASK(SDL_JOYAXISMOTION) |
   113         SDL_EVENTMASK(SDL_JOYBALLMOTION) |
   114         SDL_EVENTMASK(SDL_JOYHATMOTION) |
   115         SDL_EVENTMASK(SDL_JOYBUTTONDOWN) | SDL_EVENTMASK(SDL_JOYBUTTONUP),
   116     SDL_QUITMASK = SDL_EVENTMASK(SDL_QUIT),
   117     SDL_SYSWMEVENTMASK = SDL_EVENTMASK(SDL_SYSWMEVENT),
   118     SDL_PROXIMITYINMASK = SDL_EVENTMASK(SDL_PROXIMITYIN),
   119     SDL_PROXIMITYOUTMASK = SDL_EVENTMASK(SDL_PROXIMITYOUT)
   120 } SDL_EventMask;
   121 #define SDL_ALLEVENTS		0xFFFFFFFF
   122 /*@}*/
   123 
   124 /**
   125  *  \brief Window state change event data (event.window.*)
   126  */
   127 typedef struct SDL_WindowEvent
   128 {
   129     Uint8 type;             /**< ::SDL_WINDOWEVENT */
   130     Uint32 windowID;        /**< The associated window */
   131     Uint8 event;            /**< ::SDL_WindowEventID */
   132     int data1;              /**< event dependent data */
   133     int data2;              /**< event dependent data */
   134 } SDL_WindowEvent;
   135 
   136 /**
   137  *  \brief Keyboard button event structure (event.key.*)
   138  */
   139 typedef struct SDL_KeyboardEvent
   140 {
   141     Uint8 type;             /**< ::SDL_KEYDOWN or ::SDL_KEYUP */
   142     Uint32 windowID;        /**< The window with keyboard focus, if any */
   143     Uint8 which;            /**< The keyboard device index */
   144     Uint8 state;            /**< ::SDL_PRESSED or ::SDL_RELEASED */
   145     SDL_keysym keysym;      /**< The key that was pressed or released */
   146 } SDL_KeyboardEvent;
   147 
   148 #define SDL_TEXTEDITINGEVENT_TEXT_SIZE (32)
   149 /**
   150  *  \brief Keyboard text editing event structure (event.edit.*)
   151  */
   152 typedef struct SDL_TextEditingEvent
   153 {
   154     Uint8 type;                                 /**< ::SDL_TEXTEDITING */
   155     char text[SDL_TEXTEDITINGEVENT_TEXT_SIZE];  /**< The editing text */
   156     int start;                                  /**< The start cursor of selected editing text */
   157     int length;                                 /**< The length of selected editing text */
   158 } SDL_TextEditingEvent;
   159 
   160 
   161 #define SDL_TEXTINPUTEVENT_TEXT_SIZE (32)
   162 /**
   163  *  \brief Keyboard text input event structure (event.text.*)
   164  */
   165 typedef struct SDL_TextInputEvent
   166 {
   167     Uint8 type;                               /**< ::SDL_TEXTINPUT */
   168     Uint32 windowID;                          /**< The window with keyboard focus, if any */
   169     Uint8 which;                              /**< The keyboard device index */
   170     char text[SDL_TEXTINPUTEVENT_TEXT_SIZE];  /**< The input text */
   171 } SDL_TextInputEvent;
   172 
   173 /**
   174  *  \brief Mouse motion event structure (event.motion.*)
   175  */
   176 typedef struct SDL_MouseMotionEvent
   177 {
   178     Uint8 type;             /**< ::SDL_MOUSEMOTION */
   179     Uint32 windowID;        /**< The window with mouse focus, if any */
   180     Uint8 which;            /**< The mouse device index */
   181     Uint8 state;            /**< The current button state */
   182     int x;                  /**< X coordinate, relative to window */
   183     int y;                  /**< Y coordinate, relative to window */
   184     int z;                  /**< Z coordinate, for future use */
   185     int pressure;           /**< Pressure reported by tablets */
   186     int pressure_max;       /**< Maximum value of the pressure reported by the device */
   187     int pressure_min;       /**< Minimum value of the pressure reported by the device */
   188     int rotation;           /**< For future use */
   189     int tilt_x;             /**< For future use */
   190     int tilt_y;             /**< For future use */
   191     int cursor;             /**< The cursor being used in the event */
   192     int xrel;               /**< The relative motion in the X direction */
   193     int yrel;               /**< The relative motion in the Y direction */
   194 } SDL_MouseMotionEvent;
   195 
   196 /**
   197  *  \brief Mouse button event structure (event.button.*)
   198  */
   199 typedef struct SDL_MouseButtonEvent
   200 {
   201     Uint8 type;             /**< ::SDL_MOUSEBUTTONDOWN or ::SDL_MOUSEBUTTONUP */
   202     Uint32 windowID;        /**< The window with mouse focus, if any */
   203     Uint8 which;            /**< The mouse device index */
   204     Uint8 button;           /**< The mouse button index */
   205     Uint8 state;            /**< ::SDL_PRESSED or ::SDL_RELEASED */
   206     int x;                  /**< X coordinate, relative to window */
   207     int y;                  /**< Y coordinate, relative to window */
   208 } SDL_MouseButtonEvent;
   209 
   210 /**
   211  *  \brief Mouse wheel event structure (event.wheel.*)
   212  */
   213 typedef struct SDL_MouseWheelEvent
   214 {
   215     Uint8 type;             /**< ::SDL_MOUSEWHEEL */
   216     Uint32 windowID;        /**< The window with mouse focus, if any */
   217     Uint8 which;            /**< The mouse device index */
   218     int x;                  /**< The amount scrolled horizontally */
   219     int y;                  /**< The amount scrolled vertically */
   220 } SDL_MouseWheelEvent;
   221 
   222 /**
   223  *  \brief Joystick axis motion event structure (event.jaxis.*)
   224  */
   225 typedef struct SDL_JoyAxisEvent
   226 {
   227     Uint8 type;         /**< ::SDL_JOYAXISMOTION */
   228     Uint8 which;        /**< The joystick device index */
   229     Uint8 axis;         /**< The joystick axis index */
   230     int value;          /**< The axis value (range: -32768 to 32767) */
   231 } SDL_JoyAxisEvent;
   232 
   233 /**
   234  *  \brief Joystick trackball motion event structure (event.jball.*)
   235  */
   236 typedef struct SDL_JoyBallEvent
   237 {
   238     Uint8 type;         /**< ::SDL_JOYBALLMOTION */
   239     Uint8 which;        /**< The joystick device index */
   240     Uint8 ball;         /**< The joystick trackball index */
   241     int xrel;           /**< The relative motion in the X direction */
   242     int yrel;           /**< The relative motion in the Y direction */
   243 } SDL_JoyBallEvent;
   244 
   245 /**
   246  *  \brief Joystick hat position change event structure (event.jhat.*)
   247  */
   248 typedef struct SDL_JoyHatEvent
   249 {
   250     Uint8 type;         /**< ::SDL_JOYHATMOTION */
   251     Uint8 which;        /**< The joystick device index */
   252     Uint8 hat;          /**< The joystick hat index */
   253     Uint8 value;        /**< The hat position value.
   254                          *   \sa ::SDL_HAT_LEFTUP ::SDL_HAT_UP ::SDL_HAT_RIGHTUP
   255                          *   \sa ::SDL_HAT_LEFT ::SDL_HAT_CENTERED ::SDL_HAT_RIGHT
   256                          *   \sa ::SDL_HAT_LEFTDOWN ::SDL_HAT_DOWN ::SDL_HAT_RIGHTDOWN
   257                          *   
   258                          *   Note that zero means the POV is centered.
   259                          */
   260 } SDL_JoyHatEvent;
   261 
   262 /**
   263  *  \brief Joystick button event structure (event.jbutton.*)
   264  */
   265 typedef struct SDL_JoyButtonEvent
   266 {
   267     Uint8 type;         /**< ::SDL_JOYBUTTONDOWN or ::SDL_JOYBUTTONUP */
   268     Uint8 which;        /**< The joystick device index */
   269     Uint8 button;       /**< The joystick button index */
   270     Uint8 state;        /**< ::SDL_PRESSED or ::SDL_RELEASED */
   271 } SDL_JoyButtonEvent;
   272 
   273 /**
   274  *  \brief The "quit requested" event
   275  */
   276 typedef struct SDL_QuitEvent
   277 {
   278     Uint8 type;         /**< ::SDL_QUIT */
   279 } SDL_QuitEvent;
   280 
   281 /**
   282  *  \brief A user-defined event type (event.user.*)
   283  */
   284 typedef struct SDL_UserEvent
   285 {
   286     Uint8 type;             /**< ::SDL_USEREVENT through ::SDL_NUMEVENTS-1 */
   287     Uint32 windowID;        /**< The associated window if any*/
   288     int code;               /**< User defined event code */
   289     void *data1;            /**< User defined data pointer */
   290     void *data2;            /**< User defined data pointer */
   291 } SDL_UserEvent;
   292 
   293 struct SDL_SysWMmsg;
   294 typedef struct SDL_SysWMmsg SDL_SysWMmsg;
   295 
   296 /**
   297  *  \brief A video driver dependent system event (event.syswm.*)
   298  *  
   299  *  \note If you want to use this event, you should include SDL_syswm.h.
   300  */
   301 typedef struct SDL_SysWMEvent
   302 {
   303     Uint8 type;         /**< ::SDL_SYSWMEVENT */
   304     SDL_SysWMmsg *msg;  /**< driver dependent data, defined in SDL_syswm.h */
   305 } SDL_SysWMEvent;
   306 
   307 typedef struct SDL_ProximityEvent
   308 {
   309     Uint8 type;
   310     Uint32 windowID;    /**< The associated window */
   311     Uint8 which;
   312     int cursor;
   313     int x;
   314     int y;
   315 } SDL_ProximityEvent;
   316 
   317 #ifndef SDL_NO_COMPAT
   318 /**
   319  *  \addtogroup Compatibility 
   320  */
   321 /*@{*/
   322 
   323 /**
   324  *  \name Typedefs for backwards compatibility
   325  */
   326 /*@{*/
   327 typedef struct SDL_ActiveEvent
   328 {
   329     Uint8 type;
   330     Uint8 gain;
   331     Uint8 state;
   332 } SDL_ActiveEvent;
   333 
   334 typedef struct SDL_ResizeEvent
   335 {
   336     Uint8 type;
   337     int w;
   338     int h;
   339 } SDL_ResizeEvent;
   340 /*@}*/
   341 
   342 /*@}*//*Compatibility*/
   343 #endif
   344 
   345 /**
   346  *  \brief General event structure
   347  */
   348 typedef union SDL_Event
   349 {
   350     Uint8 type;                     /**< Event type, shared with all events */
   351     SDL_WindowEvent window;         /**< Window event data */
   352     SDL_KeyboardEvent key;          /**< Keyboard event data */
   353     SDL_TextEditingEvent edit;      /**< Text editing event data */
   354     SDL_TextInputEvent text;        /**< Text input event data */
   355     SDL_MouseMotionEvent motion;    /**< Mouse motion event data */
   356     SDL_MouseButtonEvent button;    /**< Mouse button event data */
   357     SDL_MouseWheelEvent wheel;      /**< Mouse wheel event data */
   358     SDL_JoyAxisEvent jaxis;         /**< Joystick axis event data */
   359     SDL_JoyBallEvent jball;         /**< Joystick ball event data */
   360     SDL_JoyHatEvent jhat;           /**< Joystick hat event data */
   361     SDL_JoyButtonEvent jbutton;     /**< Joystick button event data */
   362     SDL_QuitEvent quit;             /**< Quit request event data */
   363     SDL_UserEvent user;             /**< Custom event data */
   364     SDL_SysWMEvent syswm;           /**< System dependent window event data */
   365     SDL_ProximityEvent proximity;   /**< Proximity In or Out event */
   366 
   367     /** Temporarily here for backwards compatibility */
   368     /*@{*/
   369 #ifndef SDL_NO_COMPAT
   370     SDL_ActiveEvent active;
   371     SDL_ResizeEvent resize;
   372 #endif
   373     /*@}*/
   374 } SDL_Event;
   375 
   376 
   377 /* Function prototypes */
   378 
   379 /**
   380  *  Pumps the event loop, gathering events from the input devices.
   381  *  
   382  *  This function updates the event queue and internal input device state.
   383  *  
   384  *  This should only be run in the thread that sets the video mode.
   385  */
   386 extern DECLSPEC void SDLCALL SDL_PumpEvents(void);
   387 
   388 /*@{*/
   389 typedef enum
   390 {
   391     SDL_ADDEVENT,
   392     SDL_PEEKEVENT,
   393     SDL_GETEVENT
   394 } SDL_eventaction;
   395 
   396 /**
   397  *  Checks the event queue for messages and optionally returns them.
   398  *  
   399  *  If \c action is ::SDL_ADDEVENT, up to \c numevents events will be added to
   400  *  the back of the event queue.
   401  *  
   402  *  If \c action is ::SDL_PEEKEVENT, up to \c numevents events at the front
   403  *  of the event queue, matching \c mask, will be returned and will not
   404  *  be removed from the queue.
   405  *  
   406  *  If \c action is ::SDL_GETEVENT, up to \c numevents events at the front 
   407  *  of the event queue, matching \c mask, will be returned and will be
   408  *  removed from the queue.
   409  *  
   410  *  \return The number of events actually stored, or -1 if there was an error.
   411  *  
   412  *  This function is thread-safe.
   413  */
   414 extern DECLSPEC int SDLCALL SDL_PeepEvents(SDL_Event * events, int numevents,
   415                                            SDL_eventaction action,
   416                                            Uint32 mask);
   417 /*@}*/
   418 
   419 /**
   420  *  Checks to see if certain event types are in the event queue.
   421  */
   422 extern DECLSPEC SDL_bool SDLCALL SDL_HasEvent(Uint32 mask);
   423 
   424 /**
   425  *  \brief Polls for currently pending events.
   426  *  
   427  *  \return 1 if there are any pending events, or 0 if there are none available.
   428  *  
   429  *  \param event If not NULL, the next event is removed from the queue and 
   430  *               stored in that area.
   431  */
   432 extern DECLSPEC int SDLCALL SDL_PollEvent(SDL_Event * event);
   433 
   434 /**
   435  *  \brief Waits indefinitely for the next available event.
   436  *  
   437  *  \return 1, or 0 if there was an error while waiting for events.
   438  *   
   439  *  \param event If not NULL, the next event is removed from the queue and 
   440  *               stored in that area.
   441  */
   442 extern DECLSPEC int SDLCALL SDL_WaitEvent(SDL_Event * event);
   443 
   444 /**
   445  *  \brief Waits until the specified timeout (in milliseconds) for the next 
   446  *         available event.
   447  *  
   448  *  \return 1, or 0 if there was an error while waiting for events.
   449  *  
   450  *  \param event If not NULL, the next event is removed from the queue and 
   451  *               stored in that area.
   452  */
   453 extern DECLSPEC int SDLCALL SDL_WaitEventTimeout(SDL_Event * event,
   454                                                  int timeout);
   455 
   456 /**
   457  *  \brief Add an event to the event queue.
   458  *  
   459  *  \return 1 on success, 0 if the event was filtered, or -1 if the event queue 
   460  *          was full or there was some other error.
   461  */
   462 extern DECLSPEC int SDLCALL SDL_PushEvent(SDL_Event * event);
   463 
   464 typedef int (SDLCALL * SDL_EventFilter) (void *userdata, SDL_Event * event);
   465 
   466 /**
   467  *  Sets up a filter to process all events before they change internal state and
   468  *  are posted to the internal event queue.
   469  *  
   470  *  The filter is protypted as:
   471  *  \code
   472  *      int SDL_EventFilter(void *userdata, SDL_Event * event);
   473  *  \endcode
   474  *
   475  *  If the filter returns 1, then the event will be added to the internal queue.
   476  *  If it returns 0, then the event will be dropped from the queue, but the 
   477  *  internal state will still be updated.  This allows selective filtering of
   478  *  dynamically arriving events.
   479  *  
   480  *  \warning  Be very careful of what you do in the event filter function, as 
   481  *            it may run in a different thread!
   482  *  
   483  *  There is one caveat when dealing with the ::SDL_QUITEVENT event type.  The
   484  *  event filter is only called when the window manager desires to close the
   485  *  application window.  If the event filter returns 1, then the window will
   486  *  be closed, otherwise the window will remain open if possible.
   487  *
   488  *  If the quit event is generated by an interrupt signal, it will bypass the
   489  *  internal queue and be delivered to the application at the next event poll.
   490  */
   491 extern DECLSPEC void SDLCALL SDL_SetEventFilter(SDL_EventFilter filter,
   492                                                 void *userdata);
   493 
   494 /**
   495  *  Return the current event filter - can be used to "chain" filters.
   496  *  If there is no event filter set, this function returns SDL_FALSE.
   497  */
   498 extern DECLSPEC SDL_bool SDLCALL SDL_GetEventFilter(SDL_EventFilter * filter,
   499                                                     void **userdata);
   500 
   501 /**
   502  *  Run the filter function on the current event queue, removing any
   503  *  events for which the filter returns 0.
   504  */
   505 extern DECLSPEC void SDLCALL SDL_FilterEvents(SDL_EventFilter filter,
   506                                               void *userdata);
   507 
   508 /*@{*/
   509 #define SDL_QUERY	-1
   510 #define SDL_IGNORE	 0
   511 #define SDL_DISABLE	 0
   512 #define SDL_ENABLE	 1
   513 
   514 /**
   515  *  This function allows you to set the state of processing certain events.
   516  *   - If \c state is set to ::SDL_IGNORE, that event will be automatically 
   517  *     dropped from the event queue and will not event be filtered.
   518  *   - If \c state is set to ::SDL_ENABLE, that event will be processed 
   519  *     normally.
   520  *   - If \c state is set to ::SDL_QUERY, SDL_EventState() will return the 
   521  *     current processing state of the specified event.
   522  */
   523 extern DECLSPEC Uint8 SDLCALL SDL_EventState(Uint8 type, int state);
   524 /*@}*/
   525 
   526 /* Ends C function definitions when using C++ */
   527 #ifdef __cplusplus
   528 /* *INDENT-OFF* */
   529 }
   530 /* *INDENT-ON* */
   531 #endif
   532 #include "close_code.h"
   533 
   534 #endif /* _SDL_events_h */
   535 
   536 /* vi: set ts=4 sw=4 expandtab: */