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
keysnull1057 // 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
keysnull1121 // 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__}
eventnull1913 TSDL_EventFilter = function( event : PSDL_Event ): Integer; cdecl;
1914 {$ELSE}
eventnull1915 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__}
srcnull1999 TSDL_Blit = function( src: PSDL_Surface; srcrect: PSDL_Rect; dst: PSDL_Surface; dstrect: PSDL_Rect ): Integer; cdecl;
2000 {$ELSE}
srcnull2001 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().
thatnull2496 '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. }
SDL_BuildAudioCVTnull2567 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. }
SDL_ConvertAudionull2580 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
SDL_CDNumDrivesnull2618 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
SDL_CDNamenull2628 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
SDL_CDOpennull2638 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
SDL_CDStatusnull2646 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
SDL_CDPlayTracksnull2672 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
SDL_CDPlaynull2681 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
SDL_CDPausenull2686 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
SDL_CDResumenull2691 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
SDL_CDStopnull2696 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
SDL_CDEjectnull2701 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
returnsnull2741 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. }
SDL_JoystickOpenednull2747 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. }
SDL_JoystickIndexnull2752 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 }
SDL_JoystickNumAxesnull2757 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. }
SDL_JoystickNumBallsnull2764 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 }
SDL_JoystickNumHatsnull2770 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 }
SDL_JoystickNumButtonsnull2775 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
SDL_JoystickEventStatenull2793 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
SDL_JoystickGetAxisnull2801 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
SDL_JoystickGetHatnull2807 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
SDL_JoystickGetBallnull2815 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. }
SDL_JoystickGetButtonnull2821 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
SDL_PeepEventsnull2854 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
SDL_PollEventnull2862 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
SDL_WaitEventnull2870 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
SDL_PushEventnull2874 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
SDL_GetEventFilternull2899 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
SDL_EventStatenull2910 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
SDL_VERSIONNUMnull2927 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
SDL_COMPILEDVERSIONnull2931 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
SDL_VERSION_ATLEASTnull2935 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
SDL_Linked_Versionnull2942 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
SDL_VideoInitnull2963 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
SDL_VideoDriverNamenull2974 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
SDL_GetVideoSurfacenull2983 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. }
SDL_GetVideoInfonull2991 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
SDL_VideoModeOKnull3005 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
SDL_ListModesnull3017 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
SDL_SetVideoModenull3064 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
SDL_Flipnull3091 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
SDL_SetGammanull3102 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
SDL_SetGammaRampnull3117 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
SDL_GetGammaRampnull3129 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
SDL_SetColorsnull3148 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
SDL_SetPalettenull3167 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 }
SDL_MapRGBnull3172 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 }
SDL_MapRGBAnull3177 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
SDL_AllocSurfacenull3224 function SDL_AllocSurface(flags: UInt32; width, height, depth: Integer;
3225 RMask, GMask, BMask, AMask: UInt32): PSDL_Surface;
3226 {$EXTERNALSYM SDL_AllocSurface}
3227
SDL_CreateRGBSurfacenull3228 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
SDL_CreateRGBSurfaceFromnull3232 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
SDL_MustLocknull3241 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. }
SDL_LockSurfacenull3259 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(). }
SDL_LoadBMP_RWnull3271 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
SDL_LoadBMPnull3276 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
SDL_SaveBMP_RWnull3283 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
SDL_SaveBMPnull3288 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
SDL_SetColorKeynull3299 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
SDL_SetAlphanull3316 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
SDL_ConvertSurfacenull3352 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
SDL_BlitSurfacenull3427 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() }
SDL_UpperBlitnull3432 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. }
SDL_LowerBlitnull3438 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
SDL_FillRectnull3450 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
SDL_DisplayFormatnull3464 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
SDL_DisplayFormatAlphanull3480 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
SDL_CreateYUVOverlaynull3493 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
SDL_LockYUVOverlaynull3498 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
SDL_DisplayYUVOverlaynull3513 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
SDL_GL_LoadLibrarynull3536 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) }
SDL_GL_GetProcAddressnull3541 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. }
SDL_GL_SetAttributenull3546 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
SDL_GL_GetAttributenull3558 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
SDL_WM_IconifyWindownull3605 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
SDL_WM_ToggleFullScreennull3623 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
SDL_WM_GrabInputnull3631 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
SDL_GetMouseStatenull3644 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(). }
SDL_GetRelativeMouseStatenull3652 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(). }
SDL_CreateCursornull3672 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. }
SDL_GetCursornull3684 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. }
SDL_ShowCursornull3698 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
SDL_BUTTONnull3702 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. }
SDL_EnableUNICODEnull3714 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. }
SDL_EnableKeyRepeatnull3719 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
SDL_GetKeyStatenull3734 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 }
SDL_GetModStatenull3739 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 }
SDL_GetKeyNamenull3750 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
SDL_GetAppStatenull3763 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
SDL_CreateMutexnull3772 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
SDL_mutexPnull3778 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
SDL_LockMutexnull3782 function SDL_LockMutex(mutex: PSDL_mutex): Integer;
3783 {$EXTERNALSYM SDL_LockMutex}
3784
3785 { Unlock the mutex (Returns 0, or -1 on error) }
SDL_mutexVnull3786 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
SDL_UnlockMutexnull3790 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. }
SDL_CreateSemaphorenull3802 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
SDL_SemWaitnull3816 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
SDL_SemTryWaitnull3823 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
SDL_SemWaitTimeoutnull3833 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
SDL_SemPostnull3840 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
SDL_SemValuenull3846 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 }
SDL_CreateCondnull3854 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
SDL_CondSignalnull3866 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
SDL_CondBroadcastnull3873 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
SDL_CondWaitnull3882 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
SDL_CondWaitTimeoutnull3892 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 }
SDL_CreateThreadnull3901 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 }
SDL_ThreadIDnull3906 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. }
SDL_GetThreadIDnull3912 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}
_putenvnull3933 function _putenv( const variable : Pchar ): integer;
3934 cdecl;
3935 {$ENDIF}
3936
3937 {$IFDEF Unix}
3938 {$IFDEF FPC}
_putenvnull3939 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 }
SDL_putenvnull3945 //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
hasnull3949 // 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 }
SDL_getenvnull3961 //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
hasnull3965 // 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 *}
SDL_LoadObjectnull3987 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 *}
SDL_LoadFunctionnull3995 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
SDL_Swap32null4008 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
IsBitOnnull4026 function IsBitOn( value : integer; bit : Byte ) : boolean;
4027
TurnBitOnnull4028 function TurnBitOn( value : integer; bit : Byte ) : integer;
4029
TurnBitOffnull4030 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
SDL_TABLESIZEnull4038 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
SDL_RWSeeknull4050 function SDL_RWSeek(context: PSDL_RWops; offset: Integer; whence: Integer) : Integer;
4051 begin
4052 Result := context^.seek(context, offset, whence);
4053 end;
4054
SDL_RWTellnull4055 function SDL_RWTell(context: PSDL_RWops): Integer;
4056 begin
4057 Result := context^.seek(context, 0, 1);
4058 end;
4059
SDL_RWReadnull4060 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
SDL_RWWritenull4065 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
SDL_RWClosenull4070 function SDL_RWClose(context: PSDL_RWops): Integer;
4071 begin
4072 Result := context^.close(context);
4073 end;
4074
SDL_LoadWAVnull4075 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
SDL_CDInDrivenull4080 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
MSF_TO_FRAMESnull4098 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
SDL_VERSIONNUMnull4110 function SDL_VERSIONNUM(X, Y, Z: Integer): Integer;
4111 begin
4112 Result := X * 1000 + Y * 100 + Z;
4113 end;
4114
SDL_COMPILEDVERSIONnull4115 function SDL_COMPILEDVERSION: Integer;
4116 begin
4117 Result := SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL
4118 );
4119 end;
4120
SDL_VERSION_ATLEASTnull4121 function SDL_VERSION_ATLEAST(X, Y, Z: Integer): LongBool;
4122 begin
4123 Result := (SDL_COMPILEDVERSION >= SDL_VERSIONNUM(X, Y, Z));
4124 end;
4125
SDL_LoadBMPnull4126 function SDL_LoadBMP(filename: PChar): PSDL_Surface;
4127 begin
4128 Result := SDL_LoadBMP_RW(SDL_RWFromFile(filename, 'rb'), 1);
4129 end;
4130
SDL_SaveBMPnull4131 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
SDL_BlitSurfacenull4136 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
SDL_AllocSurfacenull4143 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
SDL_MustLocknull4150 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
SDL_LockMutexnull4156 function SDL_LockMutex(mutex: PSDL_mutex): Integer;
4157 begin
4158 Result := SDL_mutexP(mutex);
4159 end;
4160
SDL_UnlockMutexnull4161 function SDL_UnlockMutex(mutex: PSDL_mutex): Integer;
4162 begin
4163 Result := SDL_mutexV(mutex);
4164 end;
4165
4166 {$IFDEF WINDOWS}
_putenvnull4167 function _putenv( const variable : Pchar ): Integer;
4168 cdecl; external {$IFDEF __GPC__}name '_putenv'{$ELSE} 'MSVCRT.DLL'{$ENDIF __GPC__};
4169 {$ENDIF}
4170
4171
SDL_putenvnull4172 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__}
getenvnull4189 function getenv( const name : Pchar ): PChar;
4190 cdecl; external {$IFDEF __GPC__}name 'getenv'{$ELSE} 'MSVCRT.DLL'{$ENDIF};
4191 {$ENDIF}
4192 {$ENDIF}
4193
SDL_getenvnull4194 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
SDL_BUTTONnull4223 function SDL_BUTTON( Button : Integer ) : Integer;
4224 begin
4225 Result := SDL_PRESSED shl ( Button - 1 );
4226 end;
4227
SDL_Swap32null4228 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
IsBitOnnull4287 function IsBitOn( value : integer; bit : Byte ) : boolean;
4288 begin
4289 result := ( ( value and ( 1 shl bit ) ) <> 0 );
4290 end;
4291
TurnBitOnnull4292 function TurnBitOn( value : integer; bit : Byte ) : integer;
4293 begin
4294 result := ( value or ( 1 shl bit ) );
4295 end;
4296
TurnBitOffnull4297 function TurnBitOff( value : integer; bit : Byte ) : integer;
4298 begin
4299 result := ( value and not ( 1 shl bit ) );
4300 end;
4301
4302 end.
4303
4304
4305