src/lib/sdl/sdl.pas

   1 unit sdl;
   2 {
   3   $Id: sdl.pas,v 1.31 2007/05/29 21:30:48 savage Exp $
   4
   5 }
   6 {******************************************************************************}
   7 {                                                                              }
   8 {          JEDI-SDL : Pascal units for SDL - Simple DirectMedia Layer          }
   9 {             Conversion of the Simple DirectMedia Layer Headers               }
  10 {                                                                              }
  11 { Portions created by Sam Lantinga <slouken@devolution.com> are                }
  12 { Copyright (C) 1997-2004  Sam Lantinga                                        }
  13 { 5635-34 Springhouse Dr.                                                      }
  14 { Pleasanton, CA 94588 (USA)                                                   }
  15 {                                                                              }
  16 { All Rights Reserved.                                                         }
  17 {                                                                              }
  18 { The original files are : SDL.h                                               }
  19 {                          SDL_main.h                                          }
  20 {                          SDL_types.h                                         }
  21 {                          SDL_rwops.h                                         }
  22 {                          SDL_timer.h                                         }
  23 {                          SDL_audio.h                                         }
  24 {                          SDL_cdrom.h                                         }
  25 {                          SDL_joystick.h                                      }
  26 {                          SDL_mouse.h                                         }
  27 {                          SDL_keyboard.h                                      }
  28 {                          SDL_events.h                                        }
  29 {                          SDL_video.h                                         }
  30 {                          SDL_byteorder.h                                     }
  31 {                          SDL_version.h                                       }
  32 {                          SDL_active.h                                        }
  33 {                          SDL_thread.h                                        }
  34 {                          SDL_mutex .h                                        }
  35 {                          SDL_getenv.h                                        }
  36 {                          SDL_loadso.h                                        }
  37 {                                                                              }
  38 { The initial developer of this Pascal code was :                              }
  39 { Dominique Louis <Dominique@SavageSoftware.com.au>                            }
  40 {                                                                              }
  41 { Portions created by Dominique Louis are                                      }
  42 { Copyright (C) 2000 - 2004 Dominique Louis.                                   }
  43 {                                                                              }
  44 {                                                                              }
  45 { Contributor(s)                                                               }
  46 { --------------                                                               }
  47 { Tom Jones <tigertomjones@gmx.de>  His Project inspired this conversion       }
  48 { Matthias Thoma <ma.thoma@gmx.de>                                             }
  49 {                                                                              }
  50 { Obtained through:                                                            }
  51 { Joint Endeavour of Delphi Innovators ( Project JEDI )                        }
  52 {                                                                              }
  53 { You may retrieve the latest version of this file at the Project              }
  54 { JEDI home page, located at http://delphi-jedi.org                            }
  55 {                                                                              }
  56 { The contents of this file are used with permission, subject to               }
  57 { the Mozilla Public License Version 1.1 (the "License"); you may              }
  58 { not use this file except in compliance with the License. You may             }
  59 { obtain a copy of the License at                                              }
  60 { http://www.mozilla.org/MPL/MPL-1.1.html                                      }
  61 {                                                                              }
  62 { Software distributed under the License is distributed on an                  }
  63 { "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or               }
  64 { implied. See the License for the specific language governing                 }
  65 { rights and limitations under the License.                                    }
  66 {                                                                              }
  67 { Description                                                                  }
  68 { -----------                                                                  }
  69 {                                                                              }
  70 {                                                                              }
  71 {                                                                              }
  72 {                                                                              }
  73 {                                                                              }
  74 {                                                                              }
  75 {                                                                              }
  76 { Requires                                                                     }
  77 { --------                                                                     }
  78 {   The SDL Runtime libraris on Win32  : SDL.dll on Linux : libSDL.so          }
  79 {   They are available from...                                                 }
  80 {   http://www.libsdl.org .                                                    }
  81 {                                                                              }
  82 { Programming Notes                                                            }
  83 { -----------------                                                            }
  84 {                                                                              }
  85 {                                                                              }
  86 {                                                                              }
  87 {                                                                              }
  88 { Revision History                                                             }
  89 { ----------------                                                             }
  90 {   May      08 2001 - DL : Added Keyboard  State Array ( See demos for how to }
  91 {                           use )                                              }
  92 {                           PKeyStateArr = ^TKeyStateArr;                      }
  93 {                           TKeyStateArr = array[0..65000] of UInt8;           }
  94 {                           As most games will need it.                        }
  95 {                                                                              }
  96 {   April    02 2001 - DL : Added SDL_getenv.h definitions and tested version  }
  97 {                           1.2.0 compatability.                               }
  98 {                                                                              }
  99 {   March    13 2001 - MT : Added Linux compatibility.                         }
 100 {                                                                              }
 101 {   March    10 2001 - MT : Added externalsyms for DEFINES                     }
 102 {                           Changed the license header                         }
 103 {                                                                              }
 104 {   March    09 2001 - MT : Added Kylix Ifdefs/Deleted the uses mmsystem       }
 105 {                                                                              }
 106 {   March    01 2001 - DL : Update conversion of version 1.1.8                 }
 107 {                                                                              }
 108 {   July     22 2001 - DL : Added TUInt8Array and PUIntArray after suggestions }
 109 {                           from Matthias Thoma and Eric Grange.               }
 110 {                                                                              }
 111 {   October  12 2001 - DL : Various changes as suggested by Matthias Thoma and }
 112 {                           David Acklam                                       }
 113 {                                                                              }
 114 {   October  24 2001 - DL : Added FreePascal support as per suggestions from   }
 115 {                           Dean Ellis.                                        }
 116 {                                                                              }
 117 {   October  27 2001 - DL : Added SDL_BUTTON macro                             }
 118 {                                                                              }
 119 {  November  08 2001 - DL : Bug fix as pointed out by Puthoon.                 }
 120 {                                                                              }
 121 {  November  29 2001 - DL : Bug fix of SDL_SetGammaRamp as pointed out by Simon}
 122 {                           Rushton.                                           }
 123 {                                                                              }
 124 {  November  30 2001 - DL : SDL_NOFRAME added as pointed out by Simon Rushton. }
 125 {                                                                              }
 126 {  December  11 2001 - DL : Added $WEAKPACKAGEUNIT ON to facilitate useage in  }
 127 {                           Components                                         }
 128 {                                                                              }
 129 {  January   05 2002 - DL : Added SDL_Swap32 function as suggested by Matthias }
 130 {                           Thoma and also made sure the _getenv from          }
 131 {                           MSVCRT.DLL uses the right calling convention       }
 132 {                                                                              }
 133 {  January   25 2002 - DL : Updated conversion of SDL_AddTimer &               }
 134 {                           SDL_RemoveTimer as per suggestions from Matthias   }
 135 {                           Thoma.                                             }
 136 {                                                                              }
 137 {  January   27 2002 - DL : Commented out exported function putenv and getenv  }
 138 {                           So that developers get used to using SDL_putenv    }
 139 {                           SDL_getenv, as they are more portable              }
 140 {                                                                              }
 141 {  March     05 2002 - DL : Added FreeAnNil procedure for Delphi 4 users.      }
 142 {                                                                              }
 143 {  October   23 2002 - DL : Added Delphi 3 Define of Win32.                    }
 144 {                           If you intend to you Delphi 3...                   }
 145 {                           ( which is officially unsupported ) make sure you  }
 146 {                           remove references to $EXTERNALSYM in this and other}
 147 {                           SDL files.                                         }
 148 {                                                                              }
 149 { November  29 2002 - DL : Fixed bug in Declaration of SDL_GetRGBA that was    }
 150 {                          pointed out by Todd Lang                            }
 151 {                                                                              }
 152 {   April   03 2003 - DL : Added jedi-sdl.inc include file to support more     }
 153 {                          Pascal compilers. Initial support is now included   }
 154 {                          for GnuPascal, VirtualPascal, TMT and obviously     }
 155 {                          continue support for Delphi Kylix and FreePascal.   }
 156 {                                                                              }
 157 {   April   08 2003 - MK : Aka Mr Kroket - Added Better FPC support            }
 158 {                                                                              }
 159 {   April   24 2003 - DL : under instruction from Alexey Barkovoy, I have added}
 160 {                          better TMT Pascal support and under instruction     }
 161 {                          from Prof. Abimbola Olowofoyeku (The African Chief),}
 162 {                          I have added better Gnu Pascal support              }
 163 {                                                                              }
 164 {   April   30 2003 - DL : under instruction from David Mears AKA              }
 165 {                          Jason Siletto, I have added FPC Linux support.      }
 166 {                          This was compiled with fpc 1.1, so remember to set  }
 167 {                          include file path. ie. -Fi/usr/share/fpcsrc/rtl/*   }
 168 {                                                                              }
 169 {
 170   $Log: sdl.pas,v $
 171   Revision 1.31  2007/05/29 21:30:48  savage
 172   Changes as suggested by Almindor for 64bit compatibility.
 173
 174   Revision 1.30  2007/05/29 19:31:03  savage
 175   Fix to TSDL_Overlay structure - thanks David Pethes (aka imcold)
 176
 177   Revision 1.29  2007/05/20 20:29:11  savage
 178   Initial Changes to Handle 64 Bits
 179
 180   Revision 1.26  2007/02/11 13:38:04  savage
 181   Added Nintendo DS support - Thanks Dean.
 182
 183   Revision 1.25  2006/12/02 00:12:52  savage
 184   Updated to latest version
 185
 186   Revision 1.24  2006/05/18 21:10:04  savage
 187   Added 1.2.10 Changes
 188
 189   Revision 1.23  2005/12/04 23:17:52  drellis
 190   Added declaration of SInt8 and PSInt8
 191
 192   Revision 1.22  2005/05/24 21:59:03  savage
 193   Re-arranged uses clause to work on Win32 and Linux, Thanks again Michalis.
 194
 195   Revision 1.21  2005/05/22 18:42:31  savage
 196   Changes as suggested by Michalis Kamburelis. Thanks again.
 197
 198   Revision 1.20  2005/04/10 11:48:33  savage
 199   Changes as suggested by Michalis, thanks.
 200
 201   Revision 1.19  2005/01/05 01:47:06  savage
 202   Changed LibName to reflect what MacOS X should have. ie libSDL*-1.2.0.dylib respectively.
 203
 204   Revision 1.18  2005/01/04 23:14:41  savage
 205   Changed LibName to reflect what most Linux distros will have. ie libSDL*-1.2.so.0 respectively.
 206
 207   Revision 1.17  2005/01/03 18:40:59  savage
 208   Updated Version number to reflect latest one
 209
 210   Revision 1.16  2005/01/01 02:02:06  savage
 211   Updated to v1.2.8
 212
 213   Revision 1.15  2004/12/24 18:57:11  savage
 214   forgot to apply Michalis Kamburelis' patch to the implementation section. now fixed
 215
 216   Revision 1.14  2004/12/23 23:42:18  savage
 217   Applied Patches supplied by Michalis Kamburelis ( THANKS! ), for greater FreePascal compatability.
 218
 219   Revision 1.13  2004/09/30 22:31:59  savage
 220   Updated with slightly different header comments
 221
 222   Revision 1.12  2004/09/12 21:52:58  savage
 223   Slight changes to fix some issues with the sdl classes.
 224
 225   Revision 1.11  2004/08/14 22:54:30  savage
 226   Updated so that Library name defines are correctly defined for MacOS X.
 227
 228   Revision 1.10  2004/07/20 23:57:33  savage
 229   Thanks to Paul Toth for spotting an error in the SDL Audio Convertion structures.
 230   In TSDL_AudioCVT the filters variable should point to and array of pointers and not what I had there previously.
 231
 232   Revision 1.9  2004/07/03 22:07:22  savage
 233   Added Bitwise Manipulation Functions for TSDL_VideoInfo struct.
 234
 235   Revision 1.8  2004/05/10 14:10:03  savage
 236   Initial MacOS X support. Fixed defines for MACOS ( Classic ) and DARWIN ( MacOS X ).
 237
 238   Revision 1.7  2004/04/13 09:32:08  savage
 239   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.
 240
 241   Revision 1.6  2004/04/01 20:53:23  savage
 242   Changed Linux Shared Object names so they reflect the Symbolic Links that are created when installing the RPMs from the SDL site.
 243
 244   Revision 1.5  2004/02/22 15:32:10  savage
 245   SDL_GetEnv Fix so it also works on FPC/Linux. Thanks to Rodrigo for pointing this out.
 246
 247   Revision 1.4  2004/02/21 23:24:29  savage
 248   SDL_GetEnv Fix so that it is not define twice for FPC. Thanks to Rene Hugentobler for pointing out this bug,
 249
 250   Revision 1.3  2004/02/18 22:35:51  savage
 251   Brought sdl.pas up to 1.2.7 compatability
 252   Thus...
 253   Added SDL_GL_STEREO,
 254       SDL_GL_MULTISAMPLEBUFFERS,
 255       SDL_GL_MULTISAMPLESAMPLES
 256
 257   Add DLL/Shared object functions
 258   function SDL_LoadObject( const sofile : PChar ) : Pointer;
 259
 260   function SDL_LoadFunction( handle : Pointer; const name : PChar ) : Pointer;
 261
 262   procedure SDL_UnloadObject( handle : Pointer );
 263
 264   Added function to create RWops from const memory: SDL_RWFromConstMem()
 265   function SDL_RWFromConstMem(const mem: Pointer; size: Integer) : PSDL_RWops;
 266
 267   Ported SDL_cpuinfo.h so Now you can test for Specific CPU types.
 268
 269   Revision 1.2  2004/02/17 21:37:12  savage
 270   Tidying up of units
 271
 272   Revision 1.1  2004/02/05 00:08:20  savage
 273   Module 1.0 release
 274
 275 }
 276 {******************************************************************************}
 277
 278 {$I jedi-sdl.inc}
 279
 280 interface
 281
 282 uses
 283 {$IFDEF __GPC__}
 284   system,
 285   {$IFDEF WINDOWS}
 286   wintypes,
 287   {$ELSE}
 288   {$ENDIF}
 289   gpc;
 290 {$ENDIF}
 291
 292 {$IFDEF HAS_TYPES}
 293   Types{$IFNDEF NDS},{$ELSE};{$ENDIF}
 294 {$ENDIF}
 295
 296 {$IFDEF WINDOWS}
 297   Windows;
 298 {$ENDIF}
 299
 300 {$IFDEF OS2}
 301   doscalls;
 302 {$ENDIF OS2}
 303
 304 {$IFDEF UNIX}
 305   {$IFDEF FPC}
 306   pthreads,
 307   unixtype,
 308   baseunix,
 309   {$IFNDEF GP2X}
 310   unix,
 311   {$ELSE}
 312   unix;
 313   {$ENDIF}
 314   {$IFNDEF GP2X}
 315   x,
 316   xlib;
 317   {$ENDIF}
 318   {$ELSE}
 319   Libc,
 320   Xlib;
 321   {$ENDIF}
 322 {$ENDIF}
 323
 324 {$IFDEF __MACH__}
 325   GPCMacOSAll;
 326 {$ENDIF}
 327
 328 {$IFDEF MORPHOS}
 329   exec;
 330 {$ENDIF}
 331
 332 const
 333 {$IFDEF WINDOWS}
 334   SDLLibName = 'SDL.dll';
 335 {$ENDIF}
 336
 337 {$IFDEF OS2}
 338   SDLLibName = 'SDL12.dll';
 339 {$ENDIF OS2}
 340
 341 {$IFDEF UNIX}
 342 {$IFDEF DARWIN}
 343   SDLLibName = 'libSDL-1.2.0.dylib';
 344   {$linklib libSDL-1.2.0}
 345   {$linklib SDLmain}
 346   {$linkframework Cocoa}
 347   {$PASCALMAINNAME SDL_main}
 348 {$ELSE}
 349   {$IFDEF FPC}
 350   SDLLibName = 'libSDL.so';
 351   {$ELSE}
 352   SDLLibName = 'libSDL-1.2.so.0';
 353   {$ENDIF}
 354 {$ENDIF}
 355 {$ENDIF}
 356
 357 {$IFDEF MACOS}
 358   SDLLibName = 'SDL';
 359 {$ENDIF}
 360
 361 {$IFDEF NDS}
 362   SDLLibName = 'libSDL.a';
 363   {$linklib libSDL.a}
 364   {$linklib libnds9.a}
 365   {$linklib libc.a}
 366   {$linklib libgcc.a}
 367   {$linklib libsysbase.a}
 368 {$ENDIF}
 369
 370 {$IFDEF MORPHOS}
 371   SDLLibName = 'powersdl.library';
 372 {$ENDIF}
 373
 374   // SDL_verion.h constants
 375   // Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL
 376   SDL_MAJOR_VERSION = 1;
 377 {$EXTERNALSYM SDL_MAJOR_VERSION}
 378   SDL_MINOR_VERSION = 2;
 379 {$EXTERNALSYM SDL_MINOR_VERSION}
 380   SDL_PATCHLEVEL    = 11;
 381 {$EXTERNALSYM SDL_PATCHLEVEL}
 382
 383   // SDL.h constants
 384   SDL_INIT_TIMER = $00000001;
 385 {$EXTERNALSYM SDL_INIT_TIMER}
 386   SDL_INIT_AUDIO = $00000010;
 387 {$EXTERNALSYM SDL_INIT_AUDIO}
 388   SDL_INIT_VIDEO = $00000020;
 389 {$EXTERNALSYM SDL_INIT_VIDEO}
 390   SDL_INIT_CDROM = $00000100;
 391 {$EXTERNALSYM SDL_INIT_CDROM}
 392   SDL_INIT_JOYSTICK = $00000200;
 393 {$EXTERNALSYM SDL_INIT_JOYSTICK}
 394   SDL_INIT_NOPARACHUTE = $00100000; // Don't catch fatal signals
 395 {$EXTERNALSYM SDL_INIT_NOPARACHUTE}
 396   SDL_INIT_EVENTTHREAD = $01000000; // Not supported on all OS's
 397 {$EXTERNALSYM SDL_INIT_EVENTTHREAD}
 398   SDL_INIT_EVERYTHING = $0000FFFF;
 399 {$EXTERNALSYM SDL_INIT_EVERYTHING}
 400
 401   // SDL_error.h constants
 402   ERR_MAX_STRLEN = 128;
 403 {$EXTERNALSYM ERR_MAX_STRLEN}
 404   ERR_MAX_ARGS = 5;
 405 {$EXTERNALSYM ERR_MAX_ARGS}
 406
 407   // SDL_types.h constants
 408   SDL_PRESSED = $01;
 409 {$EXTERNALSYM SDL_PRESSED}
 410   SDL_RELEASED = $00;
 411 {$EXTERNALSYM SDL_RELEASED}
 412
 413   // SDL_timer.h constants
 414   // This is the OS scheduler timeslice, in milliseconds
 415   SDL_TIMESLICE = 10;
 416 {$EXTERNALSYM SDL_TIMESLICE}
 417   // This is the maximum resolution of the SDL timer on all platforms
 418   TIMER_RESOLUTION = 10; // Experimentally determined
 419 {$EXTERNALSYM TIMER_RESOLUTION}
 420
 421   // SDL_audio.h constants
 422   AUDIO_U8 = $0008; // Unsigned 8-bit samples
 423 {$EXTERNALSYM AUDIO_U8}
 424   AUDIO_S8 = $8008; // Signed 8-bit samples
 425 {$EXTERNALSYM AUDIO_S8}
 426   AUDIO_U16LSB = $0010; // Unsigned 16-bit samples
 427 {$EXTERNALSYM AUDIO_U16LSB}
 428   AUDIO_S16LSB = $8010; // Signed 16-bit samples
 429 {$EXTERNALSYM AUDIO_S16LSB}
 430   AUDIO_U16MSB = $1010; // As above, but big-endian byte order
 431 {$EXTERNALSYM AUDIO_U16MSB}
 432   AUDIO_S16MSB = $9010; // As above, but big-endian byte order
 433 {$EXTERNALSYM AUDIO_S16MSB}
 434   AUDIO_U16 = AUDIO_U16LSB;
 435 {$EXTERNALSYM AUDIO_U16}
 436   AUDIO_S16 = AUDIO_S16LSB;
 437 {$EXTERNALSYM AUDIO_S16}
 438
 439
 440   // SDL_cdrom.h constants
 441   // The maximum number of CD-ROM tracks on a disk
 442   SDL_MAX_TRACKS = 99;
 443 {$EXTERNALSYM SDL_MAX_TRACKS}
 444   // The types of CD-ROM track possible
 445   SDL_AUDIO_TRACK = $00;
 446 {$EXTERNALSYM SDL_AUDIO_TRACK}
 447   SDL_DATA_TRACK = $04;
 448 {$EXTERNALSYM SDL_DATA_TRACK}
 449
 450   // Conversion functions from frames to Minute/Second/Frames and vice versa
 451   CD_FPS = 75;
 452 {$EXTERNALSYM CD_FPS}
 453   // SDL_byteorder.h constants
 454   // The two types of endianness
 455   SDL_LIL_ENDIAN = 1234;
 456 {$EXTERNALSYM SDL_LIL_ENDIAN}
 457   SDL_BIG_ENDIAN = 4321;
 458 {$EXTERNALSYM SDL_BIG_ENDIAN}
 459
 460 {$IFDEF IA32}
 461
 462   SDL_BYTEORDER = SDL_LIL_ENDIAN;
 463 {$EXTERNALSYM SDL_BYTEORDER}
 464   // Native audio byte ordering
 465   AUDIO_U16SYS = AUDIO_U16LSB;
 466 {$EXTERNALSYM AUDIO_U16SYS}
 467   AUDIO_S16SYS = AUDIO_S16LSB;
 468 {$EXTERNALSYM AUDIO_S16SYS}
 469
 470 {$ELSE}
 471
 472   SDL_BYTEORDER = SDL_BIG_ENDIAN;
 473 {$EXTERNALSYM SDL_BYTEORDER}
 474   // Native audio byte ordering
 475   AUDIO_U16SYS = AUDIO_U16MSB;
 476 {$EXTERNALSYM AUDIO_U16SYS}
 477   AUDIO_S16SYS = AUDIO_S16MSB;
 478 {$EXTERNALSYM AUDIO_S16SYS}
 479
 480 {$ENDIF}
 481
 482
 483   SDL_MIX_MAXVOLUME = 128;
 484 {$EXTERNALSYM SDL_MIX_MAXVOLUME}
 485
 486   // SDL_joystick.h constants
 487   MAX_JOYSTICKS = 2; // only 2 are supported in the multimedia API
 488 {$EXTERNALSYM MAX_JOYSTICKS}
 489   MAX_AXES = 6; // each joystick can have up to 6 axes
 490 {$EXTERNALSYM MAX_AXES}
 491   MAX_BUTTONS = 32; // and 32 buttons
 492 {$EXTERNALSYM MAX_BUTTONS}
 493   AXIS_MIN = -32768; // minimum value for axis coordinate
 494 {$EXTERNALSYM AXIS_MIN}
 495   AXIS_MAX = 32767; // maximum value for axis coordinate
 496 {$EXTERNALSYM AXIS_MAX}
 497   JOY_AXIS_THRESHOLD = (((AXIS_MAX) - (AXIS_MIN)) / 100); // 1% motion
 498 {$EXTERNALSYM JOY_AXIS_THRESHOLD}
 499   //JOY_BUTTON_FLAG(n)        (1<<n)
 500   // array to hold joystick ID values
 501   //static UInt        SYS_JoystickID[MAX_JOYSTICKS];
 502   //static JOYCAPS        SYS_Joystick[MAX_JOYSTICKS];
 503
 504   { Get the current state of a POV hat on a joystick
 505     The return value is one of the following positions: }
 506   SDL_HAT_CENTERED = $00;
 507 {$EXTERNALSYM SDL_HAT_CENTERED}
 508   SDL_HAT_UP = $01;
 509 {$EXTERNALSYM SDL_HAT_UP}
 510   SDL_HAT_RIGHT = $02;
 511 {$EXTERNALSYM SDL_HAT_RIGHT}
 512   SDL_HAT_DOWN = $04;
 513 {$EXTERNALSYM SDL_HAT_DOWN}
 514   SDL_HAT_LEFT = $08;
 515 {$EXTERNALSYM SDL_HAT_LEFT}
 516   SDL_HAT_RIGHTUP = SDL_HAT_RIGHT or SDL_HAT_UP;
 517 {$EXTERNALSYM SDL_HAT_RIGHTUP}
 518   SDL_HAT_RIGHTDOWN = SDL_HAT_RIGHT or SDL_HAT_DOWN;
 519 {$EXTERNALSYM SDL_HAT_RIGHTDOWN}
 520   SDL_HAT_LEFTUP = SDL_HAT_LEFT or SDL_HAT_UP;
 521 {$EXTERNALSYM SDL_HAT_LEFTUP}
 522   SDL_HAT_LEFTDOWN = SDL_HAT_LEFT or SDL_HAT_DOWN;
 523 {$EXTERNALSYM SDL_HAT_LEFTDOWN}
 524
 525   // SDL_events.h constants
 526   SDL_NOEVENT = 0; // Unused (do not remove)
 527 {$EXTERNALSYM SDL_NOEVENT}
 528   SDL_ACTIVEEVENT = 1; // Application loses/gains visibility
 529 {$EXTERNALSYM SDL_ACTIVEEVENT}
 530   SDL_KEYDOWN = 2; // Keys pressed
 531 {$EXTERNALSYM SDL_KEYDOWN}
 532   SDL_KEYUP = 3; // Keys released
 533 {$EXTERNALSYM SDL_KEYUP}
 534   SDL_MOUSEMOTION = 4; // Mouse moved
 535 {$EXTERNALSYM SDL_MOUSEMOTION}
 536   SDL_MOUSEBUTTONDOWN = 5; // Mouse button pressed
 537 {$EXTERNALSYM SDL_MOUSEBUTTONDOWN}
 538   SDL_MOUSEBUTTONUP = 6; // Mouse button released
 539 {$EXTERNALSYM SDL_MOUSEBUTTONUP}
 540   SDL_JOYAXISMOTION = 7; // Joystick axis motion
 541 {$EXTERNALSYM SDL_JOYAXISMOTION}
 542   SDL_JOYBALLMOTION = 8; // Joystick trackball motion
 543 {$EXTERNALSYM SDL_JOYBALLMOTION}
 544   SDL_JOYHATMOTION = 9; // Joystick hat position change
 545 {$EXTERNALSYM SDL_JOYHATMOTION}
 546   SDL_JOYBUTTONDOWN = 10; // Joystick button pressed
 547 {$EXTERNALSYM SDL_JOYBUTTONDOWN}
 548   SDL_JOYBUTTONUP = 11; // Joystick button released
 549 {$EXTERNALSYM SDL_JOYBUTTONUP}
 550   SDL_QUITEV = 12; // User-requested quit ( Changed due to procedure conflict )
 551 {$EXTERNALSYM SDL_QUIT}
 552   SDL_SYSWMEVENT = 13; // System specific event
 553 {$EXTERNALSYM SDL_SYSWMEVENT}
 554   SDL_EVENT_RESERVEDA = 14; // Reserved for future use..
 555 {$EXTERNALSYM SDL_EVENT_RESERVEDA}
 556   SDL_EVENT_RESERVED = 15; // Reserved for future use..
 557 {$EXTERNALSYM SDL_EVENT_RESERVED}
 558   SDL_VIDEORESIZE = 16; // User resized video mode
 559 {$EXTERNALSYM SDL_VIDEORESIZE}
 560   SDL_VIDEOEXPOSE = 17; // Screen needs to be redrawn
 561 {$EXTERNALSYM SDL_VIDEOEXPOSE}
 562   SDL_EVENT_RESERVED2 = 18; // Reserved for future use..
 563 {$EXTERNALSYM SDL_EVENT_RESERVED2}
 564   SDL_EVENT_RESERVED3 = 19; // Reserved for future use..
 565 {$EXTERNALSYM SDL_EVENT_RESERVED3}
 566   SDL_EVENT_RESERVED4 = 20; // Reserved for future use..
 567 {$EXTERNALSYM SDL_EVENT_RESERVED4}
 568   SDL_EVENT_RESERVED5 = 21; // Reserved for future use..
 569 {$EXTERNALSYM SDL_EVENT_RESERVED5}
 570   SDL_EVENT_RESERVED6 = 22; // Reserved for future use..
 571 {$EXTERNALSYM SDL_EVENT_RESERVED6}
 572   SDL_EVENT_RESERVED7 = 23; // Reserved for future use..
 573 {$EXTERNALSYM SDL_EVENT_RESERVED7}
 574   // Events SDL_USEREVENT through SDL_MAXEVENTS-1 are for your use
 575   SDL_USEREVENT = 24;
 576 {$EXTERNALSYM SDL_USEREVENT}
 577   // This last event is only for bounding internal arrays
 578   // It is the number of bits in the event mask datatype -- UInt32
 579   SDL_NUMEVENTS = 32;
 580 {$EXTERNALSYM SDL_NUMEVENTS}
 581
 582   SDL_ALLEVENTS = $FFFFFFFF;
 583 {$EXTERNALSYM SDL_ALLEVENTS}
 584
 585   SDL_ACTIVEEVENTMASK = 1 shl SDL_ACTIVEEVENT;
 586 {$EXTERNALSYM SDL_ACTIVEEVENTMASK}
 587   SDL_KEYDOWNMASK = 1 shl SDL_KEYDOWN;
 588 {$EXTERNALSYM SDL_KEYDOWNMASK}
 589   SDL_KEYUPMASK = 1 shl SDL_KEYUP;
 590 {$EXTERNALSYM SDL_KEYUPMASK}
 591   SDL_MOUSEMOTIONMASK = 1 shl SDL_MOUSEMOTION;
 592 {$EXTERNALSYM SDL_MOUSEMOTIONMASK}
 593   SDL_MOUSEBUTTONDOWNMASK = 1 shl SDL_MOUSEBUTTONDOWN;
 594 {$EXTERNALSYM SDL_MOUSEBUTTONDOWNMASK}
 595   SDL_MOUSEBUTTONUPMASK = 1 shl SDL_MOUSEBUTTONUP;
 596 {$EXTERNALSYM SDL_MOUSEBUTTONUPMASK}
 597   SDL_MOUSEEVENTMASK = 1 shl SDL_MOUSEMOTION or
 598     1 shl SDL_MOUSEBUTTONDOWN or
 599     1 shl SDL_MOUSEBUTTONUP;
 600 {$EXTERNALSYM SDL_MOUSEEVENTMASK}
 601   SDL_JOYAXISMOTIONMASK = 1 shl SDL_JOYAXISMOTION;
 602 {$EXTERNALSYM SDL_JOYAXISMOTIONMASK}
 603   SDL_JOYBALLMOTIONMASK = 1 shl SDL_JOYBALLMOTION;
 604 {$EXTERNALSYM SDL_JOYBALLMOTIONMASK}
 605   SDL_JOYHATMOTIONMASK = 1 shl SDL_JOYHATMOTION;
 606 {$EXTERNALSYM SDL_JOYHATMOTIONMASK}
 607   SDL_JOYBUTTONDOWNMASK = 1 shl SDL_JOYBUTTONDOWN;
 608 {$EXTERNALSYM SDL_JOYBUTTONDOWNMASK}
 609   SDL_JOYBUTTONUPMASK = 1 shl SDL_JOYBUTTONUP;
 610 {$EXTERNALSYM SDL_JOYBUTTONUPMASK}
 611   SDL_JOYEVENTMASK = 1 shl SDL_JOYAXISMOTION or
 612     1 shl SDL_JOYBALLMOTION or
 613     1 shl SDL_JOYHATMOTION or
 614     1 shl SDL_JOYBUTTONDOWN or
 615     1 shl SDL_JOYBUTTONUP;
 616 {$EXTERNALSYM SDL_JOYEVENTMASK}
 617   SDL_VIDEORESIZEMASK = 1 shl SDL_VIDEORESIZE;
 618 {$EXTERNALSYM SDL_VIDEORESIZEMASK}
 619   SDL_QUITMASK = 1 shl SDL_QUITEV;
 620 {$EXTERNALSYM SDL_QUITMASK}
 621   SDL_SYSWMEVENTMASK = 1 shl SDL_SYSWMEVENT;
 622 {$EXTERNALSYM SDL_SYSWMEVENTMASK}
 623
 624   { This function allows you to set the state of processing certain events.
 625     If 'state' is set to SDL_IGNORE, that event will be automatically dropped
 626     from the event queue and will not event be filtered.
 627     If 'state' is set to SDL_ENABLE, that event will be processed normally.
 628     If 'state' is set to SDL_QUERY, SDL_EventState() will return the
 629     current processing state of the specified event. }
 630
 631   SDL_QUERY = -1;
 632 {$EXTERNALSYM SDL_QUERY}
 633   SDL_IGNORE = 0;
 634 {$EXTERNALSYM SDL_IGNORE}
 635   SDL_DISABLE = 0;
 636 {$EXTERNALSYM SDL_DISABLE}
 637   SDL_ENABLE = 1;
 638 {$EXTERNALSYM SDL_ENABLE}
 639
 640   //SDL_keyboard.h constants
 641   // This is the mask which refers to all hotkey bindings
 642   SDL_ALL_HOTKEYS = $FFFFFFFF;
 643 {$EXTERNALSYM SDL_ALL_HOTKEYS}
 644
 645 { Enable/Disable keyboard repeat.  Keyboard repeat defaults to off.
 646   'delay' is the initial delay in ms between the time when a key is
 647   pressed, and keyboard repeat begins.
 648   'interval' is the time in ms between keyboard repeat events. }
 649
 650   SDL_DEFAULT_REPEAT_DELAY = 500;
 651 {$EXTERNALSYM SDL_DEFAULT_REPEAT_DELAY}
 652   SDL_DEFAULT_REPEAT_INTERVAL = 30;
 653 {$EXTERNALSYM SDL_DEFAULT_REPEAT_INTERVAL}
 654
 655   // The keyboard syms have been cleverly chosen to map to ASCII
 656   SDLK_UNKNOWN = 0;
 657 {$EXTERNALSYM SDLK_UNKNOWN}
 658   SDLK_FIRST = 0;
 659 {$EXTERNALSYM SDLK_FIRST}
 660   SDLK_BACKSPACE = 8;
 661 {$EXTERNALSYM SDLK_BACKSPACE}
 662   SDLK_TAB = 9;
 663 {$EXTERNALSYM SDLK_TAB}
 664   SDLK_CLEAR = 12;
 665 {$EXTERNALSYM SDLK_CLEAR}
 666   SDLK_RETURN = 13;
 667 {$EXTERNALSYM SDLK_RETURN}
 668   SDLK_PAUSE = 19;
 669 {$EXTERNALSYM SDLK_PAUSE}
 670   SDLK_ESCAPE = 27;
 671 {$EXTERNALSYM SDLK_ESCAPE}
 672   SDLK_SPACE = 32;
 673 {$EXTERNALSYM SDLK_SPACE}
 674   SDLK_EXCLAIM = 33;
 675 {$EXTERNALSYM SDLK_EXCLAIM}
 676   SDLK_QUOTEDBL = 34;
 677 {$EXTERNALSYM SDLK_QUOTEDBL}
 678   SDLK_HASH = 35;
 679 {$EXTERNALSYM SDLK_HASH}
 680   SDLK_DOLLAR = 36;
 681 {$EXTERNALSYM SDLK_DOLLAR}
 682   SDLK_AMPERSAND = 38;
 683 {$EXTERNALSYM SDLK_AMPERSAND}
 684   SDLK_QUOTE = 39;
 685 {$EXTERNALSYM SDLK_QUOTE}
 686   SDLK_LEFTPAREN = 40;
 687 {$EXTERNALSYM SDLK_LEFTPAREN}
 688   SDLK_RIGHTPAREN = 41;
 689 {$EXTERNALSYM SDLK_RIGHTPAREN}
 690   SDLK_ASTERISK = 42;
 691 {$EXTERNALSYM SDLK_ASTERISK}
 692   SDLK_PLUS = 43;
 693 {$EXTERNALSYM SDLK_PLUS}
 694   SDLK_COMMA = 44;
 695 {$EXTERNALSYM SDLK_COMMA}
 696   SDLK_MINUS = 45;
 697 {$EXTERNALSYM SDLK_MINUS}
 698   SDLK_PERIOD = 46;
 699 {$EXTERNALSYM SDLK_PERIOD}
 700   SDLK_SLASH = 47;
 701 {$EXTERNALSYM SDLK_SLASH}
 702   SDLK_0 = 48;
 703 {$EXTERNALSYM SDLK_0}
 704   SDLK_1 = 49;
 705 {$EXTERNALSYM SDLK_1}
 706   SDLK_2 = 50;
 707 {$EXTERNALSYM SDLK_2}
 708   SDLK_3 = 51;
 709 {$EXTERNALSYM SDLK_3}
 710   SDLK_4 = 52;
 711 {$EXTERNALSYM SDLK_4}
 712   SDLK_5 = 53;
 713 {$EXTERNALSYM SDLK_5}
 714   SDLK_6 = 54;
 715 {$EXTERNALSYM SDLK_6}
 716   SDLK_7 = 55;
 717 {$EXTERNALSYM SDLK_7}
 718   SDLK_8 = 56;
 719 {$EXTERNALSYM SDLK_8}
 720   SDLK_9 = 57;
 721 {$EXTERNALSYM SDLK_9}
 722   SDLK_COLON = 58;
 723 {$EXTERNALSYM SDLK_COLON}
 724   SDLK_SEMICOLON = 59;
 725 {$EXTERNALSYM SDLK_SEMICOLON}
 726   SDLK_LESS = 60;
 727 {$EXTERNALSYM SDLK_LESS}
 728   SDLK_EQUALS = 61;
 729 {$EXTERNALSYM SDLK_EQUALS}
 730   SDLK_GREATER = 62;
 731 {$EXTERNALSYM SDLK_GREATER}
 732   SDLK_QUESTION = 63;
 733 {$EXTERNALSYM SDLK_QUESTION}
 734   SDLK_AT = 64;
 735 {$EXTERNALSYM SDLK_AT}
 736
 737   { Skip uppercase letters }
 738
 739   SDLK_LEFTBRACKET = 91;
 740 {$EXTERNALSYM SDLK_LEFTBRACKET}
 741   SDLK_BACKSLASH = 92;
 742 {$EXTERNALSYM SDLK_BACKSLASH}
 743   SDLK_RIGHTBRACKET = 93;
 744 {$EXTERNALSYM SDLK_RIGHTBRACKET}
 745   SDLK_CARET = 94;
 746 {$EXTERNALSYM SDLK_CARET}
 747   SDLK_UNDERSCORE = 95;
 748 {$EXTERNALSYM SDLK_UNDERSCORE}
 749   SDLK_BACKQUOTE = 96;
 750 {$EXTERNALSYM SDLK_BACKQUOTE}
 751   SDLK_a = 97;
 752 {$EXTERNALSYM SDLK_a}
 753   SDLK_b = 98;
 754 {$EXTERNALSYM SDLK_b}
 755   SDLK_c = 99;
 756 {$EXTERNALSYM SDLK_c}
 757   SDLK_d = 100;
 758 {$EXTERNALSYM SDLK_d}
 759   SDLK_e = 101;
 760 {$EXTERNALSYM SDLK_e}
 761   SDLK_f = 102;
 762 {$EXTERNALSYM SDLK_f}
 763   SDLK_g = 103;
 764 {$EXTERNALSYM SDLK_g}
 765   SDLK_h = 104;
 766 {$EXTERNALSYM SDLK_h}
 767   SDLK_i = 105;
 768 {$EXTERNALSYM SDLK_i}
 769   SDLK_j = 106;
 770 {$EXTERNALSYM SDLK_j}
 771   SDLK_k = 107;
 772 {$EXTERNALSYM SDLK_k}
 773   SDLK_l = 108;
 774 {$EXTERNALSYM SDLK_l}
 775   SDLK_m = 109;
 776 {$EXTERNALSYM SDLK_m}
 777   SDLK_n = 110;
 778 {$EXTERNALSYM SDLK_n}
 779   SDLK_o = 111;
 780 {$EXTERNALSYM SDLK_o}
 781   SDLK_p = 112;
 782 {$EXTERNALSYM SDLK_p}
 783   SDLK_q = 113;
 784 {$EXTERNALSYM SDLK_q}
 785   SDLK_r = 114;
 786 {$EXTERNALSYM SDLK_r}
 787   SDLK_s = 115;
 788 {$EXTERNALSYM SDLK_s}
 789   SDLK_t = 116;
 790 {$EXTERNALSYM SDLK_t}
 791   SDLK_u = 117;
 792 {$EXTERNALSYM SDLK_u}
 793   SDLK_v = 118;
 794 {$EXTERNALSYM SDLK_v}
 795   SDLK_w = 119;
 796 {$EXTERNALSYM SDLK_w}
 797   SDLK_x = 120;
 798 {$EXTERNALSYM SDLK_x}
 799   SDLK_y = 121;
 800 {$EXTERNALSYM SDLK_y}
 801   SDLK_z = 122;
 802 {$EXTERNALSYM SDLK_z}
 803   SDLK_DELETE = 127;
 804 {$EXTERNALSYM SDLK_DELETE}
 805   // End of ASCII mapped keysyms
 806
 807   // International keyboard syms
 808   SDLK_WORLD_0 = 160; // 0xA0
 809 {$EXTERNALSYM SDLK_WORLD_0}
 810   SDLK_WORLD_1 = 161;
 811 {$EXTERNALSYM SDLK_WORLD_1}
 812   SDLK_WORLD_2 = 162;
 813 {$EXTERNALSYM SDLK_WORLD_2}
 814   SDLK_WORLD_3 = 163;
 815 {$EXTERNALSYM SDLK_WORLD_3}
 816   SDLK_WORLD_4 = 164;
 817 {$EXTERNALSYM SDLK_WORLD_4}
 818   SDLK_WORLD_5 = 165;
 819 {$EXTERNALSYM SDLK_WORLD_5}
 820   SDLK_WORLD_6 = 166;
 821 {$EXTERNALSYM SDLK_WORLD_6}
 822   SDLK_WORLD_7 = 167;
 823 {$EXTERNALSYM SDLK_WORLD_7}
 824   SDLK_WORLD_8 = 168;
 825 {$EXTERNALSYM SDLK_WORLD_8}
 826   SDLK_WORLD_9 = 169;
 827 {$EXTERNALSYM SDLK_WORLD_9}
 828   SDLK_WORLD_10 = 170;
 829 {$EXTERNALSYM SDLK_WORLD_10}
 830   SDLK_WORLD_11 = 171;
 831 {$EXTERNALSYM SDLK_WORLD_11}
 832   SDLK_WORLD_12 = 172;
 833 {$EXTERNALSYM SDLK_WORLD_12}
 834   SDLK_WORLD_13 = 173;
 835 {$EXTERNALSYM SDLK_WORLD_13}
 836   SDLK_WORLD_14 = 174;
 837 {$EXTERNALSYM SDLK_WORLD_14}
 838   SDLK_WORLD_15 = 175;
 839 {$EXTERNALSYM SDLK_WORLD_15}
 840   SDLK_WORLD_16 = 176;
 841 {$EXTERNALSYM SDLK_WORLD_16}
 842   SDLK_WORLD_17 = 177;
 843 {$EXTERNALSYM SDLK_WORLD_17}
 844   SDLK_WORLD_18 = 178;
 845 {$EXTERNALSYM SDLK_WORLD_18}
 846   SDLK_WORLD_19 = 179;
 847 {$EXTERNALSYM SDLK_WORLD_19}
 848   SDLK_WORLD_20 = 180;
 849 {$EXTERNALSYM SDLK_WORLD_20}
 850   SDLK_WORLD_21 = 181;
 851 {$EXTERNALSYM SDLK_WORLD_21}
 852   SDLK_WORLD_22 = 182;
 853 {$EXTERNALSYM SDLK_WORLD_22}
 854   SDLK_WORLD_23 = 183;
 855 {$EXTERNALSYM SDLK_WORLD_23}
 856   SDLK_WORLD_24 = 184;
 857 {$EXTERNALSYM SDLK_WORLD_24}
 858   SDLK_WORLD_25 = 185;
 859 {$EXTERNALSYM SDLK_WORLD_25}
 860   SDLK_WORLD_26 = 186;
 861 {$EXTERNALSYM SDLK_WORLD_26}
 862   SDLK_WORLD_27 = 187;
 863 {$EXTERNALSYM SDLK_WORLD_27}
 864   SDLK_WORLD_28 = 188;
 865 {$EXTERNALSYM SDLK_WORLD_28}
 866   SDLK_WORLD_29 = 189;
 867 {$EXTERNALSYM SDLK_WORLD_29}
 868   SDLK_WORLD_30 = 190;
 869 {$EXTERNALSYM SDLK_WORLD_30}
 870   SDLK_WORLD_31 = 191;
 871 {$EXTERNALSYM SDLK_WORLD_31}
 872   SDLK_WORLD_32 = 192;
 873 {$EXTERNALSYM SDLK_WORLD_32}
 874   SDLK_WORLD_33 = 193;
 875 {$EXTERNALSYM SDLK_WORLD_33}
 876   SDLK_WORLD_34 = 194;
 877 {$EXTERNALSYM SDLK_WORLD_34}
 878   SDLK_WORLD_35 = 195;
 879 {$EXTERNALSYM SDLK_WORLD_35}
 880   SDLK_WORLD_36 = 196;
 881 {$EXTERNALSYM SDLK_WORLD_36}
 882   SDLK_WORLD_37 = 197;
 883 {$EXTERNALSYM SDLK_WORLD_37}
 884   SDLK_WORLD_38 = 198;
 885 {$EXTERNALSYM SDLK_WORLD_38}
 886   SDLK_WORLD_39 = 199;
 887 {$EXTERNALSYM SDLK_WORLD_39}
 888   SDLK_WORLD_40 = 200;
 889 {$EXTERNALSYM SDLK_WORLD_40}
 890   SDLK_WORLD_41 = 201;
 891 {$EXTERNALSYM SDLK_WORLD_41}
 892   SDLK_WORLD_42 = 202;
 893 {$EXTERNALSYM SDLK_WORLD_42}
 894   SDLK_WORLD_43 = 203;
 895 {$EXTERNALSYM SDLK_WORLD_43}
 896   SDLK_WORLD_44 = 204;
 897 {$EXTERNALSYM SDLK_WORLD_44}
 898   SDLK_WORLD_45 = 205;
 899 {$EXTERNALSYM SDLK_WORLD_45}
 900   SDLK_WORLD_46 = 206;
 901 {$EXTERNALSYM SDLK_WORLD_46}
 902   SDLK_WORLD_47 = 207;
 903 {$EXTERNALSYM SDLK_WORLD_47}
 904   SDLK_WORLD_48 = 208;
 905 {$EXTERNALSYM SDLK_WORLD_48}
 906   SDLK_WORLD_49 = 209;
 907 {$EXTERNALSYM SDLK_WORLD_49}
 908   SDLK_WORLD_50 = 210;
 909 {$EXTERNALSYM SDLK_WORLD_50}
 910   SDLK_WORLD_51 = 211;
 911 {$EXTERNALSYM SDLK_WORLD_51}
 912   SDLK_WORLD_52 = 212;
 913 {$EXTERNALSYM SDLK_WORLD_52}
 914   SDLK_WORLD_53 = 213;
 915 {$EXTERNALSYM SDLK_WORLD_53}
 916   SDLK_WORLD_54 = 214;
 917 {$EXTERNALSYM SDLK_WORLD_54}
 918   SDLK_WORLD_55 = 215;
 919 {$EXTERNALSYM SDLK_WORLD_55}
 920   SDLK_WORLD_56 = 216;
 921 {$EXTERNALSYM SDLK_WORLD_56}
 922   SDLK_WORLD_57 = 217;
 923 {$EXTERNALSYM SDLK_WORLD_57}
 924   SDLK_WORLD_58 = 218;
 925 {$EXTERNALSYM SDLK_WORLD_58}
 926   SDLK_WORLD_59 = 219;
 927 {$EXTERNALSYM SDLK_WORLD_59}
 928   SDLK_WORLD_60 = 220;
 929 {$EXTERNALSYM SDLK_WORLD_60}
 930   SDLK_WORLD_61 = 221;
 931 {$EXTERNALSYM SDLK_WORLD_61}
 932   SDLK_WORLD_62 = 222;
 933 {$EXTERNALSYM SDLK_WORLD_62}
 934   SDLK_WORLD_63 = 223;
 935 {$EXTERNALSYM SDLK_WORLD_63}
 936   SDLK_WORLD_64 = 224;
 937 {$EXTERNALSYM SDLK_WORLD_64}
 938   SDLK_WORLD_65 = 225;
 939 {$EXTERNALSYM SDLK_WORLD_65}
 940   SDLK_WORLD_66 = 226;
 941 {$EXTERNALSYM SDLK_WORLD_66}
 942   SDLK_WORLD_67 = 227;
 943 {$EXTERNALSYM SDLK_WORLD_67}
 944   SDLK_WORLD_68 = 228;
 945 {$EXTERNALSYM SDLK_WORLD_68}
 946   SDLK_WORLD_69 = 229;
 947 {$EXTERNALSYM SDLK_WORLD_69}
 948   SDLK_WORLD_70 = 230;
 949 {$EXTERNALSYM SDLK_WORLD_70}
 950   SDLK_WORLD_71 = 231;
 951 {$EXTERNALSYM SDLK_WORLD_71}
 952   SDLK_WORLD_72 = 232;
 953 {$EXTERNALSYM SDLK_WORLD_72}
 954   SDLK_WORLD_73 = 233;
 955 {$EXTERNALSYM SDLK_WORLD_73}
 956   SDLK_WORLD_74 = 234;
 957 {$EXTERNALSYM SDLK_WORLD_74}
 958   SDLK_WORLD_75 = 235;
 959 {$EXTERNALSYM SDLK_WORLD_75}
 960   SDLK_WORLD_76 = 236;
 961 {$EXTERNALSYM SDLK_WORLD_76}
 962   SDLK_WORLD_77 = 237;
 963 {$EXTERNALSYM SDLK_WORLD_77}
 964   SDLK_WORLD_78 = 238;
 965 {$EXTERNALSYM SDLK_WORLD_78}
 966   SDLK_WORLD_79 = 239;
 967 {$EXTERNALSYM SDLK_WORLD_79}
 968   SDLK_WORLD_80 = 240;
 969 {$EXTERNALSYM SDLK_WORLD_80}
 970   SDLK_WORLD_81 = 241;
 971 {$EXTERNALSYM SDLK_WORLD_81}
 972   SDLK_WORLD_82 = 242;
 973 {$EXTERNALSYM SDLK_WORLD_82}
 974   SDLK_WORLD_83 = 243;
 975 {$EXTERNALSYM SDLK_WORLD_83}
 976   SDLK_WORLD_84 = 244;
 977 {$EXTERNALSYM SDLK_WORLD_84}
 978   SDLK_WORLD_85 = 245;
 979 {$EXTERNALSYM SDLK_WORLD_85}
 980   SDLK_WORLD_86 = 246;
 981 {$EXTERNALSYM SDLK_WORLD_86}
 982   SDLK_WORLD_87 = 247;
 983 {$EXTERNALSYM SDLK_WORLD_87}
 984   SDLK_WORLD_88 = 248;
 985 {$EXTERNALSYM SDLK_WORLD_88}
 986   SDLK_WORLD_89 = 249;
 987 {$EXTERNALSYM SDLK_WORLD_89}
 988   SDLK_WORLD_90 = 250;
 989 {$EXTERNALSYM SDLK_WORLD_90}
 990   SDLK_WORLD_91 = 251;
 991 {$EXTERNALSYM SDLK_WORLD_91}
 992   SDLK_WORLD_92 = 252;
 993 {$EXTERNALSYM SDLK_WORLD_92}
 994   SDLK_WORLD_93 = 253;
 995 {$EXTERNALSYM SDLK_WORLD_93}
 996   SDLK_WORLD_94 = 254;
 997 {$EXTERNALSYM SDLK_WORLD_94}
 998   SDLK_WORLD_95 = 255; // 0xFF
 999 {$EXTERNALSYM SDLK_WORLD_95}
1000
1001   // Numeric keypad
1002   SDLK_KP0 = 256;
1003 {$EXTERNALSYM SDLK_KP0}
1004   SDLK_KP1 = 257;
1005 {$EXTERNALSYM SDLK_KP1}
1006   SDLK_KP2 = 258;
1007 {$EXTERNALSYM SDLK_KP2}
1008   SDLK_KP3 = 259;
1009 {$EXTERNALSYM SDLK_KP3}
1010   SDLK_KP4 = 260;
1011 {$EXTERNALSYM SDLK_KP4}
1012   SDLK_KP5 = 261;
1013 {$EXTERNALSYM SDLK_KP5}
1014   SDLK_KP6 = 262;
1015 {$EXTERNALSYM SDLK_KP6}
1016   SDLK_KP7 = 263;
1017 {$EXTERNALSYM SDLK_KP7}
1018   SDLK_KP8 = 264;
1019 {$EXTERNALSYM SDLK_KP8}
1020   SDLK_KP9 = 265;
1021 {$EXTERNALSYM SDLK_KP9}
1022   SDLK_KP_PERIOD = 266;
1023 {$EXTERNALSYM SDLK_KP_PERIOD}
1024   SDLK_KP_DIVIDE = 267;
1025 {$EXTERNALSYM SDLK_KP_DIVIDE}
1026   SDLK_KP_MULTIPLY = 268;
1027 {$EXTERNALSYM SDLK_KP_MULTIPLY}
1028   SDLK_KP_MINUS = 269;
1029 {$EXTERNALSYM SDLK_KP_MINUS}
1030   SDLK_KP_PLUS = 270;
1031 {$EXTERNALSYM SDLK_KP_PLUS}
1032   SDLK_KP_ENTER = 271;
1033 {$EXTERNALSYM SDLK_KP_ENTER}
1034   SDLK_KP_EQUALS = 272;
1035 {$EXTERNALSYM SDLK_KP_EQUALS}
1036
1037   // Arrows + Home/End pad
1038   SDLK_UP = 273;
1039 {$EXTERNALSYM SDLK_UP}
1040   SDLK_DOWN = 274;
1041 {$EXTERNALSYM SDLK_DOWN}
1042   SDLK_RIGHT = 275;
1043 {$EXTERNALSYM SDLK_RIGHT}
1044   SDLK_LEFT = 276;
1045 {$EXTERNALSYM SDLK_LEFT}
1046   SDLK_INSERT = 277;
1047 {$EXTERNALSYM SDLK_INSERT}
1048   SDLK_HOME = 278;
1049 {$EXTERNALSYM SDLK_HOME}
1050   SDLK_END = 279;
1051 {$EXTERNALSYM SDLK_END}
1052   SDLK_PAGEUP = 280;
1053 {$EXTERNALSYM SDLK_PAGEUP}
1054   SDLK_PAGEDOWN = 281;
1055 {$EXTERNALSYM SDLK_PAGEDOWN}
1056
1057   // Function keys
1058   SDLK_F1 = 282;
1059 {$EXTERNALSYM SDLK_F1}
1060   SDLK_F2 = 283;
1061 {$EXTERNALSYM SDLK_F2}
1062   SDLK_F3 = 284;
1063 {$EXTERNALSYM SDLK_F3}
1064   SDLK_F4 = 285;
1065 {$EXTERNALSYM SDLK_F4}
1066   SDLK_F5 = 286;
1067 {$EXTERNALSYM SDLK_F5}
1068   SDLK_F6 = 287;
1069 {$EXTERNALSYM SDLK_F6}
1070   SDLK_F7 = 288;
1071 {$EXTERNALSYM SDLK_F7}
1072   SDLK_F8 = 289;
1073 {$EXTERNALSYM SDLK_F8}
1074   SDLK_F9 = 290;
1075 {$EXTERNALSYM SDLK_F9}
1076   SDLK_F10 = 291;
1077 {$EXTERNALSYM SDLK_F10}
1078   SDLK_F11 = 292;
1079 {$EXTERNALSYM SDLK_F11}
1080   SDLK_F12 = 293;
1081 {$EXTERNALSYM SDLK_F12}
1082   SDLK_F13 = 294;
1083 {$EXTERNALSYM SDLK_F13}
1084   SDLK_F14 = 295;
1085 {$EXTERNALSYM SDLK_F14}
1086   SDLK_F15 = 296;
1087 {$EXTERNALSYM SDLK_F15}
1088
1089   // Key state modifier keys
1090   SDLK_NUMLOCK = 300;
1091 {$EXTERNALSYM SDLK_NUMLOCK}
1092   SDLK_CAPSLOCK = 301;
1093 {$EXTERNALSYM SDLK_CAPSLOCK}
1094   SDLK_SCROLLOCK = 302;
1095 {$EXTERNALSYM SDLK_SCROLLOCK}
1096   SDLK_RSHIFT = 303;
1097 {$EXTERNALSYM SDLK_RSHIFT}
1098   SDLK_LSHIFT = 304;
1099 {$EXTERNALSYM SDLK_LSHIFT}
1100   SDLK_RCTRL = 305;
1101 {$EXTERNALSYM SDLK_RCTRL}
1102   SDLK_LCTRL = 306;
1103 {$EXTERNALSYM SDLK_LCTRL}
1104   SDLK_RALT = 307;
1105 {$EXTERNALSYM SDLK_RALT}
1106   SDLK_LALT = 308;
1107 {$EXTERNALSYM SDLK_LALT}
1108   SDLK_RMETA = 309;
1109 {$EXTERNALSYM SDLK_RMETA}
1110   SDLK_LMETA = 310;
1111 {$EXTERNALSYM SDLK_LMETA}
1112   SDLK_LSUPER = 311; // Left "Windows" key
1113 {$EXTERNALSYM SDLK_LSUPER}
1114   SDLK_RSUPER = 312; // Right "Windows" key
1115 {$EXTERNALSYM SDLK_RSUPER}
1116   SDLK_MODE = 313; // "Alt Gr" key
1117 {$EXTERNALSYM SDLK_MODE}
1118   SDLK_COMPOSE = 314; // Multi-key compose key
1119 {$EXTERNALSYM SDLK_COMPOSE}
1120
1121   // Miscellaneous function keys
1122   SDLK_HELP = 315;
1123 {$EXTERNALSYM SDLK_HELP}
1124   SDLK_PRINT = 316;
1125 {$EXTERNALSYM SDLK_PRINT}
1126   SDLK_SYSREQ = 317;
1127 {$EXTERNALSYM SDLK_SYSREQ}
1128   SDLK_BREAK = 318;
1129 {$EXTERNALSYM SDLK_BREAK}
1130   SDLK_MENU = 319;
1131 {$EXTERNALSYM SDLK_MENU}
1132   SDLK_POWER = 320; // Power Macintosh power key
1133 {$EXTERNALSYM SDLK_POWER}
1134   SDLK_EURO = 321; // Some european keyboards
1135 {$EXTERNALSYM SDLK_EURO}
1136
1137 {$IFDEF GP2X}
1138 SDLK_GP2X_UP = 0;
1139 {$EXTERNALSYM SDLK_GP2X_UP}
1140 SDLK_GP2X_UPLEFT = 1;
1141 {$EXTERNALSYM SDLK_GP2X_UPLEFT}
1142 SDLK_GP2X_LEFT = 2;
1143 {$EXTERNALSYM SDLK_GP2X_LEFT}
1144 SDLK_GP2X_DOWNLEFT = 3;
1145 {$EXTERNALSYM SDLK_GP2X_DOWNLEFT}
1146 SDLK_GP2X_DOWN = 4;
1147 {$EXTERNALSYM SDLK_GP2X_DOWN}
1148 SDLK_GP2X_DOWNRIGHT = 5;
1149 {$EXTERNALSYM SDLK_GP2X_DOWNRIGHT}
1150 SDLK_GP2X_RIGHT = 6;
1151 {$EXTERNALSYM SDLK_GP2X_RIGHT}
1152 SDLK_GP2X_UPRIGHT = 7;
1153 {$EXTERNALSYM SDLK_GP2X_UPRIGHT}
1154 SDLK_GP2X_START = 8;
1155 {$EXTERNALSYM SDLK_GP2X_START}
1156 SDLK_GP2X_SELECT = 9;
1157 {$EXTERNALSYM SDLK_GP2X_SELECT}
1158 SDLK_GP2X_L = 10;
1159 {$EXTERNALSYM SDLK_GP2X_L}
1160 SDLK_GP2X_R = 11;
1161 {$EXTERNALSYM SDLK_GP2X_R}
1162 SDLK_GP2X_A = 12;
1163 {$EXTERNALSYM SDLK_GP2X_A}
1164 SDLK_GP2X_B = 13;
1165 {$EXTERNALSYM SDLK_GP2X_B}
1166 SDLK_GP2X_Y = 14;
1167 {$EXTERNALSYM SDLK_GP2X_Y}
1168 SDLK_GP2X_X = 15;
1169 {$EXTERNALSYM SDLK_GP2X_X}
1170 SDLK_GP2X_VOLUP = 16;
1171 {$EXTERNALSYM SDLK_GP2X_VOLUP}
1172 SDLK_GP2X_VOLDOWN = 17;
1173 {$EXTERNALSYM SDLK_GP2X_VOLDOWN}
1174 SDLK_GP2X_CLICK = 18;
1175 {$EXTERNALSYM SDLK_GP2X_CLICK}
1176 {$ENDIF}
1177
1178   // Enumeration of valid key mods (possibly OR'd together)
1179   KMOD_NONE = $0000;
1180 {$EXTERNALSYM KMOD_NONE}
1181   KMOD_LSHIFT = $0001;
1182 {$EXTERNALSYM KMOD_LSHIFT}
1183   KMOD_RSHIFT = $0002;
1184 {$EXTERNALSYM KMOD_RSHIFT}
1185   KMOD_LCTRL = $0040;
1186 {$EXTERNALSYM KMOD_LCTRL}
1187   KMOD_RCTRL = $0080;
1188 {$EXTERNALSYM KMOD_RCTRL}
1189   KMOD_LALT = $0100;
1190 {$EXTERNALSYM KMOD_LALT}
1191   KMOD_RALT = $0200;
1192 {$EXTERNALSYM KMOD_RALT}
1193   KMOD_LMETA = $0400;
1194 {$EXTERNALSYM KMOD_LMETA}
1195   KMOD_RMETA = $0800;
1196 {$EXTERNALSYM KMOD_RMETA}
1197   KMOD_NUM = $1000;
1198 {$EXTERNALSYM KMOD_NUM}
1199   KMOD_CAPS = $2000;
1200 {$EXTERNALSYM KMOD_CAPS}
1201   KMOD_MODE = 44000;
1202 {$EXTERNALSYM KMOD_MODE}
1203   KMOD_RESERVED = $8000;
1204 {$EXTERNALSYM KMOD_RESERVED}
1205
1206   KMOD_CTRL = (KMOD_LCTRL or KMOD_RCTRL);
1207 {$EXTERNALSYM KMOD_CTRL}
1208   KMOD_SHIFT = (KMOD_LSHIFT or KMOD_RSHIFT);
1209 {$EXTERNALSYM KMOD_SHIFT}
1210   KMOD_ALT = (KMOD_LALT or KMOD_RALT);
1211 {$EXTERNALSYM KMOD_ALT}
1212   KMOD_META = (KMOD_LMETA or KMOD_RMETA);
1213 {$EXTERNALSYM KMOD_META}
1214
1215   //SDL_video.h constants
1216   // Transparency definitions: These define alpha as the opacity of a surface */
1217   SDL_ALPHA_OPAQUE = 255;
1218 {$EXTERNALSYM SDL_ALPHA_OPAQUE}
1219   SDL_ALPHA_TRANSPARENT = 0;
1220 {$EXTERNALSYM SDL_ALPHA_TRANSPARENT}
1221
1222   // These are the currently supported flags for the SDL_surface
1223   // Available for SDL_CreateRGBSurface() or SDL_SetVideoMode()
1224   SDL_SWSURFACE = $00000000; // Surface is in system memory
1225 {$EXTERNALSYM SDL_SWSURFACE}
1226   SDL_HWSURFACE = $00000001; // Surface is in video memory
1227 {$EXTERNALSYM SDL_HWSURFACE}
1228   SDL_ASYNCBLIT = $00000004; // Use asynchronous blits if possible
1229 {$EXTERNALSYM SDL_ASYNCBLIT}
1230   // Available for SDL_SetVideoMode()
1231   SDL_ANYFORMAT = $10000000; // Allow any video depth/pixel-format
1232 {$EXTERNALSYM SDL_ANYFORMAT}
1233   SDL_HWPALETTE = $20000000; // Surface has exclusive palette
1234 {$EXTERNALSYM SDL_HWPALETTE}
1235   SDL_DOUBLEBUF = $40000000; // Set up double-buffered video mode
1236 {$EXTERNALSYM SDL_DOUBLEBUF}
1237   SDL_FULLSCREEN = $80000000; // Surface is a full screen display
1238 {$EXTERNALSYM SDL_FULLSCREEN}
1239   SDL_OPENGL = $00000002; // Create an OpenGL rendering context
1240 {$EXTERNALSYM SDL_OPENGL}
1241   SDL_OPENGLBLIT = $00000002; // Create an OpenGL rendering context
1242 {$EXTERNALSYM SDL_OPENGLBLIT}
1243   SDL_RESIZABLE = $00000010; // This video mode may be resized
1244 {$EXTERNALSYM SDL_RESIZABLE}
1245   SDL_NOFRAME = $00000020; // No window caption or edge frame
1246 {$EXTERNALSYM SDL_NOFRAME}
1247   // Used internally (read-only)
1248   SDL_HWACCEL = $00000100; // Blit uses hardware acceleration
1249 {$EXTERNALSYM SDL_HWACCEL}
1250   SDL_SRCCOLORKEY = $00001000; // Blit uses a source color key
1251 {$EXTERNALSYM SDL_SRCCOLORKEY}
1252   SDL_RLEACCELOK = $00002000; // Private flag
1253 {$EXTERNALSYM SDL_RLEACCELOK}
1254   SDL_RLEACCEL = $00004000; // Colorkey blit is RLE accelerated
1255 {$EXTERNALSYM SDL_RLEACCEL}
1256   SDL_SRCALPHA = $00010000; // Blit uses source alpha blending
1257 {$EXTERNALSYM SDL_SRCALPHA}
1258   SDL_SRCCLIPPING = $00100000; // Blit uses source clipping
1259 {$EXTERNALSYM SDL_SRCCLIPPING}
1260   SDL_PREALLOC = $01000000; // Surface uses preallocated memory
1261 {$EXTERNALSYM SDL_PREALLOC}
1262
1263   { The most common video overlay formats.
1264     For an explanation of these pixel formats, see:
1265     http://www.webartz.com/fourcc/indexyuv.htm
1266
1267    For information on the relationship between color spaces, see:
1268    http://www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html }
1269
1270   SDL_YV12_OVERLAY = $32315659; // Planar mode: Y + V + U  (3 planes)
1271 {$EXTERNALSYM SDL_YV12_OVERLAY}
1272   SDL_IYUV_OVERLAY = $56555949; // Planar mode: Y + U + V  (3 planes)
1273 {$EXTERNALSYM SDL_IYUV_OVERLAY}
1274   SDL_YUY2_OVERLAY = $32595559; // Packed mode: Y0+U0+Y1+V0 (1 plane)
1275 {$EXTERNALSYM SDL_YUY2_OVERLAY}
1276   SDL_UYVY_OVERLAY = $59565955; // Packed mode: U0+Y0+V0+Y1 (1 plane)
1277 {$EXTERNALSYM SDL_UYVY_OVERLAY}
1278   SDL_YVYU_OVERLAY = $55595659; // Packed mode: Y0+V0+Y1+U0 (1 plane)
1279 {$EXTERNALSYM SDL_YVYU_OVERLAY}
1280
1281   // flags for SDL_SetPalette()
1282   SDL_LOGPAL = $01;
1283 {$EXTERNALSYM SDL_LOGPAL}
1284   SDL_PHYSPAL = $02;
1285 {$EXTERNALSYM SDL_PHYSPAL}
1286
1287   //SDL_mouse.h constants
1288   { Used as a mask when testing buttons in buttonstate
1289     Button 1:   Left mouse button
1290     Button 2:   Middle mouse button
1291     Button 3:   Right mouse button
1292     Button 4:   Mouse Wheel Up
1293     Button 5:   Mouse Wheel Down
1294   }
1295   SDL_BUTTON_LEFT = 1;
1296 {$EXTERNALSYM SDL_BUTTON_LEFT}
1297   SDL_BUTTON_MIDDLE = 2;
1298 {$EXTERNALSYM SDL_BUTTON_MIDDLE}
1299   SDL_BUTTON_RIGHT = 3;
1300 {$EXTERNALSYM SDL_BUTTON_RIGHT}
1301   SDL_BUTTON_WHEELUP = 4;
1302 {$EXTERNALSYM SDL_BUTTON_WHEELUP}
1303   SDL_BUTTON_WHEELDOWN = 5;
1304 {$EXTERNALSYM SDL_BUTTON_WHEELDOWN}
1305   SDL_BUTTON_LMASK = SDL_PRESSED shl (SDL_BUTTON_LEFT - 1);
1306 {$EXTERNALSYM SDL_BUTTON_LMASK}
1307   SDL_BUTTON_MMASK = SDL_PRESSED shl (SDL_BUTTON_MIDDLE - 1);
1308 {$EXTERNALSYM SDL_BUTTON_MMASK}
1309   SDL_BUTTON_RMask = SDL_PRESSED shl (SDL_BUTTON_RIGHT - 1);
1310 {$EXTERNALSYM SDL_BUTTON_RMask}
1311
1312   // SDL_active.h constants
1313   // The available application states
1314   SDL_APPMOUSEFOCUS = $01; // The app has mouse coverage
1315 {$EXTERNALSYM SDL_APPMOUSEFOCUS}
1316   SDL_APPINPUTFOCUS = $02; // The app has input focus
1317 {$EXTERNALSYM SDL_APPINPUTFOCUS}
1318   SDL_APPACTIVE = $04; // The application is active
1319 {$EXTERNALSYM SDL_APPACTIVE}
1320
1321   // SDL_mutex.h constants
1322   // Synchronization functions which can time out return this value
1323   //  they time out.
1324
1325   SDL_MUTEX_TIMEDOUT = 1;
1326 {$EXTERNALSYM SDL_MUTEX_TIMEDOUT}
1327
1328   // This is the timeout value which corresponds to never time out
1329   SDL_MUTEX_MAXWAIT = not Cardinal(0);
1330 {$EXTERNALSYM SDL_MUTEX_MAXWAIT}
1331
1332   {TSDL_GrabMode = (
1333     SDL_GRAB_QUERY,
1334     SDL_GRAB_OFF,
1335     SDL_GRAB_ON,
1336     SDL_GRAB_FULLSCREEN ); // Used internally}
1337   SDL_GRAB_QUERY = -1;
1338   SDL_GRAB_OFF   = 0;
1339   SDL_GRAB_ON    = 1;
1340   //SDL_GRAB_FULLSCREEN // Used internally
1341
1342 type
1343   THandle = Cardinal;
1344   //SDL_types.h types
1345   // Basic data types
1346
1347   SDL_Bool  = (SDL_FALSE, SDL_TRUE);
1348   TSDL_Bool = SDL_Bool;
1349
1350   PUInt8Array = ^TUInt8Array;
1351   PUInt8 = ^UInt8;
1352   PPUInt8 = ^PUInt8;
1353   UInt8 = Byte;
1354 {$EXTERNALSYM UInt8}
1355   TUInt8Array = array [0..MAXINT shr 1] of UInt8;
1356
1357   PUInt16 = ^UInt16;
1358   UInt16 = word;
1359 {$EXTERNALSYM UInt16}
1360
1361   PSInt8 = ^SInt8;
1362   SInt8 = Shortint;
1363 {$EXTERNALSYM SInt8}
1364
1365   PSInt16 = ^SInt16;
1366   SInt16 = smallint;
1367 {$EXTERNALSYM SInt16}
1368
1369   PUInt32 = ^UInt32;
1370   UInt32 = Cardinal;
1371 {$EXTERNALSYM UInt32}
1372
1373   SInt32 = Integer;
1374 {$EXTERNALSYM SInt32}
1375
1376   PInt = ^Integer;
1377
1378   PShortInt = ^ShortInt;
1379
1380   PUInt64 = ^UInt64;
1381   UInt64 = record
1382     hi: UInt32;
1383     lo: UInt32;
1384   end;
1385 {$EXTERNALSYM UInt64}
1386
1387   PSInt64 = ^SInt64;
1388   SInt64 = record
1389     hi: UInt32;
1390     lo: UInt32;
1391   end;
1392 {$EXTERNALSYM SInt64}
1393
1394   TSDL_GrabMode = Integer;
1395
1396   // SDL_error.h types
1397   TSDL_errorcode = (
1398     SDL_ENOMEM,
1399     SDL_EFREAD,
1400     SDL_EFWRITE,
1401     SDL_EFSEEK,
1402     SDL_LASTERROR);
1403
1404   SDL_errorcode = TSDL_errorcode;
1405 {$EXTERNALSYM SDL_errorcode}
1406
1407   TArg = record
1408     case Byte of
1409       0: (value_ptr: Pointer);
1410       (* #if 0 means: never
1411       1 :  ( value_c : Byte );
1412       *)
1413       2: (value_i: Integer);
1414       3: (value_f: double);
1415       4: (buf: array[0..ERR_MAX_STRLEN - 1] of Byte);
1416   end;
1417
1418   PSDL_error = ^TSDL_error;
1419   TSDL_error = record
1420     { This is a numeric value corresponding to the current error }
1421     error: Integer;
1422
1423     { This is a key used to index into a language hashtable containing
1424        internationalized versions of the SDL error messages.  If the key
1425        is not in the hashtable, or no hashtable is available, the key is
1426        used directly as an error message format string. }
1427     key: array[0..ERR_MAX_STRLEN - 1] of Byte;
1428
1429     { These are the arguments for the error functions }
1430     argc: Integer;
1431     args: array[0..ERR_MAX_ARGS - 1] of TArg;
1432   end;
1433
1434   // SDL_rwops.h types
1435   // This is the read/write operation structure -- very basic
1436   // some helper types to handle the unions
1437   // "packed" is only guessed
1438
1439   TStdio = record
1440     autoclose: Integer;
1441    // FILE * is only defined in Kylix so we use a simple Pointer
1442     fp: Pointer;
1443   end;
1444
1445   TMem = record
1446     base: PUInt8;
1447     here: PUInt8;
1448     stop: PUInt8;
1449   end;
1450
1451   TUnknown = record
1452     data1: Pointer;
1453   end;
1454
1455   // first declare the pointer type
1456   PSDL_RWops = ^TSDL_RWops;
1457   // now the pointer to function types
1458   {$IFNDEF __GPC__}
1459   TSeek = function( context: PSDL_RWops; offset: Integer; whence: Integer ): Integer; cdecl;
1460   TRead = function( context: PSDL_RWops; Ptr: Pointer; size: Integer; maxnum : Integer ): Integer;  cdecl;
1461   TWrite = function( context: PSDL_RWops; Ptr: Pointer; size: Integer; num: Integer ): Integer; cdecl;
1462   TClose = function( context: PSDL_RWops ): Integer; cdecl;
1463   {$ELSE}
1464   TSeek = function( context: PSDL_RWops; offset: Integer; whence: Integer ): Integer;
1465   TRead = function( context: PSDL_RWops; Ptr: Pointer; size: Integer; maxnum : Integer ): Integer;
1466   TWrite = function( context: PSDL_RWops; Ptr: Pointer; size: Integer; num: Integer ): Integer;
1467   TClose = function( context: PSDL_RWops ): Integer;
1468   {$ENDIF}
1469   // the variant record itself
1470   TSDL_RWops = record
1471     seek: TSeek;
1472     read: TRead;
1473     write: TWrite;
1474     close: TClose;
1475     // a keyword as name is not allowed
1476     type_: UInt32;
1477     // be warned! structure alignment may arise at this point
1478     case Integer of
1479       0: (stdio: TStdio);
1480       1: (mem: TMem);
1481       2: (unknown: TUnknown);
1482   end;
1483
1484   SDL_RWops = TSDL_RWops;
1485 {$EXTERNALSYM SDL_RWops}
1486
1487
1488   // SDL_timer.h types
1489   // Function prototype for the timer callback function
1490   {$IFNDEF __GPC__}
1491   TSDL_TimerCallback = function( interval: UInt32 ): UInt32; cdecl;
1492   {$ELSE}
1493   TSDL_TimerCallback = function( interval: UInt32 ): UInt32;
1494   {$ENDIF}
1495
1496  { New timer API, supports multiple timers
1497    Written by Stephane Peter <megastep@lokigames.com> }
1498
1499  { Function prototype for the new timer callback function.
1500    The callback function is passed the current timer interval and returns
1501    the next timer interval.  If the returned value is the same as the one
1502    passed in, the periodic alarm continues, otherwise a new alarm is
1503    scheduled.  If the callback returns 0, the periodic alarm is cancelled. }
1504   {$IFNDEF __GPC__}
1505   TSDL_NewTimerCallback = function( interval: UInt32; param: Pointer ): UInt32; cdecl;
1506   {$ELSE}
1507   TSDL_NewTimerCallback = function( interval: UInt32; param: Pointer ): UInt32;
1508   {$ENDIF}
1509
1510   // Definition of the timer ID type
1511   PSDL_TimerID = ^TSDL_TimerID;
1512   TSDL_TimerID = record
1513     interval: UInt32;
1514     callback: TSDL_NewTimerCallback;
1515     param: Pointer;
1516     last_alarm: UInt32;
1517     next: PSDL_TimerID;
1518   end;
1519
1520   {$IFNDEF __GPC__}
1521   TSDL_AudioSpecCallback = procedure( userdata: Pointer; stream: PUInt8; len: Integer ); cdecl;
1522   {$ELSE}
1523   TSDL_AudioSpecCallback = procedure( userdata: Pointer; stream: PUInt8; len: Integer );
1524   {$ENDIF}
1525
1526   // SDL_audio.h types
1527   // The calculated values in this structure are calculated by SDL_OpenAudio()
1528   PSDL_AudioSpec = ^TSDL_AudioSpec;
1529   TSDL_AudioSpec = record
1530     freq: Integer; // DSP frequency -- samples per second
1531     format: UInt16; // Audio data format
1532     channels: UInt8; // Number of channels: 1 mono, 2 stereo
1533     silence: UInt8; // Audio buffer silence value (calculated)
1534     samples: UInt16; // Audio buffer size in samples
1535     padding: UInt16; // Necessary for some compile environments
1536     size: UInt32; // Audio buffer size in bytes (calculated)
1537     { This function is called when the audio device needs more data.
1538       'stream' is a pointer to the audio data buffer
1539       'len' is the length of that buffer in bytes.
1540       Once the callback returns, the buffer will no longer be valid.
1541       Stereo samples are stored in a LRLRLR ordering.}
1542     callback: TSDL_AudioSpecCallback;
1543     userdata: Pointer;
1544   end;
1545
1546   // A structure to hold a set of audio conversion filters and buffers
1547   PSDL_AudioCVT = ^TSDL_AudioCVT;
1548
1549   PSDL_AudioCVTFilter = ^TSDL_AudioCVTFilter;
1550   TSDL_AudioCVTFilter = record
1551     cvt: PSDL_AudioCVT;
1552     format: UInt16;
1553   end;
1554
1555   PSDL_AudioCVTFilterArray = ^TSDL_AudioCVTFilterArray;
1556   TSDL_AudioCVTFilterArray = array[0..9] of PSDL_AudioCVTFilter;
1557
1558   TSDL_AudioCVT = record
1559     needed: Integer; // Set to 1 if conversion possible
1560     src_format: UInt16; // Source audio format
1561     dst_format: UInt16; // Target audio format
1562     rate_incr: double; // Rate conversion increment
1563     buf: PUInt8; // Buffer to hold entire audio data
1564     len: Integer; // Length of original audio buffer
1565     len_cvt: Integer; // Length of converted audio buffer
1566     len_mult: Integer; // buffer must be len*len_mult big
1567     len_ratio: double; // Given len, final size is len*len_ratio
1568     filters: TSDL_AudioCVTFilterArray;
1569     filter_index: Integer; // Current audio conversion function
1570   end;
1571
1572   TSDL_Audiostatus = (
1573     SDL_AUDIO_STOPPED,
1574     SDL_AUDIO_PLAYING,
1575     SDL_AUDIO_PAUSED
1576     );
1577
1578   // SDL_cdrom.h types
1579   TSDL_CDStatus = (
1580     CD_ERROR,
1581     CD_TRAYEMPTY,
1582     CD_STOPPED,
1583     CD_PLAYING,
1584     CD_PAUSED );
1585
1586   PSDL_CDTrack = ^TSDL_CDTrack;
1587   TSDL_CDTrack = record
1588     id: UInt8; // Track number
1589     type_: UInt8; // Data or audio track
1590     unused: UInt16;
1591     length: UInt32; // Length, in frames, of this track
1592     offset: UInt32; // Offset, in frames, from start of disk
1593   end;
1594
1595   // This structure is only current as of the last call to SDL_CDStatus()
1596   PSDL_CD = ^TSDL_CD;
1597   TSDL_CD = record
1598     id: Integer; // Private drive identifier
1599     status: TSDL_CDStatus; // Current drive status
1600
1601     // The rest of this structure is only valid if there's a CD in drive
1602     numtracks: Integer; // Number of tracks on disk
1603     cur_track: Integer; // Current track position
1604     cur_frame: Integer; // Current frame offset within current track
1605     track: array[0..SDL_MAX_TRACKS] of TSDL_CDTrack;
1606   end;
1607
1608   //SDL_joystick.h types
1609   PTransAxis = ^TTransAxis;
1610   TTransAxis = record
1611     offset: Integer;
1612     scale: single;
1613   end;
1614
1615   // The private structure used to keep track of a joystick
1616   PJoystick_hwdata = ^TJoystick_hwdata;
1617   TJoystick_hwdata = record
1618     // joystick ID
1619     id: Integer;
1620     // values used to translate device-specific coordinates into  SDL-standard ranges
1621     transaxis: array[0..5] of TTransAxis;
1622   end;
1623
1624   PBallDelta = ^TBallDelta;
1625   TBallDelta = record
1626     dx: Integer;
1627     dy: Integer;
1628   end; // Current ball motion deltas
1629
1630   // The SDL joystick structure
1631   PSDL_Joystick = ^TSDL_Joystick;
1632   TSDL_Joystick = record
1633     index: UInt8; // Device index
1634     name: PChar; // Joystick name - system dependent
1635
1636     naxes: Integer; // Number of axis controls on the joystick
1637     axes: PUInt16; // Current axis states
1638
1639     nhats: Integer; // Number of hats on the joystick
1640     hats: PUInt8; // Current hat states
1641
1642     nballs: Integer; // Number of trackballs on the joystick
1643     balls: PBallDelta; // Current ball motion deltas
1644
1645     nbuttons: Integer; // Number of buttons on the joystick
1646     buttons: PUInt8; // Current button states
1647
1648     hwdata: PJoystick_hwdata; // Driver dependent information
1649
1650     ref_count: Integer; // Reference count for multiple opens
1651   end;
1652
1653   // SDL_verion.h types
1654   PSDL_version = ^TSDL_version;
1655   TSDL_version = record
1656     major: UInt8;
1657     minor: UInt8;
1658     patch: UInt8;
1659   end;
1660
1661   // SDL_keyboard.h types
1662   TSDLKey = LongWord;
1663
1664   TSDLMod = LongWord;
1665
1666   PSDL_KeySym = ^TSDL_KeySym;
1667   TSDL_KeySym = record
1668     scancode: UInt8; // hardware specific scancode
1669     sym: TSDLKey; // SDL virtual keysym
1670     modifier: TSDLMod; // current key modifiers
1671     unicode: UInt16; // translated character
1672   end;
1673
1674   // SDL_events.h types
1675   {Checks the event queue for messages and optionally returns them.
1676    If 'action' is SDL_ADDEVENT, up to 'numevents' events will be added to
1677    the back of the event queue.
1678    If 'action' is SDL_PEEKEVENT, up to 'numevents' events at the front
1679    of the event queue, matching 'mask', will be returned and will not
1680    be removed from the queue.
1681    If 'action' is SDL_GETEVENT, up to 'numevents' events at the front
1682    of the event queue, matching 'mask', will be returned and will be
1683    removed from the queue.
1684    This function returns the number of events actually stored, or -1
1685    if there was an error.  This function is thread-safe. }
1686
1687   TSDL_EventAction = (SDL_ADDEVENT, SDL_PEEKEVENT, SDL_GETEVENT);
1688
1689   // Application visibility event structure
1690   TSDL_ActiveEvent = record
1691     type_: UInt8; // SDL_ACTIVEEVENT
1692     gain: UInt8; // Whether given states were gained or lost (1/0)
1693     state: UInt8; // A mask of the focus states
1694   end;
1695
1696   // Keyboard event structure
1697   TSDL_KeyboardEvent = record
1698     type_: UInt8; // SDL_KEYDOWN or SDL_KEYUP
1699     which: UInt8; // The keyboard device index
1700     state: UInt8; // SDL_PRESSED or SDL_RELEASED
1701     keysym: TSDL_KeySym;
1702   end;
1703
1704   // Mouse motion event structure
1705   TSDL_MouseMotionEvent = record
1706     type_: UInt8; // SDL_MOUSEMOTION
1707     which: UInt8; // The mouse device index
1708     state: UInt8; // The current button state
1709     x, y: UInt16; // The X/Y coordinates of the mouse
1710     xrel: SInt16; // The relative motion in the X direction
1711     yrel: SInt16; // The relative motion in the Y direction
1712   end;
1713
1714   // Mouse button event structure
1715   TSDL_MouseButtonEvent = record
1716     type_: UInt8;  // SDL_MOUSEBUTTONDOWN or SDL_MOUSEBUTTONUP
1717     which: UInt8;  // The mouse device index
1718     button: UInt8; // The mouse button index
1719     state: UInt8;  // SDL_PRESSED or SDL_RELEASED
1720     x: UInt16;     // The X coordinates of the mouse at press time
1721     y: UInt16;     // The Y coordinates of the mouse at press time
1722   end;
1723
1724   // Joystick axis motion event structure
1725   TSDL_JoyAxisEvent = record
1726     type_: UInt8; // SDL_JOYAXISMOTION
1727     which: UInt8; // The joystick device index
1728     axis: UInt8; // The joystick axis index
1729     value: SInt16; // The axis value (range: -32768 to 32767)
1730   end;
1731
1732   // Joystick trackball motion event structure
1733   TSDL_JoyBallEvent = record
1734     type_: UInt8; // SDL_JOYAVBALLMOTION
1735     which: UInt8; // The joystick device index
1736     ball: UInt8; // The joystick trackball index
1737     xrel: SInt16; // The relative motion in the X direction
1738     yrel: SInt16; // The relative motion in the Y direction
1739   end;
1740
1741   // Joystick hat position change event structure
1742   TSDL_JoyHatEvent = record
1743     type_: UInt8; // SDL_JOYHATMOTION */
1744     which: UInt8; // The joystick device index */
1745     hat: UInt8; // The joystick hat index */
1746     value: UInt8; { The hat position value:
1747                     8   1   2
1748                     7   0   3
1749                     6   5   4
1750
1751                     Note that zero means the POV is centered. }
1752
1753   end;
1754
1755   // Joystick button event structure
1756   TSDL_JoyButtonEvent = record
1757     type_: UInt8; // SDL_JOYBUTTONDOWN or SDL_JOYBUTTONUP
1758     which: UInt8; // The joystick device index
1759     button: UInt8; // The joystick button index
1760     state: UInt8; // SDL_PRESSED or SDL_RELEASED
1761   end;
1762
1763   { The "window resized" event
1764     When you get this event, you are responsible for setting a new video
1765     mode with the new width and height. }
1766   TSDL_ResizeEvent = record
1767     type_: UInt8; // SDL_VIDEORESIZE
1768     w: Integer; // New width
1769     h: Integer; // New height
1770   end;
1771
1772   // The "quit requested" event
1773   PSDL_QuitEvent = ^TSDL_QuitEvent;
1774   TSDL_QuitEvent = record
1775     type_: UInt8;
1776   end;
1777
1778   // A user-defined event type
1779   PSDL_UserEvent = ^TSDL_UserEvent;
1780   TSDL_UserEvent = record
1781     type_: UInt8; // SDL_USEREVENT through SDL_NUMEVENTS-1
1782     code: Integer; // User defined event code */
1783     data1: Pointer; // User defined data pointer */
1784     data2: Pointer; // User defined data pointer */
1785   end;
1786
1787   // The "screen redraw" event
1788   PSDL_ExposeEvent = ^TSDL_ExposeEvent;
1789   TSDL_ExposeEvent = record
1790     type_ : Uint8;        // SDL_VIDEOEXPOSE
1791   end;
1792
1793  {$IFDEF Unix}
1794  //These are the various supported subsystems under UNIX
1795   TSDL_SysWm = ( SDL_SYSWM_X11 ) ;
1796  {$ENDIF}
1797
1798 // The windows custom event structure
1799 {$IFDEF WINDOWS}
1800   PSDL_SysWMmsg = ^TSDL_SysWMmsg;
1801   TSDL_SysWMmsg = record
1802     version: TSDL_version;
1803     h_wnd: HWND; // The window for the message
1804     msg: UInt; // The type of message
1805     w_Param: WPARAM; // WORD message parameter
1806     lParam: LPARAM; // LONG message parameter
1807   end;
1808 {$ELSE}
1809
1810 {$IFDEF Unix}
1811 { The Linux custom event structure }
1812   PSDL_SysWMmsg = ^TSDL_SysWMmsg;
1813   TSDL_SysWMmsg = record
1814     version : TSDL_version;
1815     subsystem : TSDL_SysWm;
1816     {$IFDEF FPC}
1817     {$IFNDEF GP2X}
1818     event : TXEvent;
1819     {$ENDIF}
1820     {$ELSE}
1821     event : XEvent;
1822     {$ENDIF}
1823   end;
1824 {$ELSE}
1825 { The generic custom event structure }
1826   PSDL_SysWMmsg = ^TSDL_SysWMmsg;
1827   TSDL_SysWMmsg = record
1828     version: TSDL_version;
1829     data: Integer;
1830   end;
1831 {$ENDIF}
1832
1833 {$ENDIF}
1834
1835 // The Windows custom window manager information structure
1836 {$IFDEF WINDOWS}
1837   PSDL_SysWMinfo = ^TSDL_SysWMinfo;
1838   TSDL_SysWMinfo = record
1839     version : TSDL_version;
1840     window : HWnd;      // The display window
1841   end;
1842 {$ELSE}
1843
1844 // The Linux custom window manager information structure
1845 {$IFDEF Unix}
1846   {$IFNDEF GP2X}
1847   TX11 = record
1848     display : PDisplay; // The X11 display
1849     window : TWindow ;          // The X11 display window */
1850     {* These locking functions should be called around
1851        any X11 functions using the display variable.
1852        They lock the event thread, so should not be
1853        called around event functions or from event filters.
1854      *}
1855     lock_func : Pointer;
1856     unlock_func : Pointer;
1857
1858     // Introduced in SDL 1.0.2
1859     fswindow : TWindow ;        // The X11 fullscreen window */
1860     wmwindow : TWindow ;        // The X11 managed input window */
1861   end;
1862   {$ENDIF}
1863
1864   PSDL_SysWMinfo = ^TSDL_SysWMinfo;
1865   TSDL_SysWMinfo = record
1866      version : TSDL_version ;
1867      subsystem : TSDL_SysWm;
1868      {$IFNDEF GP2X}
1869      X11 : TX11;
1870      {$ENDIF}
1871   end;
1872 {$ELSE}
1873   // The generic custom window manager information structure
1874   PSDL_SysWMinfo = ^TSDL_SysWMinfo;
1875   TSDL_SysWMinfo = record
1876     version : TSDL_version ;
1877     data : integer;
1878   end;
1879 {$ENDIF}
1880
1881 {$ENDIF}
1882
1883   PSDL_SysWMEvent = ^TSDL_SysWMEvent;
1884   TSDL_SysWMEvent = record
1885     type_: UInt8;
1886     msg: PSDL_SysWMmsg;
1887   end;
1888
1889   PSDL_Event = ^TSDL_Event;
1890   TSDL_Event = record
1891     case UInt8 of
1892       SDL_NOEVENT: (type_: byte);
1893       SDL_ACTIVEEVENT: (active: TSDL_ActiveEvent);
1894       SDL_KEYDOWN, SDL_KEYUP: (key: TSDL_KeyboardEvent);
1895       SDL_MOUSEMOTION: (motion: TSDL_MouseMotionEvent);
1896       SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP: (button: TSDL_MouseButtonEvent );
1897       SDL_JOYAXISMOTION: (jaxis: TSDL_JoyAxisEvent );
1898       SDL_JOYBALLMOTION: (jball: TSDL_JoyBallEvent );
1899       SDL_JOYHATMOTION: (jhat: TSDL_JoyHatEvent );
1900       SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP: (jbutton: TSDL_JoyButtonEvent );
1901       SDL_VIDEORESIZE: (resize: TSDL_ResizeEvent );
1902       SDL_QUITEV: (quit: TSDL_QuitEvent );
1903       SDL_USEREVENT : ( user : TSDL_UserEvent );
1904       SDL_SYSWMEVENT: (syswm: TSDL_SysWMEvent );
1905   end;
1906
1907
1908 { This function sets up a filter to process all events before they
1909   change internal state and are posted to the internal event queue.
1910
1911   The filter is protypted as: }
1912   {$IFNDEF __GPC__}
1913   TSDL_EventFilter = function( event : PSDL_Event ): Integer; cdecl;
1914   {$ELSE}
1915   TSDL_EventFilter = function( event : PSDL_Event ): Integer;
1916   {$ENDIF}
1917
1918   // SDL_video.h types
1919   // Useful data types
1920   PPSDL_Rect = ^PSDL_Rect;
1921   PSDL_Rect = ^TSDL_Rect;
1922   TSDL_Rect = record
1923     x, y: SInt16;
1924     w, h: UInt16;
1925   end;
1926
1927   SDL_Rect = TSDL_Rect;
1928 {$EXTERNALSYM SDL_Rect}
1929
1930   PSDL_Color = ^TSDL_Color;
1931   TSDL_Color = record
1932     r: UInt8;
1933     g: UInt8;
1934     b: UInt8;
1935     unused: UInt8;
1936   end;
1937
1938   PSDL_ColorArray = ^TSDL_ColorArray;
1939   TSDL_ColorArray = array[0..65000] of TSDL_Color;
1940
1941   PSDL_Palette = ^TSDL_Palette;
1942   TSDL_Palette = record
1943     ncolors: Integer;
1944     colors: PSDL_ColorArray;
1945   end;
1946
1947   // Everything in the pixel format structure is read-only
1948   PSDL_PixelFormat = ^TSDL_PixelFormat;
1949   TSDL_PixelFormat = record
1950     palette: PSDL_Palette;
1951     BitsPerPixel: UInt8;
1952     BytesPerPixel: UInt8;
1953     Rloss: UInt8;
1954     Gloss: UInt8;
1955     Bloss: UInt8;
1956     Aloss: UInt8;
1957     Rshift: UInt8;
1958     Gshift: UInt8;
1959     Bshift: UInt8;
1960     Ashift: UInt8;
1961     RMask: UInt32;
1962     GMask: UInt32;
1963     BMask: UInt32;
1964     AMask: UInt32;
1965     colorkey: UInt32; // RGB color key information
1966     alpha: UInt8; // Alpha value information (per-surface alpha)
1967   end;
1968
1969 {$IFDEF WINDOWS}
1970   {PPrivate_hwdata = ^TPrivate_hwdata;
1971   TPrivate_hwdata = record
1972     dd_surface : IDIRECTDRAWSURFACE3;
1973     dd_writebuf : IDIRECTDRAWSURFACE3;
1974   end;}
1975   {ELSE}
1976 {$ENDIF}
1977
1978   // The structure passed to the low level blit functions
1979   PSDL_BlitInfo = ^TSDL_BlitInfo;
1980   TSDL_BlitInfo = record
1981     s_pixels: PUInt8;
1982     s_width: Integer;
1983     s_height: Integer;
1984     s_skip: Integer;
1985     d_pixels: PUInt8;
1986     d_width: Integer;
1987     d_height: Integer;
1988     d_skip: Integer;
1989     aux_data: Pointer;
1990     src: PSDL_PixelFormat;
1991     table: PUInt8;
1992     dst: PSDL_PixelFormat;
1993   end;
1994
1995   // typedef for private surface blitting functions
1996   PSDL_Surface = ^TSDL_Surface;
1997
1998   {$IFNDEF __GPC__}
1999   TSDL_Blit = function( src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect ): Integer; cdecl;
2000   {$ELSE}
2001   TSDL_Blit = function( src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect ): Integer;
2002   {$ENDIF}
2003
2004   // The type definition for the low level blit functions
2005   //TSDL_LoBlit = procedure( info : PSDL_BlitInfo ); cdecl;
2006
2007   // This is the private info structure for software accelerated blits
2008   {PPrivate_swaccel = ^TPrivate_swaccel;
2009   TPrivate_swaccel = record
2010     blit : TSDL_LoBlit;
2011     aux_data : Pointer;
2012   end;}
2013
2014   // Blit mapping definition
2015   {PSDL_BlitMap = ^TSDL_BlitMap;
2016   TSDL_BlitMap = record
2017     dst : PSDL_Surface;
2018     identity : Integer;
2019     table : PUInt8;
2020     hw_blit : TSDL_Blit;
2021     sw_blit : TSDL_Blit;
2022     hw_data : PPrivate_hwaccel;
2023     sw_data : PPrivate_swaccel;
2024
2025     // the version count matches the destination; mismatch indicates an invalid mapping
2026     format_version : Cardinal;
2027   end;}
2028
2029   TSDL_Surface = record
2030     flags: UInt32; // Read-only
2031     format: PSDL_PixelFormat; // Read-only
2032     w, h: Integer; // Read-only
2033     pitch: UInt16; // Read-only
2034     pixels: Pointer; // Read-write
2035     offset: Integer; // Private
2036     hwdata: Pointer; //TPrivate_hwdata;  Hardware-specific surface info
2037
2038     // clipping information:
2039     clip_rect: TSDL_Rect; // Read-only
2040     unused1: UInt32; // for binary compatibility
2041     // Allow recursive locks
2042     locked: UInt32; // Private
2043     // info for fast blit mapping to other surfaces
2044     Blitmap: Pointer; // PSDL_BlitMap; //   Private
2045     // format version, bumped at every change to invalidate blit maps
2046     format_version: Cardinal; // Private
2047     refcount: Integer;
2048   end;
2049
2050   // Useful for determining the video hardware capabilities
2051   PSDL_VideoInfo = ^TSDL_VideoInfo;
2052   TSDL_VideoInfo = record
2053     hw_available: UInt8; // Hardware and WindowManager flags in first 2 bits ( see below )
2054     {hw_available: 1; // Can you create hardware surfaces
2055     wm_available: 1; // Can you talk to a window manager?
2056     UnusedBits1: 6;}
2057     blit_hw: UInt8; // Blit Hardware flags. See below for which bits do what
2058     {UnusedBits2: 1;
2059     blit_hw: 1; // Flag:UInt32  Accelerated blits HW --> HW
2060     blit_hw_CC: 1; // Flag:UInt32  Accelerated blits with Colorkey
2061     blit_hw_A: 1; // Flag:UInt32  Accelerated blits with Alpha
2062     blit_sw: 1; // Flag:UInt32  Accelerated blits SW --> HW
2063     blit_sw_CC: 1; // Flag:UInt32  Accelerated blits with Colorkey
2064     blit_sw_A: 1; // Flag:UInt32  Accelerated blits with Alpha
2065     blit_fill: 1; // Flag:UInt32  Accelerated color fill}
2066     UnusedBits3: UInt8; // Unused at this point
2067     video_mem: UInt32; // The total amount of video memory (in K)
2068     vfmt: PSDL_PixelFormat; // Value: The format of the video surface
2069     current_w : SInt32; // Value: The current video mode width
2070           current_h : SInt32;   // Value: The current video mode height
2071   end;
2072
2073   // The YUV hardware video overlay
2074   PSDL_Overlay = ^TSDL_Overlay;
2075   TSDL_Overlay = record
2076     format: UInt32; // Overlay format
2077     w, h: Integer; // Width and height of overlay
2078     planes: Integer; // Number of planes in the overlay. Usually either 1 or 3
2079     pitches: PUInt16;
2080       // An array of pitches, one for each plane. Pitch is the length of a row in bytes.
2081     pixels: PPUInt8;
2082       // An array of pointers to the data of each plane. The overlay should be locked before these pointers are used.
2083     hw_overlay: UInt32;
2084       // This will be set to 1 if the overlay is hardware accelerated.
2085   end;
2086
2087   // Public enumeration for setting the OpenGL window attributes.
2088   TSDL_GLAttr = (
2089     SDL_GL_RED_SIZE,
2090     SDL_GL_GREEN_SIZE,
2091     SDL_GL_BLUE_SIZE,
2092     SDL_GL_ALPHA_SIZE,
2093     SDL_GL_BUFFER_SIZE,
2094     SDL_GL_DOUBLEBUFFER,
2095     SDL_GL_DEPTH_SIZE,
2096     SDL_GL_STENCIL_SIZE,
2097     SDL_GL_ACCUM_RED_SIZE,
2098     SDL_GL_ACCUM_GREEN_SIZE,
2099     SDL_GL_ACCUM_BLUE_SIZE,
2100     SDL_GL_ACCUM_ALPHA_SIZE,
2101     SDL_GL_STEREO,
2102     SDL_GL_MULTISAMPLEBUFFERS,
2103     SDL_GL_MULTISAMPLESAMPLES,
2104     SDL_GL_ACCELERATED_VISUAL,
2105     SDL_GL_SWAP_CONTROL);
2106
2107
2108
2109   PSDL_Cursor = ^TSDL_Cursor;
2110   TSDL_Cursor = record
2111     area: TSDL_Rect; // The area of the mouse cursor
2112     hot_x, hot_y: SInt16; // The "tip" of the cursor
2113     data: PUInt8; // B/W cursor data
2114     mask: PUInt8; // B/W cursor mask
2115     save: array[1..2] of PUInt8; // Place to save cursor area
2116     wm_cursor: Pointer; // Window-manager cursor
2117   end;
2118
2119 // SDL_mutex.h types
2120
2121 {$IFDEF WINDOWS}
2122   PSDL_Mutex = ^TSDL_Mutex;
2123   TSDL_Mutex = record
2124     id: THANDLE;
2125   end;
2126 {$ENDIF}
2127
2128 {$IFDEF Unix}
2129   PSDL_Mutex = ^TSDL_Mutex;
2130   TSDL_mutex = record
2131     id: pthread_mutex_t;
2132 {$IFDEF PTHREAD_NO_RECURSIVE_MUTEX}
2133     recursive: Integer;
2134     owner: pthread_t;
2135 {$ENDIF}
2136   end;
2137 {$ENDIF}
2138
2139 {$IFDEF NDS}
2140   PSDL_mutex = ^TSDL_Mutex;
2141   TSDL_Mutex = record
2142     recursive: Integer;
2143     Owner: UInt32;
2144     sem: PSDL_sem;
2145   end;
2146 {$ENDIF}
2147
2148 {$IFDEF MORPHOS}
2149   PSDL_Mutex = ^TSDL_Mutex;
2150   TSDL_Mutex = record
2151 {$WARNING FIXME!!}
2152     dummy: longint;
2153   end;
2154 {$ENDIF}
2155
2156 {$IFDEF __MACH__}
2157   {$define USE_NAMED_SEMAPHORES}
2158   // Broken sem_getvalue() in MacOS X Public Beta */
2159   {$define BROKEN_SEMGETVALUE}
2160 {$ENDIF}
2161
2162 PSDL_semaphore = ^TSDL_semaphore;
2163 {$IFDEF WINDOWS}
2164   // WINDOWS or Machintosh
2165   TSDL_semaphore = record
2166     id: THANDLE;
2167     count: UInt32;
2168   end;
2169 {$ELSE}
2170   {$IFDEF FPC}
2171   // This should be semaphore.h
2172   __sem_lock_t = {packed} record { Not in header file - anonymous }
2173     status: Longint;
2174     spinlock: Integer;
2175   end;
2176
2177   sem_t = {packed} record
2178     __sem_lock: __sem_lock_t;
2179     __sem_value: Integer;
2180     __sem_waiting: longint ; {_pthread_queue;}
2181   end;
2182   {$ENDIF}
2183
2184   TSDL_semaphore = record
2185     sem: Pointer; //PSem_t;
2186   {$IFNDEF USE_NAMED_SEMAPHORES}
2187     sem_data: Sem_t;
2188   {$ENDIF}
2189
2190   {$IFDEF BROKEN_SEMGETVALUE}
2191     { This is a little hack for MacOS X -
2192       It's not thread-safe, but it's better than nothing }
2193     sem_value: Integer;
2194   {$ENDIF}
2195   end;
2196 {$ENDIF}
2197
2198   PSDL_Sem = ^TSDL_Sem;
2199   TSDL_Sem = TSDL_Semaphore;
2200
2201   PSDL_Cond = ^TSDL_Cond;
2202   TSDL_Cond = record
2203 {$IFDEF Unix}
2204     cond: pthread_cond_t;
2205 {$ELSE}
2206     // Generic Cond structure
2207     lock: PSDL_mutex;
2208     waiting: Integer;
2209     signals: Integer;
2210     wait_sem: PSDL_Sem;
2211     wait_done: PSDL_Sem;
2212 {$ENDIF}
2213   end;
2214
2215   // SDL_thread.h types
2216 {$IFDEF WINDOWS}
2217   TSYS_ThreadHandle = THandle;
2218 {$ENDIF}
2219
2220 {$IFDEF Unix}
2221   TSYS_ThreadHandle = pthread_t;
2222 {$ENDIF}
2223
2224 {$IFDEF NDS}
2225   TSYS_ThreadHandle = Integer;
2226 {$ENDIF}
2227
2228 {$IFDEF MORPHOS}
2229   TSYS_ThreadHandle = Pointer;
2230 {$ENDIF}
2231
2232   { This is the system-independent thread info structure }
2233   PSDL_Thread = ^TSDL_Thread;
2234   TSDL_Thread = record
2235     threadid: UInt32;
2236     handle: TSYS_ThreadHandle;
2237     status: Integer;
2238     errbuf: TSDL_Error;
2239     data: Pointer;
2240   end;
2241
2242   // Helper Types
2243
2244   // Keyboard  State Array ( See demos for how to use )
2245   PKeyStateArr = ^TKeyStateArr;
2246   TKeyStateArr = array[0..65000] of UInt8;
2247
2248   // Types required so we don't need to use Windows.pas
2249   PInteger = ^Integer;
2250   PByte = ^Byte;
2251   PWord = ^Word;
2252   PLongWord = ^Longword;
2253
2254   // General arrays
2255   PByteArray = ^TByteArray;
2256   TByteArray = array[0..32767] of Byte;
2257
2258   PWordArray = ^TWordArray;
2259   TWordArray = array[0..16383] of Word;
2260
2261   PPoint = ^TPoint;
2262   {$IFDEF HAS_TYPES}
2263   TPoint = Types.TPoint;
2264   {$ELSE}
2265     {$IFDEF WINDOWS}
2266       {$IFDEF __GPC__}
2267       TPoint = wintypes.TPoint;
2268       {$ELSE}
2269       TPoint = Windows.TPoint;
2270       {$ENDIF}
2271     {$ELSE}
2272       //Can't define TPoint : neither Types nor Windows unit available.
2273     {$ENDIF}
2274   {$ENDIF}
2275
2276   PRect = ^TRect;
2277   {$IFDEF HAS_TYPES}
2278   TRect = Types.TRect;
2279   {$ELSE}
2280     {$IFDEF WINDOWS}
2281       {$IFDEF __GPC__}
2282       TRect = wintypes.TRect;
2283       {$ELSE}
2284       TRect = Windows.TRect;
2285       {$ENDIF}
2286     {$ELSE}
2287       //Can't define TRect: neither Types nor Windows unit available.
2288     {$ENDIF}
2289   {$ENDIF}
2290
2291   { Generic procedure pointer }
2292   TProcedure = procedure;
2293
2294 {------------------------------------------------------------------------------}
2295 { initialization                                                               }
2296 {------------------------------------------------------------------------------}
2297
2298 { This function loads the SDL dynamically linked library and initializes
2299   the subsystems specified by 'flags' (and those satisfying dependencies)
2300   Unless the SDL_INIT_NOPARACHUTE flag is set, it will install cleanup
2301   signal handlers for some commonly ignored fatal signals (like SIGSEGV) }
2302
2303 {$IFDEF MORPHOS}
2304 {$I powersdl.inc}
2305 {$ELSE}
2306 function SDL_Init( flags : UInt32 ) : Integer;
2307 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Init'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2308 {$EXTERNALSYM SDL_Init}
2309
2310 // This function initializes specific SDL subsystems
2311 function SDL_InitSubSystem( flags : UInt32 ) : Integer;
2312 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_InitSubSystem'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2313 {$EXTERNALSYM SDL_InitSubSystem}
2314
2315 // This function cleans up specific SDL subsystems
2316 procedure SDL_QuitSubSystem( flags : UInt32 );
2317 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_QuitSubSystem'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2318 {$EXTERNALSYM SDL_QuitSubSystem}
2319
2320 { This function returns mask of the specified subsystems which have
2321   been initialized.
2322   If 'flags' is 0, it returns a mask of all initialized subsystems. }
2323
2324 function SDL_WasInit( flags : UInt32 ): UInt32;
2325 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WasInit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2326 {$EXTERNALSYM SDL_WasInit}
2327
2328 { This function cleans up all initialized subsystems and unloads the
2329   dynamically linked library.  You should call it upon all exit conditions. }
2330 procedure SDL_Quit;
2331 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Quit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2332 {$EXTERNALSYM SDL_Quit}
2333
2334 {$IFDEF WINDOWS}
2335 // This should be called from your WinMain() function, if any
2336 function SDL_RegisterApp(name: PChar; style: UInt32; h_Inst: Pointer): Integer;
2337 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RegisterApp'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2338 {$EXTERNALSYM SDL_RegisterApp}
2339 {$ENDIF}
2340
2341 {$IFDEF __MACH__}
2342 // This should be called from your main() function, if any
2343 procedure SDL_InitQuickDraw( the_qd: QDGlobals );
2344 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_InitQuickDraw'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2345 {$EXTERNALSYM SDL_InitQuickDraw}
2346 {$ENDIF}
2347
2348
2349 {------------------------------------------------------------------------------}
2350 { types }
2351 {------------------------------------------------------------------------------}
2352 // The number of elements in a table
2353 function SDL_TableSize( table: PChar ): Integer;
2354 {$EXTERNALSYM SDL_TABLESIZE}
2355
2356
2357 {------------------------------------------------------------------------------}
2358 { error-handling }
2359 {------------------------------------------------------------------------------}
2360 // Public functions
2361 function SDL_GetError: PChar;
2362 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetError'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2363 {$EXTERNALSYM SDL_GetError}
2364 procedure SDL_SetError(fmt: PChar);
2365 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetError'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2366 {$EXTERNALSYM SDL_SetError}
2367 procedure SDL_ClearError;
2368 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ClearError'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2369 {$EXTERNALSYM SDL_ClearError}
2370
2371 {$IFNDEF WINDOWS}
2372 procedure SDL_Error(Code: TSDL_errorcode);
2373 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Error'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2374 {$EXTERNALSYM SDL_Error}
2375 {$ENDIF}
2376
2377 // Private error message function - used internally
2378 procedure SDL_OutOfMemory;
2379
2380 {------------------------------------------------------------------------------}
2381 { io handling                                                                  }
2382 {------------------------------------------------------------------------------}
2383 // Functions to create SDL_RWops structures from various data sources
2384
2385 function SDL_RWFromFile(filename, mode: PChar): PSDL_RWops;
2386 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RWFromFile'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2387 {$EXTERNALSYM SDL_RWFromFile}
2388 procedure SDL_FreeRW(area: PSDL_RWops);
2389 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FreeRW'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2390 {$EXTERNALSYM SDL_FreeRW}
2391
2392 //fp is FILE *fp ???
2393 function SDL_RWFromFP(fp: Pointer; autoclose: Integer): PSDL_RWops;
2394 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RWFromFP'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2395 {$EXTERNALSYM SDL_RWFromFP}
2396 function SDL_RWFromMem(mem: Pointer; size: Integer): PSDL_RWops;
2397 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RWFromMem'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2398 {$EXTERNALSYM SDL_RWFromMem}
2399 function SDL_RWFromConstMem(const mem: Pointer; size: Integer) : PSDL_RWops;
2400 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RWFromConstMem'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2401 {$EXTERNALSYM SDL_RWFromConstMem}
2402 function SDL_AllocRW: PSDL_RWops;
2403 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_AllocRW'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2404 {$EXTERNALSYM SDL_AllocRW}
2405
2406 function SDL_RWSeek(context: PSDL_RWops; offset: Integer; whence: Integer) : Integer;
2407 {$EXTERNALSYM SDL_RWSeek}
2408 function SDL_RWTell(context: PSDL_RWops): Integer;
2409 {$EXTERNALSYM SDL_RWTell}
2410 function SDL_RWRead(context: PSDL_RWops; ptr: Pointer; size: Integer; n : Integer): Integer;
2411 {$EXTERNALSYM SDL_RWRead}
2412 function SDL_RWWrite(context: PSDL_RWops; ptr: Pointer; size: Integer; n : Integer): Integer;
2413 {$EXTERNALSYM SDL_RWWrite}
2414 function SDL_RWClose(context: PSDL_RWops): Integer;
2415 {$EXTERNALSYM SDL_RWClose}
2416
2417 {------------------------------------------------------------------------------}
2418 { time-handling                                                                }
2419 {------------------------------------------------------------------------------}
2420
2421 { Get the number of milliseconds since the SDL library initialization. }
2422 { Note that this value wraps if the program runs for more than ~49 days. }
2423 function SDL_GetTicks: UInt32;
2424 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetTicks'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2425 {$EXTERNALSYM SDL_GetTicks}
2426
2427 // Wait a specified number of milliseconds before returning
2428 procedure SDL_Delay(msec: UInt32);
2429 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Delay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2430 {$EXTERNALSYM SDL_Delay}
2431
2432 { Add a new timer to the pool of timers already running. }
2433 { Returns a timer ID, or NULL when an error occurs.      }
2434 function SDL_AddTimer(interval: UInt32; callback: TSDL_NewTimerCallback; param : Pointer): PSDL_TimerID;
2435 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_AddTimer'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2436 {$EXTERNALSYM SDL_AddTimer}
2437
2438 { Remove one of the multiple timers knowing its ID. }
2439 { Returns a boolean value indicating success. }
2440 function SDL_RemoveTimer(t: PSDL_TimerID): TSDL_Bool;
2441 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_RemoveTimer'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2442 {$EXTERNALSYM SDL_RemoveTimer}
2443
2444 function SDL_SetTimer(interval: UInt32; callback: TSDL_TimerCallback): Integer;
2445 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetTimer'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2446 {$EXTERNALSYM SDL_SetTimer}
2447
2448 {------------------------------------------------------------------------------}
2449 { audio-routines                                                               }
2450 {------------------------------------------------------------------------------}
2451
2452 { These functions are used internally, and should not be used unless you
2453   have a specific need to specify the audio driver you want to use.
2454   You should normally use SDL_Init() or SDL_InitSubSystem(). }
2455
2456 function SDL_AudioInit(driver_name: PChar): Integer;
2457 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_AudioInit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2458 {$EXTERNALSYM SDL_AudioInit}
2459 procedure SDL_AudioQuit;
2460 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_AudioQuit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2461 {$EXTERNALSYM SDL_AudioQuit}
2462
2463 { This function fills the given character buffer with the name of the
2464   current audio driver, and returns a Pointer to it if the audio driver has
2465   been initialized.  It returns NULL if no driver has been initialized. }
2466
2467 function SDL_AudioDriverName(namebuf: PChar; maxlen: Integer): PChar;
2468 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_AudioDriverName'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2469 {$EXTERNALSYM SDL_AudioDriverName}
2470
2471 { This function opens the audio device with the desired parameters, and
2472   returns 0 if successful, placing the actual hardware parameters in the
2473   structure pointed to by 'obtained'.  If 'obtained' is NULL, the audio
2474   data passed to the callback function will be guaranteed to be in the
2475   requested format, and will be automatically converted to the hardware
2476   audio format if necessary.  This function returns -1 if it failed
2477   to open the audio device, or couldn't set up the audio thread.
2478
2479   When filling in the desired audio spec structure,
2480    'desired->freq' should be the desired audio frequency in samples-per-second.
2481    'desired->format' should be the desired audio format.
2482    'desired->samples' is the desired size of the audio buffer, in samples.
2483       This number should be a power of two, and may be adjusted by the audio
2484       driver to a value more suitable for the hardware.  Good values seem to
2485       range between 512 and 8096 inclusive, depending on the application and
2486       CPU speed.  Smaller values yield faster response time, but can lead
2487       to underflow if the application is doing heavy processing and cannot
2488       fill the audio buffer in time.  A stereo sample consists of both right
2489       and left channels in LR ordering.
2490       Note that the number of samples is directly related to time by the
2491       following formula:  ms = (samples*1000)/freq
2492    'desired->size' is the size in bytes of the audio buffer, and is
2493       calculated by SDL_OpenAudio().
2494    'desired->silence' is the value used to set the buffer to silence,
2495       and is calculated by SDL_OpenAudio().
2496    'desired->callback' should be set to a function that will be called
2497       when the audio device is ready for more data.  It is passed a pointer
2498       to the audio buffer, and the length in bytes of the audio buffer.
2499       This function usually runs in a separate thread, and so you should
2500       protect data structures that it accesses by calling SDL_LockAudio()
2501       and SDL_UnlockAudio() in your code.
2502    'desired->userdata' is passed as the first parameter to your callback
2503       function.
2504
2505   The audio device starts out playing silence when it's opened, and should
2506   be enabled for playing by calling SDL_PauseAudio(0) when you are ready
2507   for your audio callback function to be called.  Since the audio driver
2508   may modify the requested size of the audio buffer, you should allocate
2509   any local mixing buffers after you open the audio device. }
2510
2511 function SDL_OpenAudio(desired, obtained: PSDL_AudioSpec): Integer;
2512 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_OpenAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2513 {$EXTERNALSYM SDL_OpenAudio}
2514
2515 { Get the current audio state: }
2516 function SDL_GetAudioStatus: TSDL_Audiostatus;
2517 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetAudioStatus'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2518 {$EXTERNALSYM SDL_GetAudioStatus}
2519
2520 { This function pauses and unpauses the audio callback processing.
2521   It should be called with a parameter of 0 after opening the audio
2522   device to start playing sound.  This is so you can safely initialize
2523   data for your callback function after opening the audio device.
2524   Silence will be written to the audio device during the pause. }
2525
2526 procedure SDL_PauseAudio(pause_on: Integer);
2527 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_PauseAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2528 {$EXTERNALSYM SDL_PauseAudio}
2529
2530 { This function loads a WAVE from the data source, automatically freeing
2531   that source if 'freesrc' is non-zero.  For example, to load a WAVE file,
2532   you could do:
2533   SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...);
2534
2535   If this function succeeds, it returns the given SDL_AudioSpec,
2536   filled with the audio data format of the wave data, and sets
2537   'audio_buf' to a malloc()'d buffer containing the audio data,
2538   and sets 'audio_len' to the length of that audio buffer, in bytes.
2539   You need to free the audio buffer with SDL_FreeWAV() when you are
2540   done with it.
2541
2542   This function returns NULL and sets the SDL error message if the
2543   wave file cannot be opened, uses an unknown data format, or is
2544   corrupt.  Currently raw and MS-ADPCM WAVE files are supported. }
2545
2546 function SDL_LoadWAV_RW(src: PSDL_RWops; freesrc: Integer; spec:
2547   PSDL_AudioSpec; audio_buf: PUInt8; audiolen: PUInt32): PSDL_AudioSpec;
2548 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LoadWAV_RW'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2549 {$EXTERNALSYM SDL_LoadWAV_RW}
2550
2551 // Compatibility convenience function -- loads a WAV from a file
2552 function SDL_LoadWAV(filename: PChar; spec: PSDL_AudioSpec; audio_buf:
2553   PUInt8; audiolen: PUInt32): PSDL_AudioSpec;
2554 {$EXTERNALSYM SDL_LoadWAV}
2555
2556 { This function frees data previously allocated with SDL_LoadWAV_RW() }
2557
2558 procedure SDL_FreeWAV(audio_buf: PUInt8);
2559 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FreeWAV'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2560 {$EXTERNALSYM SDL_FreeWAV}
2561
2562 { This function takes a source format and rate and a destination format
2563   and rate, and initializes the 'cvt' structure with information needed
2564   by SDL_ConvertAudio() to convert a buffer of audio data from one format
2565   to the other.
2566   This function returns 0, or -1 if there was an error. }
2567 function SDL_BuildAudioCVT(cvt: PSDL_AudioCVT; src_format: UInt16;
2568   src_channels: UInt8; src_rate: Integer; dst_format: UInt16; dst_channels: UInt8;
2569   dst_rate: Integer): Integer;
2570 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_BuildAudioCVT'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2571 {$EXTERNALSYM SDL_BuildAudioCVT}
2572
2573 { Once you have initialized the 'cvt' structure using SDL_BuildAudioCVT(),
2574   created an audio buffer cvt->buf, and filled it with cvt->len bytes of
2575   audio data in the source format, this function will convert it in-place
2576   to the desired format.
2577   The data conversion may expand the size of the audio data, so the buffer
2578   cvt->buf should be allocated after the cvt structure is initialized by
2579   SDL_BuildAudioCVT(), and should be cvt->len*cvt->len_mult bytes long. }
2580 function SDL_ConvertAudio(cvt: PSDL_AudioCVT): Integer;
2581 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ConvertAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2582 {$EXTERNALSYM SDL_ConvertAudio}
2583
2584 { This takes two audio buffers of the playing audio format and mixes
2585   them, performing addition, volume adjustment, and overflow clipping.
2586   The volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME
2587   for full audio volume.  Note this does not change hardware volume.
2588   This is provided for convenience -- you can mix your own audio data. }
2589
2590 procedure SDL_MixAudio(dst, src: PUInt8; len: UInt32; volume: Integer);
2591 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_MixAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2592 {$EXTERNALSYM SDL_MixAudio}
2593
2594 { The lock manipulated by these functions protects the callback function.
2595   During a LockAudio/UnlockAudio pair, you can be guaranteed that the
2596   callback function is not running.  Do not call these from the callback
2597   function or you will cause deadlock. }
2598 procedure SDL_LockAudio;
2599 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LockAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2600 {$EXTERNALSYM SDL_LockAudio}
2601 procedure SDL_UnlockAudio;
2602 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UnlockAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2603 {$EXTERNALSYM SDL_UnlockAudio}
2604
2605 { This function shuts down audio processing and closes the audio device. }
2606
2607 procedure SDL_CloseAudio;
2608 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CloseAudio'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2609 {$EXTERNALSYM SDL_CloseAudio}
2610
2611 {------------------------------------------------------------------------------}
2612 { CD-routines }
2613 {------------------------------------------------------------------------------}
2614
2615 { Returns the number of CD-ROM drives on the system, or -1 if
2616   SDL_Init() has not been called with the SDL_INIT_CDROM flag. }
2617
2618 function SDL_CDNumDrives: Integer;
2619 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDNumDrives'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2620 {$EXTERNALSYM SDL_CDNumDrives}
2621
2622 { Returns a human-readable, system-dependent identifier for the CD-ROM.
2623    Example:
2624    "/dev/cdrom"
2625    "E:"
2626    "/dev/disk/ide/1/master" }
2627
2628 function SDL_CDName(drive: Integer): PChar;
2629 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDName'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2630 {$EXTERNALSYM SDL_CDName}
2631
2632 { Opens a CD-ROM drive for access.  It returns a drive handle on success,
2633   or NULL if the drive was invalid or busy.  This newly opened CD-ROM
2634   becomes the default CD used when other CD functions are passed a NULL
2635   CD-ROM handle.
2636   Drives are numbered starting with 0.  Drive 0 is the system default CD-ROM. }
2637
2638 function SDL_CDOpen(drive: Integer): PSDL_CD;
2639 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDOpen'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2640 {$EXTERNALSYM SDL_CDOpen}
2641
2642 { This function returns the current status of the given drive.
2643   If the drive has a CD in it, the table of contents of the CD and current
2644   play position of the CD will be stored in the SDL_CD structure. }
2645
2646 function SDL_CDStatus(cdrom: PSDL_CD): TSDL_CDStatus;
2647 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDStatus'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2648 {$EXTERNALSYM SDL_CDStatus}
2649
2650 {  Play the given CD starting at 'start_track' and 'start_frame' for 'ntracks'
2651    tracks and 'nframes' frames.  If both 'ntrack' and 'nframe' are 0, play
2652    until the end of the CD.  This function will skip data tracks.
2653    This function should only be called after calling SDL_CDStatus() to
2654    get track information about the CD.
2655
2656    For example:
2657    // Play entire CD:
2658   if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) then
2659     SDL_CDPlayTracks(cdrom, 0, 0, 0, 0);
2660    // Play last track:
2661    if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) then
2662    begin
2663     SDL_CDPlayTracks(cdrom, cdrom->numtracks-1, 0, 0, 0);
2664    end;
2665
2666    // Play first and second track and 10 seconds of third track:
2667    if ( CD_INDRIVE(SDL_CDStatus(cdrom)) )
2668     SDL_CDPlayTracks(cdrom, 0, 0, 2, 10);
2669
2670    This function returns 0, or -1 if there was an error. }
2671
2672 function SDL_CDPlayTracks(cdrom: PSDL_CD; start_track: Integer; start_frame:
2673   Integer; ntracks: Integer; nframes: Integer): Integer;
2674 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDPlayTracks'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2675 {$EXTERNALSYM SDL_CDPlayTracks}
2676
2677
2678 {  Play the given CD starting at 'start' frame for 'length' frames.
2679    It returns 0, or -1 if there was an error. }
2680
2681 function SDL_CDPlay(cdrom: PSDL_CD; start: Integer; length: Integer): Integer;
2682 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDPlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2683 {$EXTERNALSYM SDL_CDPlay}
2684
2685 // Pause play -- returns 0, or -1 on error
2686 function SDL_CDPause(cdrom: PSDL_CD): Integer;
2687 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDPause'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2688 {$EXTERNALSYM SDL_CDPause}
2689
2690 // Resume play -- returns 0, or -1 on error
2691 function SDL_CDResume(cdrom: PSDL_CD): Integer;
2692 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDResume'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2693 {$EXTERNALSYM SDL_CDResume}
2694
2695 // Stop play -- returns 0, or -1 on error
2696 function SDL_CDStop(cdrom: PSDL_CD): Integer;
2697 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDStop'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2698 {$EXTERNALSYM SDL_CDStop}
2699
2700 // Eject CD-ROM -- returns 0, or -1 on error
2701 function SDL_CDEject(cdrom: PSDL_CD): Integer;
2702 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDEject'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2703 {$EXTERNALSYM SDL_CDEject}
2704
2705 // Closes the handle for the CD-ROM drive
2706 procedure SDL_CDClose(cdrom: PSDL_CD);
2707 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CDClose'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2708 {$EXTERNALSYM SDL_CDClose}
2709
2710 // Given a status, returns true if there's a disk in the drive
2711 function SDL_CDInDrive( status : TSDL_CDStatus ) : LongBool;
2712 {$EXTERNALSYM SDL_CDInDrive}
2713
2714 // Conversion functions from frames to Minute/Second/Frames and vice versa
2715 procedure FRAMES_TO_MSF(frames: Integer; var M: Integer; var S: Integer; var
2716   F: Integer);
2717 {$EXTERNALSYM FRAMES_TO_MSF}
2718 function MSF_TO_FRAMES(M: Integer; S: Integer; F: Integer): Integer;
2719 {$EXTERNALSYM MSF_TO_FRAMES}
2720
2721 {------------------------------------------------------------------------------}
2722 { JoyStick-routines                                                            }
2723 {------------------------------------------------------------------------------}
2724
2725 { Count the number of joysticks attached to the system }
2726 function SDL_NumJoysticks: Integer;
2727 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_NumJoysticks'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2728 {$EXTERNALSYM SDL_NumJoysticks}
2729
2730 { Get the implementation dependent name of a joystick.
2731   This can be called before any joysticks are opened.
2732   If no name can be found, this function returns NULL. }
2733 function SDL_JoystickName(index: Integer): PChar;
2734 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickName'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2735 {$EXTERNALSYM SDL_JoystickName}
2736
2737 { Open a joystick for use - the index passed as an argument refers to
2738   the N'th joystick on the system.  This index is the value which will
2739   identify this joystick in future joystick events.
2740
2741   This function returns a joystick identifier, or NULL if an error occurred. }
2742 function SDL_JoystickOpen(index: Integer): PSDL_Joystick;
2743 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickOpen'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2744 {$EXTERNALSYM SDL_JoystickOpen}
2745
2746 { Returns 1 if the joystick has been opened, or 0 if it has not. }
2747 function SDL_JoystickOpened(index: Integer): Integer;
2748 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickOpened'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2749 {$EXTERNALSYM SDL_JoystickOpened}
2750
2751 { Get the device index of an opened joystick. }
2752 function SDL_JoystickIndex(joystick: PSDL_Joystick): Integer;
2753 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickIndex'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2754 {$EXTERNALSYM SDL_JoystickIndex}
2755
2756 { Get the number of general axis controls on a joystick }
2757 function SDL_JoystickNumAxes(joystick: PSDL_Joystick): Integer;
2758 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickNumAxes'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2759 {$EXTERNALSYM SDL_JoystickNumAxes}
2760
2761 { Get the number of trackballs on a joystick
2762   Joystick trackballs have only relative motion events associated
2763   with them and their state cannot be polled. }
2764 function SDL_JoystickNumBalls(joystick: PSDL_Joystick): Integer;
2765 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickNumBalls'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2766 {$EXTERNALSYM SDL_JoystickNumBalls}
2767
2768
2769 { Get the number of POV hats on a joystick }
2770 function SDL_JoystickNumHats(joystick: PSDL_Joystick): Integer;
2771 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickNumHats'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2772 {$EXTERNALSYM SDL_JoystickNumHats}
2773
2774 { Get the number of buttons on a joystick }
2775 function SDL_JoystickNumButtons(joystick: PSDL_Joystick): Integer;
2776 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickNumButtons'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2777 {$EXTERNALSYM SDL_JoystickNumButtons}
2778
2779 { Update the current state of the open joysticks.
2780   This is called automatically by the event loop if any joystick
2781   events are enabled. }
2782
2783 procedure SDL_JoystickUpdate;
2784 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickUpdate'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2785 {$EXTERNALSYM SDL_JoystickUpdate;}
2786
2787 { Enable/disable joystick event polling.
2788   If joystick events are disabled, you must call SDL_JoystickUpdate()
2789   yourself and check the state of the joystick when you want joystick
2790   information.
2791   The state can be one of SDL_QUERY, SDL_ENABLE or SDL_IGNORE. }
2792
2793 function SDL_JoystickEventState(state: Integer): Integer;
2794 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickEventState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2795 {$EXTERNALSYM SDL_JoystickEventState}
2796
2797 { Get the current state of an axis control on a joystick
2798   The state is a value ranging from -32768 to 32767.
2799   The axis indices start at index 0. }
2800
2801 function SDL_JoystickGetAxis(joystick: PSDL_Joystick; axis: Integer) : SInt16;
2802 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickGetAxis'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2803 {$EXTERNALSYM SDL_JoystickGetAxis}
2804
2805 { The hat indices start at index 0. }
2806
2807 function SDL_JoystickGetHat(joystick: PSDL_Joystick; hat: Integer): UInt8;
2808 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickGetHat'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2809 {$EXTERNALSYM SDL_JoystickGetHat}
2810
2811 { Get the ball axis change since the last poll
2812   This returns 0, or -1 if you passed it invalid parameters.
2813   The ball indices start at index 0. }
2814
2815 function SDL_JoystickGetBall(joystick: PSDL_Joystick; ball: Integer; var dx: Integer; var dy: Integer): Integer;
2816 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickGetBall'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2817 {$EXTERNALSYM SDL_JoystickGetBall}
2818
2819 { Get the current state of a button on a joystick
2820   The button indices start at index 0. }
2821 function SDL_JoystickGetButton( joystick: PSDL_Joystick; Button: Integer): UInt8;
2822 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickGetButton'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2823 {$EXTERNALSYM SDL_JoystickGetButton}
2824
2825 { Close a joystick previously opened with SDL_JoystickOpen() }
2826 procedure SDL_JoystickClose(joystick: PSDL_Joystick);
2827 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_JoystickClose'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2828 {$EXTERNALSYM SDL_JoystickClose}
2829
2830 {------------------------------------------------------------------------------}
2831 { event-handling }
2832 {------------------------------------------------------------------------------}
2833
2834 { Pumps the event loop, gathering events from the input devices.
2835   This function updates the event queue and internal input device state.
2836   This should only be run in the thread that sets the video mode. }
2837
2838 procedure SDL_PumpEvents;
2839 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_PumpEvents'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2840 {$EXTERNALSYM SDL_PumpEvents;}
2841
2842 { Checks the event queue for messages and optionally returns them.
2843   If 'action' is SDL_ADDEVENT, up to 'numevents' events will be added to
2844   the back of the event queue.
2845   If 'action' is SDL_PEEKEVENT, up to 'numevents' events at the front
2846   of the event queue, matching 'mask', will be returned and will not
2847   be removed from the queue.
2848   If 'action' is SDL_GETEVENT, up to 'numevents' events at the front
2849   of the event queue, matching 'mask', will be returned and will be
2850   removed from the queue.
2851   This function returns the number of events actually stored, or -1
2852   if there was an error.  This function is thread-safe. }
2853
2854 function SDL_PeepEvents(events: PSDL_Event; numevents: Integer; action: TSDL_eventaction; mask: UInt32): Integer;
2855 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_PeepEvents'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2856 {$EXTERNALSYM SDL_PeepEvents}
2857
2858 { Polls for currently pending events, and returns 1 if there are any pending
2859    events, or 0 if there are none available.  If 'event' is not NULL, the next
2860    event is removed from the queue and stored in that area. }
2861
2862 function SDL_PollEvent(event: PSDL_Event): Integer;
2863 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_PollEvent'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2864 {$EXTERNALSYM SDL_PollEvent}
2865
2866 {  Waits indefinitely for the next available event, returning 1, or 0 if there
2867    was an error while waiting for events.  If 'event' is not NULL, the next
2868    event is removed from the queue and stored in that area. }
2869
2870 function SDL_WaitEvent(event: PSDL_Event): Integer;
2871 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WaitEvent'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2872 {$EXTERNALSYM SDL_WaitEvent}
2873
2874 function SDL_PushEvent( event : PSDL_Event ) : Integer;
2875 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_PushEvent'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2876 {$EXTERNALSYM SDL_PushEvent}
2877
2878 { If the filter returns 1, then the event will be added to the internal queue.
2879   If it returns 0, then the event will be dropped from the queue, but the
2880   internal state will still be updated.  This allows selective filtering of
2881   dynamically arriving events.
2882
2883   WARNING:  Be very careful of what you do in the event filter function, as
2884             it may run in a different thread!
2885
2886   There is one caveat when dealing with the SDL_QUITEVENT event type.  The
2887   event filter is only called when the window manager desires to close the
2888   application window.  If the event filter returns 1, then the window will
2889   be closed, otherwise the window will remain open if possible.
2890   If the quit event is generated by an interrupt signal, it will bypass the
2891   internal queue and be delivered to the application at the next event poll. }
2892 procedure SDL_SetEventFilter( filter : TSDL_EventFilter );
2893 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetEventFilter'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2894 {$EXTERNALSYM SDL_SetEventFilter}
2895
2896 { Return the current event filter - can be used to "chain" filters.
2897   If there is no event filter set, this function returns NULL. }
2898
2899 function SDL_GetEventFilter: TSDL_EventFilter;
2900 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetEventFilter'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2901 {$EXTERNALSYM SDL_GetEventFilter}
2902
2903 { This function allows you to set the state of processing certain events.
2904   If 'state' is set to SDL_IGNORE, that event will be automatically dropped
2905   from the event queue and will not event be filtered.
2906   If 'state' is set to SDL_ENABLE, that event will be processed normally.
2907   If 'state' is set to SDL_QUERY, SDL_EventState() will return the
2908   current processing state of the specified event. }
2909
2910 function SDL_EventState(type_: UInt8; state: Integer): UInt8;
2911 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_EventState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2912 {$EXTERNALSYM SDL_EventState}
2913
2914 {------------------------------------------------------------------------------}
2915 { Version Routines }
2916 {------------------------------------------------------------------------------}
2917
2918 { This macro can be used to fill a version structure with the compile-time
2919   version of the SDL library. }
2920 procedure SDL_VERSION(var X: TSDL_Version);
2921 {$EXTERNALSYM SDL_VERSION}
2922
2923 { This macro turns the version numbers into a numeric value:
2924    (1,2,3) -> (1203)
2925    This assumes that there will never be more than 100 patchlevels }
2926
2927 function SDL_VERSIONNUM(X, Y, Z: Integer): Integer;
2928 {$EXTERNALSYM SDL_VERSIONNUM}
2929
2930 // This is the version number macro for the current SDL version
2931 function SDL_COMPILEDVERSION: Integer;
2932 {$EXTERNALSYM SDL_COMPILEDVERSION}
2933
2934 // This macro will evaluate to true if compiled with SDL at least X.Y.Z
2935 function SDL_VERSION_ATLEAST(X: Integer; Y: Integer; Z: Integer) : LongBool;
2936 {$EXTERNALSYM SDL_VERSION_ATLEAST}
2937
2938 { This function gets the version of the dynamically linked SDL library.
2939   it should NOT be used to fill a version structure, instead you should
2940   use the SDL_Version() macro. }
2941
2942 function SDL_Linked_Version: PSDL_version;
2943 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Linked_Version'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2944 {$EXTERNALSYM SDL_Linked_Version}
2945
2946 {------------------------------------------------------------------------------}
2947 { video                                                                        }
2948 {------------------------------------------------------------------------------}
2949
2950 { These functions are used internally, and should not be used unless you
2951   have a specific need to specify the video driver you want to use.
2952   You should normally use SDL_Init() or SDL_InitSubSystem().
2953
2954   SDL_VideoInit() initializes the video subsystem -- sets up a connection
2955   to the window manager, etc, and determines the current video mode and
2956   pixel format, but does not initialize a window or graphics mode.
2957   Note that event handling is activated by this routine.
2958
2959   If you use both sound and video in your application, you need to call
2960   SDL_Init() before opening the sound device, otherwise under Win32 DirectX,
2961   you won't be able to set full-screen display modes. }
2962
2963 function SDL_VideoInit(driver_name: PChar; flags: UInt32): Integer;
2964 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_VideoInit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2965 {$EXTERNALSYM SDL_VideoInit}
2966 procedure SDL_VideoQuit;
2967 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_VideoQuit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2968 {$EXTERNALSYM SDL_VideoQuit}
2969
2970 { This function fills the given character buffer with the name of the
2971   video driver, and returns a pointer to it if the video driver has
2972   been initialized.  It returns NULL if no driver has been initialized. }
2973
2974 function SDL_VideoDriverName(namebuf: PChar; maxlen: Integer): PChar;
2975 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_VideoDriverName'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2976 {$EXTERNALSYM SDL_VideoDriverName}
2977
2978 { This function returns a pointer to the current display surface.
2979   If SDL is doing format conversion on the display surface, this
2980   function returns the publicly visible surface, not the real video
2981   surface. }
2982
2983 function SDL_GetVideoSurface: PSDL_Surface;
2984 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetVideoSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2985 {$EXTERNALSYM SDL_GetVideoSurface}
2986
2987 { This function returns a read-only pointer to information about the
2988   video hardware.  If this is called before SDL_SetVideoMode(), the 'vfmt'
2989   member of the returned structure will contain the pixel format of the
2990   "best" video mode. }
2991 function SDL_GetVideoInfo: PSDL_VideoInfo;
2992 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetVideoInfo'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
2993 {$EXTERNALSYM SDL_GetVideoInfo}
2994
2995 { Check to see if a particular video mode is supported.
2996   It returns 0 if the requested mode is not supported under any bit depth,
2997   or returns the bits-per-pixel of the closest available mode with the
2998   given width and height.  If this bits-per-pixel is different from the
2999   one used when setting the video mode, SDL_SetVideoMode() will succeed,
3000   but will emulate the requested bits-per-pixel with a shadow surface.
3001
3002   The arguments to SDL_VideoModeOK() are the same ones you would pass to
3003   SDL_SetVideoMode() }
3004
3005 function SDL_VideoModeOK(width, height, bpp: Integer; flags: UInt32): Integer;
3006 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_VideoModeOK'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3007 {$EXTERNALSYM SDL_VideoModeOK}
3008
3009 { Return a pointer to an array of available screen dimensions for the
3010   given format and video flags, sorted largest to smallest.  Returns
3011   NULL if there are no dimensions available for a particular format,
3012   or (SDL_Rect **)-1 if any dimension is okay for the given format.
3013
3014   if 'format' is NULL, the mode list will be for the format given
3015   by SDL_GetVideoInfo( ) - > vfmt }
3016
3017 function SDL_ListModes(format: PSDL_PixelFormat; flags: UInt32): PPSDL_Rect;
3018 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ListModes'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3019 {$EXTERNALSYM SDL_ListModes}
3020
3021
3022 { Set up a video mode with the specified width, height and bits-per-pixel.
3023
3024   If 'bpp' is 0, it is treated as the current display bits per pixel.
3025
3026   If SDL_ANYFORMAT is set in 'flags', the SDL library will try to set the
3027   requested bits-per-pixel, but will return whatever video pixel format is
3028   available.  The default is to emulate the requested pixel format if it
3029   is not natively available.
3030
3031   If SDL_HWSURFACE is set in 'flags', the video surface will be placed in
3032   video memory, if possible, and you may have to call SDL_LockSurface()
3033   in order to access the raw framebuffer.  Otherwise, the video surface
3034   will be created in system memory.
3035
3036   If SDL_ASYNCBLIT is set in 'flags', SDL will try to perform rectangle
3037   updates asynchronously, but you must always lock before accessing pixels.
3038   SDL will wait for updates to complete before returning from the lock.
3039
3040   If SDL_HWPALETTE is set in 'flags', the SDL library will guarantee
3041   that the colors set by SDL_SetColors() will be the colors you get.
3042   Otherwise, in 8-bit mode, SDL_SetColors() may not be able to set all
3043   of the colors exactly the way they are requested, and you should look
3044   at the video surface structure to determine the actual palette.
3045   If SDL cannot guarantee that the colors you request can be set,
3046   i.e. if the colormap is shared, then the video surface may be created
3047   under emulation in system memory, overriding the SDL_HWSURFACE flag.
3048
3049   If SDL_FULLSCREEN is set in 'flags', the SDL library will try to set
3050   a fullscreen video mode.  The default is to create a windowed mode
3051   if the current graphics system has a window manager.
3052   If the SDL library is able to set a fullscreen video mode, this flag
3053   will be set in the surface that is returned.
3054
3055   If SDL_DOUBLEBUF is set in 'flags', the SDL library will try to set up
3056   two surfaces in video memory and swap between them when you call
3057   SDL_Flip().  This is usually slower than the normal single-buffering
3058   scheme, but prevents "tearing" artifacts caused by modifying video
3059   memory while the monitor is refreshing.  It should only be used by
3060   applications that redraw the entire screen on every update.
3061
3062   This function returns the video framebuffer surface, or NULL if it fails. }
3063
3064 function SDL_SetVideoMode(width, height, bpp: Integer; flags: UInt32): PSDL_Surface;
3065 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetVideoMode'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3066 {$EXTERNALSYM SDL_SetVideoMode}
3067
3068
3069 { Makes sure the given list of rectangles is updated on the given screen.
3070   If 'x', 'y', 'w' and 'h' are all 0, SDL_UpdateRect will update the entire
3071   screen.
3072   These functions should not be called while 'screen' is locked. }
3073
3074 procedure SDL_UpdateRects(screen: PSDL_Surface; numrects: Integer; rects: PSDL_Rect);
3075 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UpdateRects'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3076 {$EXTERNALSYM SDL_UpdateRects}
3077 procedure SDL_UpdateRect(screen: PSDL_Surface; x, y: SInt32; w, h: UInt32);
3078 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UpdateRect'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3079 {$EXTERNALSYM SDL_UpdateRect}
3080
3081
3082 { On hardware that supports double-buffering, this function sets up a flip
3083   and returns.  The hardware will wait for vertical retrace, and then swap
3084   video buffers before the next video surface blit or lock will return.
3085   On hardware that doesn not support double-buffering, this is equivalent
3086   to calling SDL_UpdateRect(screen, 0, 0, 0, 0);
3087   The SDL_DOUBLEBUF flag must have been passed to SDL_SetVideoMode() when
3088   setting the video mode for this function to perform hardware flipping.
3089   This function returns 0 if successful, or -1 if there was an error.}
3090
3091 function SDL_Flip(screen: PSDL_Surface): Integer;
3092 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Flip'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3093 {$EXTERNALSYM SDL_Flip}
3094
3095 { Set the gamma correction for each of the color channels.
3096   The gamma values range (approximately) between 0.1 and 10.0
3097
3098   If this function isn't supported directly by the hardware, it will
3099   be emulated using gamma ramps, if available.  If successful, this
3100   function returns 0, otherwise it returns -1. }
3101
3102 function SDL_SetGamma(redgamma: single; greengamma: single; bluegamma: single ): Integer;
3103 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetGamma'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3104 {$EXTERNALSYM SDL_SetGamma}
3105
3106 { Set the gamma translation table for the red, green, and blue channels
3107   of the video hardware.  Each table is an array of 256 16-bit quantities,
3108   representing a mapping between the input and output for that channel.
3109   The input is the index into the array, and the output is the 16-bit
3110   gamma value at that index, scaled to the output color precision.
3111
3112   You may pass NULL for any of the channels to leave it unchanged.
3113   If the call succeeds, it will return 0.  If the display driver or
3114   hardware does not support gamma translation, or otherwise fails,
3115   this function will return -1. }
3116
3117 function SDL_SetGammaRamp( redtable: PUInt16; greentable: PUInt16; bluetable: PUInt16): Integer;
3118 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetGammaRamp'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3119 {$EXTERNALSYM SDL_SetGammaRamp}
3120
3121 { Retrieve the current values of the gamma translation tables.
3122
3123   You must pass in valid pointers to arrays of 256 16-bit quantities.
3124   Any of the pointers may be NULL to ignore that channel.
3125   If the call succeeds, it will return 0.  If the display driver or
3126   hardware does not support gamma translation, or otherwise fails,
3127   this function will return -1. }
3128
3129 function SDL_GetGammaRamp( redtable: PUInt16; greentable: PUInt16; bluetable: PUInt16): Integer;
3130 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetGammaRamp'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3131 {$EXTERNALSYM SDL_GetGammaRamp}
3132
3133 { Sets a portion of the colormap for the given 8-bit surface.  If 'surface'
3134   is not a palettized surface, this function does nothing, returning 0.
3135   If all of the colors were set as passed to SDL_SetColors(), it will
3136   return 1.  If not all the color entries were set exactly as given,
3137   it will return 0, and you should look at the surface palette to
3138   determine the actual color palette.
3139
3140   When 'surface' is the surface associated with the current display, the
3141   display colormap will be updated with the requested colors.  If
3142   SDL_HWPALETTE was set in SDL_SetVideoMode() flags, SDL_SetColors()
3143   will always return 1, and the palette is guaranteed to be set the way
3144   you desire, even if the window colormap has to be warped or run under
3145   emulation. }
3146
3147
3148 function SDL_SetColors(surface: PSDL_Surface; colors: PSDL_Color; firstcolor : Integer; ncolors: Integer) : Integer;
3149 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetColors'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3150 {$EXTERNALSYM SDL_SetColors}
3151
3152 { Sets a portion of the colormap for a given 8-bit surface.
3153   'flags' is one or both of:
3154   SDL_LOGPAL  -- set logical palette, which controls how blits are mapped
3155                  to/from the surface,
3156   SDL_PHYSPAL -- set physical palette, which controls how pixels look on
3157                  the screen
3158   Only screens have physical palettes. Separate change of physical/logical
3159   palettes is only possible if the screen has SDL_HWPALETTE set.
3160
3161   The return value is 1 if all colours could be set as requested, and 0
3162   otherwise.
3163
3164   SDL_SetColors() is equivalent to calling this function with
3165   flags = (SDL_LOGPAL or SDL_PHYSPAL). }
3166
3167 function SDL_SetPalette(surface: PSDL_Surface; flags: Integer; colors: PSDL_Color; firstcolor: Integer; ncolors: Integer): Integer;
3168 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetPalette'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3169 {$EXTERNALSYM SDL_SetPalette}
3170
3171 { Maps an RGB triple to an opaque pixel value for a given pixel format }
3172 function SDL_MapRGB(format: PSDL_PixelFormat; r: UInt8; g: UInt8; b: UInt8) : UInt32;
3173 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_MapRGB'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3174 {$EXTERNALSYM SDL_MapRGB}
3175
3176 { Maps an RGBA quadruple to a pixel value for a given pixel format }
3177 function SDL_MapRGBA(format: PSDL_PixelFormat; r: UInt8; g: UInt8; b: UInt8; a: UInt8): UInt32;
3178 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_MapRGBA'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3179 {$EXTERNALSYM SDL_MapRGBA}
3180
3181 { Maps a pixel value into the RGB components for a given pixel format }
3182 procedure SDL_GetRGB(pixel: UInt32; fmt: PSDL_PixelFormat; r: PUInt8; g: PUInt8; b: PUInt8);
3183 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetRGB'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3184 {$EXTERNALSYM SDL_GetRGB}
3185
3186 { Maps a pixel value into the RGBA components for a given pixel format }
3187 procedure SDL_GetRGBA(pixel: UInt32; fmt: PSDL_PixelFormat; r: PUInt8; g: PUInt8; b: PUInt8; a: PUInt8);
3188 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetRGBA'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3189 {$EXTERNALSYM SDL_GetRGBA}
3190
3191 { Allocate and free an RGB surface (must be called after SDL_SetVideoMode)
3192   If the depth is 4 or 8 bits, an empty palette is allocated for the surface.
3193   If the depth is greater than 8 bits, the pixel format is set using the
3194   flags '[RGB]mask'.
3195   If the function runs out of memory, it will return NULL.
3196
3197   The 'flags' tell what kind of surface to create.
3198   SDL_SWSURFACE means that the surface should be created in system memory.
3199   SDL_HWSURFACE means that the surface should be created in video memory,
3200   with the same format as the display surface.  This is useful for surfaces
3201   that will not change much, to take advantage of hardware acceleration
3202   when being blitted to the display surface.
3203   SDL_ASYNCBLIT means that SDL will try to perform asynchronous blits with
3204   this surface, but you must always lock it before accessing the pixels.
3205   SDL will wait for current blits to finish before returning from the lock.
3206   SDL_SRCCOLORKEY indicates that the surface will be used for colorkey blits.
3207   If the hardware supports acceleration of colorkey blits between
3208   two surfaces in video memory, SDL will try to place the surface in
3209   video memory. If this isn't possible or if there is no hardware
3210   acceleration available, the surface will be placed in system memory.
3211   SDL_SRCALPHA means that the surface will be used for alpha blits and
3212   if the hardware supports hardware acceleration of alpha blits between
3213   two surfaces in video memory, to place the surface in video memory
3214   if possible, otherwise it will be placed in system memory.
3215   If the surface is created in video memory, blits will be _much_ faster,
3216   but the surface format must be identical to the video surface format,
3217   and the only way to access the pixels member of the surface is to use
3218   the SDL_LockSurface() and SDL_UnlockSurface() calls.
3219   If the requested surface actually resides in video memory, SDL_HWSURFACE
3220   will be set in the flags member of the returned surface.  If for some
3221   reason the surface could not be placed in video memory, it will not have
3222   the SDL_HWSURFACE flag set, and will be created in system memory instead. }
3223
3224 function SDL_AllocSurface(flags: UInt32; width, height, depth: Integer;
3225   RMask, GMask, BMask, AMask: UInt32): PSDL_Surface;
3226 {$EXTERNALSYM SDL_AllocSurface}
3227
3228 function SDL_CreateRGBSurface(flags: UInt32; width, height, depth: Integer; RMask, GMask, BMask, AMask: UInt32): PSDL_Surface;
3229 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateRGBSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3230 {$EXTERNALSYM SDL_CreateRGBSurface}
3231
3232 function SDL_CreateRGBSurfaceFrom(pixels: Pointer; width, height, depth, pitch
3233   : Integer; RMask, GMask, BMask, AMask: UInt32): PSDL_Surface;
3234 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateRGBSurfaceFrom'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3235 {$EXTERNALSYM SDL_CreateRGBSurfaceFrom}
3236
3237 procedure SDL_FreeSurface(surface: PSDL_Surface);
3238 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FreeSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3239 {$EXTERNALSYM SDL_FreeSurface}
3240
3241 function SDL_MustLock(Surface: PSDL_Surface): Boolean;
3242 {$EXTERNALSYM SDL_MustLock}
3243 { SDL_LockSurface() sets up a surface for directly accessing the pixels.
3244   Between calls to SDL_LockSurface()/SDL_UnlockSurface(), you can write
3245   to and read from 'surface->pixels', using the pixel format stored in
3246   'surface->format'.  Once you are done accessing the surface, you should
3247   use SDL_UnlockSurface() to release it.
3248
3249   Not all surfaces require locking.  If SDL_MUSTLOCK(surface) evaluates
3250   to 0, then you can read and write to the surface at any time, and the
3251   pixel format of the surface will not change.  In particular, if the
3252   SDL_HWSURFACE flag is not given when calling SDL_SetVideoMode(), you
3253   will not need to lock the display surface before accessing it.
3254
3255   No operating system or library calls should be made between lock/unlock
3256   pairs, as critical system locks may be held during this time.
3257
3258   SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked. }
3259 function SDL_LockSurface(surface: PSDL_Surface): Integer;
3260 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LockSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3261 {$EXTERNALSYM SDL_LockSurface}
3262
3263 procedure SDL_UnlockSurface(surface: PSDL_Surface);
3264 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UnlockSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3265 {$EXTERNALSYM SDL_UnlockSurface}
3266
3267 { Load a surface from a seekable SDL data source (memory or file.)
3268   If 'freesrc' is non-zero, the source will be closed after being read.
3269   Returns the new surface, or NULL if there was an error.
3270   The new surface should be freed with SDL_FreeSurface(). }
3271 function SDL_LoadBMP_RW(src: PSDL_RWops; freesrc: Integer): PSDL_Surface;
3272 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LoadBMP_RW'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3273 {$EXTERNALSYM SDL_LoadBMP_RW}
3274
3275 // Convenience macro -- load a surface from a file
3276 function SDL_LoadBMP(filename: PChar): PSDL_Surface;
3277 {$EXTERNALSYM SDL_LoadBMP}
3278
3279 { Save a surface to a seekable SDL data source (memory or file.)
3280   If 'freedst' is non-zero, the source will be closed after being written.
3281   Returns 0 if successful or -1 if there was an error. }
3282
3283 function SDL_SaveBMP_RW(surface: PSDL_Surface; dst: PSDL_RWops; freedst: Integer): Integer;
3284 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SaveBMP_RW'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3285 {$EXTERNALSYM SDL_SaveBMP_RW}
3286
3287 // Convenience macro -- save a surface to a file
3288 function SDL_SaveBMP(surface: PSDL_Surface; filename: PChar): Integer;
3289 {$EXTERNALSYM SDL_SaveBMP}
3290
3291 { Sets the color key (transparent pixel) in a blittable surface.
3292   If 'flag' is SDL_SRCCOLORKEY (optionally OR'd with SDL_RLEACCEL),
3293   'key' will be the transparent pixel in the source image of a blit.
3294   SDL_RLEACCEL requests RLE acceleration for the surface if present,
3295   and removes RLE acceleration if absent.
3296   If 'flag' is 0, this function clears any current color key.
3297   This function returns 0, or -1 if there was an error. }
3298
3299 function SDL_SetColorKey(surface: PSDL_Surface; flag, key: UInt32) : Integer;
3300 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetColorKey'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3301 {$EXTERNALSYM SDL_SetColorKey}
3302
3303 { This function sets the alpha value for the entire surface, as opposed to
3304   using the alpha component of each pixel. This value measures the range
3305   of transparency of the surface, 0 being completely transparent to 255
3306   being completely opaque. An 'alpha' value of 255 causes blits to be
3307   opaque, the source pixels copied to the destination (the default). Note
3308   that per-surface alpha can be combined with colorkey transparency.
3309
3310   If 'flag' is 0, alpha blending is disabled for the surface.
3311   If 'flag' is SDL_SRCALPHA, alpha blending is enabled for the surface.
3312   OR:ing the flag with SDL_RLEACCEL requests RLE acceleration for the
3313   surface; if SDL_RLEACCEL is not specified, the RLE accel will be removed. }
3314
3315
3316 function SDL_SetAlpha(surface: PSDL_Surface; flag: UInt32; alpha: UInt8): Integer;
3317 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetAlpha'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3318 {$EXTERNALSYM SDL_SetAlpha}
3319
3320 { Sets the clipping rectangle for the destination surface in a blit.
3321
3322   If the clip rectangle is NULL, clipping will be disabled.
3323   If the clip rectangle doesn't intersect the surface, the function will
3324   return SDL_FALSE and blits will be completely clipped.  Otherwise the
3325   function returns SDL_TRUE and blits to the surface will be clipped to
3326   the intersection of the surface area and the clipping rectangle.
3327
3328   Note that blits are automatically clipped to the edges of the source
3329   and destination surfaces. }
3330 procedure SDL_SetClipRect(surface: PSDL_Surface; rect: PSDL_Rect); cdecl;
3331 external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetClipRect'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3332 {$EXTERNALSYM SDL_SetClipRect}
3333
3334 { Gets the clipping rectangle for the destination surface in a blit.
3335   'rect' must be a pointer to a valid rectangle which will be filled
3336   with the correct values. }
3337 procedure SDL_GetClipRect(surface: PSDL_Surface; rect: PSDL_Rect); cdecl;
3338 external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetClipRect'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3339 {$EXTERNALSYM SDL_GetClipRect}
3340
3341 { Creates a new surface of the specified format, and then copies and maps
3342   the given surface to it so the blit of the converted surface will be as
3343   fast as possible.  If this function fails, it returns NULL.
3344
3345   The 'flags' parameter is passed to SDL_CreateRGBSurface() and has those
3346   semantics.  You can also pass SDL_RLEACCEL in the flags parameter and
3347   SDL will try to RLE accelerate colorkey and alpha blits in the resulting
3348   surface.
3349
3350   This function is used internally by SDL_DisplayFormat(). }
3351
3352 function SDL_ConvertSurface(src: PSDL_Surface; fmt: PSDL_PixelFormat; flags: UInt32): PSDL_Surface;
3353 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ConvertSurface'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3354 {$EXTERNALSYM SDL_ConvertSurface}
3355
3356 {
3357   This performs a fast blit from the source surface to the destination
3358   surface.  It assumes that the source and destination rectangles are
3359   the same size.  If either 'srcrect' or 'dstrect' are NULL, the entire
3360   surface (src or dst) is copied.  The final blit rectangles are saved
3361   in 'srcrect' and 'dstrect' after all clipping is performed.
3362   If the blit is successful, it returns 0, otherwise it returns -1.
3363
3364   The blit function should not be called on a locked surface.
3365
3366   The blit semantics for surfaces with and without alpha and colorkey
3367   are defined as follows:
3368
3369   RGBA->RGB:
3370       SDL_SRCALPHA set:
3371    alpha-blend (using alpha-channel).
3372    SDL_SRCCOLORKEY ignored.
3373       SDL_SRCALPHA not set:
3374    copy RGB.
3375    if SDL_SRCCOLORKEY set, only copy the pixels matching the
3376    RGB values of the source colour key, ignoring alpha in the
3377    comparison.
3378
3379   RGB->RGBA:
3380       SDL_SRCALPHA set:
3381    alpha-blend (using the source per-surface alpha value);
3382    set destination alpha to opaque.
3383       SDL_SRCALPHA not set:
3384    copy RGB, set destination alpha to opaque.
3385       both:
3386    if SDL_SRCCOLORKEY set, only copy the pixels matching the
3387    source colour key.
3388
3389   RGBA->RGBA:
3390       SDL_SRCALPHA set:
3391    alpha-blend (using the source alpha channel) the RGB values;
3392    leave destination alpha untouched. [Note: is this correct?]
3393    SDL_SRCCOLORKEY ignored.
3394       SDL_SRCALPHA not set:
3395    copy all of RGBA to the destination.
3396    if SDL_SRCCOLORKEY set, only copy the pixels matching the
3397    RGB values of the source colour key, ignoring alpha in the
3398    comparison.
3399
3400   RGB->RGB:
3401       SDL_SRCALPHA set:
3402    alpha-blend (using the source per-surface alpha value).
3403       SDL_SRCALPHA not set:
3404    copy RGB.
3405       both:
3406    if SDL_SRCCOLORKEY set, only copy the pixels matching the
3407    source colour key.
3408
3409   If either of the surfaces were in video memory, and the blit returns -2,
3410   the video memory was lost, so it should be reloaded with artwork and
3411   re-blitted:
3412   while ( SDL_BlitSurface(image, imgrect, screen, dstrect) = -2 ) do
3413   begin
3414   while ( SDL_LockSurface(image) < 0 ) do
3415    Sleep(10);
3416   -- Write image pixels to image->pixels --
3417   SDL_UnlockSurface(image);
3418  end;
3419
3420   This happens under DirectX 5.0 when the system switches away from your
3421   fullscreen application.  The lock will also fail until you have access
3422   to the video memory again. }
3423
3424 { You should call SDL_BlitSurface() unless you know exactly how SDL
3425    blitting works internally and how to use the other blit functions. }
3426
3427 function SDL_BlitSurface(src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): Integer;
3428 {$EXTERNALSYM SDL_BlitSurface}
3429
3430 {  This is the public blit function, SDL_BlitSurface(), and it performs
3431    rectangle validation and clipping before passing it to SDL_LowerBlit() }
3432 function SDL_UpperBlit(src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): Integer;
3433 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UpperBlit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3434 {$EXTERNALSYM SDL_UpperBlit}
3435
3436 { This is a semi-private blit function and it performs low-level surface
3437   blitting only. }
3438 function SDL_LowerBlit(src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect): Integer;
3439 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LowerBlit'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3440 {$EXTERNALSYM SDL_LowerBlit}
3441
3442 { This function performs a fast fill of the given rectangle with 'color'
3443   The given rectangle is clipped to the destination surface clip area
3444   and the final fill rectangle is saved in the passed in pointer.
3445   If 'dstrect' is NULL, the whole surface will be filled with 'color'
3446   The color should be a pixel of the format used by the surface, and
3447   can be generated by the SDL_MapRGB() function.
3448   This function returns 0 on success, or -1 on error. }
3449
3450 function SDL_FillRect(dst: PSDL_Surface; dstrect: PSDL_Rect; color: UInt32) : Integer;
3451 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FillRect'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3452 {$EXTERNALSYM SDL_FillRect}
3453
3454 { This function takes a surface and copies it to a new surface of the
3455   pixel format and colors of the video framebuffer, suitable for fast
3456   blitting onto the display surface.  It calls SDL_ConvertSurface()
3457
3458   If you want to take advantage of hardware colorkey or alpha blit
3459   acceleration, you should set the colorkey and alpha value before
3460   calling this function.
3461
3462   If the conversion fails or runs out of memory, it returns NULL }
3463
3464 function SDL_DisplayFormat(surface: PSDL_Surface): PSDL_Surface; cdecl;
3465 external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DisplayFormat'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3466 {$EXTERNALSYM SDL_DisplayFormat}
3467
3468 { This function takes a surface and copies it to a new surface of the
3469   pixel format and colors of the video framebuffer (if possible),
3470   suitable for fast alpha blitting onto the display surface.
3471   The new surface will always have an alpha channel.
3472
3473   If you want to take advantage of hardware colorkey or alpha blit
3474   acceleration, you should set the colorkey and alpha value before
3475   calling this function.
3476
3477   If the conversion fails or runs out of memory, it returns NULL }
3478
3479
3480 function SDL_DisplayFormatAlpha(surface: PSDL_Surface): PSDL_Surface; cdecl;
3481 external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DisplayFormatAlpha'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3482 {$EXTERNALSYM SDL_DisplayFormatAlpha}
3483
3484 //* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
3485 //* YUV video surface overlay functions                                       */
3486 //* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
3487
3488 { This function creates a video output overlay
3489   Calling the returned surface an overlay is something of a misnomer because
3490   the contents of the display surface underneath the area where the overlay
3491   is shown is undefined - it may be overwritten with the converted YUV data. }
3492
3493 function SDL_CreateYUVOverlay(width: Integer; height: Integer; format: UInt32; display: PSDL_Surface): PSDL_Overlay;
3494 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3495 {$EXTERNALSYM SDL_CreateYUVOverlay}
3496
3497 // Lock an overlay for direct access, and unlock it when you are done
3498 function SDL_LockYUVOverlay(Overlay: PSDL_Overlay): Integer;
3499 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LockYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3500 {$EXTERNALSYM SDL_LockYUVOverlay}
3501
3502 procedure SDL_UnlockYUVOverlay(Overlay: PSDL_Overlay); cdecl;
3503 external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UnlockYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3504 {$EXTERNALSYM SDL_UnlockYUVOverlay}
3505
3506
3507 { Blit a video overlay to the display surface.
3508   The contents of the video surface underneath the blit destination are
3509   not defined.
3510   The width and height of the destination rectangle may be different from
3511   that of the overlay, but currently only 2x scaling is supported. }
3512
3513 function SDL_DisplayYUVOverlay(Overlay: PSDL_Overlay; dstrect: PSDL_Rect) : Integer;
3514 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DisplayYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3515 {$EXTERNALSYM SDL_DisplayYUVOverlay}
3516
3517 // Free a video overlay
3518 procedure SDL_FreeYUVOverlay(Overlay: PSDL_Overlay);
3519 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FreeYUVOverlay'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3520 {$EXTERNALSYM SDL_FreeYUVOverlay}
3521
3522 {------------------------------------------------------------------------------}
3523 { OpenGL Routines                                                              }
3524 {------------------------------------------------------------------------------}
3525
3526 { Dynamically load a GL driver, if SDL is built with dynamic GL.
3527
3528   SDL links normally with the OpenGL library on your system by default,
3529   but you can compile it to dynamically load the GL driver at runtime.
3530   If you do this, you need to retrieve all of the GL functions used in
3531   your program from the dynamic library using SDL_GL_GetProcAddress().
3532
3533   This is disabled in default builds of SDL. }
3534
3535
3536 function SDL_GL_LoadLibrary(filename: PChar): Integer;
3537 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_LoadLibrary'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3538 {$EXTERNALSYM SDL_GL_LoadLibrary}
3539
3540 { Get the address of a GL function (for extension functions) }
3541 function SDL_GL_GetProcAddress(procname: PChar) : Pointer;
3542 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_GetProcAddress'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3543 {$EXTERNALSYM SDL_GL_GetProcAddress}
3544
3545 { Set an attribute of the OpenGL subsystem before intialization. }
3546 function SDL_GL_SetAttribute(attr: TSDL_GLAttr; value: Integer) : Integer;
3547 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_SetAttribute'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3548 {$EXTERNALSYM SDL_GL_SetAttribute}
3549
3550 { Get an attribute of the OpenGL subsystem from the windowing
3551   interface, such as glX. This is of course different from getting
3552   the values from SDL's internal OpenGL subsystem, which only
3553   stores the values you request before initialization.
3554
3555   Developers should track the values they pass into SDL_GL_SetAttribute
3556   themselves if they want to retrieve these values. }
3557
3558 function SDL_GL_GetAttribute(attr: TSDL_GLAttr; var value: Integer): Integer;
3559 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_GetAttribute'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3560 {$EXTERNALSYM SDL_GL_GetAttribute}
3561
3562 { Swap the OpenGL buffers, if double-buffering is supported. }
3563
3564 procedure SDL_GL_SwapBuffers;
3565 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_SwapBuffers'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3566 {$EXTERNALSYM SDL_GL_SwapBuffers;}
3567
3568 { Internal functions that should not be called unless you have read
3569   and understood the source code for these functions. }
3570
3571 procedure SDL_GL_UpdateRects(numrects: Integer; rects: PSDL_Rect);
3572 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_UpdateRects'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3573 {$EXTERNALSYM SDL_GL_UpdateRects}
3574 procedure SDL_GL_Lock;
3575 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_Lock'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3576 {$EXTERNALSYM SDL_GL_Lock;}
3577 procedure SDL_GL_Unlock;
3578 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GL_Unlock'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3579 {$EXTERNALSYM SDL_GL_Unlock;}
3580
3581 {* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
3582 {* These functions allow interaction with the window manager, if any.        *}
3583 {* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *}
3584
3585 { Sets/Gets the title and icon text of the display window }
3586 procedure SDL_WM_GetCaption(var title : PChar; var icon : PChar);
3587 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_GetCaption'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3588 {$EXTERNALSYM SDL_WM_GetCaption}
3589 procedure SDL_WM_SetCaption( const title : PChar; const icon : PChar);
3590 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_SetCaption'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3591 {$EXTERNALSYM SDL_WM_SetCaption}
3592
3593 { Sets the icon for the display window.
3594   This function must be called before the first call to SDL_SetVideoMode().
3595   It takes an icon surface, and a mask in MSB format.
3596   If 'mask' is NULL, the entire icon surface will be used as the icon. }
3597 procedure SDL_WM_SetIcon(icon: PSDL_Surface; mask: PUInt8);
3598 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_SetIcon'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3599 {$EXTERNALSYM SDL_WM_SetIcon}
3600
3601 { This function iconifies the window, and returns 1 if it succeeded.
3602   If the function succeeds, it generates an SDL_APPACTIVE loss event.
3603   This function is a noop and returns 0 in non-windowed environments. }
3604
3605 function SDL_WM_IconifyWindow: Integer;
3606 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_IconifyWindow'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3607 {$EXTERNALSYM SDL_WM_IconifyWindow}
3608
3609 { Toggle fullscreen mode without changing the contents of the screen.
3610   If the display surface does not require locking before accessing
3611   the pixel information, then the memory pointers will not change.
3612
3613   If this function was able to toggle fullscreen mode (change from
3614   running in a window to fullscreen, or vice-versa), it will return 1.
3615   If it is not implemented, or fails, it returns 0.
3616
3617   The next call to SDL_SetVideoMode() will set the mode fullscreen
3618   attribute based on the flags parameter - if SDL_FULLSCREEN is not
3619   set, then the display will be windowed by default where supported.
3620
3621   This is currently only implemented in the X11 video driver. }
3622
3623 function SDL_WM_ToggleFullScreen(surface: PSDL_Surface): Integer;
3624 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_ToggleFullScreen'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3625 {$EXTERNALSYM SDL_WM_ToggleFullScreen}
3626
3627 { Grabbing means that the mouse is confined to the application window,
3628   and nearly all keyboard input is passed directly to the application,
3629   and not interpreted by a window manager, if any. }
3630
3631 function SDL_WM_GrabInput(mode: TSDL_GrabMode): TSDL_GrabMode;
3632 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WM_GrabInput'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3633 {$EXTERNALSYM SDL_WM_GrabInput}
3634
3635 {------------------------------------------------------------------------------}
3636 { mouse-routines }
3637 {------------------------------------------------------------------------------}
3638
3639 { Retrieve the current state of the mouse.
3640   The current button state is returned as a button bitmask, which can
3641   be tested using the SDL_BUTTON(X) macros, and x and y are set to the
3642   current mouse cursor position.  You can pass NULL for either x or y. }
3643
3644 function SDL_GetMouseState(var x: Integer; var y: Integer): UInt8;
3645 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetMouseState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3646 {$EXTERNALSYM SDL_GetMouseState}
3647
3648 { Retrieve the current state of the mouse.
3649   The current button state is returned as a button bitmask, which can
3650   be tested using the SDL_BUTTON(X) macros, and x and y are set to the
3651   mouse deltas since the last call to SDL_GetRelativeMouseState(). }
3652 function SDL_GetRelativeMouseState(var x: Integer; var y: Integer): UInt8;
3653 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetRelativeMouseState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3654 {$EXTERNALSYM SDL_GetRelativeMouseState}
3655
3656 { Set the position of the mouse cursor (generates a mouse motion event) }
3657 procedure SDL_WarpMouse(x, y: UInt16);
3658 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WarpMouse'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3659 {$EXTERNALSYM SDL_WarpMouse}
3660
3661 { Create a cursor using the specified data and mask (in MSB format).
3662   The cursor width must be a multiple of 8 bits.
3663
3664   The cursor is created in black and white according to the following:
3665   data  mask    resulting pixel on screen
3666    0     1       White
3667    1     1       Black
3668    0     0       Transparent
3669    1     0       Inverted color if possible, black if not.
3670
3671   Cursors created with this function must be freed with SDL_FreeCursor(). }
3672 function SDL_CreateCursor(data, mask: PUInt8; w, h, hot_x, hot_y: Integer): PSDL_Cursor;
3673 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateCursor'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3674 {$EXTERNALSYM SDL_CreateCursor}
3675
3676 { Set the currently active cursor to the specified one.
3677   If the cursor is currently visible, the change will be immediately
3678   represented on the display. }
3679 procedure SDL_SetCursor(cursor: PSDL_Cursor);
3680 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetCursor'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3681 {$EXTERNALSYM SDL_SetCursor}
3682
3683 { Returns the currently active cursor. }
3684 function SDL_GetCursor: PSDL_Cursor;
3685 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetCursor'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3686 {$EXTERNALSYM SDL_GetCursor}
3687
3688 { Deallocates a cursor created with SDL_CreateCursor(). }
3689 procedure SDL_FreeCursor(cursor: PSDL_Cursor);
3690 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_FreeCursor'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3691 {$EXTERNALSYM SDL_FreeCursor}
3692
3693 { Toggle whether or not the cursor is shown on the screen.
3694   The cursor start off displayed, but can be turned off.
3695   SDL_ShowCursor() returns 1 if the cursor was being displayed
3696   before the call, or 0 if it was not.  You can query the current
3697   state by passing a 'toggle' value of -1. }
3698 function SDL_ShowCursor(toggle: Integer): Integer;
3699 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ShowCursor'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3700 {$EXTERNALSYM SDL_ShowCursor}
3701
3702 function SDL_BUTTON( Button : Integer ) : Integer;
3703
3704 {------------------------------------------------------------------------------}
3705 { Keyboard-routines                                                            }
3706 {------------------------------------------------------------------------------}
3707
3708 { Enable/Disable UNICODE translation of keyboard input.
3709   This translation has some overhead, so translation defaults off.
3710   If 'enable' is 1, translation is enabled.
3711   If 'enable' is 0, translation is disabled.
3712   If 'enable' is -1, the translation state is not changed.
3713   It returns the previous state of keyboard translation. }
3714 function SDL_EnableUNICODE(enable: Integer): Integer;
3715 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_EnableUNICODE'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3716 {$EXTERNALSYM SDL_EnableUNICODE}
3717
3718 { If 'delay' is set to 0, keyboard repeat is disabled. }
3719 function SDL_EnableKeyRepeat(delay: Integer; interval: Integer): Integer;
3720 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_EnableKeyRepeat'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3721 {$EXTERNALSYM SDL_EnableKeyRepeat}
3722
3723 procedure SDL_GetKeyRepeat(delay : PInteger; interval: PInteger);
3724 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetKeyRepeat'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3725 {$EXTERNALSYM SDL_GetKeyRepeat}
3726
3727 { Get a snapshot of the current state of the keyboard.
3728   Returns an array of keystates, indexed by the SDLK_* syms.
3729   Used:
3730
3731   UInt8 *keystate = SDL_GetKeyState(NULL);
3732   if ( keystate[SDLK_RETURN] ) ... <RETURN> is pressed }
3733
3734 function SDL_GetKeyState(numkeys: PInt): PUInt8;
3735 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetKeyState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3736 {$EXTERNALSYM SDL_GetKeyState}
3737
3738 { Get the current key modifier state }
3739 function SDL_GetModState: TSDLMod;
3740 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetModState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3741 {$EXTERNALSYM SDL_GetModState}
3742
3743 { Set the current key modifier state
3744   This does not change the keyboard state, only the key modifier flags. }
3745 procedure SDL_SetModState(modstate: TSDLMod);
3746 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SetModState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3747 {$EXTERNALSYM SDL_SetModState}
3748
3749 { Get the name of an SDL virtual keysym }
3750 function SDL_GetKeyName(key: TSDLKey): PChar;
3751 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetKeyName'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3752 {$EXTERNALSYM SDL_GetKeyName}
3753
3754 {------------------------------------------------------------------------------}
3755 { Active Routines                                                              }
3756 {------------------------------------------------------------------------------}
3757
3758 { This function returns the current state of the application, which is a
3759   bitwise combination of SDL_APPMOUSEFOCUS, SDL_APPINPUTFOCUS, and
3760   SDL_APPACTIVE.  If SDL_APPACTIVE is set, then the user is able to
3761   see your application, otherwise it has been iconified or disabled. }
3762
3763 function SDL_GetAppState: UInt8;
3764 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetAppState'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3765 {$EXTERNALSYM SDL_GetAppState}
3766
3767
3768 { Mutex functions }
3769
3770 { Create a mutex, initialized unlocked }
3771
3772 function SDL_CreateMutex: PSDL_Mutex;
3773 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateMutex'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3774 {$EXTERNALSYM SDL_CreateMutex}
3775
3776 { Lock the mutex  (Returns 0, or -1 on error) }
3777
3778  function SDL_mutexP(mutex: PSDL_mutex): Integer;
3779  cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_mutexP'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3780 { $ EXTERNALSYM SDL_mutexP}
3781
3782 function SDL_LockMutex(mutex: PSDL_mutex): Integer;
3783 {$EXTERNALSYM SDL_LockMutex}
3784
3785 { Unlock the mutex  (Returns 0, or -1 on error) }
3786 function SDL_mutexV(mutex: PSDL_mutex): Integer;
3787 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_mutexV'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3788 {$EXTERNALSYM SDL_mutexV}
3789
3790 function SDL_UnlockMutex(mutex: PSDL_mutex): Integer;
3791 {$EXTERNALSYM SDL_UnlockMutex}
3792
3793 { Destroy a mutex }
3794 procedure SDL_DestroyMutex(mutex: PSDL_mutex);
3795 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DestroyMutex'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3796 {$EXTERNALSYM SDL_DestroyMutex}
3797
3798 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
3799 { Semaphore functions                                           }
3800 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
3801 { Create a semaphore, initialized with value, returns NULL on failure. }
3802 function SDL_CreateSemaphore(initial_value: UInt32): PSDL_Sem;
3803 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateSemaphore'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3804 {$EXTERNALSYM SDL_CreateSemaphore}
3805
3806
3807 { Destroy a semaphore }
3808 procedure SDL_DestroySemaphore(sem: PSDL_sem);
3809 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DestroySemaphore'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3810 {$EXTERNALSYM SDL_DestroySemaphore}
3811
3812 { This function suspends the calling thread until the semaphore pointed
3813   to by sem has a positive count. It then atomically decreases the semaphore
3814   count. }
3815
3816 function SDL_SemWait(sem: PSDL_sem): Integer;
3817 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SemWait'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3818 {$EXTERNALSYM SDL_SemWait}
3819
3820 { Non-blocking variant of SDL_SemWait(), returns 0 if the wait succeeds,
3821    SDL_MUTEX_TIMEDOUT if the wait would block, and -1 on error. }
3822
3823 function SDL_SemTryWait(sem: PSDL_sem): Integer;
3824 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SemTryWait'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3825 {$EXTERNALSYM SDL_SemTryWait}
3826
3827 { Variant of SDL_SemWait() with a timeout in milliseconds, returns 0 if
3828    the wait succeeds, SDL_MUTEX_TIMEDOUT if the wait does not succeed in
3829    the allotted time, and -1 on error.
3830    On some platforms this function is implemented by looping with a delay
3831    of 1 ms, and so should be avoided if possible. }
3832
3833 function SDL_SemWaitTimeout(sem: PSDL_sem; ms: UInt32): Integer;
3834 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SemWaitTimeout'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3835 {$EXTERNALSYM SDL_SemTryWait}
3836
3837 { Atomically increases the semaphore's count (not blocking), returns 0,
3838    or -1 on error. }
3839
3840 function SDL_SemPost(sem: PSDL_sem): Integer;
3841 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SemPost'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3842 {$EXTERNALSYM SDL_SemTryWait}
3843
3844 { Returns the current count of the semaphore }
3845
3846 function SDL_SemValue(sem: PSDL_sem): UInt32;
3847 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_SemValue'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3848 {$EXTERNALSYM SDL_SemValue}
3849
3850 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
3851 { Condition variable functions                                  }
3852 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
3853 { Create a condition variable }
3854 function SDL_CreateCond: PSDL_Cond;
3855 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateCond'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3856 {$EXTERNALSYM SDL_CreateCond}
3857
3858 { Destroy a condition variable }
3859 procedure SDL_DestroyCond(cond: PSDL_Cond);
3860 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_DestroyCond'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3861 {$EXTERNALSYM SDL_DestroyCond}
3862
3863 { Restart one of the threads that are waiting on the condition variable,
3864    returns 0 or -1 on error. }
3865
3866 function SDL_CondSignal(cond: PSDL_cond): Integer;
3867 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CondSignal'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3868 {$EXTERNALSYM SDL_CondSignal}
3869
3870 { Restart all threads that are waiting on the condition variable,
3871   returns 0 or -1 on error. }
3872
3873 function SDL_CondBroadcast(cond: PSDL_cond): Integer;
3874 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CondBroadcast'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3875 {$EXTERNALSYM SDL_CondBroadcast}
3876
3877
3878 { Wait on the condition variable, unlocking the provided mutex.
3879   The mutex must be locked before entering this function!
3880   Returns 0 when it is signaled, or -1 on error. }
3881
3882 function SDL_CondWait(cond: PSDL_cond; mut: PSDL_mutex): Integer;
3883 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CondWait'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3884 {$EXTERNALSYM SDL_CondWait}
3885
3886 { Waits for at most 'ms' milliseconds, and returns 0 if the condition
3887   variable is signaled, SDL_MUTEX_TIMEDOUT if the condition is not
3888   signaled in the allotted time, and -1 on error.
3889   On some platforms this function is implemented by looping with a delay
3890   of 1 ms, and so should be avoided if possible. }
3891
3892 function SDL_CondWaitTimeout(cond: PSDL_cond; mut: PSDL_mutex; ms: UInt32) : Integer;
3893 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CondWaitTimeout'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3894 {$EXTERNALSYM SDL_CondWaitTimeout}
3895
3896 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
3897 { Condition variable functions                                  }
3898 { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
3899
3900 { Create a thread }
3901 function SDL_CreateThread(fn: PInt; data: Pointer): PSDL_Thread;
3902 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_CreateThread'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3903 {$EXTERNALSYM SDL_CreateThread}
3904
3905 { Get the 32-bit thread identifier for the current thread }
3906 function SDL_ThreadID: UInt32;
3907 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_ThreadID'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3908 {$EXTERNALSYM SDL_ThreadID}
3909
3910 { Get the 32-bit thread identifier for the specified thread,
3911   equivalent to SDL_ThreadID() if the specified thread is NULL. }
3912 function SDL_GetThreadID(thread: PSDL_Thread): UInt32;
3913 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetThreadID'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3914 {$EXTERNALSYM SDL_GetThreadID}
3915
3916 { Wait for a thread to finish.
3917   The return code for the thread function is placed in the area
3918   pointed to by 'status', if 'status' is not NULL. }
3919
3920 procedure SDL_WaitThread(thread: PSDL_Thread; var status: Integer);
3921 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_WaitThread'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3922 {$EXTERNALSYM SDL_WaitThread}
3923
3924 { Forcefully kill a thread without worrying about its state }
3925 procedure SDL_KillThread(thread: PSDL_Thread);
3926 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_KillThread'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3927 {$EXTERNALSYM SDL_KillThread}
3928
3929 {------------------------------------------------------------------------------}
3930 { Get Environment Routines                                                     }
3931 {------------------------------------------------------------------------------}
3932 {$IFDEF WINDOWS}
3933 function _putenv( const variable : Pchar ): integer;
3934 cdecl;
3935 {$ENDIF}
3936
3937 {$IFDEF Unix}
3938 {$IFDEF FPC}
3939 function _putenv( const variable : Pchar ): integer;
3940 cdecl; external 'libc.so' name 'putenv';
3941 {$ENDIF}
3942 {$ENDIF}
3943
3944 { Put a variable of the form "name=value" into the environment }
3945 //function SDL_putenv(const variable: PChar): integer; cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Init'{$ELSE} SDLLibName{$ENDIF __GPC__}SDLLibName name '';
3946 function SDL_putenv(const variable: PChar): integer;
3947 {$EXTERNALSYM SDL_putenv}
3948
3949 // The following function has been commented out to encourage developers to use
3950 // SDL_putenv as it it more portable
3951 //function putenv(const variable: PChar): integer;
3952 //{$EXTERNALSYM putenv}
3953
3954 {$IFDEF WINDOWS}
3955 {$IFNDEF __GPC__}
3956 function getenv( const name : Pchar ): PChar; cdecl;
3957 {$ENDIF}
3958 {$ENDIF}
3959
3960 {* Retrieve a variable named "name" from the environment }
3961 //function SDL_getenv(const name: PChar): PChar; cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_Init'{$ELSE} SDLLibName{$ENDIF __GPC__}SDLLibName name '';
3962 function SDL_getenv(const name: PChar): PChar;
3963 {$EXTERNALSYM SDL_getenv}
3964
3965 // The following function has been commented out to encourage developers to use
3966 // SDL_getenv as it it more portable
3967 //function getenv(const name: PChar): PChar;
3968 //{$EXTERNALSYM getenv}
3969
3970 {*
3971  * This function gives you custom hooks into the window manager information.
3972  * It fills the structure pointed to by 'info' with custom information and
3973  * returns 1 if the function is implemented.  If it's not implemented, or
3974  * the version member of the 'info' structure is invalid, it returns 0.
3975  *}
3976 function SDL_GetWMInfo(info : PSDL_SysWMinfo) : integer;
3977 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_GetWMInfo'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3978 {$EXTERNALSYM SDL_GetWMInfo}
3979
3980 {------------------------------------------------------------------------------}
3981
3982 //SDL_loadso.h
3983 {* This function dynamically loads a shared object and returns a pointer
3984  * to the object handle (or NULL if there was an error).
3985  * The 'sofile' parameter is a system dependent name of the object file.
3986  *}
3987 function SDL_LoadObject( const sofile : PChar ) : Pointer;
3988 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LoadObject'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3989 {$EXTERNALSYM SDL_LoadObject}
3990
3991 {* Given an object handle, this function looks up the address of the
3992  * named function in the shared object and returns it.  This address
3993  * is no longer valid after calling SDL_UnloadObject().
3994  *}
3995 function SDL_LoadFunction( handle : Pointer; const name : PChar ) : Pointer;
3996 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_LoadFunction'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
3997 {$EXTERNALSYM SDL_LoadFunction}
3998
3999 {* Unload a shared object from memory *}
4000 procedure SDL_UnloadObject( handle : Pointer );
4001 cdecl; external {$IFNDEF NDS}{$IFDEF __GPC__}name 'SDL_UnloadObject'{$ELSE} SDLLibName{$ENDIF __GPC__}{$ENDIF};
4002 {$EXTERNALSYM SDL_UnloadObject}
4003
4004
4005
4006 {------------------------------------------------------------------------------}
4007
4008 function SDL_Swap32(D: Uint32): Uint32;
4009 {$EXTERNALSYM SDL_Swap32}
4010
4011 {$ENDIF MORPHOS}
4012
4013 { FreeAndNil frees the given TObject instance and sets the variable reference
4014   to nil.  Be careful to only pass TObjects to this routine. }
4015 procedure FreeAndNil(var Obj);
4016
4017 { Exit procedure handling }
4018
4019 { AddExitProc adds the given procedure to the run-time library's exit
4020   procedure list. When an application terminates, its exit procedures are
4021   executed in reverse order of definition, i.e. the last procedure passed
4022   to AddExitProc is the first one to get executed upon termination. }
4023 procedure AddExitProc(Proc: TProcedure);
4024
4025 // Bitwise Checking functions
4026 function IsBitOn( value : integer; bit : Byte ) : boolean;
4027
4028 function TurnBitOn( value : integer; bit : Byte ) : integer;
4029
4030 function TurnBitOff( value : integer; bit : Byte ) : integer;
4031
4032 implementation
4033
4034 {$IFDEF __GPC__}
4035   {$L 'sdl'}  { link sdl.dll.a or libsdl.so or libsdl.a }
4036 {$ENDIF}
4037
4038 function SDL_TABLESIZE(table: PChar): Integer;
4039 begin
4040   Result := SizeOf(table) div SizeOf(table[0]);
4041 end;
4042
4043 procedure SDL_OutOfMemory;
4044 begin
4045   {$IFNDEF WINDOWS}
4046   SDL_Error(SDL_ENOMEM);
4047   {$ENDIF}
4048 end;
4049
4050 function SDL_RWSeek(context: PSDL_RWops; offset: Integer; whence: Integer) : Integer;
4051 begin
4052   Result := context^.seek(context, offset, whence);
4053 end;
4054
4055 function SDL_RWTell(context: PSDL_RWops): Integer;
4056 begin
4057   Result := context^.seek(context, 0, 1);
4058 end;
4059
4060 function SDL_RWRead(context: PSDL_RWops; ptr: Pointer; size: Integer; n: Integer): Integer;
4061 begin
4062   Result := context^.read(context, ptr, size, n);
4063 end;
4064
4065 function SDL_RWWrite(context: PSDL_RWops; ptr: Pointer; size: Integer; n: Integer): Integer;
4066 begin
4067   Result := context^.write(context, ptr, size, n);
4068 end;
4069
4070 function SDL_RWClose(context: PSDL_RWops): Integer;
4071 begin
4072   Result := context^.close(context);
4073 end;
4074
4075 function SDL_LoadWAV(filename: PChar; spec: PSDL_AudioSpec; audio_buf: PUInt8; audiolen: PUInt32): PSDL_AudioSpec;
4076 begin
4077   Result := SDL_LoadWAV_RW(SDL_RWFromFile(filename, 'rb'), 1, spec, audio_buf, audiolen);
4078 end;
4079
4080 function SDL_CDInDrive( status : TSDL_CDStatus ): LongBool;
4081 begin
4082   Result := ord( status ) > ord( CD_ERROR );
4083 end;
4084
4085 procedure FRAMES_TO_MSF(frames: Integer; var M: Integer; var S: Integer; var
4086   F: Integer);
4087 var
4088   value: Integer;
4089 begin
4090   value := frames;
4091   F := value mod CD_FPS;
4092   value := value div CD_FPS;
4093   S := value mod 60;
4094   value := value div 60;
4095   M := value;
4096 end;
4097
4098 function MSF_TO_FRAMES(M: Integer; S: Integer; F: Integer): Integer;
4099 begin
4100   Result := M * 60 * CD_FPS + S * CD_FPS + F;
4101 end;
4102
4103 procedure SDL_VERSION(var X: TSDL_Version);
4104 begin
4105   X.major := SDL_MAJOR_VERSION;
4106   X.minor := SDL_MINOR_VERSION;
4107   X.patch := SDL_PATCHLEVEL;
4108 end;
4109
4110 function SDL_VERSIONNUM(X, Y, Z: Integer): Integer;
4111 begin
4112   Result := X * 1000 + Y * 100 + Z;
4113 end;
4114
4115 function SDL_COMPILEDVERSION: Integer;
4116 begin
4117   Result := SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL
4118     );
4119 end;
4120
4121 function SDL_VERSION_ATLEAST(X, Y, Z: Integer): LongBool;
4122 begin
4123   Result := (SDL_COMPILEDVERSION >= SDL_VERSIONNUM(X, Y, Z));
4124 end;
4125
4126 function SDL_LoadBMP(filename: PChar): PSDL_Surface;
4127 begin
4128   Result := SDL_LoadBMP_RW(SDL_RWFromFile(filename, 'rb'), 1);
4129 end;
4130
4131 function SDL_SaveBMP(surface: PSDL_Surface; filename: PChar): Integer;
4132 begin
4133   Result := SDL_SaveBMP_RW(surface, SDL_RWFromFile(filename, 'wb'), 1);
4134 end;
4135
4136 function SDL_BlitSurface(src: PSDL_Surface; srcrect: PSDL_Rect; dst:
4137   PSDL_Surface;
4138   dstrect: PSDL_Rect): Integer;
4139 begin
4140   Result := SDL_UpperBlit(src, srcrect, dst, dstrect);
4141 end;
4142
4143 function SDL_AllocSurface(flags: UInt32; width, height, depth: Integer;
4144   RMask, GMask, BMask, AMask: UInt32): PSDL_Surface;
4145 begin
4146   Result := SDL_CreateRGBSurface(flags, width, height, depth, RMask, GMask,
4147     BMask, AMask);
4148 end;
4149
4150 function SDL_MustLock(Surface: PSDL_Surface): Boolean;
4151 begin
4152   Result := ( ( surface^.offset <> 0 ) or
4153            ( ( surface^.flags and ( SDL_HWSURFACE or SDL_ASYNCBLIT or SDL_RLEACCEL ) ) <> 0 ) );
4154 end;
4155
4156 function SDL_LockMutex(mutex: PSDL_mutex): Integer;
4157 begin
4158   Result := SDL_mutexP(mutex);
4159 end;
4160
4161 function SDL_UnlockMutex(mutex: PSDL_mutex): Integer;
4162 begin
4163   Result := SDL_mutexV(mutex);
4164 end;
4165
4166 {$IFDEF WINDOWS}
4167 function _putenv( const variable : Pchar ): Integer;
4168 cdecl; external {$IFDEF __GPC__}name '_putenv'{$ELSE} 'MSVCRT.DLL'{$ENDIF __GPC__};
4169 {$ENDIF}
4170
4171
4172 function SDL_putenv(const variable: PChar): Integer;
4173 begin
4174   {$IFDEF WINDOWS}
4175   Result := _putenv(variable);
4176   {$ENDIF}
4177
4178   {$IFDEF UNIX}
4179   {$IFDEF FPC}
4180   Result := _putenv(variable);
4181   {$ELSE}
4182   Result := libc.putenv(variable);
4183   {$ENDIF}
4184   {$ENDIF}
4185 end;
4186
4187 {$IFDEF WINDOWS}
4188 {$IFNDEF __GPC__}
4189 function getenv( const name : Pchar ): PChar;
4190 cdecl; external {$IFDEF __GPC__}name 'getenv'{$ELSE} 'MSVCRT.DLL'{$ENDIF};
4191 {$ENDIF}
4192 {$ENDIF}
4193
4194 function SDL_getenv(const name: PChar): PChar;
4195 begin
4196   {$IFDEF WINDOWS}
4197
4198   {$IFDEF __GPC__}
4199   Result := getenv( string( name ) );
4200   {$ELSE}
4201   Result := getenv( name );
4202   {$ENDIF}
4203
4204   {$ELSE}
4205
4206   {$IFDEF UNIX}
4207
4208   {$IFDEF FPC}
4209   Result := fpgetenv(name);
4210   {$ELSE}
4211   Result := libc.getenv(name);
4212   {$ENDIF}
4213
4214   {$ELSE UNIX}
4215    {$IFDEF OS2}
4216   DosScanEnv (Name, Result);
4217    {$ENDIF OS2}
4218   {$ENDIF}
4219
4220   {$ENDIF}
4221 end;
4222
4223 function SDL_BUTTON( Button : Integer ) : Integer;
4224 begin
4225   Result := SDL_PRESSED shl ( Button - 1 );
4226 end;
4227
4228 function SDL_Swap32(D: Uint32): Uint32;
4229 begin
4230   Result := ((D shl 24) or ((D shl 8) and $00FF0000) or ((D shr 8) and $0000FF00) or (D shr 24));
4231 end;
4232
4233 procedure FreeAndNil(var Obj);
4234 {$IFNDEF __GPC__}
4235 {$IFNDEF __TMT__}
4236 var
4237   Temp: TObject;
4238 {$ENDIF}
4239 {$ENDIF}
4240 begin
4241 {$IFNDEF __GPC__}
4242 {$IFNDEF __TMT__}
4243   Temp := TObject(Obj);
4244   Pointer(Obj) := nil;
4245   Temp.Free;
4246 {$ENDIF}
4247 {$ENDIF}
4248 end;
4249
4250 { Exit procedure handling }
4251 type
4252   PExitProcInfo = ^TExitProcInfo;
4253   TExitProcInfo = record
4254     Next: PExitProcInfo;
4255     SaveExit: Pointer;
4256     Proc: TProcedure;
4257   end;
4258
4259 var
4260   ExitProcList: PExitProcInfo = nil;
4261
4262 procedure DoExitProc;
4263 var
4264   P: PExitProcInfo;
4265   Proc: TProcedure;
4266 begin
4267   P := ExitProcList;
4268   ExitProcList := P^.Next;
4269   ExitProc := P^.SaveExit;
4270   Proc := P^.Proc;
4271   Dispose(P);
4272   Proc;
4273 end;
4274
4275 procedure AddExitProc(Proc: TProcedure);
4276 var
4277   P: PExitProcInfo;
4278 begin
4279   New(P);
4280   P^.Next := ExitProcList;
4281   P^.SaveExit := ExitProc;
4282   P^.Proc := Proc;
4283   ExitProcList := P;
4284   ExitProc := @DoExitProc;
4285 end;
4286
4287 function IsBitOn( value : integer; bit : Byte ) : boolean;
4288 begin
4289   result := ( ( value and ( 1 shl bit ) ) <> 0 );
4290 end;
4291
4292 function TurnBitOn( value : integer; bit : Byte ) : integer;
4293 begin
4294   result := ( value or ( 1 shl bit ) );
4295 end;
4296
4297 function TurnBitOff( value : integer; bit : Byte ) : integer;
4298 begin
4299   result := ( value and not ( 1 shl bit ) );
4300 end;
4301
4302 end.
4303
4304