path: root/lib/wrappers/sdl/sdl.nim

#******************************************************************************
#
#          JEDI-SDL : Pascal units for SDL - Simple DirectMedia Layer
#             Conversion of the Simple DirectMedia Layer Headers
#
# Portions created by Sam Lantinga <slouken@devolution.com> are
# Copyright (C) 1997-2004  Sam Lantinga
# 5635-34 Springhouse Dr.
# Pleasanton, CA 94588 (USA)
#
# All Rights Reserved.
#
# The original files are : SDL.h
#                          SDL_main.h
#                          SDL_types.h
#                          SDL_rwops.h
#                          SDL_timer.h
#                          SDL_audio.h
#                          SDL_cdrom.h
#                          SDL_joystick.h
#                          SDL_mouse.h
#                          SDL_keyboard.h
#                          SDL_events.h
#                          SDL_video.h
#                          SDL_byteorder.h
#                          SDL_version.h
#                          SDL_active.h
#                          SDL_thread.h
#                          SDL_mutex .h
#                          SDL_getenv.h
#                          SDL_loadso.h
#
# The initial developer of this Pascal code was :
# Dominique Louis <Dominique@SavageSoftware.com.au>
#
# Portions created by Dominique Louis are
# Copyright (C) 2000 - 2004 Dominique Louis.
#
#
# Contributor(s)
# --------------
# Tom Jones <tigertomjones@gmx.de>  His Project inspired this conversion
# Matthias Thoma <ma.thoma@gmx.de>
#
# Obtained through:
# Joint Endeavour of Delphi Innovators ( Project JEDI )
#
# You may retrieve the latest version of this file at the Project
# JEDI home page, located at http://delphi-jedi.org
#
# The contents of this file are used with permission, subject to
# the Mozilla Public License Version 1.1 (the "License"); you may
# not use this file except in compliance with the License. You may
# obtain a copy of the License at
# http://www.mozilla.org/MPL/MPL-1.1.html
#
# Software distributed under the License is distributed on an
# "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
# implied. See the License for the specific language governing
# rights and limitations under the License.
#
# Description
# -----------
#
#
#
#
#
#
#
# Requires
# --------
#   The SDL Runtime libraris on Win32  : SDL.dll on Linux : libSDL.so
#   They are available from...
#   http://www.libsdl.org .
#
# Programming Notes
# -----------------
#
#
#
#
# Revision History
# ----------------
#   May      08 2001 - DL : Added Keyboard  State Array ( See demos for how to
#                           use )
#                           PKeyStateArr = ^TKeyStateArr;
#                           TKeyStateArr = array[0..65000] of UInt8;
#                           As most games will need it.
#
#   April    02 2001 - DL : Added SDL_getenv.h definitions and tested version
#                           1.2.0 compatability.
#
#   March    13 2001 - MT : Added Linux compatibility.
#
#   March    10 2001 - MT : Added externalsyms for DEFINES
#                           Changed the license header
#
#   March    09 2001 - MT : Added Kylix Ifdefs/Deleted the uses mmsystem
#
#   March    01 2001 - DL : Update conversion of version 1.1.8
#
#   July     22 2001 - DL : Added TUInt8Array and PUIntArray after suggestions
#                           from Matthias Thoma and Eric Grange.
#
#   October  12 2001 - DL : Various changes as suggested by Matthias Thoma and
#                           David Acklam
#
#   October  24 2001 - DL : Added FreePascal support as per suggestions from
#                           Dean Ellis.
#
#   October  27 2001 - DL : Added SDL_BUTTON macro
#
#  November  08 2001 - DL : Bug fix as pointed out by Puthoon.
#
#  November  29 2001 - DL : Bug fix of SDL_SetGammaRamp as pointed out by Simon
#                           Rushton.
#
#  November  30 2001 - DL : SDL_NOFRAME added as pointed out by Simon Rushton.
#
#  December  11 2001 - DL : Added $WEAKPACKAGEUNIT ON to facilitate useage in
#                           Components
#
#  January   05 2002 - DL : Added SDL_Swap32 function as suggested by Matthias
#                           Thoma and also made sure the _getenv from
#                           MSVCRT.DLL uses the right calling convention
#
#  January   25 2002 - DL : Updated conversion of SDL_AddTimer &
#                           SDL_RemoveTimer as per suggestions from Matthias
#                           Thoma.
#
#  January   27 2002 - DL : Commented out exported function putenv and getenv
#                           So that developers get used to using SDL_putenv
#                           SDL_getenv, as they are more portable
#
#  March     05 2002 - DL : Added FreeAnNil procedure for Delphi 4 users.
#
#  October   23 2002 - DL : Added Delphi 3 Define of Win32.
#                           If you intend to you Delphi 3...
#                           ( which is officially unsupported ) make sure you
#                           remove references to $EXTERNALSYM in this and other
#                           SDL files.
#
# November  29 2002 - DL : Fixed bug in Declaration of SDL_GetRGBA that was
#                          pointed out by Todd Lang
#
#   April   03 2003 - DL : Added jedi-sdl.inc include file to support more
#                          Pascal compilers. Initial support is now included
#                          for GnuPascal, VirtualPascal, TMT and obviously
#                          continue support for Delphi Kylix and FreePascal.
#
#   April   08 2003 - MK : Aka Mr Kroket - Added Better FPC support
#
#   April   24 2003 - DL : under instruction from Alexey Barkovoy, I have added
#                          better TMT Pascal support and under instruction
#                          from Prof. Abimbola Olowofoyeku (The African Chief),
#                          I have added better Gnu Pascal support
#
#   April   30 2003 - DL : under instruction from David Mears AKA
#                          Jason Siletto, I have added FPC Linux support.
#                          This was compiled with fpc 1.1, so remember to set
#                          include file path. ie. -Fi/usr/share/fpcsrc/rtl/*
#
#
#
#  Revision 1.31  2007/05/29 21:30:48  savage
#  Changes as suggested by Almindor for 64bit compatibility.
#
#  Revision 1.30  2007/05/29 19:31:03  savage
#  Fix to TSDL_Overlay structure - thanks David Pethes (aka imcold)
#
#  Revision 1.29  2007/05/20 20:29:11  savage
#  Initial Changes to Handle 64 Bits
#
#  Revision 1.26  2007/02/11 13:38:04  savage
#  Added Nintendo DS support - Thanks Dean.
#
#  Revision 1.25  2006/12/02 00:12:52  savage
#  Updated to latest version
#
#  Revision 1.24  2006/05/18 21:10:04  savage
#  Added 1.2.10 Changes
#
#  Revision 1.23  2005/12/04 23:17:52  drellis
#  Added declaration of SInt8 and PSInt8
#
#  Revision 1.22  2005/05/24 21:59:03  savage
#  Re-arranged uses clause to work on Win32 and Linux, Thanks again Michalis.
#
#  Revision 1.21  2005/05/22 18:42:31  savage
#  Changes as suggested by Michalis Kamburelis. Thanks again.
#
#  Revision 1.20  2005/04/10 11:48:33  savage
#  Changes as suggested by Michalis, thanks.
#
#  Revision 1.19  2005/01/05 01:47:06  savage
#  Changed LibName to reflect what MacOS X should have. ie libSDL*-1.2.0.dylib respectively.
#
#  Revision 1.18  2005/01/04 23:14:41  savage
#  Changed LibName to reflect what most Linux distros will have. ie libSDL*-1.2.so.0 respectively.
#
#  Revision 1.17  2005/01/03 18:40:59  savage
#  Updated Version number to reflect latest one
#
#  Revision 1.16  2005/01/01 02:02:06  savage
#  Updated to v1.2.8
#
#  Revision 1.15  2004/12/24 18:57:11  savage
#  forgot to apply Michalis Kamburelis' patch to the implementation section. now fixed
#
#  Revision 1.14  2004/12/23 23:42:18  savage
#  Applied Patches supplied by Michalis Kamburelis ( THANKS! ), for greater FreePascal compatability.
#
#  Revision 1.13  2004/09/30 22:31:59  savage
#  Updated with slightly different header comments
#
#  Revision 1.12  2004/09/12 21:52:58  savage
#  Slight changes to fix some issues with the sdl classes.
#
#  Revision 1.11  2004/08/14 22:54:30  savage
#  Updated so that Library name defines are correctly defined for MacOS X.
#
#  Revision 1.10  2004/07/20 23:57:33  savage
#  Thanks to Paul Toth for spotting an error in the SDL Audio Convertion structures.
#  In TSDL_AudioCVT the filters variable should point to and array of pointers and not what I had there previously.
#
#  Revision 1.9  2004/07/03 22:07:22  savage
#  Added Bitwise Manipulation Functions for TSDL_VideoInfo struct.
#
#  Revision 1.8  2004/05/10 14:10:03  savage
#  Initial MacOS X support. Fixed defines for MACOS ( Classic ) and DARWIN ( MacOS X ).
#
#  Revision 1.7  2004/04/13 09:32:08  savage
#  Changed Shared object names back to just the .so extension to avoid conflicts on various Linux/Unix distros. Therefore developers will need to create Symbolic links to the actual Share Objects if necessary.
#
#  Revision 1.6  2004/04/01 20:53:23  savage
#  Changed Linux Shared Object names so they reflect the Symbolic Links that are created when installing the RPMs from the SDL site.
#
#  Revision 1.5  2004/02/22 15:32:10  savage
#  SDL_GetEnv Fix so it also works on FPC/Linux. Thanks to Rodrigo for pointing this out.
#
#  Revision 1.4  2004/02/21 23:24:29  savage
#  SDL_GetEnv Fix so that it is not define twice for FPC. Thanks to Rene Hugentobler for pointing out this bug,
#
#  Revision 1.3  2004/02/18 22:35:51  savage
#  Brought sdl.pas up to 1.2.7 compatability
#  Thus...
#  Added SDL_GL_STEREO,
#      SDL_GL_MULTISAMPLEBUFFERS,
#      SDL_GL_MULTISAMPLESAMPLES
#
#  Add DLL/Shared object functions
#  function SDL_LoadObject( const sofile : PChar ) : Pointer;
#
#  function SDL_LoadFunction( handle : Pointer; const name : PChar ) : Pointer;
#
#  procedure SDL_UnloadObject( handle : Pointer );
#
#  Added function to create RWops from const memory: SDL_RWFromConstMem()
#  function SDL_RWFromConstMem(const mem: Pointer; size: Integer) : PSDL_RWops;
#
#  Ported SDL_cpuinfo.h so Now you can test for Specific CPU types.
#
#  Revision 1.2  2004/02/17 21:37:12  savage
#  Tidying up of units
#
#  Revision 1.1  2004/02/05 00:08:20  savage
#  Module 1.0 release
#
#

{.deadCodeElim: on.}

when defined(windows):
  const SDLLibName = "SDL.dll"
elif defined(macosx):
  const SDLLibName = "libSDL-1.2.0.dylib"
else:
  const SDLLibName = "libSDL.so"

const
  SDL_MAJOR_VERSION* = 1'i8
  SDL_MINOR_VERSION* = 2'i8
  SDL_PATCHLEVEL* = 11'i8        # SDL.h constants
  SDL_INIT_TIMER* = 0x00000001
  SDL_INIT_AUDIO* = 0x00000010
  SDL_INIT_VIDEO* = 0x00000020
  SDL_INIT_CDROM* = 0x00000100
  SDL_INIT_JOYSTICK* = 0x00000200
  SDL_INIT_NOPARACHUTE* = 0x00100000 # Don't catch fatal signals
  SDL_INIT_EVENTTHREAD* = 0x01000000 # Not supported on all OS's
  SDL_INIT_EVERYTHING* = 0x0000FFFF # SDL_error.h constants
  ERR_MAX_STRLEN* = 128
  ERR_MAX_ARGS* = 5           # SDL_types.h constants
  SDL_PRESSED* = 0x00000001
  SDL_RELEASED* = 0x00000000  # SDL_timer.h constants
                              # This is the OS scheduler timeslice, in milliseconds
  SDL_TIMESLICE* = 10         # This is the maximum resolution of the SDL timer on all platforms
  TIMER_RESOLUTION* = 10      # Experimentally determined
                              # SDL_audio.h constants
  AUDIO_U8* = 0x00000008      # Unsigned 8-bit samples
  AUDIO_S8* = 0x00008008      # Signed 8-bit samples
  AUDIO_U16LSB* = 0x00000010  # Unsigned 16-bit samples
  AUDIO_S16LSB* = 0x00008010  # Signed 16-bit samples
  AUDIO_U16MSB* = 0x00001010  # As above, but big-endian byte order
  AUDIO_S16MSB* = 0x00009010  # As above, but big-endian byte order
  AUDIO_U16* = AUDIO_U16LSB
  AUDIO_S16* = AUDIO_S16LSB   # SDL_cdrom.h constants
                              # The maximum number of CD-ROM tracks on a disk
  SDL_MAX_TRACKS* = 99        # The types of CD-ROM track possible
  SDL_AUDIO_TRACK* = 0x00000000
  SDL_DATA_TRACK* = 0x00000004 # Conversion functions from frames to Minute/Second/Frames and vice versa
  CD_FPS* = 75                # SDL_byteorder.h constants
                              # The two types of endianness
  SDL_LIL_ENDIAN* = 1234
  SDL_BIG_ENDIAN* = 4321

when cpuEndian == littleEndian:
  const
    SDL_BYTEORDER* = SDL_LIL_ENDIAN # Native audio byte ordering
    AUDIO_U16SYS* = AUDIO_U16LSB
    AUDIO_S16SYS* = AUDIO_S16LSB
else:
  const
    SDL_BYTEORDER* = SDL_BIG_ENDIAN # Native audio byte ordering
    AUDIO_U16SYS* = AUDIO_U16MSB
    AUDIO_S16SYS* = AUDIO_S16MSB
const
  SDL_MIX_MAXVOLUME* = 128    # SDL_joystick.h constants
  MAX_JOYSTICKS* = 2          # only 2 are supported in the multimedia API
  MAX_AXES* = 6               # each joystick can have up to 6 axes
  MAX_BUTTONS* = 32           # and 32 buttons
  AXIS_MIN* = - 32768         # minimum value for axis coordinate
  AXIS_MAX* = 32767           # maximum value for axis coordinate
  JOY_AXIS_THRESHOLD* = (toFloat((AXIS_MAX) - (AXIS_MIN)) / 100.0) # 1% motion
  SDL_HAT_CENTERED* = 0x00000000
  SDL_HAT_UP* = 0x00000001
  SDL_HAT_RIGHT* = 0x00000002
  SDL_HAT_DOWN* = 0x00000004
  SDL_HAT_LEFT* = 0x00000008
  SDL_HAT_RIGHTUP* = SDL_HAT_RIGHT or SDL_HAT_UP
  SDL_HAT_RIGHTDOWN* = SDL_HAT_RIGHT or SDL_HAT_DOWN
  SDL_HAT_LEFTUP* = SDL_HAT_LEFT or SDL_HAT_UP
  SDL_HAT_LEFTDOWN* = SDL_HAT_LEFT or SDL_HAT_DOWN # SDL_events.h constants

type
  TSDL_EventKind* = enum        # kind of an SDL event
    SDL_NOEVENT = 0,            # Unused (do not remove)
    SDL_ACTIVEEVENT = 1,        # Application loses/gains visibility
    SDL_KEYDOWN = 2,            # Keys pressed
    SDL_KEYUP = 3,              # Keys released
    SDL_MOUSEMOTION = 4,        # Mouse moved
    SDL_MOUSEBUTTONDOWN = 5,    # Mouse button pressed
    SDL_MOUSEBUTTONUP = 6,      # Mouse button released
    SDL_JOYAXISMOTION = 7,      # Joystick axis motion
    SDL_JOYBALLMOTION = 8,      # Joystick trackball motion
    SDL_JOYHATMOTION = 9,       # Joystick hat position change
    SDL_JOYBUTTONDOWN = 10,     # Joystick button pressed
    SDL_JOYBUTTONUP = 11,       # Joystick button released
    SDL_QUITEV = 12,            # User-requested quit ( Changed due to procedure conflict )
    SDL_SYSWMEVENT = 13,        # System specific event
    SDL_EVENT_RESERVEDA = 14,   # Reserved for future use..
    SDL_EVENT_RESERVED = 15,    # Reserved for future use..
    SDL_VIDEORESIZE = 16,       # User resized video mode
    SDL_VIDEOEXPOSE = 17,       # Screen needs to be redrawn
    SDL_EVENT_RESERVED2 = 18,   # Reserved for future use..
    SDL_EVENT_RESERVED3 = 19,   # Reserved for future use..
    SDL_EVENT_RESERVED4 = 20,   # Reserved for future use..
    SDL_EVENT_RESERVED5 = 21,   # Reserved for future use..
    SDL_EVENT_RESERVED6 = 22,   # Reserved for future use..
    SDL_EVENT_RESERVED7 = 23,   # Reserved for future use..
                                # Events SDL_USEREVENT through SDL_MAXEVENTS-1 are for your use
    SDL_USEREVENT = 24 # This last event is only for bounding internal arrays
                       # It is the number of bits in the event mask datatype -- UInt32

const
  SDL_NUMEVENTS* = 32
  SDL_ALLEVENTS* = 0xFFFFFFFF
  SDL_ACTIVEEVENTMASK* = 1 shl ord(SDL_ACTIVEEVENT)
  SDL_KEYDOWNMASK* = 1 shl ord(SDL_KEYDOWN)
  SDL_KEYUPMASK* = 1 shl ord(SDL_KEYUP)
  SDL_MOUSEMOTIONMASK* = 1 shl ord(SDL_MOUSEMOTION)
  SDL_MOUSEBUTTONDOWNMASK* = 1 shl ord(SDL_MOUSEBUTTONDOWN)
  SDL_MOUSEBUTTONUPMASK* = 1 shl ord(SDL_MOUSEBUTTONUP)
  SDL_MOUSEEVENTMASK* = 1 shl ord(SDL_MOUSEMOTION) or 1 shl ord(SDL_MOUSEBUTTONDOWN) or
      1 shl ord(SDL_MOUSEBUTTONUP)
  SDL_JOYAXISMOTIONMASK* = 1 shl ord(SDL_JOYAXISMOTION)
  SDL_JOYBALLMOTIONMASK* = 1 shl ord(SDL_JOYBALLMOTION)
  SDL_JOYHATMOTIONMASK* = 1 shl ord(SDL_JOYHATMOTION)
  SDL_JOYBUTTONDOWNMASK* = 1 shl ord(SDL_JOYBUTTONDOWN)
  SDL_JOYBUTTONUPMASK* = 1 shl ord(SDL_JOYBUTTONUP)
  SDL_JOYEVENTMASK* = 1 shl ord(SDL_JOYAXISMOTION) or 1 shl ord(SDL_JOYBALLMOTION) or
      1 shl ord(SDL_JOYHATMOTION) or 1 shl ord(SDL_JOYBUTTONDOWN) or
      1 shl ord(SDL_JOYBUTTONUP)
  SDL_VIDEORESIZEMASK* = 1 shl ord(SDL_VIDEORESIZE)
  SDL_QUITMASK* = 1 shl ord(SDL_QUITEV)
  SDL_SYSWMEVENTMASK* = 1 shl ord(SDL_SYSWMEVENT)
  SDL_QUERY* = - 1
  SDL_IGNORE* = 0
  SDL_DISABLE* = 0
  SDL_ENABLE* = 1             #SDL_keyboard.h constants
                              # This is the mask which refers to all hotkey bindings
  SDL_ALL_HOTKEYS* = 0xFFFFFFFF # Enable/Disable keyboard repeat.  Keyboard repeat defaults to off.
                                #  'delay' is the initial delay in ms between the time when a key is
                                #  pressed, and keyboard repeat begins.
                                #  'interval' is the time in ms between keyboard repeat events.
  SDL_DEFAULT_REPEAT_DELAY* = 500
  SDL_DEFAULT_REPEAT_INTERVAL* = 30 # The keyboard syms have been cleverly chosen to map to ASCII
  SDLK_UNKNOWN* = 0
  SDLK_FIRST* = 0
  SDLK_BACKSPACE* = 8
  SDLK_TAB* = 9
  SDLK_CLEAR* = 12
  SDLK_RETURN* = 13
  SDLK_PAUSE* = 19
  SDLK_ESCAPE* = 27
  SDLK_SPACE* = 32
  SDLK_EXCLAIM* = 33
  SDLK_QUOTEDBL* = 34
  SDLK_HASH* = 35
  SDLK_DOLLAR* = 36
  SDLK_AMPERSAND* = 38
  SDLK_QUOTE* = 39
  SDLK_LEFTPAREN* = 40
  SDLK_RIGHTPAREN* = 41
  SDLK_ASTERISK* = 42
  SDLK_PLUS* = 43
  SDLK_COMMA* = 44
  SDLK_MINUS* = 45
  SDLK_PERIOD* = 46
  SDLK_SLASH* = 47
  SDLK_0* = 48
  SDLK_1* = 49
  SDLK_2* = 50
  SDLK_3* = 51
  SDLK_4* = 52
  SDLK_5* = 53
  SDLK_6* = 54
  SDLK_7* = 55
  SDLK_8* = 56
  SDLK_9* = 57
  SDLK_COLON* = 58
  SDLK_SEMICOLON* = 59
  SDLK_LESS* = 60
  SDLK_EQUALS* = 61
  SDLK_GREATER* = 62
  SDLK_QUESTION* = 63
  SDLK_AT* = 64               # Skip uppercase letters
  SDLK_LEFTBRACKET* = 91
  SDLK_BACKSLASH* = 92
  SDLK_RIGHTBRACKET* = 93
  SDLK_CARET* = 94
  SDLK_UNDERSCORE* = 95
  SDLK_BACKQUOTE* = 96
  SDLK_a* = 97
  SDLK_b* = 98
  SDLK_c* = 99
  SDLK_d* = 100
  SDLK_e* = 101
  SDLK_f* = 102
  SDLK_g* = 103
  SDLK_h* = 104
  SDLK_i* = 105
  SDLK_j* = 106
  SDLK_k* = 107
  SDLK_l* = 108
  SDLK_m* = 109
  SDLK_n* = 110
  SDLK_o* = 111
  SDLK_p* = 112
  SDLK_q* = 113
  SDLK_r* = 114
  SDLK_s* = 115
  SDLK_t* = 116
  SDLK_u* = 117
  SDLK_v* = 118
  SDLK_w* = 119
  SDLK_x* = 120
  SDLK_y* = 121
  SDLK_z* = 122
  SDLK_DELETE* = 127          # End of ASCII mapped keysyms
                              # International keyboard syms
  SDLK_WORLD_0* = 160         # 0xA0
  SDLK_WORLD_1* = 161
  SDLK_WORLD_2* = 162
  SDLK_WORLD_3* = 163
  SDLK_WORLD_4* = 164
  SDLK_WORLD_5* = 165
  SDLK_WORLD_6* = 166
  SDLK_WORLD_7* = 167
  SDLK_WORLD_8* = 168
  SDLK_WORLD_9* = 169
  SDLK_WORLD_10* = 170
  SDLK_WORLD_11* = 171
  SDLK_WORLD_12* = 172
  SDLK_WORLD_13* = 173
  SDLK_WORLD_14* = 174
  SDLK_WORLD_15* = 175
  SDLK_WORLD_16* = 176
  SDLK_WORLD_17* = 177
  SDLK_WORLD_18* = 178
  SDLK_WORLD_19* = 179
  SDLK_WORLD_20* = 180
  SDLK_WORLD_21* = 181
  SDLK_WORLD_22* = 182
  SDLK_WORLD_23* = 183
  SDLK_WORLD_24* = 184
  SDLK_WORLD_25* = 185
  SDLK_WORLD_26* = 186
  SDLK_WORLD_27* = 187
  SDLK_WORLD_28* = 188
  SDLK_WORLD_29* = 189
  SDLK_WORLD_30* = 190
  SDLK_WORLD_31* = 191
  SDLK_WORLD_32* = 192
  SDLK_WORLD_33* = 193
  SDLK_WORLD_34* = 194
  SDLK_WORLD_35* = 195
  SDLK_WORLD_36* = 196
  SDLK_WORLD_37* = 197
  SDLK_WORLD_38* = 198
  SDLK_WORLD_39* = 199
  SDLK_WORLD_40* = 200
  SDLK_WORLD_41* = 201
  SDLK_WORLD_42* = 202
  SDLK_WORLD_43* = 203
  SDLK_WORLD_44* = 204
  SDLK_WORLD_45* = 205
  SDLK_WORLD_46* = 206
  SDLK_WORLD_47* = 207
  SDLK_WORLD_48* = 208
  SDLK_WORLD_49* = 209
  SDLK_WORLD_50* = 210
  SDLK_WORLD_51* = 211
  SDLK_WORLD_52* = 212
  SDLK_WORLD_53* = 213
  SDLK_WORLD_54* = 214
  SDLK_WORLD_55* = 215
  SDLK_WORLD_56* = 216
  SDLK_WORLD_57* = 217
  SDLK_WORLD_58* = 218
  SDLK_WORLD_59* = 219
  SDLK_WORLD_60* = 220
  SDLK_WORLD_61* = 221
  SDLK_WORLD_62* = 222
  SDLK_WORLD_63* = 223
  SDLK_WORLD_64* = 224
  SDLK_WORLD_65* = 225
  SDLK_WORLD_66* = 226
  SDLK_WORLD_67* = 227
  SDLK_WORLD_68* = 228
  SDLK_WORLD_69* = 229
  SDLK_WORLD_70* = 230
  SDLK_WORLD_71* = 231
  SDLK_WORLD_72* = 232
  SDLK_WORLD_73* = 233
  SDLK_WORLD_74* = 234
  SDLK_WORLD_75* = 235
  SDLK_WORLD_76* = 236
  SDLK_WORLD_77* = 237
  SDLK_WORLD_78* = 238
  SDLK_WORLD_79* = 239
  SDLK_WORLD_80* = 240
  SDLK_WORLD_81* = 241
  SDLK_WORLD_82* = 242
  SDLK_WORLD_83* = 243
  SDLK_WORLD_84* = 244
  SDLK_WORLD_85* = 245
  SDLK_WORLD_86* = 246
  SDLK_WORLD_87* = 247
  SDLK_WORLD_88* = 248
  SDLK_WORLD_89* = 249
  SDLK_WORLD_90* = 250
  SDLK_WORLD_91* = 251
  SDLK_WORLD_92* = 252
  SDLK_WORLD_93* = 253
  SDLK_WORLD_94* = 254
  SDLK_WORLD_95* = 255        # 0xFF
                              # Numeric keypad
  SDLK_KP0* = 256
  SDLK_KP1* = 257
  SDLK_KP2* = 258
  SDLK_KP3* = 259
  SDLK_KP4* = 260
  SDLK_KP5* = 261
  SDLK_KP6* = 262
  SDLK_KP7* = 263
  SDLK_KP8* = 264
  SDLK_KP9* = 265
  SDLK_KP_PERIOD* = 266
  SDLK_KP_DIVIDE* = 267
  SDLK_KP_MULTIPLY* = 268
  SDLK_KP_MINUS* = 269
  SDLK_KP_PLUS* = 270
  SDLK_KP_ENTER* = 271
  SDLK_KP_EQUALS* = 272       # Arrows + Home/End pad
  SDLK_UP* = 273
  SDLK_DOWN* = 274
  SDLK_RIGHT* = 275
  SDLK_LEFT* = 276
  SDLK_INSERT* = 277
  SDLK_HOME* = 278
  SDLK_END* = 279
  SDLK_PAGEUP* = 280
  SDLK_PAGEDOWN* = 281        # Function keys
  SDLK_F1* = 282
  SDLK_F2* = 283
  SDLK_F3* = 284
  SDLK_F4* = 285
  SDLK_F5* = 286
  SDLK_F6* = 287
  SDLK_F7* = 288
  SDLK_F8* = 289
  SDLK_F9* = 290
  SDLK_F10* = 291
  SDLK_F11* = 292
  SDLK_F12* = 293
  SDLK_F13* = 294
  SDLK_F14* = 295
  SDLK_F15* = 296             # Key state modifier keys
  SDLK_NUMLOCK* = 300
  SDLK_CAPSLOCK* = 301
  SDLK_SCROLLOCK* = 302
  SDLK_RSHIFT* = 303
  SDLK_LSHIFT* = 304
  SDLK_RCTRL* = 305
  SDLK_LCTRL* = 306
  SDLK_RALT* = 307
  SDLK_LALT* = 308
  SDLK_RMETA* = 309
  SDLK_LMETA* = 310
  SDLK_LSUPER* = 311          # Left "Windows" key
  SDLK_RSUPER* = 312          # Right "Windows" key
  SDLK_MODE* = 313            # "Alt Gr" key
  SDLK_COMPOSE* = 314         # Multi-key compose key
                              # Miscellaneous function keys
  SDLK_HELP* = 315
  SDLK_PRINT* = 316
  SDLK_SYSREQ* = 317
  SDLK_BREAK* = 318
  SDLK_MENU* = 319
  SDLK_POWER* = 320           # Power Macintosh power key
  SDLK_EURO* = 321            # Some european keyboards
  SDLK_GP2X_UP* = 0
  SDLK_GP2X_UPLEFT* = 1
  SDLK_GP2X_LEFT* = 2
  SDLK_GP2X_DOWNLEFT* = 3
  SDLK_GP2X_DOWN* = 4
  SDLK_GP2X_DOWNRIGHT* = 5
  SDLK_GP2X_RIGHT* = 6
  SDLK_GP2X_UPRIGHT* = 7
  SDLK_GP2X_START* = 8
  SDLK_GP2X_SELECT* = 9
  SDLK_GP2X_L* = 10
  SDLK_GP2X_R* = 11
  SDLK_GP2X_A* = 12
  SDLK_GP2X_B* = 13
  SDLK_GP2X_Y* = 14
  SDLK_GP2X_X* = 15
  SDLK_GP2X_VOLUP* = 16
  SDLK_GP2X_VOLDOWN* = 17
  SDLK_GP2X_CLICK* = 18

const                         # Enumeration of valid key mods (possibly OR'd together)
  KMOD_NONE* = 0x00000000
  KMOD_LSHIFT* = 0x00000001
  KMOD_RSHIFT* = 0x00000002
  KMOD_LCTRL* = 0x00000040
  KMOD_RCTRL* = 0x00000080
  KMOD_LALT* = 0x00000100
  KMOD_RALT* = 0x00000200
  KMOD_LMETA* = 0x00000400
  KMOD_RMETA* = 0x00000800
  KMOD_NUM* = 0x00001000
  KMOD_CAPS* = 0x00002000
  KMOD_MODE* = 44000
  KMOD_RESERVED* = 0x00008000
  KMOD_CTRL* = (KMOD_LCTRL or KMOD_RCTRL)
  KMOD_SHIFT* = (KMOD_LSHIFT or KMOD_RSHIFT)
  KMOD_ALT* = (KMOD_LALT or KMOD_RALT)
  KMOD_META* = (KMOD_LMETA or KMOD_RMETA) #SDL_video.h constants
                                          # Transparency definitions: These define alpha as the opacity of a surface */
  SDL_ALPHA_OPAQUE* = 255
  SDL_ALPHA_TRANSPARENT* = 0 # These are the currently supported flags for the SDL_surface
                             # Available for SDL_CreateRGBSurface() or SDL_SetVideoMode()
  SDL_SWSURFACE* = 0x00000000 # Surface is in system memory
  SDL_HWSURFACE* = 0x00000001 # Surface is in video memory
  SDL_ASYNCBLIT* = 0x00000004 # Use asynchronous blits if possible
                              # Available for SDL_SetVideoMode()
  SDL_ANYFORMAT* = 0x10000000 # Allow any video depth/pixel-format
  SDL_HWPALETTE* = 0x20000000 # Surface has exclusive palette
  SDL_DOUBLEBUF* = 0x40000000 # Set up double-buffered video mode
  SDL_FULLSCREEN* = 0x80000000 # Surface is a full screen display
  SDL_OPENGL* = 0x00000002    # Create an OpenGL rendering context
  SDL_OPENGLBLIT* = 0x00000002 # Create an OpenGL rendering context
  SDL_RESIZABLE* = 0x00000010 # This video mode may be resized
  SDL_NOFRAME* = 0x00000020   # No window caption or edge frame
                              # Used internally (read-only)
  SDL_HWACCEL* = 0x00000100   # Blit uses hardware acceleration
  SDL_SRCCOLORKEY* = 0x00001000 # Blit uses a source color key
  SDL_RLEACCELOK* = 0x00002000 # Private flag
  SDL_RLEACCEL* = 0x00004000  # Colorkey blit is RLE accelerated
  SDL_SRCALPHA* = 0x00010000  # Blit uses source alpha blending
  SDL_SRCCLIPPING* = 0x00100000 # Blit uses source clipping
  SDL_PREALLOC* = 0x01000000 # Surface uses preallocated memory
                             # The most common video overlay formats.
                             #    For an explanation of these pixel formats, see:
                             #    http://www.webartz.com/fourcc/indexyuv.htm
                             #
                             #   For information on the relationship between color spaces, see:
                             #
                             #   http://www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html
  SDL_YV12_OVERLAY* = 0x32315659 # Planar mode: Y + V + U  (3 planes)
  SDL_IYUV_OVERLAY* = 0x56555949 # Planar mode: Y + U + V  (3 planes)
  SDL_YUY2_OVERLAY* = 0x32595559 # Packed mode: Y0+U0+Y1+V0 (1 plane)
  SDL_UYVY_OVERLAY* = 0x59565955 # Packed mode: U0+Y0+V0+Y1 (1 plane)
  SDL_YVYU_OVERLAY* = 0x55595659 # Packed mode: Y0+V0+Y1+U0 (1 plane)
                                 # flags for SDL_SetPalette()
  SDL_LOGPAL* = 0x00000001
  SDL_PHYSPAL* = 0x00000002 #SDL_mouse.h constants
                            # Used as a mask when testing buttons in buttonstate
                            #    Button 1:	Left mouse button
                            #    Button 2:	Middle mouse button
                            #    Button 3:	Right mouse button
                            #    Button 4:	Mouse Wheel Up
                            #    Button 5:	Mouse Wheel Down
                            #
  SDL_BUTTON_LEFT* = 1
  SDL_BUTTON_MIDDLE* = 2
  SDL_BUTTON_RIGHT* = 3
  SDL_BUTTON_WHEELUP* = 4
  SDL_BUTTON_WHEELDOWN* = 5
  SDL_BUTTON_LMASK* = SDL_PRESSED shl (SDL_BUTTON_LEFT - 1)
  SDL_BUTTON_MMASK* = SDL_PRESSED shl (SDL_BUTTON_MIDDLE - 1)
  SDL_BUTTON_RMask* = SDL_PRESSED shl (SDL_BUTTON_RIGHT - 1) # SDL_active.h constants
                                                             # The available application states
  SDL_APPMOUSEFOCUS* = 0x00000001 # The app has mouse coverage
  SDL_APPINPUTFOCUS* = 0x00000002 # The app has input focus
  SDL_APPACTIVE* = 0x00000004 # The application is active
                              # SDL_mutex.h constants
                              # Synchronization functions which can time out return this value
                              #  they time out.
  SDL_MUTEX_TIMEDOUT* = 1     # This is the timeout value which corresponds to never time out
  SDL_MUTEX_MAXWAIT* = not int(0)
  SDL_GRAB_QUERY* = - 1
  SDL_GRAB_OFF* = 0
  SDL_GRAB_ON* = 1            #SDL_GRAB_FULLSCREEN // Used internally

type
  THandle* = int              #SDL_types.h types
                              # Basic data types
  TSDL_Bool* = enum
    SDL_FALSE, SDL_TRUE
  PUInt8Array* = ptr TUInt8Array
  PUInt8* = ptr UInt8
  PPUInt8* = ptr PUInt8
  UInt8* = int8
  TUInt8Array* = array[0..high(int) shr 1, UInt8]
  PUInt16* = ptr UInt16
  UInt16* = int16
  PSInt8* = ptr SInt8
  SInt8* = int8
  PSInt16* = ptr SInt16
  SInt16* = int16
  PUInt32* = ptr UInt32
  UInt32* = int
  SInt32* = int
  PInt* = ptr int
  PShortInt* = ptr int8
  PUInt64* = ptr UInt64
  UInt64*{.final.} = object
    hi*: UInt32
    lo*: UInt32

  PSInt64* = ptr SInt64
  SInt64*{.final.} = object
    hi*: UInt32
    lo*: UInt32

  TSDL_GrabMode* = int        # SDL_error.h types
  TSDL_errorcode* = enum
    SDL_ENOMEM, SDL_EFREAD, SDL_EFWRITE, SDL_EFSEEK, SDL_LASTERROR
  SDL_errorcode* = TSDL_errorcode
  TArg*{.final.} = object
    buf*: array[0..ERR_MAX_STRLEN - 1, int8]

  PSDL_error* = ptr TSDL_error
  TSDL_error*{.final.} = object  # This is a numeric value corresponding to the current error
                                 # SDL_rwops.h types
                                 # This is the read/write operation structure -- very basic
                                 # some helper types to handle the unions
                                 # "packed" is only guessed
    error*: int # This is a key used to index into a language hashtable containing
                #       internationalized versions of the SDL error messages.  If the key
                #       is not in the hashtable, or no hashtable is available, the key is
                #       used directly as an error message format string.
    key*: array[0..ERR_MAX_STRLEN - 1, int8] # These are the arguments for the error functions
    argc*: int
    args*: array[0..ERR_MAX_ARGS - 1, TArg]

  TStdio*{.final.} = object
    autoclose*: int           # FILE * is only defined in Kylix so we use a simple Pointer
    fp*: Pointer

  TMem*{.final.} = object
    base*: PUInt8
    here*: PUInt8
    stop*: PUInt8

  TUnknown*{.final.} = object  # first declare the pointer type
    data1*: Pointer

  PSDL_RWops* = ptr TSDL_RWops # now the pointer to function types
  TSeek* = proc (context: PSDL_RWops, offset: int, whence: int): int{.cdecl.}
  TRead* = proc (context: PSDL_RWops, thePtr: Pointer, size: int, maxnum: int): int{.
      cdecl.}
  TWrite* = proc (context: PSDL_RWops, thePtr: Pointer, size: int, num: int): int{.
      cdecl.}
  TClose* = proc (context: PSDL_RWops): int{.cdecl.} # the variant record itself
  trange010 = range[0..2]
  TSDL_RWops*{.final.} = object
    seek*: TSeek
    read*: TRead
    write*: TWrite
    closeFile*: TClose        # a keyword as name is not allowed
                              # be warned! structure alignment may arise at this point
    case theType*: trange010
    of trange010(0):
      stdio*: TStdio
    of trange010(1):
      mem*: TMem
    of trange010(2):
      unknown*: TUnknown


  SDL_RWops* = TSDL_RWops     # SDL_timer.h types
                              # Function prototype for the timer callback function
  TSDL_TimerCallback* = proc (interval: UInt32): UInt32{.cdecl.} # New timer API, supports multiple timers
                                                                 #   Written by Stephane Peter
                                                                 #   <megastep@lokigames.com>
                                                                 # Function prototype for the new timer callback function.
                                                                 #   The callback function is passed the current timer interval and returns
                                                                 #   the next timer interval.  If the returned value is the same as the one
                                                                 #   passed in, the periodic alarm continues, otherwise a new alarm is
                                                                 #   scheduled.  If the callback returns 0, the periodic alarm is cancelled.
  TSDL_NewTimerCallback* = proc (interval: UInt32, param: Pointer): UInt32{.
      cdecl.}                 # Definition of the timer ID type
  PSDL_TimerID* = ptr TSDL_TimerID
  TSDL_TimerID*{.final.} = object
    interval*: UInt32
    callback*: TSDL_NewTimerCallback
    param*: Pointer
    last_alarm*: UInt32
    next*: PSDL_TimerID

  TSDL_AudioSpecCallback* = proc (userdata: Pointer, stream: PUInt8, length: int){.
      cdecl.}                 # SDL_audio.h types
                              # The calculated values in this structure are calculated by SDL_OpenAudio()
  PSDL_AudioSpec* = ptr TSDL_AudioSpec
  TSDL_AudioSpec*{.final.} = object  # A structure to hold a set of audio conversion filters and buffers
    freq*: int                # DSP frequency -- samples per second
    format*: UInt16           # Audio data format
    channels*: UInt8          # Number of channels: 1 mono, 2 stereo
    silence*: UInt8           # Audio buffer silence value (calculated)
    samples*: UInt16          # Audio buffer size in samples
    padding*: UInt16          # Necessary for some compile environments
    size*: UInt32 # Audio buffer size in bytes (calculated)
                  # This function is called when the audio device needs more data.
                  #      'stream' is a pointer to the audio data buffer
                  #      'len' is the length of that buffer in bytes.
                  #      Once the callback returns, the buffer will no longer be valid.
                  #      Stereo samples are stored in a LRLRLR ordering.
    callback*: TSDL_AudioSpecCallback
    userdata*: Pointer

  PSDL_AudioCVT* = ptr TSDL_AudioCVT
  PSDL_AudioCVTFilter* = ptr TSDL_AudioCVTFilter
  TSDL_AudioCVTFilter*{.final.} = object
    cvt*: PSDL_AudioCVT
    format*: UInt16

  PSDL_AudioCVTFilterArray* = ptr TSDL_AudioCVTFilterArray
  TSDL_AudioCVTFilterArray* = array[0..9, PSDL_AudioCVTFilter]
  TSDL_AudioCVT*{.final.} = object
    needed*: int              # Set to 1 if conversion possible
    src_format*: UInt16       # Source audio format
    dst_format*: UInt16       # Target audio format
    rate_incr*: float64       # Rate conversion increment
    buf*: PUInt8              # Buffer to hold entire audio data
    length*: int              # Length of original audio buffer
    len_cvt*: int             # Length of converted audio buffer
    len_mult*: int            # buffer must be len*len_mult big
    len_ratio*: float64       # Given len, final size is len*len_ratio
    filters*: TSDL_AudioCVTFilterArray
    filter_index*: int        # Current audio conversion function

  TSDL_Audiostatus* = enum    # SDL_cdrom.h types
    SDL_AUDIO_STOPPED, SDL_AUDIO_PLAYING, SDL_AUDIO_PAUSED
  TSDL_CDStatus* = enum
    CD_ERROR, CD_TRAYEMPTY, CD_STOPPED, CD_PLAYING, CD_PAUSED
  PSDL_CDTrack* = ptr TSDL_CDTrack
  TSDL_CDTrack*{.final.} = object  # This structure is only current as of the last call to SDL_CDStatus()
    id*: UInt8                # Track number
    theType*: UInt8           # Data or audio track
    unused*: UInt16
    len*: UInt32              # Length, in frames, of this track
    offset*: UInt32           # Offset, in frames, from start of disk

  PSDL_CD* = ptr TSDL_CD
  TSDL_CD*{.final.} = object  #SDL_joystick.h types
    id*: int                  # Private drive identifier
    status*: TSDL_CDStatus    # Current drive status
                              # The rest of this structure is only valid if there's a CD in drive
    numtracks*: int           # Number of tracks on disk
    cur_track*: int           # Current track position
    cur_frame*: int           # Current frame offset within current track
    track*: array[0..SDL_MAX_TRACKS, TSDL_CDTrack]

  PTransAxis* = ptr TTransAxis
  TTransAxis*{.final.} = object  # The private structure used to keep track of a joystick
    offset*: int
    scale*: float32

  PJoystick_hwdata* = ptr TJoystick_hwdata
  TJoystick_hwdata*{.final.} = object  # joystick ID
    id*: int                  # values used to translate device-specific coordinates into  SDL-standard ranges
    transaxis*: array[0..5, TTransAxis]

  PBallDelta* = ptr TBallDelta
  TBallDelta*{.final.} = object  # Current ball motion deltas
                                 # The SDL joystick structure
    dx*: int
    dy*: int

  PSDL_Joystick* = ptr TSDL_Joystick
  TSDL_Joystick*{.final.} = object  # SDL_verion.h types
    index*: UInt8             # Device index
    name*: cstring            # Joystick name - system dependent
    naxes*: int               # Number of axis controls on the joystick
    axes*: PUInt16            # Current axis states
    nhats*: int               # Number of hats on the joystick
    hats*: PUInt8             # Current hat states
    nballs*: int              # Number of trackballs on the joystick
    balls*: PBallDelta        # Current ball motion deltas
    nbuttons*: int            # Number of buttons on the joystick
    buttons*: PUInt8          # Current button states
    hwdata*: PJoystick_hwdata # Driver dependent information
    ref_count*: int           # Reference count for multiple opens

  PSDL_version* = ptr TSDL_version
  TSDL_version*{.final.} = object  # SDL_keyboard.h types
    major*: UInt8
    minor*: UInt8
    patch*: UInt8

  TSDLKey* = int32
  TSDLMod* = int32
  PSDL_KeySym* = ptr TSDL_KeySym
  TSDL_KeySym*{.final.} = object  # SDL_events.h types
                                  #Checks the event queue for messages and optionally returns them.
                                  #   If 'action' is SDL_ADDEVENT, up to 'numevents' events will be added to
                                  #   the back of the event queue.
                                  #   If 'action' is SDL_PEEKEVENT, up to 'numevents' events at the front
                                  #   of the event queue, matching 'mask', will be returned and will not
                                  #   be removed from the queue.
                                  #   If 'action' is SDL_GETEVENT, up to 'numevents' events at the front
                                  #   of the event queue, matching 'mask', will be returned and will be
                                  #   removed from the queue.
                                  #   This function returns the number of events actually stored, or -1
                                  #   if there was an error.  This function is thread-safe.
    scancode*: UInt8          # hardware specific scancode
    sym*: TSDLKey             # SDL virtual keysym
    modifier*: TSDLMod        # current key modifiers
    unicode*: UInt16          # translated character

  TSDL_EventAction* = enum    # Application visibility event structure
    SDL_ADDEVENT, SDL_PEEKEVENT, SDL_GETEVENT
  TSDL_ActiveEvent*{.final.} = object  # SDL_ACTIVEEVENT
                                       # Keyboard event structure
    gain*: UInt8              # Whether given states were gained or lost (1/0)
    state*: UInt8             # A mask of the focus states

  TSDL_KeyboardEvent*{.final.} = object  # SDL_KEYDOWN or SDL_KEYUP
                                         # Mouse motion event structure
    which*: UInt8             # The keyboard device index
    state*: UInt8             # SDL_PRESSED or SDL_RELEASED
    keysym*: TSDL_KeySym

  TSDL_MouseMotionEvent*{.final.} = object  # SDL_MOUSEMOTION
                                            # Mouse button event structure
    which*: UInt8             # The mouse device index
    state*: UInt8             # The current button state
    x*, y*: UInt16            # The X/Y coordinates of the mouse
    xrel*: SInt16             # The relative motion in the X direction
    yrel*: SInt16             # The relative motion in the Y direction

  TSDL_MouseButtonEvent*{.final.} = object  # SDL_MOUSEBUTTONDOWN or SDL_MOUSEBUTTONUP
                                            # Joystick axis motion event structure
    which*: UInt8             # The mouse device index
    button*: UInt8            # The mouse button index
    state*: UInt8             # SDL_PRESSED or SDL_RELEASED
    x*: UInt16                # The X coordinates of the mouse at press time
    y*: UInt16                # The Y coordinates of the mouse at press time

  TSDL_JoyAxisEvent*{.final.} = object  # SDL_JOYAXISMOTION
                                        # Joystick trackball motion event structure
    which*: UInt8             # The joystick device index
    axis*: UInt8              # The joystick axis index
    value*: SInt16            # The axis value (range: -32768 to 32767)

  TSDL_JoyBallEvent*{.final.} = object  # SDL_JOYAVBALLMOTION
                                        # Joystick hat position change event structure
    which*: UInt8             # The joystick device index
    ball*: UInt8              # The joystick trackball index
    xrel*: SInt16             # The relative motion in the X direction
    yrel*: SInt16             # The relative motion in the Y direction

  TSDL_JoyHatEvent*{.final.} = object  # SDL_JOYHATMOTION */
                                       # Joystick button event structure
    which*: UInt8             # The joystick device index */
    hat*: UInt8               # The joystick hat index */
    value*: UInt8             # The hat position value:
                              #                    8   1   2
                              #                    7   0   3
                              #                    6   5   4
                              #                    Note that zero means the POV is centered.

  TSDL_JoyButtonEvent*{.final.} = object  # SDL_JOYBUTTONDOWN or SDL_JOYBUTTONUP
                                          # The "window resized" event
                                          #    When you get this event, you are responsible for setting a new video
                                          #    mode with the new width and height.
    which*: UInt8             # The joystick device index
    button*: UInt8            # The joystick button index
    state*: UInt8             # SDL_PRESSED or SDL_RELEASED

  TSDL_ResizeEvent*{.final.} = object  # SDL_VIDEORESIZE
                                       # A user-defined event type
    w*: int                   # New width
    h*: int                   # New height

  PSDL_UserEvent* = ptr TSDL_UserEvent
  TSDL_UserEvent*{.final.} = object  # SDL_USEREVENT through SDL_NUMEVENTS-1
    code*: int                # User defined event code */
    data1*: Pointer           # User defined data pointer */
    data2*: Pointer           # User defined data pointer */


when defined(Unix):
  type                        #These are the various supported subsystems under UNIX
    TSDL_SysWm* = enum
      SDL_SYSWM_X11
# The windows custom event structure

when defined(WINDOWS):
  type
    PSDL_SysWMmsg* = ptr TSDL_SysWMmsg
    TSDL_SysWMmsg*{.final.} = object
      version*: TSDL_version
      hwnd*: THandle          # The window for the message
      msg*: int               # The type of message
      w_Param*: int32         # WORD message parameter
      lParam*: int32          # LONG message parameter

elif defined(Unix):
  type                      # The Linux custom event structure
    PSDL_SysWMmsg* = ptr TSDL_SysWMmsg
    TSDL_SysWMmsg*{.final.} = object
      version*: TSDL_version
      subsystem*: TSDL_SysWm
      when false:
        event*: TXEvent
else:
  type                      # The generic custom event structure
    PSDL_SysWMmsg* = ptr TSDL_SysWMmsg
    TSDL_SysWMmsg*{.final.} = object
      version*: TSDL_version
      data*: int

# The Windows custom window manager information structure

when defined(WINDOWS):
  type
    PSDL_SysWMinfo* = ptr TSDL_SysWMinfo
    TSDL_SysWMinfo*{.final.} = object
      version*: TSDL_version
      window*: THandle        # The display window

elif defined(Unix):
  type
    TX11*{.final.} = object
      when false:
        display*: PDisplay # The X11 display
        window*: TWindow # The X11 display window
                         # These locking functions should be called around
                         # any X11 functions using the display variable.
                         # They lock the event thread, so should not be
                         # called around event functions or from event filters.
        lock_func*: Pointer
        unlock_func*: Pointer # Introduced in SDL 1.0.2
        fswindow*: TWindow    # The X11 fullscreen window
        wmwindow*: TWindow    # The X11 managed input window

  type
    PSDL_SysWMinfo* = ptr TSDL_SysWMinfo
    TSDL_SysWMinfo*{.final.} = object
      version*: TSDL_version
      subsystem*: TSDL_SysWm
      X11*: TX11
else:
  type  # The generic custom window manager information structure
    PSDL_SysWMinfo* = ptr TSDL_SysWMinfo
    TSDL_SysWMinfo*{.final.} = object
      version*: TSDL_version
      data*: int

type
  PSDL_SysWMEvent* = ptr TSDL_SysWMEvent
  TSDL_SysWMEvent*{.final.} = object
    msg*: PSDL_SysWMmsg

  PSDL_Event* = ptr TSDL_Event
  TSDL_Event*{.final.} = object  # This function sets up a filter to process all events before they
                                 #  change internal state and are posted to the internal event queue.
                                 #
                                 #  The filter is protypted as:
    case theType*: TSDL_EventKind      # SDL_NOEVENT, SDL_QUITEV: ();
    of SDL_ACTIVEEVENT:
      active*: TSDL_ActiveEvent
    of SDL_KEYDOWN, SDL_KEYUP:
      key*: TSDL_KeyboardEvent
    of SDL_MOUSEMOTION:
      motion*: TSDL_MouseMotionEvent
    of SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP:
      button*: TSDL_MouseButtonEvent
    of SDL_JOYAXISMOTION:
      jaxis*: TSDL_JoyAxisEvent
    of SDL_JOYBALLMOTION:
      jball*: TSDL_JoyBallEvent
    of SDL_JOYHATMOTION:
      jhat*: TSDL_JoyHatEvent
    of SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP:
      jbutton*: TSDL_JoyButtonEvent
    of SDL_VIDEORESIZE:
      resize*: TSDL_ResizeEvent
    of SDL_USEREVENT:
      user*: TSDL_UserEvent
    of SDL_SYSWMEVENT:
      syswm*: TSDL_SysWMEvent
    else:
      nil

  TSDL_EventFilter* = proc (event: PSDL_Event): int{.cdecl.} # SDL_video.h types
                                                             # Useful data types
  PPSDL_Rect* = ptr PSDL_Rect
  PSDL_Rect* = ptr TSDL_Rect
  TSDL_Rect*{.final.} = object
    x*, y*: SInt16
    w*, h*: UInt16

  SDL_Rect* = TSDL_Rect
  PSDL_Color* = ptr TSDL_Color
  TSDL_Color*{.final.} = object
    r*: UInt8
    g*: UInt8
    b*: UInt8
    unused*: UInt8

  PSDL_ColorArray* = ptr TSDL_ColorArray
  TSDL_ColorArray* = array[0..65000, TSDL_Color]
  PSDL_Palette* = ptr TSDL_Palette
  TSDL_Palette*{.final.} = object  # Everything in the pixel format structure is read-only
    ncolors*: int
    colors*: PSDL_ColorArray

  PSDL_PixelFormat* = ptr TSDL_PixelFormat
  TSDL_PixelFormat*{.final.} = object  # The structure passed to the low level blit functions
    palette*: PSDL_Palette
    BitsPerPixel*: UInt8
    BytesPerPixel*: UInt8
    Rloss*: UInt8
    Gloss*: UInt8
    Bloss*: UInt8
    Aloss*: UInt8
    Rshift*: UInt8
    Gshift*: UInt8
    Bshift*: UInt8
    Ashift*: UInt8
    RMask*: UInt32
    GMask*: UInt32
    BMask*: UInt32
    AMask*: UInt32
    colorkey*: UInt32         # RGB color key information
    alpha*: UInt8             # Alpha value information (per-surface alpha)

  PSDL_BlitInfo* = ptr TSDL_BlitInfo
  TSDL_BlitInfo*{.final.} = object  # typedef for private surface blitting functions
    s_pixels*: PUInt8
    s_width*: int
    s_height*: int
    s_skip*: int
    d_pixels*: PUInt8
    d_width*: int
    d_height*: int
    d_skip*: int
    aux_data*: Pointer
    src*: PSDL_PixelFormat
    table*: PUInt8
    dst*: PSDL_PixelFormat

  PSDL_Surface* = ptr TSDL_Surface
  TSDL_Blit* = proc (src: PSDL_Surface, srcrect: PSDL_Rect, dst: PSDL_Surface,
                     dstrect: PSDL_Rect): int{.cdecl.}
  TSDL_Surface*{.final.} = object  # Useful for determining the video hardware capabilities
    flags*: UInt32            # Read-only
    format*: PSDL_PixelFormat # Read-only
    w*, h*: int               # Read-only
    pitch*: UInt16            # Read-only
    pixels*: Pointer          # Read-write
    offset*: int              # Private
    hwdata*: Pointer          #TPrivate_hwdata;  Hardware-specific surface info
                              # clipping information:
    clip_rect*: TSDL_Rect     # Read-only
    unused1*: UInt32          # for binary compatibility
                              # Allow recursive locks
    locked*: UInt32           # Private
                              # info for fast blit mapping to other surfaces
    Blitmap*: Pointer         # PSDL_BlitMap; //   Private
                              # format version, bumped at every change to invalidate blit maps
    format_version*: int      # Private
    refcount*: int

  PSDL_VideoInfo* = ptr TSDL_VideoInfo
  TSDL_VideoInfo*{.final.} = object  # The YUV hardware video overlay
    hw_available*: UInt8 # Hardware and WindowManager flags in first 2 bits ( see below )
                         #hw_available: 1; // Can you create hardware surfaces
                         #    wm_available: 1; // Can you talk to a window manager?
                         #    UnusedBits1: 6;
    blit_hw*: UInt8 # Blit Hardware flags. See below for which bits do what
                    #UnusedBits2: 1;
                    #    blit_hw: 1; // Flag:UInt32  Accelerated blits HW --> HW
                    #    blit_hw_CC: 1; // Flag:UInt32  Accelerated blits with Colorkey
                    #    blit_hw_A: 1; // Flag:UInt32  Accelerated blits with Alpha
                    #    blit_sw: 1; // Flag:UInt32  Accelerated blits SW --> HW
                    #    blit_sw_CC: 1; // Flag:UInt32  Accelerated blits with Colorkey
                    #    blit_sw_A: 1; // Flag:UInt32  Accelerated blits with Alpha
                    #    blit_fill: 1; // Flag:UInt32  Accelerated color fill
    UnusedBits3*: UInt8       # Unused at this point
    video_mem*: UInt32        # The total amount of video memory (in K)
    vfmt*: PSDL_PixelFormat   # Value: The format of the video surface
    current_w*: SInt32        # Value: The current video mode width
    current_h*: SInt32        # Value: The current video mode height

  PSDL_Overlay* = ptr TSDL_Overlay
  TSDL_Overlay*{.final.} = object  # Public enumeration for setting the OpenGL window attributes.
    format*: UInt32           # Overlay format
    w*, h*: int               # Width and height of overlay
    planes*: int              # Number of planes in the overlay. Usually either 1 or 3
    pitches*: PUInt16         # An array of pitches, one for each plane. Pitch is the length of a row in bytes.
    pixels*: PPUInt8          # An array of pointers to the data of each plane. The overlay should be locked before these pointers are used.
    hw_overlay*: UInt32       # This will be set to 1 if the overlay is hardware accelerated.

  TSDL_GLAttr* = enum
    SDL_GL_RED_SIZE, SDL_GL_GREEN_SIZE, SDL_GL_BLUE_SIZE, SDL_GL_ALPHA_SIZE,
    SDL_GL_BUFFER_SIZE, SDL_GL_DOUBLEBUFFER, SDL_GL_DEPTH_SIZE,
    SDL_GL_STENCIL_SIZE, SDL_GL_ACCUM_RED_SIZE, SDL_GL_ACCUM_GREEN_SIZE,
    SDL_GL_ACCUM_BLUE_SIZE, SDL_GL_ACCUM_ALPHA_SIZE, SDL_GL_STEREO,
    SDL_GL_MULTISAMPLEBUFFERS, SDL_GL_MULTISAMPLESAMPLES,
    SDL_GL_ACCELERATED_VISUAL, SDL_GL_SWAP_CONTROL
  PSDL_Cursor* = ptr TSDL_Cursor
  TSDL_Cursor*{.final.} = object  # SDL_mutex.h types
    area*: TSDL_Rect          # The area of the mouse cursor
    hot_x*, hot_y*: SInt16    # The "tip" of the cursor
    data*: PUInt8             # B/W cursor data
    mask*: PUInt8             # B/W cursor mask
    save*: array[1..2, PUInt8] # Place to save cursor area
    wm_cursor*: Pointer       # Window-manager cursor


type
  PSDL_Mutex* = ptr TSDL_Mutex
  TSDL_Mutex*{.final.} = object
  PSDL_semaphore* = ptr TSDL_semaphore
  TSDL_semaphore*{.final.} = object
  PSDL_Sem* = ptr TSDL_Sem
  TSDL_Sem* = TSDL_Semaphore
  PSDL_Cond* = ptr TSDL_Cond
  TSDL_Cond*{.final.} = object  # SDL_thread.h types

when defined(WINDOWS):
  type
    TSYS_ThreadHandle* = THandle
when defined(Unix):
  type
    TSYS_ThreadHandle* = pointer
type                          # This is the system-independent thread info structure
  PSDL_Thread* = ptr TSDL_Thread
  TSDL_Thread*{.final.} = object  # Helper Types
                                  # Keyboard  State Array ( See demos for how to use )
    threadid*: UInt32
    handle*: TSYS_ThreadHandle
    status*: int
    errbuf*: TSDL_Error
    data*: Pointer

  PKeyStateArr* = ptr TKeyStateArr
  TKeyStateArr* = array[0..65000, UInt8] # Types required so we don't need to use Windows.pas
  PInteger* = ptr int
  PByte* = ptr int8
  PWord* = ptr int16
  PLongWord* = ptr int32      # General arrays
  PByteArray* = ptr TByteArray
  TByteArray* = array[0..32767, int8]
  PWordArray* = ptr TWordArray
  TWordArray* = array[0..16383, int16] # Generic procedure pointer
  TProcedure* = proc () #------------------------------------------------------------------------------
                        # initialization
                        #------------------------------------------------------------------------------
                        # This function loads the SDL dynamically linked library and initializes
                        #  the subsystems specified by 'flags' (and those satisfying dependencies)
                        #  Unless the SDL_INIT_NOPARACHUTE flag is set, it will install cleanup
                        #  signal handlers for some commonly ignored fatal signals (like SIGSEGV)

proc SDL_Init*(flags: UInt32): int{.cdecl, importc, dynlib: SDLLibName.}
  # This function initializes specific SDL subsystems
proc SDL_InitSubSystem*(flags: UInt32): int{.cdecl, importc, dynlib: SDLLibName.}
  # This function cleans up specific SDL subsystems
proc SDL_QuitSubSystem*(flags: UInt32){.cdecl, importc, dynlib: SDLLibName.}
  # This function returns mask of the specified subsystems which have
  #  been initialized.
  #  If 'flags' is 0, it returns a mask of all initialized subsystems.
proc SDL_WasInit*(flags: UInt32): UInt32{.cdecl, importc, dynlib: SDLLibName.}
  # This function cleans up all initialized subsystems and unloads the
  #  dynamically linked library.  You should call it upon all exit conditions.
proc SDL_Quit*(){.cdecl, importc, dynlib: SDLLibName.}
when defined(WINDOWS):
  # This should be called from your WinMain() function, if any
  proc SDL_RegisterApp*(name: cstring, style: UInt32, h_Inst: Pointer): int{.
      cdecl, importc, dynlib: SDLLibName.}
#------------------------------------------------------------------------------
# types
#------------------------------------------------------------------------------
# The number of elements in a table

proc SDL_TableSize*(table: cstring): int
  #------------------------------------------------------------------------------
  # error-handling
  #------------------------------------------------------------------------------
  # Public functions
proc SDL_GetError*(): cstring{.cdecl, importc, dynlib: SDLLibName.}
proc SDL_SetError*(fmt: cstring){.cdecl, importc, dynlib: SDLLibName.}
proc SDL_ClearError*(){.cdecl, importc, dynlib: SDLLibName.}
when not(defined(WINDOWS)):
  proc SDL_Error*(Code: TSDL_errorcode){.cdecl, importc, dynlib: SDLLibName.}
# Private error message function - used internally

proc SDL_OutOfMemory*()
  #------------------------------------------------------------------------------
  # io handling
  #------------------------------------------------------------------------------
  # Functions to create SDL_RWops structures from various data sources
proc SDL_RWFromFile*(filename, mode: cstring): PSDL_RWops{.cdecl,
    importc, dynlib: SDLLibName.}
proc SDL_FreeRW*(area: PSDL_RWops){.cdecl, importc, dynlib: SDLLibName.}
  #fp is FILE *fp ???
proc SDL_RWFromFP*(fp: Pointer, autoclose: int): PSDL_RWops{.cdecl,
    importc, dynlib: SDLLibName.}
proc SDL_RWFromMem*(mem: Pointer, size: int): PSDL_RWops{.cdecl,
    importc, dynlib: SDLLibName.}
proc SDL_RWFromConstMem*(mem: Pointer, size: int): PSDL_RWops{.cdecl,
    importc, dynlib: SDLLibName.}
proc SDL_AllocRW*(): PSDL_RWops{.cdecl, importc, dynlib: SDLLibName.}
proc SDL_RWSeek*(context: PSDL_RWops, offset: int, whence: int): int
proc SDL_RWTell*(context: PSDL_RWops): int
proc SDL_RWRead*(context: PSDL_RWops, theptr: Pointer, size: int, n: int): int
proc SDL_RWWrite*(context: PSDL_RWops, theptr: Pointer, size: int, n: int): int
proc SDL_RWClose*(context: PSDL_RWops): int
  #------------------------------------------------------------------------------
  # time-handling
  #------------------------------------------------------------------------------
  # Get the number of milliseconds since the SDL library initialization.
  # Note that this value wraps if the program runs for more than ~49 days.
proc SDL_GetTicks*(): UInt32{.cdecl, importc, dynlib: SDLLibName.}
  # Wait a specified number of milliseconds before returning
proc SDL_Delay*(msec: UInt32){.cdecl, importc, dynlib: SDLLibName.}
  # Add a new timer to the pool of timers already running.
  # Returns a timer ID, or NULL when an error occurs.
proc SDL_AddTimer*(interval: UInt32, callback: TSDL_NewTimerCallback,
                   param: Pointer): PSDL_TimerID{.cdecl, importc, dynlib: SDLLibName.}
  # Remove one of the multiple timers knowing its ID.
  # Returns a boolean value indicating success.
proc SDL_RemoveTimer*(t: PSDL_TimerID): TSDL_Bool{.cdecl, importc, dynlib: SDLLibName.}
proc SDL_SetTimer*(interval: UInt32, callback: TSDL_TimerCallback): int{.cdecl,
    importc, dynlib: SDLLibName.}
  #------------------------------------------------------------------------------
  # audio-routines
  #------------------------------------------------------------------------------
  # These functions are used internally, and should not be used unless you
  #  have a specific need to specify the audio driver you want to use.
  #  You should normally use SDL_Init() or SDL_InitSubSystem().
proc SDL_AudioInit*(driver_name: cstring): int{.cdecl, importc, dynlib: SDLLibName.}
proc SDL_AudioQuit*(){.cdecl, importc, dynlib: SDLLibName.}
  # This function fills the given character buffer with the name of the
  #  current audio driver, and returns a Pointer to it if the audio driver has
  #  been initialized.  It returns NULL if no driver has been initialized.
proc SDL_AudioDriverName*(namebuf: cstring, maxlen: int): cstring{.cdecl,
    importc, dynlib: SDLLibName.}
  # This function opens the audio device with the desired parameters, and
  #  returns 0 if successful, placing the actual hardware parameters in the
  #  structure pointed to by 'obtained'.  If 'obtained' is NULL, the audio
  #  data passed to the callback function will be guaranteed to be in the
  #  requested format, and will be automatically converted to the hardware
  #  audio format if necessary.  This function returns -1 if it failed
  #  to open the audio device, or couldn't set up the audio thread.
  #
  #  When filling in the desired audio spec structure,
  #   'desired->freq' should be the desired audio frequency in samples-per-second.
  #   'desired->format' should be the desired audio format.
  #   'desired->samples' is the desired size of the audio buffer, in samples.
  #      This number should be a power of two, and may be adjusted by the audio
  #      driver to a value more suitable for the hardware.  Good values seem to
  #      range between 512 and 8096 inclusive, depending on the application and
  #      CPU speed.  Smaller values yield faster response time, but can lead
  #      to underflow if the application is doing heavy processing and cannot
  #      fill the audio buffer in time.  A stereo sample consists of both right
  #      and left channels in LR ordering.
  #      Note that the number of samples is directly related to time by the
  #      following formula:  ms = (samples*1000)/freq
  #   'desired->size' is the size in bytes of the audio buffer, and is
  #      calculated by SDL_OpenAudio().
  #   'desired->silence' is the value used to set the buffer to silence,
  #      and is calculated by SDL_OpenAudio().
  #   'desired->callback' should be set to a function that will be called
  #      when the audio device is ready for more data.  It is passed a pointer
  #      to the audio buffer, and the length in bytes of the audio buffer.
  #      This function usually runs in a separate thread, and so you should
  #      protect data structures that it accesses by calling SDL_LockAudio()
  #      and SDL_UnlockAudio() in your code.
  #   'desired->userdata' is passed as the first parameter to your callback
  #      function.
  #
  #  The audio device starts out playing silence when it's opened, and should
  #  be enabled for playing by calling SDL_PauseAudio(0) when you are ready
  #  for your audio callback function to be called.  Since the audio driver
  #  may modify the requested size of the audio buffer, you should allocate
  #  any local mixing buffers after you open the audio device.
proc SDL_OpenAudio*(desired, obtained: PSDL_AudioSpec): int{.cdecl,
    importc, dynlib: SDLLibName.}
  # Get the current audio state:
proc SDL_GetAudioStatus*(): TSDL_Audiostatus{.cdecl, importc, dynlib: SDLLibName.}
  # This function pauses and unpauses the audio callback processing.
  #  It should be called with a parameter of 0 after opening the audio
  #  device to start playing sound.  This is so you can safely initialize
  #  data for your callback function after opening the audio device.
  #  Silence will be written to the audio device during the pause.
proc SDL_PauseAudio*(pause_on: int){.cdecl, importc, dynlib: SDLLibName.}
  # This function loads a WAVE from the data source, automatically freeing
  #  that source if 'freesrc' is non-zero.  For example, to load a WAVE file,
  #  you could do:
  #  SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...);
  #
  #  If this function succeeds, it returns the given SDL_AudioSpec,
  #  filled with the audio data format of the wave data, and sets
  #  'audio_buf' to a malloc()'d buffer containing the audio data,
  #  and sets 'audio_len' to the length of that audio buffer, in bytes.
  #  You need to free the audio buffer with SDL_FreeWAV() when you are
  #  done with it.
  #
  #  This function returns NULL and sets the SDL error message if the
  #  wave file cannot be opened, uses an unknown data format, or is
  #  corrupt.  Currently raw and MS-ADPCM WAVE files are supported.
proc SDL_LoadWAV_RW*(src: PSDL_RWops, freesrc: int, spec: PSDL_AudioSpec,
                     audio_buf: PUInt8, audiolen: PUInt32): PSDL_AudioSpec{.
    cdecl, importc, dynlib: SDLLibName.}
  # Compatibility convenience function -- loads a WAV from a file
proc SDL_LoadWAV*(filename: cstring, spec: PSDL_AudioSpec, audio_buf: PUInt8,
                  audiolen: PUInt32): PSDL_AudioSpec
  # This function frees data previously allocated with SDL_LoadWAV_RW()
proc SDL_FreeWAV*(audio_buf: PUInt8){.cdecl, importc, dynlib: SDLLibName.}
  # This function takes a source format and rate and a destination format
  #  and rate, and initializes the 'cvt' structure with information needed
  #  by SDL_ConvertAudio() to convert a buffer of audio data from one format
  #  to the other.
  #  This function returns 0, or -1 if there was an error.
proc SDL_BuildAudioCVT*(cvt: PSDL_AudioCVT, src_format: UInt16,
                        src_channels: UInt8, src_rate: int, dst_format: UInt16,
                        dst_channels: UInt8, dst_rate: int): int{.cdecl,
    importc, dynlib: SDLLibName.}
  # Once you have initialized the 'cvt' structure using SDL_BuildAudioCVT(),
  #  created an audio buffer cvt->buf, and filled it with cvt->len bytes of
  #  audio data in the source format, this function will convert it in-place
  #  to the desired format.
  #  The data conversion may expand the size of the audio data, so the buffer
  #  cvt->buf should be allocated after the cvt structure is initialized by
  #  SDL_BuildAudioCVT(), and should be cvt->len*cvt->len_mult bytes long.
proc SDL_ConvertAudio*(cvt: PSDL_AudioCVT): int{.cdecl, importc, dynlib: SDLLibName.}
  # This takes two audio buffers of the playing audio format and mixes
  #  them, performing addition, volume adjustment, and overflow clipping.
  #  The volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME
  #  for full audio volume.  Note this does not change hardware volume.
  #  This is provided for convenience -- you can mix your own audio data.
proc SDL_MixAudio*(dst, src: PUInt8, length: UInt32, volume: int){.cdecl,
    importc, dynlib: SDLLibName.}
  # The lock manipulated by these functions protects the callback function.
  #  During a LockAudio/UnlockAudio pair, you can be guaranteed that the
  #  callback function is not running.  Do not call these from the callback
  #  function or you will cause deadlock.
proc SDL_LockAudio*(){.cdecl, importc, dynlib: SDLLibName.}
proc SDL_UnlockAudio*(){.cdecl, importc, dynlib: SDLLibName.}
  # This function shuts down audio processing and closes the audio device.
proc SDL_CloseAudio*(){.cdecl, importc, dynlib: SDLLibName.}
  #------------------------------------------------------------------------------
  # CD-routines
  #------------------------------------------------------------------------------
  # Returns the number of CD-ROM drives on the system, or -1 if
  #  SDL_Init() has not been called with the SDL_INIT_CDROM flag.
proc SDL_CDNumDrives*(): int{.cdecl, importc, dynlib: SDLLibName.}
  # Returns a human-readable, system-dependent identifier for the CD-ROM.
  #   Example:
  #   "/dev/cdrom"
  #   "E:"
  #   "/dev/disk/ide/1/master"
proc SDL_CDName*(drive: int): cstring{.cdecl, importc, dynlib: SDLLibName.}
  # Opens a CD-ROM drive for access.  It returns a drive handle on success,
  #  or NULL if the drive was invalid or busy.  This newly opened CD-ROM
  #  becomes the default CD used when other CD functions are passed a NULL
  #  CD-ROM handle.
  #  Drives are numbered starting with 0.  Drive 0 is the system default CD-ROM.
proc SDL_CDOpen*(drive: int): PSDL_CD{.cdecl, importc, dynlib: SDLLibName.}
  # This function returns the current status of the given drive.
  #  If the drive has a CD in it, the table of contents of the CD and current
  #  play position of the CD will be stored in the SDL_CD structure.
proc SDL_CDStatus*(cdrom: PSDL_CD): TSDL_CDStatus{.cdecl, importc, dynlib: SDLLibName.}
  #  Play the given CD starting at 'start_track' and 'start_frame' for 'ntracks'
  #   tracks and 'nframes' frames.  If both 'ntrack' and 'nframe' are 0, play
  #   until the end of the CD.  This function will skip data tracks.
  #   This function should only be called after calling SDL_CDStatus() to
  #   get track information about the CD.
  #
  #   For example:
  #   // Play entire CD:
  #  if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) then
  #    SDL_CDPlayTracks(cdrom, 0, 0, 0, 0);
  #   // Play last track:
  #   if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) then
  #   begin
  #    SDL_CDPlayTracks(cdrom, cdrom->numtracks-1, 0, 0, 0);
  #   end;
  #
  #   // Play first and second track and 10 seconds of third track:
  #   if ( CD_INDRIVE(SDL_CDStatus(cdrom)) )
  #    SDL_CDPlayTracks(cdrom, 0, 0, 2, 10);
  #
  #   This function returns 0, or -1 if there was an error.
proc SDL_CDPlayTracks*(cdrom: PSDL_CD, start_track: int, start_frame: int,
                       ntracks: int, nframes: int): int{.cdecl,
    importc, dynlib: SDLLibName.}
  #  Play the given CD starting at 'start' frame for 'length' frames.
  #   It returns 0, or -1 if there was an error.
proc SDL_CDPlay*(cdrom: PSDL_CD, start: int, len: int): int{.cdecl,
    importc, dynlib: SDLLibName.}
  # Pause play -- returns 0, or -1 on error
proc SDL_CDPause*(cdrom: PSDL_CD): int{.cdecl, importc, dynlib: SDLLibName.}
  # Resume play -- returns 0, or -1 on error
proc SDL_CDResume*(cdrom: PSDL_CD): int{.cdecl, importc, dynlib: SDLLibName.}
  # Stop play -- returns 0, or -1 on error
proc SDL_CDStop*(cdrom: PSDL_CD): int{.cdecl, importc, dynlib: SDLLibName.}
  # Eject CD-ROM -- returns 0, or -1 on error
proc SDL_CDEject*(cdrom: PSDL_CD): int{.cdecl, importc, dynlib: SDLLibName.}
  # Closes the handle for the CD-ROM drive
proc SDL_CDClose*(cdrom: PSDL_CD){.cdecl, importc, dynlib: SDLLibName.}
  # Given a status, returns true if there's a disk in the drive
proc SDL_CDInDrive*(status: TSDL_CDStatus): bool
  # Conversion functions from frames to Minute/Second/Frames and vice versa
proc FRAMES_TO_MSF*(frames: int, M: var int, S: var int, F: var int)
proc MSF_TO_FRAMES*(M: int, S: int, F: int): int
  #------------------------------------------------------------------------------
  # JoyStick-routines
  #------------------------------------------------------------------------------
  # Count the number of joysticks attached to the system
proc SDL_NumJoysticks*(): int{.cdecl, importc, dynlib: SDLLibName.}
  # Get the implementation dependent name of a joystick.
  #  This can be called before any joysticks are opened.
  #  If no name can be found, this function returns NULL.
proc SDL_JoystickName*(index: int): cstring{.cdecl, importc, dynlib: SDLLibName.}
  # Open a joystick for use - the index passed as an argument refers to
  #  the N'th joystick on the system.  This index is the value which will
  #  identify this joystick in future joystick events.
  #
  #  This function returns a joystick identifier, or NULL if an error occurred.
proc SDL_JoystickOpen*(index: int): PSDL_Joystick{.cdecl, importc, dynlib: SDLLibName.}
  # Returns 1 if the joystick has been opened, or 0 if it has not.
proc SDL_JoystickOpened*(index: int): int{.cdecl, importc, dynlib: SDLLibName.}
  # Get the device index of an opened joystick.
proc SDL_JoystickIndex*(joystick: PSDL_Joystick): int{.cdecl, importc, dynlib: SDLLibName.}
  # Get the number of general axis controls on a joystick
proc SDL_JoystickNumAxes*(joystick: PSDL_Joystick): int{.cdecl,
    importc, dynlib: SDLLibName.}
  # Get the number of trackballs on a joystick
  #  Joystick trackballs have only relative motion events associated
  #  with them and their state cannot be polled.
proc SDL_JoystickNumBalls*(joystick: PSDL_Joystick): int{.cdecl,
    importc, dynlib: SDLLibName.}
  # Get the number of POV hats on a joystick
proc SDL_JoystickNumHats*(joystick: PSDL_Joystick): int{.cdecl,
    importc, dynlib: SDLLibName.}
  # Get the number of buttons on a joystick
proc SDL_JoystickNumButtons*(joystick: PSDL_Joystick): int{.cdecl,
    importc, dynlib: SDLLibName.}
  # Update the current state of the open joysticks.
  #  This is called automatically by the event loop if any joystick
  #  events are enabled.
proc SDL_JoystickUpdate*(){.cdecl, importc, dynlib: SDLLibName.}
  # Enable/disable joystick event polling.
  #  If joystick events are disabled, you must call SDL_JoystickUpdate()
  #  yourself and check the state of the joystick when you want joystick
  #  information.
  #  The state can be one of SDL_QUERY, SDL_ENABLE or SDL_IGNORE.
proc SDL_JoystickEventState*(state: int): int{.cdecl, importc, dynlib: SDLLibName.}
  # Get the current state of an axis control on a joystick
  #  The state is a value ranging from -32768 to 32767.
  #  The axis indices start at index 0.
proc SDL_JoystickGetAxis*(joystick: PSDL_Joystick, axis: int): SInt16{.cdecl,
    importc, dynlib: SDLLibName.}
  # The hat indices start at index 0.
proc SDL_JoystickGetHat*(joystick: PSDL_Joystick, hat: int): UInt8{.cdecl,
    importc, dynlib: SDLLibName.}
  # Get the ball axis change since the last poll
  #  This returns 0, or -1 if you passed it invalid parameters.
  #  The ball indices start at index 0.
proc SDL_JoystickGetBall*(joystick: PSDL_Joystick, ball: int, dx: var int,
                          dy: var int): int{.cdecl, importc, dynlib: SDLLibName.}
  # Get the current state of a button on a joystick
  #  The button indices start at index 0.
proc SDL_JoystickGetButton*(joystick: PSDL_Joystick, Button: int): UInt8{.cdecl,
    importc, dynlib: SDLLibName.}
  # Close a joystick previously opened with SDL_JoystickOpen()
proc SDL_JoystickClose*(joystick: PSDL_Joystick){.cdecl, importc, dynlib: SDLLibName.}
  #------------------------------------------------------------------------------
  # event-handling
  #------------------------------------------------------------------------------
  # Pumps the event loop, gathering events from the input devices.
  #  This function updates the event queue and internal input device state.
  #  This should only be run in the thread that sets the video mode.
proc SDL_PumpEvents*(){.cdecl, importc, dynlib: SDLLibName.}
  # Checks the event queue for messages and optionally returns them.
  #  If 'action' is SDL_ADDEVENT, up to 'numevents' events will be added to
  #  the back of the event queue.
  #  If 'action' is SDL_PEEKEVENT, up to 'numevents' events at the front
  #  of the event queue, matching 'mask', will be returned and will not
  #  be removed from the queue.
  #  If 'action' is SDL_GETEVENT, up to 'numevents' events at the front
  #  of the event queue, matching 'mask', will be returned and will be
  #  removed from the queue.
  #  This function returns the number of events actually stored, or -1
  #  if there was an error.  This function is thread-safe.
proc SDL_PeepEvents*(events: PSDL_Event, numevents: int,
                     action: TSDL_eventaction, mask: UInt32): int{.cdecl,
    importc, dynlib: SDLLibName.}
  # Polls for currently pending events, and returns 1 if there are any pending
  #   events, or 0 if there are none available.  If 'event' is not NULL, the next
  #   event is removed from the queue and stored in that area.
proc SDL_PollEvent*(event: PSDL_Event): int{.cdecl, importc, dynlib: SDLLibName.}
  #  Waits indefinitely for the next available event, returning 1, or 0 if there
  #   was an error while waiting for events.  If 'event' is not NULL, the next
  #   event is removed from the queue and stored in that area.
proc SDL_WaitEvent*(event: PSDL_Event): int{.cdecl, importc, dynlib: SDLLibName.}
proc SDL_PushEvent*(event: PSDL_Event): int{.cdecl, importc, dynlib: SDLLibName.}
  # If the filter returns 1, then the event will be added to the internal queue.
  #  If it returns 0, then the event will be dropped from the queue, but the
  #  internal state will still be updated.  This allows selective filtering of
  #  dynamically arriving events.
  #
  #  WARNING:  Be very careful of what you do in the event filter function, as
  #            it may run in a different thread!
  #
  #  There is one caveat when dealing with the SDL_QUITEVENT event type.  The
  #  event filter is only called when the window manager desires to close the
  #  application window.  If the event filter returns 1, then the window will
  #  be closed, otherwise the window will remain open if possible.
  #  If the quit event is generated by an interrupt signal, it will bypass the
  #  internal queue and be delivered to the application at the next event poll.
proc SDL_SetEventFilter*(filter: TSDL_EventFilter){.cdecl, importc, dynlib: SDLLibName.}
  # Return the current event filter - can be used to "chain" filters.
  #  If there is no event filter set, this function returns NULL.
proc SDL_GetEventFilter*(): TSDL_EventFilter{.cdecl, importc, dynlib: SDLLibName.}
  # This function allows you to set the state of processing certain events.
  #  If 'state' is set to SDL_IGNORE, that event will be automatically dropped
  #  from the event queue and will not event be filtered.
  #  If 'state' is set to SDL_ENABLE, that event will be processed normally.
  #  If 'state' is set to SDL_QUERY, SDL_EventState() will return the
  #  current processing state of the specified event.
proc SDL_EventState*(theType: UInt8, state: int): UInt8{.cdecl,
    importc, dynlib: SDLLibName.}
  #------------------------------------------------------------------------------
  # Version Routines
  #------------------------------------------------------------------------------
  # This macro can be used to fill a version structure with the compile-time
  #  version of the SDL library.
proc SDL_VERSION*(X: var TSDL_Version)
  # This macro turns the version numbers into a numeric value:
  #   (1,2,3) -> (1203)
  #   This assumes that there will never be more than 100 patchlevels
proc SDL_VERSIONNUM*(X, Y, Z: int): int
  # This is the version number macro for the current SDL version
proc SDL_COMPILEDVERSION*(): int
  # This macro will evaluate to true if compiled with SDL at least X.Y.Z
proc SDL_VERSION_ATLEAST*(X: int, Y: int, Z: int): bool
  # This function gets the version of the dynamically linked SDL library.
  #  it should NOT be used to fill a version structure, instead you should
  #  use the SDL_Version() macro.
proc SDL_Linked_Version*(): PSDL_version{.cdecl, importc, dynlib: SDLLibName.}
  #------------------------------------------------------------------------------
  # video
  #------------------------------------------------------------------------------
  # These functions are used internally, and should not be used unless you
  #  have a specific need to specify the video driver you want to use.
  #  You should normally use SDL_Init() or SDL_InitSubSystem().
  #
  #  SDL_VideoInit() initializes the video subsystem -- sets up a connection
  #  to the window manager, etc, and determines the current video mode and
  #  pixel format, but does not initialize a window or graphics mode.
  #  Note that event handling is activated by this routine.
  #
  #  If you use both sound and video in your application, you need to call
  #  SDL_Init() before opening the sound device, otherwise under Win32 DirectX,
  #  you won't be able to set full-screen display modes.
proc SDL_VideoInit*(driver_name: cstring, flags: UInt32): int{.cdecl,
    importc, dynlib: SDLLibName.}
proc SDL_VideoQuit*(){.cdecl, importc, dynlib: SDLLibName.}
  # This function fills the given character buffer with the name of the
  #  video driver, and returns a pointer to it if the video driver has
  #  been initialized.  It returns NULL if no driver has been initialized.
proc SDL_VideoDriverName*(namebuf: cstring, maxlen: int): cstring{.cdecl,
    importc, dynlib: SDLLibName.}
  # This function returns a pointer to the current display surface.
  #  If SDL is doing format conversion on the display surface, this
  #  function returns the publicly visible surface, not the real video
  #  surface.
proc SDL_GetVideoSurface*(): PSDL_Surface{.cdecl, importc, dynlib: SDLLibName.}
  # This function returns a read-only pointer to information about the
  #  video hardware.  If this is called before SDL_SetVideoMode(), the 'vfmt'
  #  member of the returned structure will contain the pixel format of the
  #  "best" video mode.
proc SDL_GetVideoInfo*(): PSDL_VideoInfo{.cdecl, importc, dynlib: SDLLibName.}
  # Check to see if a particular video mode is supported.
  #  It returns 0 if the requested mode is not supported under any bit depth,
  #  or returns the bits-per-pixel of the closest available mode with the
  #  given width and height.  If this bits-per-pixel is different from the
  #  one used when setting the video mode, SDL_SetVideoMode() will succeed,
  #  but will emulate the requested bits-per-pixel with a shadow surface.
  #
  #  The arguments to SDL_VideoModeOK() are the same ones you would pass to
  #  SDL_SetVideoMode()
proc SDL_VideoModeOK*(width, height, bpp: int, flags: UInt32): int{.cdecl,
    importc, importc, dynlib: SDLLibName.}
  # Return a pointer to an array of available screen dimensions for the
  #  given format and video flags, sorted largest to smallest.  Returns
  #  NULL if there are no dimensions available for a particular format,
  #  or (SDL_Rect **)-1 if any dimension is okay for the given format.
  #
  #  if 'format' is NULL, the mode list will be for the format given
  #  by SDL_GetVideoInfo( ) - > vfmt
proc SDL_ListModes*(format: PSDL_PixelFormat, flags: UInt32): PPSDL_Rect{.cdecl,
    importc, dynlib: SDLLibName.}
  # Set up a video mode with the specified width, height and bits-per-pixel.
  #
  #  If 'bpp' is 0, it is treated as the current display bits per pixel.
  #
  #  If SDL_ANYFORMAT is set in 'flags', the SDL library will try to set the
  #  requested bits-per-pixel, but will return whatever video pixel format is
  #  available.  The default is to emulate the requested pixel format if it
  #  is not natively available.
  #
  #  If SDL_HWSURFACE is set in 'flags', the video surface will be placed in
  #  video memory, if possible, and you may have to call SDL_LockSurface()
  #  in order to access the raw framebuffer.  Otherwise, the video surface
  #  will be created in system memory.
  #
  #  If SDL_ASYNCBLIT is set in 'flags', SDL will try to perform rectangle
  #  updates asynchronously, but you must always lock before accessing pixels.
  #  SDL will wait for updates to complete before returning from the lock.
  #
  #  If SDL_HWPALETTE is set in 'flags', the SDL library will guarantee
  #  that the colors set by SDL_SetColors() will be the colors you get.
  #  Otherwise, in 8-bit mode, SDL_SetColors() may not be able to set all
  #  of the colors exactly the way they are requested, and you should look
  #  at the video surface structure to determine the actual palette.
  #  If SDL cannot guarantee that the colors you request can be set,
  #  i.e. if the colormap is shared, then the video surface may be created
  #  under emulation in system memory, overriding the SDL_HWSURFACE flag.
  #
  #  If SDL_FULLSCREEN is set in 'flags', the SDL library will try to set
  #  a fullscreen video mode.  The default is to create a windowed mode
  #  if the current graphics system has a window manager.
  #  If the SDL library is able to set a fullscreen video mode, this flag
  #  will be set in the surface that is returned.
  #
  #  If SDL_DOUBLEBUF is set in 'flags', the SDL library will try to set up
  #  two surfaces in video memory and swap between them when you call
  #  SDL_Flip().  This is usually slower than the normal single-buffering
  #  scheme, but prevents "tearing" artifacts caused by modifying video
  #  memory while the monitor is refreshing.  It should only be used by
  #  applications that redraw the entire screen on every update.
  #
  #  This function returns the video framebuffer surface, or NULL if it fails.
proc SDL_SetVideoMode*(width, height, bpp: int, flags: UInt32): PSDL_Surface{.
    cdecl, importc, dynlib: SDLLibName.}
  # Makes sure the given list of rectangles is updated on the given screen.
  #  If 'x', 'y', 'w' and 'h' are all 0, SDL_UpdateRect will update the entire
  #  screen.
  #  These functions should not be called while 'screen' is locked.
proc SDL_UpdateRects*(screen: PSDL_Surface, numrects: int, rects: PSDL_Rect){.
    cdecl, importc, dynlib: SDLLibName.}
proc SDL_UpdateRect*(screen: PSDL_Surface, x, y: SInt32, w, h: UInt32){.cdecl,
    importc, dynlib: SDLLibName.}
  # On hardware that supports double-buffering, this function sets up a flip
  #  and returns.  The hardware will wait for vertical retrace, and then swap
  #  video buffers before the next video surface blit or lock will return.
  #  On hardware that doesn not support double-buffering, this is equivalent
  #  to calling SDL_UpdateRect(screen, 0, 0, 0, 0);
  #  The SDL_DOUBLEBUF flag must have been passed to SDL_SetVideoMode() when
  #  setting the video mode for this function to perform hardware flipping.
  #  This function returns 0 if successful, or -1 if there was an error.
proc SDL_Flip*(screen: PSDL_Surface): int{.cdecl, importc, dynlib: SDLLibName.}
  # Set the gamma correction for each of the color channels.
  #  The gamma values range (approximately) between 0.1 and 10.0
  #
  #  If this function isn't supported directly by the hardware, it will
  #  be emulated using gamma ramps, if available.  If successful, this
  #  function returns 0, otherwise it returns -1.
proc SDL_SetGamma*(redgamma: float32, greengamma: float32, bluegamma: float32): int{.
    cdecl, importc, dynlib: SDLLibName.}
  # Set the gamma translation table for the red, green, and blue channels
  #  of the video hardware.  Each table is an array of 256 16-bit quantities,
  #  representing a mapping between the input and output for that channel.
  #  The input is the index into the array, and the output is the 16-bit
  #  gamma value at that index, scaled to the output color precision.
  #
  #  You may pass NULL for any of the channels to leave it unchanged.
  #  If the call succeeds, it will return 0.  If the display driver or
  #  hardware does not support gamma translation, or otherwise fails,
  #  this function will return -1.
proc SDL_SetGammaRamp*(redtable: PUInt16, greentable: PUInt16,
                       bluetable: PUInt16): int{.cdecl, importc, dynlib: SDLLibName.}
  # Retrieve the current values of the gamma translation tables.
  #
  #  You must pass in valid pointers to arrays of 256 16-bit quantities.
  #  Any of the pointers may be NULL to ignore that channel.
  #  If the call succeeds, it will return 0.  If the display driver or
  #  hardware does not support gamma translation, or otherwise fails,
  #  this function will return -1.
proc SDL_GetGammaRamp*(redtable: PUInt16, greentable: PUInt16,
                       bluetable: PUInt16): int{.cdecl, importc, dynlib: SDLLibName.}
  # Sets a portion of the colormap for the given 8-bit surface.  If 'surface'
  #  is not a palettized surface, this function does nothing, returning 0.
  #  If all of the colors were set as passed to SDL_SetColors(), it will
  #  return 1.  If not all the color entries were set exactly as given,
  #  it will return 0, and you should look at the surface palette to
  #  determine the actual color palette.
  #
  #  When 'surface' is the surface associated with the current display, the
  #  display colormap will be updated with the requested colors.  If
  #  SDL_HWPALETTE was set in SDL_SetVideoMode() flags, SDL_SetColors()
  #  will always return 1, and the palette is guaranteed to be set the way
  #  you desire, even if the window colormap has to be warped or run under
  #  emulation.
proc SDL_SetColors*(surface: PSDL_Surface, colors: PSDL_Color, firstcolor: int,
                    ncolors: int): int{.cdecl, importc, dynlib: SDLLibName.}
  # Sets a portion of the colormap for a given 8-bit surface.
  #  'flags' is one or both of:
  #  SDL_LOGPAL  -- set logical palette, which controls how blits are mapped
  #                 to/from the surface,
  #  SDL_PHYSPAL -- set physical palette, which controls how pixels look on
  #                 the screen
  #  Only screens have physical palettes. Separate change of physical/logical
  #  palettes is only possible if the screen has SDL_HWPALETTE set.
  #
  #  The return value is 1 if all colours could be set as requested, and 0
  #  otherwise.
  #
  #  SDL_SetColors() is equivalent to calling this function with
  #  flags = (SDL_LOGPAL or SDL_PHYSPAL).
proc SDL_SetPalette*(surface: PSDL_Surface, flags: int, colors: PSDL_Color,
                     firstcolor: int, ncolors: int): int{.cdecl,
    importc, dynlib: SDLLibName.}
  # Maps an RGB triple to an opaque pixel value for a given pixel format
proc SDL_MapRGB*(format: PSDL_PixelFormat, r: UInt8, g: UInt8, b: UInt8): UInt32{.
    cdecl, importc, dynlib: SDLLibName.}
  # Maps an RGBA quadruple to a pixel value for a given pixel format
proc SDL_MapRGBA*(format: PSDL_PixelFormat, r: UInt8, g: UInt8, b: UInt8,
                  a: UInt8): UInt32{.cdecl, importc, dynlib: SDLLibName.}
  # Maps a pixel value into the RGB components for a given pixel format
proc SDL_GetRGB*(pixel: UInt32, fmt: PSDL_PixelFormat, r: PUInt8, g: PUInt8,
                 b: PUInt8){.cdecl, importc, dynlib: SDLLibName.}
  # Maps a pixel value into the RGBA components for a given pixel format
proc SDL_GetRGBA*(pixel: UInt32, fmt: PSDL_PixelFormat, r: PUInt8, g: PUInt8,
                  b: PUInt8, a: PUInt8){.cdecl, importc, dynlib: SDLLibName.}
  # Allocate and free an RGB surface (must be called after SDL_SetVideoMode)
  #  If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
  #  If the depth is greater than 8 bits, the pixel format is set using the
  #  flags '[RGB]mask'.
  #  If the function runs out of memory, it will return NULL.
  #
  #  The 'flags' tell what kind of surface to create.
  #  SDL_SWSURFACE means that the surface should be created in system memory.
  #  SDL_HWSURFACE means that the surface should be created in video memory,
  #  with the same format as the display surface.  This is useful for surfaces
  #  that will not change much, to take advantage of hardware acceleration
  #  when being blitted to the display surface.
  #  SDL_ASYNCBLIT means that SDL will try to perform asynchronous blits with
  #  this surface, but you must always lock it before accessing the pixels.
  #  SDL will wait for current blits to finish before returning from the lock.
  #  SDL_SRCCOLORKEY indicates that the surface will be used for colorkey blits.
  #  If the hardware supports acceleration of colorkey blits between
  #  two surfaces in video memory, SDL will try to place the surface in
  #  video memory. If this isn't possible or if there is no hardware
  #  acceleration available, the surface will be placed in system memory.
  #  SDL_SRCALPHA means that the surface will be used for alpha blits and
  #  if the hardware supports hardware acceleration of alpha blits between
  #  two surfaces in video memory, to place the surface in video memory
  #  if possible, otherwise it will be placed in system memory.
  #  If the surface is created in video memory, blits will be _much_ faster,
  #  but the surface format must be identical to the video surface format,
  #  and the only way to access the pixels member of the surface is to use
  #  the SDL_LockSurface() and SDL_UnlockSurface() calls.
  #  If the requested surface actually resides in video memory, SDL_HWSURFACE
  #  will be set in the flags member of the returned surface.  If for some
  #  reason the surface could not be placed in video memory, it will not have
  #  the SDL_HWSURFACE flag set, and will be created in system memory instead.
proc SDL_AllocSurface*(flags: UInt32, width, height, depth: int,
                       RMask, GMask, BMask, AMask: UInt32): PSDL_Surface
proc SDL_CreateRGBSurface*(flags: UInt32, width, height, depth: int,
                           RMask, GMask, BMask, AMask: UInt32): PSDL_Surface{.
    cdecl, importc, dynlib: SDLLibName.}
proc SDL_CreateRGBSurfaceFrom*(pixels: Pointer,
                               width, height, depth, pitch: int,
                               RMask, GMask, BMask, AMask: UInt32): PSDL_Surface{.
    cdecl, importc, dynlib: SDLLibName.}
proc SDL_FreeSurface*(surface: PSDL_Surface){.cdecl, importc, dynlib: SDLLibName.}
proc SDL_MustLock*(Surface: PSDL_Surface): bool
  # SDL_LockSurface() sets up a surface for directly accessing the pixels.
  #  Between calls to SDL_LockSurface()/SDL_UnlockSurface(), you can write
  #  to and read from 'surface->pixels', using the pixel format stored in
  #  'surface->format'.  Once you are done accessing the surface, you should
  #  use SDL_UnlockSurface() to release it.
  #
  #  Not all surfaces require locking.  If SDL_MUSTLOCK(surface) evaluates
  #  to 0, then you can read and write to the surface at any time, and the
  #  pixel format of the surface will not change.  In particular, if the
  #  SDL_HWSURFACE flag is not given when calling SDL_SetVideoMode(), you
  #  will not need to lock the display surface before accessing it.
  #
  #  No operating system or library calls should be made between lock/unlock
  #  pairs, as critical system locks may be held during this time.
  #
  #  SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked.
proc SDL_LockSurface*(surface: PSDL_Surface): int{.cdecl, importc, dynlib: SDLLibName.}
proc SDL_UnlockSurface*(surface: PSDL_Surface){.cdecl, importc, dynlib: SDLLibName.}
  # Load a surface from a seekable SDL data source (memory or file.)
  #  If 'freesrc' is non-zero, the source will be closed after being read.
  #  Returns the new surface, or NULL if there was an error.
  #  The new surface should be freed with SDL_FreeSurface().
proc SDL_LoadBMP_RW*(src: PSDL_RWops, freesrc: int): PSDL_Surface{.cdecl,
    importc, dynlib: SDLLibName.}
  # Convenience macro -- load a surface from a file
proc SDL_LoadBMP*(filename: cstring): PSDL_Surface
  # Save a surface to a seekable SDL data source (memory or file.)
  #  If 'freedst' is non-zero, the source will be closed after being written.
  #  Returns 0 if successful or -1 if there was an error.
proc SDL_SaveBMP_RW*(surface: PSDL_Surface, dst: PSDL_RWops, freedst: int): int{.
    cdecl, importc, dynlib: SDLLibName.}
  # Convenience macro -- save a surface to a file
proc SDL_SaveBMP*(surface: PSDL_Surface, filename: cstring): int
  # Sets the color key (transparent pixel) in a blittable surface.
  #  If 'flag' is SDL_SRCCOLORKEY (optionally OR'd with SDL_RLEACCEL),
  #  'key' will be the transparent pixel in the source image of a blit.
  #  SDL_RLEACCEL requests RLE acceleration for the surface if present,
  #  and removes RLE acceleration if absent.
  #  If 'flag' is 0, this function clears any current color key.
  #  This function returns 0, or -1 if there was an error.
proc SDL_SetColorKey*(surface: PSDL_Surface, flag, key: UInt32): int{.cdecl,
    importc, dynlib: SDLLibName.}
  # This function sets the alpha value for the entire surface, as opposed to
  #  using the alpha component of each pixel. This value measures the range
  #  of transparency of the surface, 0 being completely transparent to 255
  #  being completely opaque. An 'alpha' value of 255 causes blits to be
  #  opaque, the source pixels copied to the destination (the default). Note
  #  that per-surface alpha can be combined with colorkey transparency.
  #
  #  If 'flag' is 0, alpha blending is disabled for the surface.
  #  If 'flag' is SDL_SRCALPHA, alpha blending is enabled for the surface.
  #  OR:ing the flag with SDL_RLEACCEL requests RLE acceleration for the
  #  surface; if SDL_RLEACCEL is not specified, the RLE accel will be removed.
proc SDL_SetAlpha*(surface: PSDL_Surface, flag: UInt32, alpha: UInt8): int{.
    cdecl, importc, dynlib: SDLLibName.}
  # Sets the clipping rectangle for the destination surface in a blit.
  #
  #  If the clip rectangle is NULL, clipping will be disabled.
  #  If the clip rectangle doesn't intersect the surface, the function will
  #  return SDL_FALSE and blits will be completely clipped.  Otherwise the
  #  function returns SDL_TRUE and blits to the surface will be clipped to
  #  the intersection of the surface area and the clipping rectangle.
  #
  #  Note that blits are automatically clipped to the edges of the source
  #  and destination surfaces.
proc SDL_SetClipRect*(surface: PSDL_Surface, rect: PSDL_Rect){.cdecl,
    importc, dynlib: SDLLibName.}
  # Gets the clipping rectangle for the destination surface in a blit.
  #  'rect' must be a pointer to a valid rectangle which will be filled
  #  with the correct values.
proc SDL_GetClipRect*(surface: PSDL_Surface, rect: PSDL_Rect){.cdecl,
    importc, dynlib: SDLLibName.}
  # Creates a new surface of the specified format, and then copies and maps
  #  the given surface to it so the blit of the converted surface will be as
  #  fast as possible.  If this function fails, it returns NULL.
  #
  #  The 'flags' parameter is passed to SDL_CreateRGBSurface() and has those
  #  semantics.  You can also pass SDL_RLEACCEL in the flags parameter and
  #  SDL will try to RLE accelerate colorkey and alpha blits in the resulting
  #  surface.
  #
  #  This function is used internally by SDL_DisplayFormat().
proc SDL_ConvertSurface*(src: PSDL_Surface, fmt: PSDL_PixelFormat, flags: UInt32): PSDL_Surface{.
    cdecl, importc, dynlib: SDLLibName.}
  #
  #  This performs a fast blit from the source surface to the destination
  #  surface.  It assumes that the source and destination rectangles are
  #  the same size.  If either 'srcrect' or 'dstrect' are NULL, the entire
  #  surface (src or dst) is copied.  The final blit rectangles are saved
  #  in 'srcrect' and 'dstrect' after all clipping is performed.
  #  If the blit is successful, it returns 0, otherwise it returns -1.
  #
  #  The blit function should not be called on a locked surface.
  #
  #  The blit semantics for surfaces with and without alpha and colorkey
  #  are defined as follows:
  #
  #  RGBA->RGB:
  #      SDL_SRCALPHA set:
  #   alpha-blend (using alpha-channel).
  #   SDL_SRCCOLORKEY ignored.
  #      SDL_SRCALPHA not set:
  #   copy RGB.
  #   if SDL_SRCCOLORKEY set, only copy the pixels matching the
  #   RGB values of the source colour key, ignoring alpha in the
  #   comparison.
  #
  #  RGB->RGBA:
  #      SDL_SRCALPHA set:
  #   alpha-blend (using the source per-surface alpha value);
  #   set destination alpha to opaque.
  #      SDL_SRCALPHA not set:
  #   copy RGB, set destination alpha to opaque.
  #      both:
  #   if SDL_SRCCOLORKEY set, only copy the pixels matching the
  #   source colour key.
  #
  #  RGBA->RGBA:
  #      SDL_SRCALPHA set:
  #   alpha-blend (using the source alpha channel) the RGB values;
  #   leave destination alpha untouched. [Note: is this correct?]
  #   SDL_SRCCOLORKEY ignored.
  #      SDL_SRCALPHA not set:
  #   copy all of RGBA to the destination.
  #   if SDL_SRCCOLORKEY set, only copy the pixels matching the
  #   RGB values of the source colour key, ignoring alpha in the
  #   comparison.
  #
  #  RGB->RGB:
  #      SDL_SRCALPHA set:
  #   alpha-blend (using the source per-surface alpha value).
  #      SDL_SRCALPHA not set:
  #   copy RGB.
  #      both:
  #   if SDL_SRCCOLORKEY set, only copy the pixels matching the
  #   source colour key.
  #
  #  If either of the surfaces were in video memory, and the blit returns -2,
  #  the video memory was lost, so it should be reloaded with artwork and
  #  re-blitted:
  #  while ( SDL_BlitSurface(image, imgrect, screen, dstrect) = -2 ) do
  #  begin
  #  while ( SDL_LockSurface(image) < 0 ) do
  #   Sleep(10);
  #  -- Write image pixels to image->pixels --
  #  SDL_UnlockSurface(image);
  # end;
  #
  #  This happens under DirectX 5.0 when the system switches away from your
  #  fullscreen application.  The lock will also fail until you have access
  #  to the video memory again.
  # You should call SDL_BlitSurface() unless you know exactly how SDL
  #   blitting works internally and how to use the other blit functions.
proc SDL_BlitSurface*(src: PSDL_Surface, srcrect: PSDL_Rect, dst: PSDL_Surface,
                      dstrect: PSDL_Rect): int
  #  This is the public blit function, SDL_BlitSurface(), and it performs
  #   rectangle validation and clipping before passing it to SDL_LowerBlit()
proc SDL_UpperBlit*(src: PSDL_Surface, srcrect: PSDL_Rect, dst: PSDL_Surface,
                    dstrect: PSDL_Rect): int{.cdecl, importc, dynlib: SDLLibName.}
  # This is a semi-private blit function and it performs low-level surface
  #  blitting only.
proc SDL_LowerBlit*(src: PSDL_Surface, srcrect: PSDL_Rect, dst: PSDL_Surface,
                    dstrect: PSDL_Rect): int{.cdecl, importc, dynlib: SDLLibName.}
  # This function performs a fast fill of the given rectangle with 'color'
  #  The given rectangle is clipped to the destination surface clip area
  #  and the final fill rectangle is saved in the passed in pointer.
  #  If 'dstrect' is NULL, the whole surface will be filled with 'color'
  #  The color should be a pixel of the format used by the surface, and
  #  can be generated by the SDL_MapRGB() function.
  #  This function returns 0 on success, or -1 on error.
proc SDL_FillRect*(dst: PSDL_Surface, dstrect: PSDL_Rect, color: UInt32): int{.
    cdecl, importc, dynlib: SDLLibName.}
  # This function takes a surface and copies it to a new surface of the
  #  pixel format and colors of the video framebuffer, suitable for fast
  #  blitting onto the display surface.  It calls SDL_ConvertSurface()
  #
  #  If you want to take advantage of hardware colorkey or alpha blit
  #  acceleration, you should set the colorkey and alpha value before
  #  calling this function.
  #
  #  If the conversion fails or runs out of memory, it returns NULL
proc SDL_DisplayFormat*(surface: PSDL_Surface): PSDL_Surface{.cdecl,
    importc, dynlib: SDLLibName.}
  # This function takes a surface and copies it to a new surface of the
  #  pixel format and colors of the video framebuffer (if possible),
  #  suitable for fast alpha blitting onto the display surface.
  #  The new surface will always have an alpha channel.
  #
  #  If you want to take advantage of hardware colorkey or alpha blit
  #  acceleration, you should set the colorkey and alpha value before
  #  calling this function.
  #
  #  If the conversion fails or runs out of memory, it returns NULL
proc SDL_DisplayFormatAlpha*(surface: PSDL_Surface): PSDL_Surface{.cdecl,
    importc, dynlib: SDLLibName.}
  #* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  #* YUV video surface overlay functions                                       */
  #* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  # This function creates a video output overlay
  #  Calling the returned surface an overlay is something of a misnomer because
  #  the contents of the display surface underneath the area where the overlay
  #  is shown is undefined - it may be overwritten with the converted YUV data.
proc SDL_CreateYUVOverlay*(width: int, height: int, format: UInt32,
                           display: PSDL_Surface): PSDL_Overlay{.cdecl,
    importc, dynlib: SDLLibName.}
  # Lock an overlay for direct access, and unlock it when you are done
proc SDL_LockYUVOverlay*(Overlay: PSDL_Overlay): int{.cdecl, importc, dynlib: SDLLibName.}
proc SDL_UnlockYUVOverlay*(Overlay: PSDL_Overlay){.cdecl, importc, dynlib: SDLLibName.}
  # Blit a video overlay to the display surface.
  #  The contents of the video surface underneath the blit destination are
  #  not defined.
  #  The width and height of the destination rectangle may be different from
  #  that of the overlay, but currently only 2x scaling is supported.
proc SDL_DisplayYUVOverlay*(Overlay: PSDL_Overlay, dstrect: PSDL_Rect): int{.
    cdecl, importc, dynlib: SDLLibName.}
  # Free a video overlay
proc SDL_FreeYUVOverlay*(Overlay: PSDL_Overlay){.cdecl, importc, dynlib: SDLLibName.}
  #------------------------------------------------------------------------------
  # OpenGL Routines
  #------------------------------------------------------------------------------
  # Dynamically load a GL driver, if SDL is built with dynamic GL.
  #
  #  SDL links normally with the OpenGL library on your system by default,
  #  but you can compile it to dynamically load the GL driver at runtime.
  #  If you do this, you need to retrieve all of the GL functions used in
  #  your program from the dynamic library using SDL_GL_GetProcAddress().
  #
  #  This is disabled in default builds of SDL.
proc SDL_GL_LoadLibrary*(filename: cstring): int{.cdecl, importc, dynlib: SDLLibName.}
  # Get the address of a GL function (for extension functions)
proc SDL_GL_GetProcAddress*(procname: cstring): Pointer{.cdecl,
    importc, dynlib: SDLLibName.}
  # Set an attribute of the OpenGL subsystem before intialization.
proc SDL_GL_SetAttribute*(attr: TSDL_GLAttr, value: int): int{.cdecl,
    importc, dynlib: SDLLibName.}
  # Get an attribute of the OpenGL subsystem from the windowing
  #  interface, such as glX. This is of course different from getting
  #  the values from SDL's internal OpenGL subsystem, which only
  #  stores the values you request before initialization.
  #
  #  Developers should track the values they pass into SDL_GL_SetAttribute
  #  themselves if they want to retrieve these values.
proc SDL_GL_GetAttribute*(attr: TSDL_GLAttr, value: var int): int{.cdecl,
    importc, dynlib: SDLLibName.}
  # Swap the OpenGL buffers, if double-buffering is supported.
proc SDL_GL_SwapBuffers*(){.cdecl, importc, dynlib: SDLLibName.}
  # Internal functions that should not be called unless you have read
  #  and understood the source code for these functions.
proc SDL_GL_UpdateRects*(numrects: int, rects: PSDL_Rect){.cdecl,
    importc, dynlib: SDLLibName.}
proc SDL_GL_Lock*(){.cdecl, importc, dynlib: SDLLibName.}
proc SDL_GL_Unlock*(){.cdecl, importc, dynlib: SDLLibName.}
  #* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  #* These functions allow interaction with the window manager, if any.        *
  #* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  # Sets/Gets the title and icon text of the display window
proc SDL_WM_GetCaption*(title: var cstring, icon: var cstring){.cdecl,
    importc, dynlib: SDLLibName.}
proc SDL_WM_SetCaption*(title: cstring, icon: cstring){.cdecl,
    importc, dynlib: SDLLibName.}
  # Sets the icon for the display window.
  #  This function must be called before the first call to SDL_SetVideoMode().
  #  It takes an icon surface, and a mask in MSB format.
  #  If 'mask' is NULL, the entire icon surface will be used as the icon.
proc SDL_WM_SetIcon*(icon: PSDL_Surface, mask: UInt8){.cdecl, importc, dynlib: SDLLibName.}
  # This function iconifies the window, and returns 1 if it succeeded.
  #  If the function succeeds, it generates an SDL_APPACTIVE loss event.
  #  This function is a noop and returns 0 in non-windowed environments.
proc SDL_WM_IconifyWindow*(): int{.cdecl, importc, dynlib: SDLLibName.}
  # Toggle fullscreen mode without changing the contents of the screen.
  #  If the display surface does not require locking before accessing
  #  the pixel information, then the memory pointers will not change.
  #
  #  If this function was able to toggle fullscreen mode (change from
  #  running in a window to fullscreen, or vice-versa), it will return 1.
  #  If it is not implemented, or fails, it returns 0.
  #
  #  The next call to SDL_SetVideoMode() will set the mode fullscreen
  #  attribute based on the flags parameter - if SDL_FULLSCREEN is not
  #  set, then the display will be windowed by default where supported.
  #
  #  This is currently only implemented in the X11 video driver.
proc SDL_WM_ToggleFullScreen*(surface: PSDL_Surface): int{.cdecl,
    importc, dynlib: SDLLibName.}
  # Grabbing means that the mouse is confined to the application window,
  #  and nearly all keyboard input is passed directly to the application,
  #  and not interpreted by a window manager, if any.
proc SDL_WM_GrabInput*(mode: TSDL_GrabMode): TSDL_GrabMode{.cdecl,
    importc, dynlib: SDLLibName.}
  #------------------------------------------------------------------------------
  # mouse-routines
  #------------------------------------------------------------------------------
  # Retrieve the current state of the mouse.
  #  The current button state is returned as a button bitmask, which can
  #  be tested using the SDL_BUTTON(X) macros, and x and y are set to the
  #  current mouse cursor position.  You can pass NULL for either x or y.
proc SDL_GetMouseState*(x: var int, y: var int): UInt8{.cdecl,
    importc, dynlib: SDLLibName.}
  # Retrieve the current state of the mouse.
  #  The current button state is returned as a button bitmask, which can
  #  be tested using the SDL_BUTTON(X) macros, and x and y are set to the
  #  mouse deltas since the last call to SDL_GetRelativeMouseState().
proc SDL_GetRelativeMouseState*(x: var int, y: var int): UInt8{.cdecl,
    importc, dynlib: SDLLibName.}
  # Set the position of the mouse cursor (generates a mouse motion event)
proc SDL_WarpMouse*(x, y: UInt16){.cdecl, importc, dynlib: SDLLibName.}
  # Create a cursor using the specified data and mask (in MSB format).
  #  The cursor width must be a multiple of 8 bits.
  #
  #  The cursor is created in black and white according to the following:
  #  data  mask    resulting pixel on screen
  #   0     1       White
  #   1     1       Black
  #   0     0       Transparent
  #   1     0       Inverted color if possible, black if not.
  #
  #  Cursors created with this function must be freed with SDL_FreeCursor().
proc SDL_CreateCursor*(data, mask: PUInt8, w, h, hot_x, hot_y: int): PSDL_Cursor{.
    cdecl, importc, dynlib: SDLLibName.}
  # Set the currently active cursor to the specified one.
  #  If the cursor is currently visible, the change will be immediately
  #  represented on the display.
proc SDL_SetCursor*(cursor: PSDL_Cursor){.cdecl, importc, dynlib: SDLLibName.}
  # Returns the currently active cursor.
proc SDL_GetCursor*(): PSDL_Cursor{.cdecl, importc, dynlib: SDLLibName.}
  # Deallocates a cursor created with SDL_CreateCursor().
proc SDL_FreeCursor*(cursor: PSDL_Cursor){.cdecl, importc, dynlib: SDLLibName.}
  # Toggle whether or not the cursor is shown on the screen.
  #  The cursor start off displayed, but can be turned off.
  #  SDL_ShowCursor() returns 1 if the cursor was being displayed
  #  before the call, or 0 if it was not.  You can query the current
  #  state by passing a 'toggle' value of -1.
proc SDL_ShowCursor*(toggle: int): int{.cdecl, importc, dynlib: SDLLibName.}
proc SDL_BUTTON*(Button: int): int
  #------------------------------------------------------------------------------
  # Keyboard-routines
  #------------------------------------------------------------------------------
  # Enable/Disable UNICODE translation of keyboard input.
  #  This translation has some overhead, so translation defaults off.
  #  If 'enable' is 1, translation is enabled.
  #  If 'enable' is 0, translation is disabled.
  #  If 'enable' is -1, the translation state is not changed.
  #  It returns the previous state of keyboard translation.
proc SDL_EnableUNICODE*(enable: int): int{.cdecl, importc, dynlib: SDLLibName.}
  # If 'delay' is set to 0, keyboard repeat is disabled.
proc SDL_EnableKeyRepeat*(delay: int, interval: int): int{.cdecl,
    importc, dynlib: SDLLibName.}
proc SDL_GetKeyRepeat*(delay: PInteger, interval: PInteger){.cdecl,
    importc, dynlib: SDLLibName.}
  # Get a snapshot of the current state of the keyboard.
  #  Returns an array of keystates, indexed by the SDLK_* syms.
  #  Used:
  #
  #  UInt8 *keystate = SDL_GetKeyState(NULL);
  #  if ( keystate[SDLK_RETURN] ) ... <RETURN> is pressed
proc SDL_GetKeyState*(numkeys: PInt): PUInt8{.cdecl, importc, dynlib: SDLLibName.}
  # Get the current key modifier state
proc SDL_GetModState*(): TSDLMod{.cdecl, importc, dynlib: SDLLibName.}
  # Set the current key modifier state
  #  This does not change the keyboard state, only the key modifier flags.
proc SDL_SetModState*(modstate: TSDLMod){.cdecl, importc, dynlib: SDLLibName.}
  # Get the name of an SDL virtual keysym
proc SDL_GetKeyName*(key: TSDLKey): cstring{.cdecl, importc, dynlib: SDLLibName.}
  #------------------------------------------------------------------------------
  # Active Routines
  #------------------------------------------------------------------------------
  # This function returns the current state of the application, which is a
  #  bitwise combination of SDL_APPMOUSEFOCUS, SDL_APPINPUTFOCUS, and
  #  SDL_APPACTIVE.  If SDL_APPACTIVE is set, then the user is able to
  #  see your application, otherwise it has been iconified or disabled.
proc SDL_GetAppState*(): UInt8{.cdecl, importc, dynlib: SDLLibName.}
  # Mutex functions
  # Create a mutex, initialized unlocked
proc SDL_CreateMutex*(): PSDL_Mutex{.cdecl, importc, dynlib: SDLLibName.}
  # Lock the mutex  (Returns 0, or -1 on error)
proc SDL_mutexP*(mutex: PSDL_mutex): int{.cdecl, importc, dynlib: SDLLibName.}
proc SDL_LockMutex*(mutex: PSDL_mutex): int
  # Unlock the mutex  (Returns 0, or -1 on error)
proc SDL_mutexV*(mutex: PSDL_mutex): int{.cdecl, importc, dynlib: SDLLibName.}
proc SDL_UnlockMutex*(mutex: PSDL_mutex): int
  # Destroy a mutex
proc SDL_DestroyMutex*(mutex: PSDL_mutex){.cdecl, importc, dynlib: SDLLibName.}
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  # Semaphore functions
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  # Create a semaphore, initialized with value, returns NULL on failure.
proc SDL_CreateSemaphore*(initial_value: UInt32): PSDL_Sem{.cdecl,
    importc, dynlib: SDLLibName.}
  # Destroy a semaphore
proc SDL_DestroySemaphore*(sem: PSDL_sem){.cdecl, importc, dynlib: SDLLibName.}
  # This function suspends the calling thread until the semaphore pointed
  #  to by sem has a positive count. It then atomically decreases the semaphore
  #  count.
proc SDL_SemWait*(sem: PSDL_sem): int{.cdecl, importc, dynlib: SDLLibName.}
  # Non-blocking variant of SDL_SemWait(), returns 0 if the wait succeeds,
  #   SDL_MUTEX_TIMEDOUT if the wait would block, and -1 on error.
proc SDL_SemTryWait*(sem: PSDL_sem): int{.cdecl, importc, dynlib: SDLLibName.}
  # Variant of SDL_SemWait() with a timeout in milliseconds, returns 0 if
  #   the wait succeeds, SDL_MUTEX_TIMEDOUT if the wait does not succeed in
  #   the allotted time, and -1 on error.
  #   On some platforms this function is implemented by looping with a delay
  #   of 1 ms, and so should be avoided if possible.
proc SDL_SemWaitTimeout*(sem: PSDL_sem, ms: UInt32): int{.cdecl,
    importc, dynlib: SDLLibName.}
  # Atomically increases the semaphore's count (not blocking), returns 0,
  #   or -1 on error.
proc SDL_SemPost*(sem: PSDL_sem): int{.cdecl, importc, dynlib: SDLLibName.}
  # Returns the current count of the semaphore
proc SDL_SemValue*(sem: PSDL_sem): UInt32{.cdecl, importc, dynlib: SDLLibName.}
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  # Condition variable functions
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  # Create a condition variable
proc SDL_CreateCond*(): PSDL_Cond{.cdecl, importc, dynlib: SDLLibName.}
  # Destroy a condition variable
proc SDL_DestroyCond*(cond: PSDL_Cond){.cdecl, importc, dynlib: SDLLibName.}
  # Restart one of the threads that are waiting on the condition variable,
  #   returns 0 or -1 on error.
proc SDL_CondSignal*(cond: PSDL_cond): int{.cdecl, importc, dynlib: SDLLibName.}
  # Restart all threads that are waiting on the condition variable,
  #  returns 0 or -1 on error.
proc SDL_CondBroadcast*(cond: PSDL_cond): int{.cdecl, importc, dynlib: SDLLibName.}
  # Wait on the condition variable, unlocking the provided mutex.
  #  The mutex must be locked before entering this function!
  #  Returns 0 when it is signaled, or -1 on error.
proc SDL_CondWait*(cond: PSDL_cond, mut: PSDL_mutex): int{.cdecl,
    importc, dynlib: SDLLibName.}
  # Waits for at most 'ms' milliseconds, and returns 0 if the condition
  #  variable is signaled, SDL_MUTEX_TIMEDOUT if the condition is not
  #  signaled in the allotted time, and -1 on error.
  #  On some platforms this function is implemented by looping with a delay
  #  of 1 ms, and so should be avoided if possible.
proc SDL_CondWaitTimeout*(cond: PSDL_cond, mut: PSDL_mutex, ms: UInt32): int{.
    cdecl, importc, dynlib: SDLLibName.}
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  # Condition variable functions
  # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  # Create a thread
proc SDL_CreateThread*(fn: PInt, data: Pointer): PSDL_Thread{.cdecl,
    importc, dynlib: SDLLibName.}
  # Get the 32-bit thread identifier for the current thread
proc SDL_ThreadID*(): UInt32{.cdecl, importc, dynlib: SDLLibName.}
  # Get the 32-bit thread identifier for the specified thread,
  #  equivalent to SDL_ThreadID() if the specified thread is NULL.
proc SDL_GetThreadID*(thread: PSDL_Thread): UInt32{.cdecl, importc, dynlib: SDLLibName.}
  # Wait for a thread to finish.
  #  The return code for the thread function is placed in the area
  #  pointed to by 'status', if 'status' is not NULL.
proc SDL_WaitThread*(thread: PSDL_Thread, status: var int){.cdecl,
    importc, dynlib: SDLLibName.}
  # Forcefully kill a thread without worrying about its state
proc SDL_KillThread*(thread: PSDL_Thread){.cdecl, importc, dynlib: SDLLibName.}
  #------------------------------------------------------------------------------
  # Get Environment Routines
  #------------------------------------------------------------------------------
  #*
  # * This function gives you custom hooks into the window manager information.
  # * It fills the structure pointed to by 'info' with custom information and
  # * returns 1 if the function is implemented.  If it's not implemented, or
  # * the version member of the 'info' structure is invalid, it returns 0.
  # *
proc SDL_GetWMInfo*(info: PSDL_SysWMinfo): int{.cdecl, importc, dynlib: SDLLibName.}
  #------------------------------------------------------------------------------
  #SDL_loadso.h
  #* This function dynamically loads a shared object and returns a pointer
  # * to the object handle (or NULL if there was an error).
  # * The 'sofile' parameter is a system dependent name of the object file.
  # *
proc SDL_LoadObject*(sofile: cstring): Pointer{.cdecl, importc, dynlib: SDLLibName.}
  #* Given an object handle, this function looks up the address of the
  # * named function in the shared object and returns it.  This address
  # * is no longer valid after calling SDL_UnloadObject().
  # *
proc SDL_LoadFunction*(handle: Pointer, name: cstring): Pointer{.cdecl,
    importc, dynlib: SDLLibName.}
  #* Unload a shared object from memory *
proc SDL_UnloadObject*(handle: Pointer){.cdecl, importc, dynlib: SDLLibName.}
  #------------------------------------------------------------------------------
proc SDL_Swap32*(D: Uint32): Uint32
  # Bitwise Checking functions
proc IsBitOn*(value: int, bit: int8): bool
proc TurnBitOn*(value: int, bit: int8): int
proc TurnBitOff*(value: int, bit: int8): int
# implementation

proc SDL_TABLESIZE(table: cstring): int =
  Result = SizeOf(table) div SizeOf(table[0])

proc SDL_OutOfMemory() =
  when not(defined(WINDOWS)): SDL_Error(SDL_ENOMEM)

proc SDL_RWSeek(context: PSDL_RWops, offset: int, whence: int): int =
  Result = context.seek(context, offset, whence)

proc SDL_RWTell(context: PSDL_RWops): int =
  Result = context.seek(context, 0, 1)

proc SDL_RWRead(context: PSDL_RWops, theptr: Pointer, size: int, n: int): int =
  Result = context.read(context, theptr, size, n)

proc SDL_RWWrite(context: PSDL_RWops, theptr: Pointer, size: int, n: int): int =
  Result = context.write(context, theptr, size, n)

proc SDL_RWClose(context: PSDL_RWops): int =
  Result = context.closeFile(context)

proc SDL_LoadWAV(filename: cstring, spec: PSDL_AudioSpec, audio_buf: PUInt8,
                 audiolen: PUInt32): PSDL_AudioSpec =
  Result = SDL_LoadWAV_RW(SDL_RWFromFile(filename, "rb"), 1, spec, audio_buf,
                          audiolen)

proc SDL_CDInDrive(status: TSDL_CDStatus): bool =
  Result = ord(status) > ord(CD_ERROR)

proc FRAMES_TO_MSF(frames: int, M: var int, S: var int, F: var int) =
  var value: int
  value = frames
  F = value mod CD_FPS
  value = value div CD_FPS
  S = value mod 60
  value = value div 60
  M = value

proc MSF_TO_FRAMES(M: int, S: int, F: int): int =
  Result = M * 60 * CD_FPS + S * CD_FPS + F

proc SDL_VERSION(X: var TSDL_Version) =
  X.major = SDL_MAJOR_VERSION
  X.minor = SDL_MINOR_VERSION
  X.patch = SDL_PATCHLEVEL

proc SDL_VERSIONNUM(X, Y, Z: int): int =
  Result = X * 1000 + Y * 100 + Z

proc SDL_COMPILEDVERSION(): int =
  Result = SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL)

proc SDL_VERSION_ATLEAST(X, Y, Z: int): bool =
  Result = (SDL_COMPILEDVERSION() >= SDL_VERSIONNUM(X, Y, Z))

proc SDL_LoadBMP(filename: cstring): PSDL_Surface =
  Result = SDL_LoadBMP_RW(SDL_RWFromFile(filename, "rb"), 1)

proc SDL_SaveBMP(surface: PSDL_Surface, filename: cstring): int =
  Result = SDL_SaveBMP_RW(surface, SDL_RWFromFile(filename, "wb"), 1)

proc SDL_BlitSurface(src: PSDL_Surface, srcrect: PSDL_Rect, dst: PSDL_Surface,
                     dstrect: PSDL_Rect): int =
  Result = SDL_UpperBlit(src, srcrect, dst, dstrect)

proc SDL_AllocSurface(flags: UInt32, width, height, depth: int,
                      RMask, GMask, BMask, AMask: UInt32): PSDL_Surface =
  Result = SDL_CreateRGBSurface(flags, width, height, depth, RMask, GMask,
                                BMask, AMask)

proc SDL_MustLock(Surface: PSDL_Surface): bool =
  Result = ((surface^ .offset != 0) or
      ((surface^ .flags and (SDL_HWSURFACE or SDL_ASYNCBLIT or SDL_RLEACCEL)) !=
      0))

proc SDL_LockMutex(mutex: PSDL_mutex): int =
  Result = SDL_mutexP(mutex)

proc SDL_UnlockMutex(mutex: PSDL_mutex): int =
  Result = SDL_mutexV(mutex)

proc SDL_BUTTON(Button: int): int =
  Result = SDL_PRESSED shl (Button - 1)

proc SDL_Swap32(D: Uint32): Uint32 =
  Result = ((D shl 24) or ((D shl 8) and 0x00FF0000) or
      ((D shr 8) and 0x0000FF00) or (D shr 24))

proc IsBitOn(value: int, bit: int8): bool =
  result = ((value and (1 shl ze(bit))) != 0)

proc TurnBitOn(value: int, bit: int8): int =
  result = (value or (1 shl ze(bit)))

proc TurnBitOff(value: int, bit: int8): int =
  result = (value and not (1 shl ze(bit)))