/contrib/sdk/sources/SDL-1.2.2_newlib/fire-1.0/Makefile |
---|
0,0 → 1,21 |
CC = kos32-gcc |
LD = kos32-ld |
SDK_DIR = ../../../ |
LDFLAGS = -nostdlib -static --image-base 0 -T $(SDK_DIR)/sources/newlib/app.lds |
CFLAGS = -c -fno-ident -O2 -fomit-frame-pointer -fno-ident -U__WIN32__ -U_Win32 -U_WIN32 -U__MINGW32__ -UWIN32 |
INCLUDES = -I $(SDK_DIR)/sources/newlib/libc/include -I ../include/ |
LIBPATH = -L $(SDK_DIR)/lib -L /home/autobuild/tools/win32/mingw32/lib |
default: fire |
fire: $(OBJECTS) Makefile |
$(CC) $(CFLAGS) $(INCLUDES) -o sdlfire.o fire.c |
$(LD) $(LDFLAGS) $(LIBPATH) --subsystem native -o sdlfire sdlfire.o -lgcc -lSDL -lc.dll -lc -lsound |
kos32-strip -s sdlfire -o sdlfire |
objcopy sdlfire -O binary |
rm sdlfire.o |
clean: |
rm sdlfire |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/fire-1.0/README |
---|
0,0 → 1,5 |
Fire demo by David Ashley. |
dash@xdr.com |
http://www.xdr.com/dash |
See the start of the fire.c program for more details. |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/fire-1.0/fire.c |
---|
0,0 → 1,508 |
/* Fireworks demo written by Dave Ashley */ |
/* dash@xdr.com */ |
/* http://www.xdr.com/dash */ |
/* Sat Jun 13 02:46:09 PDT 1998 */ |
/* This is my first attempt at an SDL program */ |
/* See the SDL home page http://www.devolution.com/~slouken/projects/SDL/ */ |
#include <stdio.h> |
#include <stdlib.h> |
#include <string.h> |
#include <time.h> |
#include "SDL.h" |
#define XSIZE 640 |
#define YSIZE 480 |
SDL_Surface *thescreen; |
unsigned char *vmem1, *vmem2; |
int mousex,mousey; |
SDL_Color themap[256]; |
int scrlock() |
{ |
if(SDL_MUSTLOCK(thescreen)) |
{ |
if ( SDL_LockSurface(thescreen) < 0 ) |
{ |
SDL_printf("Couldn't lock display surface: %s\n", |
SDL_GetError()); |
return -1; |
} |
} |
return 0; |
} |
void scrunlock(void) |
{ |
if(SDL_MUSTLOCK(thescreen)) |
SDL_UnlockSurface(thescreen); |
SDL_UpdateRect(thescreen, 0, 0, 0, 0); |
} |
#define MOUSEFRAC 2 |
#define MAXBLOBS 512 |
#define BLOBFRAC 6 |
#define BLOBGRAVITY 5 |
#define THRESHOLD 20 |
#define SMALLSIZE 3 |
#define BIGSIZE 6 |
#define ABS(x) ((x)<0 ? -(x) : (x)) |
int explodenum; |
char sizes[]={2,3,4,5,8,5,4,3}; |
struct blob { |
struct blob *blobnext; |
int blobx; |
int bloby; |
int blobdx; |
int blobdy; |
int bloblife; |
int blobsize; |
} *blobs,*freeblobs,*activeblobs; |
unsigned char **mul640; |
int oldmode; |
char sqrttab[]={ |
0,1,1,1,2,2,2,2,2,3,3,3,3,3,3,3, |
4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5, |
5,5,5,5,6,6,6,6,6,6,6,6,6,6,6,6, |
6,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, |
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, |
8,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, |
9,9,9,9,10,10,10,10,10,10,10,10,10,10,10,10, |
10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,11, |
11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11, |
12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12, |
12,12,12,12,12,12,12,12,12,13,13,13,13,13,13,13, |
13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13, |
13,13,13,13,14,14,14,14,14,14,14,14,14,14,14,14, |
14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14, |
14,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15, |
15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15 |
}; |
void nomem(void) |
{ |
SDL_printf("Not enough low memory!\n"); |
SDL_Quit(); |
exit(1); |
} |
void fire(unsigned char *p1,unsigned char *p2,int pitch,char *map) |
{ |
int x,y; |
unsigned char *p3, *p4; |
for(y=2;y<YSIZE;y++) |
{ |
for(x=0;x<XSIZE;x++) |
{ |
p3 = p1+y*XSIZE+x; |
p4 = p2+y*pitch+x; |
*p4=map[*p3+p3[-XSIZE]+p3[-XSIZE-1]+p3[-XSIZE+1]+p3[-1]+p3[1]+p3[-XSIZE-XSIZE-1]+p3[-XSIZE-XSIZE]+p3[-XSIZE-XSIZE+1]]; |
} |
} |
} |
void disk(x,y,rad) |
{ |
unsigned char *p; |
int i,j,k,aj; |
int rad2=rad*rad; |
int w; |
for(j=-rad;j<=rad;j++) |
{ |
w=sqrttab[rad2-j*j]; |
aj=ABS(j)<<2; |
if(w) |
{ |
p=mul640[y+j]+x-w; |
k=w+w+1; |
i=-w; |
while(k--) {*p++=255-(ABS(i)<<2)-aj;i++;} |
} |
} |
} |
void trydisk(void) |
{ |
if(mousex>10 && mousex<XSIZE-10 && mousey>10 && mousey<YSIZE-10) |
disk(mousex,mousey,8); |
} |
void addblob(void) |
{ |
int dx,dy; |
struct blob *ablob; |
if(!freeblobs) return; |
dx=(rand()&255)-128; |
dy=(rand()%200)+340; |
ablob=freeblobs; |
freeblobs=freeblobs->blobnext; |
ablob->bloblife=(rand()&511)+256; |
ablob->blobdx=dx; |
ablob->blobdy=dy; |
ablob->blobx=(256+(rand()&127))<<BLOBFRAC; |
ablob->bloby=2<<BLOBFRAC; |
ablob->blobnext=activeblobs; |
ablob->blobsize=BIGSIZE; |
activeblobs=ablob; |
} |
void moveblobs(void) |
{ |
struct blob **lastblob,*ablob; |
int x,y; |
lastblob=&activeblobs; |
while(ablob=*lastblob) |
{ |
x=ablob->blobx>>BLOBFRAC; |
y=ablob->bloby>>BLOBFRAC; |
if(!--ablob->bloblife || y<0 || x<10 || x>XSIZE-10) |
{ |
*lastblob=ablob->blobnext; |
ablob->blobnext=freeblobs; |
freeblobs=ablob; |
continue; |
} |
ablob->blobx+=ablob->blobdx; |
ablob->bloby+=ablob->blobdy; |
ablob->blobdy-=BLOBGRAVITY; |
lastblob=&ablob->blobnext; |
} |
} |
void putblobs(void) |
{ |
struct blob *ablob,*ablob2,*temp; |
int x,y,dy; |
int i,size; |
long x2,y2,vel; |
ablob=activeblobs; |
activeblobs=0; |
while(ablob) |
{ |
dy=ablob->blobdy; |
if(ablob->blobsize!=SMALLSIZE && (dy>-THRESHOLD && dy<THRESHOLD && !(rand()&7) || (rand()&127)==63)) |
{ |
i=explodenum; |
while(i-- && freeblobs) |
{ |
ablob2=freeblobs; |
freeblobs=freeblobs->blobnext; |
ablob2->blobx=ablob->blobx; |
ablob2->bloby=ablob->bloby; |
for(;;) |
{ |
x2=(rand()&511)-256; |
y2=(rand()&511)-256; |
vel=x2*x2+y2*y2; |
if(vel>0x3000 && vel<0x10000L) break; |
} |
ablob2->blobdx=ablob->blobdx+x2; |
ablob2->blobdy=ablob->blobdy+y2; |
ablob2->bloblife=16+(rand()&31); |
ablob2->blobsize=SMALLSIZE; |
ablob2->blobnext=activeblobs; |
activeblobs=ablob2; |
ablob->bloblife=1; |
} |
} |
x=ablob->blobx>>BLOBFRAC; |
y=ablob->bloby>>BLOBFRAC; |
size=ablob->blobsize; |
if(size==BIGSIZE && ablob->blobdy>0 && ablob->blobdy<200) |
size=sizes[ablob->bloblife&7]; |
if(x>10 && x<XSIZE-10 && y>10 && y<YSIZE-10) |
disk(x,YSIZE-1-y,size); |
temp=ablob; |
ablob=ablob->blobnext; |
temp->blobnext=activeblobs; |
activeblobs=temp; |
} |
} |
#define RATE 1 |
void normal(char *map) |
{ |
int i,j; |
for(i=0;i<8192;i++) |
{ |
j=i/9; |
map[i]=j<256 ? (j>=RATE ? j-RATE : 0) : 255; |
} |
} |
void bright(char *map) |
{ |
int i; |
for(i=0;i<8192;i++) map[i]=i>>3<255 ? (i>>3) : 255; |
} |
void updatemap(void) |
{ |
SDL_SetColors(thescreen, themap, 0, 256); |
} |
void loadcolor(int n,int r,int g,int b) |
{ |
themap[n].r=r<<2; |
themap[n].g=g<<2; |
themap[n].b=b<<2; |
} |
void loadcolors(unsigned int which) |
{ |
int i,j; |
int r,g,b; |
which%=11; |
for(i=0;i<256;i++) |
{ |
switch(which) |
{ |
case 0: |
if(i<64) loadcolor(i,0,0,0); |
else if(i<128) loadcolor(i,i-64,0,0); |
else if(i<192) loadcolor(i,63,i-128,0); |
else loadcolor(i,63,63,i-192); |
break; |
case 1: |
if(i<64) loadcolor(i,0,0,0); |
else if(i<128) loadcolor(i,0,0,i-64); |
else loadcolor(i,(i-128)>>1,(i-128)>>1,63); |
break; |
case 2: |
loadcolor(i,i>>2,i>>2,i>>2); |
break; |
case 3: |
r=rand()&0x3f; |
g=rand()&0x3f; |
b=rand()&0x3f; |
loadcolor(i,r*i>>8,g*i>>8,b*i>>8); |
break; |
case 4: |
loadcolor(i,i>>2,0,0); |
break; |
case 5: |
loadcolor(i,0,i>>2,0); |
break; |
case 6: |
loadcolor(i,0,0,i>>2); |
break; |
case 7: |
j=i&15; |
if(i&16) j=15-j; |
j=(i>>2)*j/16; |
loadcolor(i,j,j,j); |
break; |
case 8: |
j=0; |
if(i>8 && i<128) j=63; |
loadcolor(i,j,j,j); |
break; |
case 9: |
j=31-(i&31)<<1; |
r=i&32 ? j : 0; |
g=i&64 ? j : 0; |
b=i&128 ? j : 0; |
loadcolor(i,r,g,b); |
break; |
case 10: |
j=(i&15)<<2; |
if(i&16) j=63-j; |
r=i&32 ? j : 0; |
g=i&64 ? j : 0; |
b=i&128 ? j : 0; |
loadcolor(i,r,g,b); |
break; |
} |
} |
updatemap(); |
} |
int main(int argc, char *argv[]) |
{ |
int i,k; |
char *remap,*remap2; |
unsigned char *p1, *p2; |
long frames; |
int flash; |
int whichmap; |
int key; |
int ispaused; |
unsigned long videoflags; |
int done; |
int now; |
SDL_Event event; |
long starttime; |
int buttonstate; |
srand(time(NULL)); |
if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) |
{ |
SDL_printf("Couldn't initialize SDL: %s\n",SDL_GetError()); |
exit(1); |
} |
videoflags = SDL_SWSURFACE; |
thescreen = SDL_SetVideoMode(XSIZE, YSIZE, 8, videoflags); |
if ( thescreen == NULL ) |
{ |
SDL_printf("Couldn't set display mode: %s\n", |
SDL_GetError()); |
SDL_Quit(); |
exit(5); |
} |
vmem1=NULL; |
vmem2=malloc(XSIZE*YSIZE); |
if(!vmem2) nomem(); |
mul640=malloc(YSIZE*sizeof(char *)); |
if(!mul640) nomem(); |
remap=malloc(16384); |
if(!remap) nomem(); |
remap2=malloc(16384); |
if(!remap2) nomem(); |
blobs=malloc(MAXBLOBS*sizeof(struct blob)); |
if(!blobs) nomem(); |
SDL_printf("Fire demo by David Ashley (dash@xdr.com)"); |
SDL_printf("1 = Change color map"); |
SDL_printf("2 = Randomly change color map"); |
SDL_printf("p = Pause"); |
SDL_printf("spc = Fire"); |
SDL_printf("esc = Exit"); |
SDL_printf("Left mouse button = paint"); |
SDL_printf("Right mouse button, CR = ignite atmosphere"); |
freeblobs=activeblobs=0; |
for(i=0;i<MAXBLOBS;i++) |
{ |
blobs[i].blobnext=freeblobs; |
freeblobs=blobs+i; |
} |
normal(remap); |
bright(remap2); |
flash=0; |
whichmap=0; |
loadcolors(whichmap); |
frames=0; |
ispaused=0; |
addblob(); |
done = 0; |
now=0; |
starttime=SDL_GetTicks(); |
buttonstate=0; |
mousex=mousey=0; |
while(!done) |
{ |
if ( scrlock() < 0 ) continue; |
frames++; |
if ( vmem1 != (unsigned char *)thescreen->pixels ) |
{ |
p1=vmem1=thescreen->pixels; |
for (i=0;i<YSIZE;i++) |
{ |
mul640[i]=i*thescreen->pitch+vmem1; |
memset(p1,0,XSIZE); |
p1+=thescreen->pitch; |
} |
} |
if(!ispaused) |
{ |
now++; |
if(!flash) |
{ |
if(explodenum>96 && explodenum<160 && !(rand()&511) || (buttonstate&8)) |
flash=60; |
} else --flash; |
explodenum=(now>>4)+1;if(explodenum==320) now=0; |
if(explodenum>256) explodenum=256; |
if(!(rand()&31)) |
addblob(); |
moveblobs(); |
putblobs(); |
if(buttonstate&2) trydisk(); |
p1=vmem1; |
p2=vmem2; |
k=thescreen->pitch; |
for(i=0;i<YSIZE;i++) |
{ |
memcpy(p2,p1,XSIZE); |
p2+=XSIZE; |
p1+=k; |
} |
fire(vmem2,vmem1,k,flash ? remap2 :remap); |
} |
scrunlock(); |
while(SDL_PollEvent(&event)) |
{ |
switch (event.type) |
{ |
case SDL_MOUSEBUTTONDOWN: |
case SDL_MOUSEBUTTONUP: |
if ( event.button.state == SDL_PRESSED ) |
buttonstate|=1<<event.button.button; |
else |
buttonstate&=~(1<<event.button.button); |
mousex=event.button.x; |
mousey=event.button.y; |
if(!ispaused && buttonstate&2) trydisk(); |
break; |
case SDL_MOUSEMOTION: |
mousex=event.motion.x; |
mousey=event.motion.y; |
if(!ispaused && buttonstate&2) trydisk(); |
break; |
case SDL_KEYDOWN: |
key=event.key.keysym.sym; |
if(key==SDLK_RETURN) {flash=60;break;} |
if(key==SDLK_1 || key==SDLK_2) |
{ |
if(key==SDLK_1) |
++whichmap; |
else |
whichmap=rand(); |
loadcolors(whichmap); |
break; |
} |
if(key==SDLK_ESCAPE) {done=1;break;} |
if(key==SDLK_SPACE && !ispaused) {addblob();break;} |
if(key==SDLK_p) {ispaused=!ispaused;break;} |
break; |
case SDL_QUIT: |
done = 1; |
break; |
default: |
break; |
} |
} |
} |
starttime=SDL_GetTicks()-starttime; |
if(!starttime) starttime=1; |
SDL_Quit(); |
SDL_printf("fps = %d\n",1000*frames/starttime); |
exit(0); |
} |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL.h |
---|
0,0 → 1,97 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* Main include header for the SDL library */ |
#ifndef _SDL_H |
#define _SDL_H |
#include "SDL_main.h" |
#include "SDL_types.h" |
#include "SDL_getenv.h" |
#include "SDL_error.h" |
#include "SDL_rwops.h" |
#include "SDL_timer.h" |
#include "SDL_audio.h" |
#include "SDL_cdrom.h" |
#include "SDL_joystick.h" |
#include "SDL_events.h" |
#include "SDL_video.h" |
#include "SDL_byteorder.h" |
#include "SDL_version.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* As of version 0.5, SDL is loaded dynamically into the application */ |
/* These are the flags which may be passed to SDL_Init() -- you should |
specify the subsystems which you will be using in your application. |
*/ |
#define SDL_INIT_TIMER 0x00000001 |
#define SDL_INIT_AUDIO 0x00000010 |
#define SDL_INIT_VIDEO 0x00000020 |
#define SDL_INIT_CDROM 0x00000100 |
#define SDL_INIT_JOYSTICK 0x00000200 |
#define SDL_INIT_NOPARACHUTE 0x00100000 /* Don't catch fatal signals */ |
#define SDL_INIT_EVENTTHREAD 0x01000000 /* Not supported on all OS's */ |
#define SDL_INIT_EVERYTHING 0x0000FFFF |
/* This function loads the SDL dynamically linked library and initializes |
* the subsystems specified by 'flags' (and those satisfying dependencies) |
* Unless the SDL_INIT_NOPARACHUTE flag is set, it will install cleanup |
* signal handlers for some commonly ignored fatal signals (like SIGSEGV) |
*/ |
extern DECLSPEC int SDL_Init(Uint32 flags); |
/* This function initializes specific SDL subsystems */ |
extern DECLSPEC int SDL_InitSubSystem(Uint32 flags); |
/* This function cleans up specific SDL subsystems */ |
extern DECLSPEC void SDL_QuitSubSystem(Uint32 flags); |
/* This function returns mask of the specified subsystems which have |
been initialized. |
If 'flags' is 0, it returns a mask of all initialized subsystems. |
*/ |
extern DECLSPEC Uint32 SDL_WasInit(Uint32 flags); |
/* This function cleans up all initialized subsystems and unloads the |
* dynamically linked library. You should call it upon all exit conditions. |
*/ |
extern DECLSPEC void SDL_Quit(void); |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_H */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_active.h |
---|
0,0 → 1,60 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_active.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* Include file for SDL application focus event handling */ |
#ifndef _SDL_active_h |
#define _SDL_active_h |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* The available application states */ |
#define SDL_APPMOUSEFOCUS 0x01 /* The app has mouse coverage */ |
#define SDL_APPINPUTFOCUS 0x02 /* The app has input focus */ |
#define SDL_APPACTIVE 0x04 /* The application is active */ |
/* Function prototypes */ |
/* |
* This function returns the current state of the application, which is a |
* bitwise combination of SDL_APPMOUSEFOCUS, SDL_APPINPUTFOCUS, and |
* SDL_APPACTIVE. If SDL_APPACTIVE is set, then the user is able to |
* see your application, otherwise it has been iconified or disabled. |
*/ |
extern DECLSPEC Uint8 SDL_GetAppState(void); |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_active_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_audio.h |
---|
0,0 → 1,260 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_audio.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* Access to the raw audio mixing buffer for the SDL library */ |
#ifndef _SDL_audio_h |
#define _SDL_audio_h |
#include <stdio.h> |
#include "SDL_main.h" |
#include "SDL_types.h" |
#include "SDL_error.h" |
#include "SDL_rwops.h" |
#include "SDL_byteorder.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* The calculated values in this structure are calculated by SDL_OpenAudio() */ |
typedef struct { |
int freq; /* DSP frequency -- samples per second */ |
Uint16 format; /* Audio data format */ |
Uint8 channels; /* Number of channels: 1 mono, 2 stereo */ |
Uint8 silence; /* Audio buffer silence value (calculated) */ |
Uint16 samples; /* Audio buffer size in samples */ |
Uint16 padding; /* Necessary for some compile environments */ |
Uint32 size; /* Audio buffer size in bytes (calculated) */ |
/* This function is called when the audio device needs more data. |
'stream' is a pointer to the audio data buffer |
'len' is the length of that buffer in bytes. |
Once the callback returns, the buffer will no longer be valid. |
Stereo samples are stored in a LRLRLR ordering. |
*/ |
void (*callback)(void *userdata, Uint8 *stream, int len); |
void *userdata; |
} SDL_AudioSpec; |
/* Audio format flags (defaults to LSB byte order) */ |
#define AUDIO_U8 0x0008 /* Unsigned 8-bit samples */ |
#define AUDIO_S8 0x8008 /* Signed 8-bit samples */ |
#define AUDIO_U16LSB 0x0010 /* Unsigned 16-bit samples */ |
#define AUDIO_S16LSB 0x8010 /* Signed 16-bit samples */ |
#define AUDIO_U16MSB 0x1010 /* As above, but big-endian byte order */ |
#define AUDIO_S16MSB 0x9010 /* As above, but big-endian byte order */ |
#define AUDIO_U16 AUDIO_U16LSB |
#define AUDIO_S16 AUDIO_S16LSB |
/* Native audio byte ordering */ |
#if SDL_BYTEORDER == SDL_LIL_ENDIAN |
#define AUDIO_U16SYS AUDIO_U16LSB |
#define AUDIO_S16SYS AUDIO_S16LSB |
#else |
#define AUDIO_U16SYS AUDIO_U16MSB |
#define AUDIO_S16SYS AUDIO_S16MSB |
#endif |
/* A structure to hold a set of audio conversion filters and buffers */ |
typedef struct SDL_AudioCVT { |
int needed; /* Set to 1 if conversion possible */ |
Uint16 src_format; /* Source audio format */ |
Uint16 dst_format; /* Target audio format */ |
double rate_incr; /* Rate conversion increment */ |
Uint8 *buf; /* Buffer to hold entire audio data */ |
int len; /* Length of original audio buffer */ |
int len_cvt; /* Length of converted audio buffer */ |
int len_mult; /* buffer must be len*len_mult big */ |
double len_ratio; /* Given len, final size is len*len_ratio */ |
void (*filters[10])(struct SDL_AudioCVT *cvt, Uint16 format); |
int filter_index; /* Current audio conversion function */ |
} SDL_AudioCVT; |
/* Function prototypes */ |
/* These functions are used internally, and should not be used unless you |
* have a specific need to specify the audio driver you want to use. |
* You should normally use SDL_Init() or SDL_InitSubSystem(). |
*/ |
extern DECLSPEC int SDL_AudioInit(const char *driver_name); |
extern DECLSPEC void SDL_AudioQuit(void); |
/* This function fills the given character buffer with the name of the |
* current audio driver, and returns a pointer to it if the audio driver has |
* been initialized. It returns NULL if no driver has been initialized. |
*/ |
extern DECLSPEC char *SDL_AudioDriverName(char *namebuf, int maxlen); |
/* |
* This function opens the audio device with the desired parameters, and |
* returns 0 if successful, placing the actual hardware parameters in the |
* structure pointed to by 'obtained'. If 'obtained' is NULL, the audio |
* data passed to the callback function will be guaranteed to be in the |
* requested format, and will be automatically converted to the hardware |
* audio format if necessary. This function returns -1 if it failed |
* to open the audio device, or couldn't set up the audio thread. |
* |
* When filling in the desired audio spec structure, |
* 'desired->freq' should be the desired audio frequency in samples-per-second. |
* 'desired->format' should be the desired audio format. |
* 'desired->samples' is the desired size of the audio buffer, in samples. |
* This number should be a power of two, and may be adjusted by the audio |
* driver to a value more suitable for the hardware. Good values seem to |
* range between 512 and 8096 inclusive, depending on the application and |
* CPU speed. Smaller values yield faster response time, but can lead |
* to underflow if the application is doing heavy processing and cannot |
* fill the audio buffer in time. A stereo sample consists of both right |
* and left channels in LR ordering. |
* Note that the number of samples is directly related to time by the |
* following formula: ms = (samples*1000)/freq |
* 'desired->size' is the size in bytes of the audio buffer, and is |
* calculated by SDL_OpenAudio(). |
* 'desired->silence' is the value used to set the buffer to silence, |
* and is calculated by SDL_OpenAudio(). |
* 'desired->callback' should be set to a function that will be called |
* when the audio device is ready for more data. It is passed a pointer |
* to the audio buffer, and the length in bytes of the audio buffer. |
* This function usually runs in a separate thread, and so you should |
* protect data structures that it accesses by calling SDL_LockAudio() |
* and SDL_UnlockAudio() in your code. |
* 'desired->userdata' is passed as the first parameter to your callback |
* function. |
* |
* The audio device starts out playing silence when it's opened, and should |
* be enabled for playing by calling SDL_PauseAudio(0) when you are ready |
* for your audio callback function to be called. Since the audio driver |
* may modify the requested size of the audio buffer, you should allocate |
* any local mixing buffers after you open the audio device. |
*/ |
extern DECLSPEC int SDL_OpenAudio(SDL_AudioSpec *desired, SDL_AudioSpec *obtained); |
/* |
* Get the current audio state: |
*/ |
typedef enum { |
SDL_AUDIO_STOPPED = 0, |
SDL_AUDIO_PLAYING, |
SDL_AUDIO_PAUSED |
} SDL_audiostatus; |
extern DECLSPEC SDL_audiostatus SDL_GetAudioStatus(void); |
/* |
* This function pauses and unpauses the audio callback processing. |
* It should be called with a parameter of 0 after opening the audio |
* device to start playing sound. This is so you can safely initialize |
* data for your callback function after opening the audio device. |
* Silence will be written to the audio device during the pause. |
*/ |
extern DECLSPEC void SDL_PauseAudio(int pause_on); |
/* |
* This function loads a WAVE from the data source, automatically freeing |
* that source if 'freesrc' is non-zero. For example, to load a WAVE file, |
* you could do: |
* SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...); |
* |
* If this function succeeds, it returns the given SDL_AudioSpec, |
* filled with the audio data format of the wave data, and sets |
* 'audio_buf' to a malloc()'d buffer containing the audio data, |
* and sets 'audio_len' to the length of that audio buffer, in bytes. |
* You need to free the audio buffer with SDL_FreeWAV() when you are |
* done with it. |
* |
* This function returns NULL and sets the SDL error message if the |
* wave file cannot be opened, uses an unknown data format, or is |
* corrupt. Currently raw and MS-ADPCM WAVE files are supported. |
*/ |
extern DECLSPEC SDL_AudioSpec *SDL_LoadWAV_RW(SDL_RWops *src, int freesrc, |
SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len); |
/* Compatibility convenience function -- loads a WAV from a file */ |
#define SDL_LoadWAV(file, spec, audio_buf, audio_len) \ |
SDL_LoadWAV_RW(SDL_RWFromFile(file, "rb"),1, spec,audio_buf,audio_len) |
/* |
* This function frees data previously allocated with SDL_LoadWAV_RW() |
*/ |
extern DECLSPEC void SDL_FreeWAV(Uint8 *audio_buf); |
/* |
* This function takes a source format and rate and a destination format |
* and rate, and initializes the 'cvt' structure with information needed |
* by SDL_ConvertAudio() to convert a buffer of audio data from one format |
* to the other. |
* This function returns 0, or -1 if there was an error. |
*/ |
extern DECLSPEC int SDL_BuildAudioCVT(SDL_AudioCVT *cvt, |
Uint16 src_format, Uint8 src_channels, int src_rate, |
Uint16 dst_format, Uint8 dst_channels, int dst_rate); |
/* Once you have initialized the 'cvt' structure using SDL_BuildAudioCVT(), |
* created an audio buffer cvt->buf, and filled it with cvt->len bytes of |
* audio data in the source format, this function will convert it in-place |
* to the desired format. |
* The data conversion may expand the size of the audio data, so the buffer |
* cvt->buf should be allocated after the cvt structure is initialized by |
* SDL_BuildAudioCVT(), and should be cvt->len*cvt->len_mult bytes long. |
*/ |
extern DECLSPEC int SDL_ConvertAudio(SDL_AudioCVT *cvt); |
/* |
* This takes two audio buffers of the playing audio format and mixes |
* them, performing addition, volume adjustment, and overflow clipping. |
* The volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME |
* for full audio volume. Note this does not change hardware volume. |
* This is provided for convenience -- you can mix your own audio data. |
*/ |
#define SDL_MIX_MAXVOLUME 128 |
extern DECLSPEC void SDL_MixAudio(Uint8 *dst, const Uint8 *src, Uint32 len, int volume); |
/* |
* The lock manipulated by these functions protects the callback function. |
* During a LockAudio/UnlockAudio pair, you can be guaranteed that the |
* callback function is not running. Do not call these from the callback |
* function or you will cause deadlock. |
*/ |
extern DECLSPEC void SDL_LockAudio(void); |
extern DECLSPEC void SDL_UnlockAudio(void); |
/* |
* This function shuts down audio processing and closes the audio device. |
*/ |
extern DECLSPEC void SDL_CloseAudio(void); |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_audio_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_byteorder.h |
---|
0,0 → 1,52 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_byteorder.h,v 1.3 2001/05/10 20:25:51 hercules Exp $"; |
#endif |
/* Macros for determining the byte-order of this platform */ |
#ifndef _SDL_byteorder_h |
#define _SDL_byteorder_h |
/* The two types of endianness */ |
#define SDL_LIL_ENDIAN 1234 |
#define SDL_BIG_ENDIAN 4321 |
/* Pardon the mess, I'm trying to determine the endianness of this host. |
I'm doing it by preprocessor defines rather than some sort of configure |
script so that application code can use this too. The "right" way would |
be to dynamically generate this file on install, but that's a lot of work. |
*/ |
#if defined(__i386__) || defined(__ia64__) || defined(WIN32UNDEFINED) || \ |
(defined(__alpha__) || defined(__alpha)) || \ |
defined(__arm__) || \ |
(defined(__mips__) && defined(__MIPSEL__)) || \ |
defined(__LITTLE_ENDIAN__) |
#define SDL_BYTEORDER SDL_LIL_ENDIAN |
#else |
#define SDL_BYTEORDER SDL_BIG_ENDIAN |
#endif |
#endif /* _SDL_byteorder_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_cdrom.h |
---|
0,0 → 1,175 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_cdrom.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* This is the CD-audio control API for Simple DirectMedia Layer */ |
#ifndef _SDL_cdrom_h |
#define _SDL_cdrom_h |
#include "SDL_types.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* In order to use these functions, SDL_Init() must have been called |
with the SDL_INIT_CDROM flag. This causes SDL to scan the system |
for CD-ROM drives, and load appropriate drivers. |
*/ |
/* The maximum number of CD-ROM tracks on a disk */ |
#define SDL_MAX_TRACKS 99 |
/* The types of CD-ROM track possible */ |
#define SDL_AUDIO_TRACK 0x00 |
#define SDL_DATA_TRACK 0x04 |
/* The possible states which a CD-ROM drive can be in. */ |
typedef enum { |
CD_TRAYEMPTY, |
CD_STOPPED, |
CD_PLAYING, |
CD_PAUSED, |
CD_ERROR = -1 |
} CDstatus; |
/* Given a status, returns true if there's a disk in the drive */ |
#define CD_INDRIVE(status) ((int)status > 0) |
typedef struct { |
Uint8 id; /* Track number */ |
Uint8 type; /* Data or audio track */ |
Uint16 unused; |
Uint32 length; /* Length, in frames, of this track */ |
Uint32 offset; /* Offset, in frames, from start of disk */ |
} SDL_CDtrack; |
/* This structure is only current as of the last call to SDL_CDStatus() */ |
typedef struct SDL_CD { |
int id; /* Private drive identifier */ |
CDstatus status; /* Current drive status */ |
/* The rest of this structure is only valid if there's a CD in drive */ |
int numtracks; /* Number of tracks on disk */ |
int cur_track; /* Current track position */ |
int cur_frame; /* Current frame offset within current track */ |
SDL_CDtrack track[SDL_MAX_TRACKS+1]; |
} SDL_CD; |
/* Conversion functions from frames to Minute/Second/Frames and vice versa */ |
#define CD_FPS 75 |
#define FRAMES_TO_MSF(f, M,S,F) { \ |
int value = f; \ |
*(F) = value%CD_FPS; \ |
value /= CD_FPS; \ |
*(S) = value%60; \ |
value /= 60; \ |
*(M) = value; \ |
} |
#define MSF_TO_FRAMES(M, S, F) ((M)*60*CD_FPS+(S)*CD_FPS+(F)) |
/* CD-audio API functions: */ |
/* Returns the number of CD-ROM drives on the system, or -1 if |
SDL_Init() has not been called with the SDL_INIT_CDROM flag. |
*/ |
extern DECLSPEC int SDL_CDNumDrives(void); |
/* Returns a human-readable, system-dependent identifier for the CD-ROM. |
Example: |
"/dev/cdrom" |
"E:" |
"/dev/disk/ide/1/master" |
*/ |
extern DECLSPEC const char * SDL_CDName(int drive); |
/* Opens a CD-ROM drive for access. It returns a drive handle on success, |
or NULL if the drive was invalid or busy. This newly opened CD-ROM |
becomes the default CD used when other CD functions are passed a NULL |
CD-ROM handle. |
Drives are numbered starting with 0. Drive 0 is the system default CD-ROM. |
*/ |
extern DECLSPEC SDL_CD * SDL_CDOpen(int drive); |
/* This function returns the current status of the given drive. |
If the drive has a CD in it, the table of contents of the CD and current |
play position of the CD will be stored in the SDL_CD structure. |
*/ |
extern DECLSPEC CDstatus SDL_CDStatus(SDL_CD *cdrom); |
/* Play the given CD starting at 'start_track' and 'start_frame' for 'ntracks' |
tracks and 'nframes' frames. If both 'ntrack' and 'nframe' are 0, play |
until the end of the CD. This function will skip data tracks. |
This function should only be called after calling SDL_CDStatus() to |
get track information about the CD. |
For example: |
// Play entire CD: |
if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) |
SDL_CDPlayTracks(cdrom, 0, 0, 0, 0); |
// Play last track: |
if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) { |
SDL_CDPlayTracks(cdrom, cdrom->numtracks-1, 0, 0, 0); |
} |
// Play first and second track and 10 seconds of third track: |
if ( CD_INDRIVE(SDL_CDStatus(cdrom)) ) |
SDL_CDPlayTracks(cdrom, 0, 0, 2, 10); |
This function returns 0, or -1 if there was an error. |
*/ |
extern DECLSPEC int SDL_CDPlayTracks(SDL_CD *cdrom, |
int start_track, int start_frame, int ntracks, int nframes); |
/* Play the given CD starting at 'start' frame for 'length' frames. |
It returns 0, or -1 if there was an error. |
*/ |
extern DECLSPEC int SDL_CDPlay(SDL_CD *cdrom, int start, int length); |
/* Pause play -- returns 0, or -1 on error */ |
extern DECLSPEC int SDL_CDPause(SDL_CD *cdrom); |
/* Resume play -- returns 0, or -1 on error */ |
extern DECLSPEC int SDL_CDResume(SDL_CD *cdrom); |
/* Stop play -- returns 0, or -1 on error */ |
extern DECLSPEC int SDL_CDStop(SDL_CD *cdrom); |
/* Eject CD-ROM -- returns 0, or -1 on error */ |
extern DECLSPEC int SDL_CDEject(SDL_CD *cdrom); |
/* Closes the handle for the CD-ROM drive */ |
extern DECLSPEC void SDL_CDClose(SDL_CD *cdrom); |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_video_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_copying.h |
---|
0,0 → 1,27 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_copying.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_endian.h |
---|
0,0 → 1,138 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_endian.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* Functions for reading and writing endian-specific values */ |
#ifndef _SDL_endian_h |
#define _SDL_endian_h |
/* These functions read and write data of the specified endianness, |
dynamically translating to the host machine endianness. |
e.g.: If you want to read a 16 bit value on big-endian machine from |
an open file containing little endian values, you would use: |
value = SDL_ReadLE16(rp); |
Note that the read/write functions use SDL_RWops pointers |
instead of FILE pointers. This allows you to read and write |
endian values from large chunks of memory as well as files |
and other data sources. |
*/ |
#include <stdio.h> |
#include "SDL_types.h" |
#include "SDL_rwops.h" |
#include "SDL_byteorder.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* Use inline functions for compilers that support them, and static |
functions for those that do not. Because these functions become |
static for compilers that do not support inline functions, this |
header should only be included in files that actually use them. |
*/ |
#ifndef SDL_Swap16 |
static __inline__ Uint16 SDL_Swap16(Uint16 D) { |
return((D<<8)|(D>>8)); |
} |
#endif |
#ifndef SDL_Swap32 |
static __inline__ Uint32 SDL_Swap32(Uint32 D) { |
return((D<<24)|((D<<8)&0x00FF0000)|((D>>8)&0x0000FF00)|(D>>24)); |
} |
#endif |
#ifdef SDL_HAS_64BIT_TYPE |
#ifndef SDL_Swap64 |
static __inline__ Uint64 SDL_Swap64(Uint64 val) { |
Uint32 hi, lo; |
/* Separate into high and low 32-bit values and swap them */ |
lo = (Uint32)(val&0xFFFFFFFF); |
val >>= 32; |
hi = (Uint32)(val&0xFFFFFFFF); |
val = SDL_Swap32(lo); |
val <<= 32; |
val |= SDL_Swap32(hi); |
return(val); |
} |
#endif |
#else |
#ifndef SDL_Swap64 |
/* This is mainly to keep compilers from complaining in SDL code. |
If there is no real 64-bit datatype, then compilers will complain about |
the fake 64-bit datatype that SDL provides when it compiles user code. |
*/ |
#define SDL_Swap64(X) (X) |
#endif |
#endif /* SDL_HAS_64BIT_TYPE */ |
/* Byteswap item from the specified endianness to the native endianness */ |
#if SDL_BYTEORDER == SDL_LIL_ENDIAN |
#define SDL_SwapLE16(X) (X) |
#define SDL_SwapLE32(X) (X) |
#define SDL_SwapLE64(X) (X) |
#define SDL_SwapBE16(X) SDL_Swap16(X) |
#define SDL_SwapBE32(X) SDL_Swap32(X) |
#define SDL_SwapBE64(X) SDL_Swap64(X) |
#else |
#define SDL_SwapLE16(X) SDL_Swap16(X) |
#define SDL_SwapLE32(X) SDL_Swap32(X) |
#define SDL_SwapLE64(X) SDL_Swap64(X) |
#define SDL_SwapBE16(X) (X) |
#define SDL_SwapBE32(X) (X) |
#define SDL_SwapBE64(X) (X) |
#endif |
/* Read an item of the specified endianness and return in native format */ |
extern DECLSPEC Uint16 SDL_ReadLE16(SDL_RWops *src); |
extern DECLSPEC Uint16 SDL_ReadBE16(SDL_RWops *src); |
extern DECLSPEC Uint32 SDL_ReadLE32(SDL_RWops *src); |
extern DECLSPEC Uint32 SDL_ReadBE32(SDL_RWops *src); |
extern DECLSPEC Uint64 SDL_ReadLE64(SDL_RWops *src); |
extern DECLSPEC Uint64 SDL_ReadBE64(SDL_RWops *src); |
/* Write an item of native format to the specified endianness */ |
extern DECLSPEC int SDL_WriteLE16(SDL_RWops *dst, Uint16 value); |
extern DECLSPEC int SDL_WriteBE16(SDL_RWops *dst, Uint16 value); |
extern DECLSPEC int SDL_WriteLE32(SDL_RWops *dst, Uint32 value); |
extern DECLSPEC int SDL_WriteBE32(SDL_RWops *dst, Uint32 value); |
extern DECLSPEC int SDL_WriteLE64(SDL_RWops *dst, Uint64 value); |
extern DECLSPEC int SDL_WriteBE64(SDL_RWops *dst, Uint64 value); |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_endian_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_error.h |
---|
0,0 → 1,62 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_error.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* Simple error message routines for SDL */ |
#ifndef _SDL_error_h |
#define _SDL_error_h |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* Public functions */ |
extern DECLSPEC void SDL_SetError(const char *fmt, ...); |
extern DECLSPEC char * SDL_GetError(void); |
extern DECLSPEC void SDL_ClearError(void); |
/* Private error message function - used internally */ |
#define SDL_OutOfMemory() SDL_Error(SDL_ENOMEM) |
typedef enum { |
SDL_ENOMEM, |
SDL_EFREAD, |
SDL_EFWRITE, |
SDL_EFSEEK, |
SDL_LASTERROR |
} SDL_errorcode; |
extern void SDL_Error(SDL_errorcode code); |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_error_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_events.h |
---|
0,0 → 1,335 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_events.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* Include file for SDL event handling */ |
#ifndef _SDL_events_h |
#define _SDL_events_h |
#include "SDL_types.h" |
#include "SDL_active.h" |
#include "SDL_keyboard.h" |
#include "SDL_mouse.h" |
#include "SDL_joystick.h" |
#include "SDL_quit.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* Event enumerations */ |
enum { SDL_NOEVENT = 0, /* Unused (do not remove) */ |
SDL_ACTIVEEVENT, /* Application loses/gains visibility */ |
SDL_KEYDOWN, /* Keys pressed */ |
SDL_KEYUP, /* Keys released */ |
SDL_MOUSEMOTION, /* Mouse moved */ |
SDL_MOUSEBUTTONDOWN, /* Mouse button pressed */ |
SDL_MOUSEBUTTONUP, /* Mouse button released */ |
SDL_JOYAXISMOTION, /* Joystick axis motion */ |
SDL_JOYBALLMOTION, /* Joystick trackball motion */ |
SDL_JOYHATMOTION, /* Joystick hat position change */ |
SDL_JOYBUTTONDOWN, /* Joystick button pressed */ |
SDL_JOYBUTTONUP, /* Joystick button released */ |
SDL_QUIT, /* User-requested quit */ |
SDL_SYSWMEVENT, /* System specific event */ |
SDL_EVENT_RESERVEDA, /* Reserved for future use.. */ |
SDL_EVENT_RESERVEDB, /* Reserved for future use.. */ |
SDL_VIDEORESIZE, /* User resized video mode */ |
SDL_VIDEOEXPOSE, /* Screen needs to be redrawn */ |
SDL_EVENT_RESERVED2, /* Reserved for future use.. */ |
SDL_EVENT_RESERVED3, /* Reserved for future use.. */ |
SDL_EVENT_RESERVED4, /* Reserved for future use.. */ |
SDL_EVENT_RESERVED5, /* Reserved for future use.. */ |
SDL_EVENT_RESERVED6, /* Reserved for future use.. */ |
SDL_EVENT_RESERVED7, /* Reserved for future use.. */ |
/* Events SDL_USEREVENT through SDL_MAXEVENTS-1 are for your use */ |
SDL_USEREVENT = 24, |
SDL_PAINT_WND = 31, |
/* This last event is only for bounding internal arrays |
It is the number of bits in the event mask datatype -- Uint32 |
*/ |
SDL_NUMEVENTS = 32 |
}; |
/* Predefined event masks */ |
#define SDL_EVENTMASK(X) (1<<(X)) |
enum { |
SDL_ACTIVEEVENTMASK = SDL_EVENTMASK(SDL_ACTIVEEVENT), |
SDL_KEYDOWNMASK = SDL_EVENTMASK(SDL_KEYDOWN), |
SDL_KEYUPMASK = SDL_EVENTMASK(SDL_KEYUP), |
SDL_MOUSEMOTIONMASK = SDL_EVENTMASK(SDL_MOUSEMOTION), |
SDL_MOUSEBUTTONDOWNMASK = SDL_EVENTMASK(SDL_MOUSEBUTTONDOWN), |
SDL_MOUSEBUTTONUPMASK = SDL_EVENTMASK(SDL_MOUSEBUTTONUP), |
SDL_MOUSEEVENTMASK = SDL_EVENTMASK(SDL_MOUSEMOTION)| |
SDL_EVENTMASK(SDL_MOUSEBUTTONDOWN)| |
SDL_EVENTMASK(SDL_MOUSEBUTTONUP), |
SDL_JOYAXISMOTIONMASK = SDL_EVENTMASK(SDL_JOYAXISMOTION), |
SDL_JOYBALLMOTIONMASK = SDL_EVENTMASK(SDL_JOYBALLMOTION), |
SDL_JOYHATMOTIONMASK = SDL_EVENTMASK(SDL_JOYHATMOTION), |
SDL_JOYBUTTONDOWNMASK = SDL_EVENTMASK(SDL_JOYBUTTONDOWN), |
SDL_JOYBUTTONUPMASK = SDL_EVENTMASK(SDL_JOYBUTTONUP), |
SDL_JOYEVENTMASK = SDL_EVENTMASK(SDL_JOYAXISMOTION)| |
SDL_EVENTMASK(SDL_JOYBALLMOTION)| |
SDL_EVENTMASK(SDL_JOYHATMOTION)| |
SDL_EVENTMASK(SDL_JOYBUTTONDOWN)| |
SDL_EVENTMASK(SDL_JOYBUTTONUP), |
SDL_VIDEORESIZEMASK = SDL_EVENTMASK(SDL_VIDEORESIZE), |
SDL_VIDEOEXPOSEMASK = SDL_EVENTMASK(SDL_VIDEOEXPOSE), |
SDL_QUITMASK = SDL_EVENTMASK(SDL_QUIT), |
SDL_SYSWMEVENTMASK = SDL_EVENTMASK(SDL_SYSWMEVENT) |
}; |
#define SDL_ALLEVENTS 0xFFFFFFFF |
/* Application visibility event structure */ |
typedef struct { |
Uint8 type; /* SDL_ACTIVEEVENT */ |
Uint8 gain; /* Whether given states were gained or lost (1/0) */ |
Uint8 state; /* A mask of the focus states */ |
} SDL_ActiveEvent; |
/* Keyboard event structure */ |
typedef struct { |
Uint8 type; /* SDL_KEYDOWN or SDL_KEYUP */ |
Uint8 which; /* The keyboard device index */ |
Uint8 state; /* SDL_PRESSED or SDL_RELEASED */ |
SDL_keysym keysym; |
} SDL_KeyboardEvent; |
/* Mouse motion event structure */ |
typedef struct { |
Uint8 type; /* SDL_MOUSEMOTION */ |
Uint8 which; /* The mouse device index */ |
Uint8 state; /* The current button state */ |
Uint16 x, y; /* The X/Y coordinates of the mouse */ |
Sint16 xrel; /* The relative motion in the X direction */ |
Sint16 yrel; /* The relative motion in the Y direction */ |
} SDL_MouseMotionEvent; |
/* Mouse button event structure */ |
typedef struct { |
Uint8 type; /* SDL_MOUSEBUTTONDOWN or SDL_MOUSEBUTTONUP */ |
Uint8 which; /* The mouse device index */ |
Uint8 button; /* The mouse button index */ |
Uint8 state; /* SDL_PRESSED or SDL_RELEASED */ |
Uint16 x, y; /* The X/Y coordinates of the mouse at press time */ |
} SDL_MouseButtonEvent; |
/* Joystick axis motion event structure */ |
typedef struct { |
Uint8 type; /* SDL_JOYAXISMOTION */ |
Uint8 which; /* The joystick device index */ |
Uint8 axis; /* The joystick axis index */ |
Sint16 value; /* The axis value (range: -32768 to 32767) */ |
} SDL_JoyAxisEvent; |
/* Joystick trackball motion event structure */ |
typedef struct { |
Uint8 type; /* SDL_JOYBALLMOTION */ |
Uint8 which; /* The joystick device index */ |
Uint8 ball; /* The joystick trackball index */ |
Sint16 xrel; /* The relative motion in the X direction */ |
Sint16 yrel; /* The relative motion in the Y direction */ |
} SDL_JoyBallEvent; |
/* Joystick hat position change event structure */ |
typedef struct { |
Uint8 type; /* SDL_JOYHATMOTION */ |
Uint8 which; /* The joystick device index */ |
Uint8 hat; /* The joystick hat index */ |
Uint8 value; /* The hat position value: |
8 1 2 |
7 0 3 |
6 5 4 |
Note that zero means the POV is centered. |
*/ |
} SDL_JoyHatEvent; |
/* Joystick button event structure */ |
typedef struct { |
Uint8 type; /* SDL_JOYBUTTONDOWN or SDL_JOYBUTTONUP */ |
Uint8 which; /* The joystick device index */ |
Uint8 button; /* The joystick button index */ |
Uint8 state; /* SDL_PRESSED or SDL_RELEASED */ |
} SDL_JoyButtonEvent; |
/* The "window resized" event |
When you get this event, you are responsible for setting a new video |
mode with the new width and height. |
*/ |
typedef struct { |
Uint8 type; /* SDL_VIDEORESIZE */ |
int w; /* New width */ |
int h; /* New height */ |
} SDL_ResizeEvent; |
/* The "screen redraw" event */ |
typedef struct { |
Uint8 type; /* SDL_VIDEOEXPOSE */ |
} SDL_ExposeEvent; |
/* The "quit requested" event */ |
typedef struct { |
Uint8 type; /* SDL_QUIT */ |
} SDL_QuitEvent; |
/* A user-defined event type */ |
typedef struct { |
Uint8 type; /* SDL_USEREVENT through SDL_NUMEVENTS-1 */ |
int code; /* User defined event code */ |
void *data1; /* User defined data pointer */ |
void *data2; /* User defined data pointer */ |
} SDL_UserEvent; |
/* If you want to use this event, you should include SDL_syswm.h */ |
struct SDL_SysWMmsg; |
typedef struct SDL_SysWMmsg SDL_SysWMmsg; |
typedef struct { |
Uint8 type; |
SDL_SysWMmsg *msg; |
} SDL_SysWMEvent; |
/* General event structure */ |
typedef union { |
Uint8 type; |
SDL_ActiveEvent active; |
SDL_KeyboardEvent key; |
SDL_MouseMotionEvent motion; |
SDL_MouseButtonEvent button; |
SDL_JoyAxisEvent jaxis; |
SDL_JoyBallEvent jball; |
SDL_JoyHatEvent jhat; |
SDL_JoyButtonEvent jbutton; |
SDL_ResizeEvent resize; |
SDL_ExposeEvent expose; |
SDL_QuitEvent quit; |
SDL_UserEvent user; |
SDL_SysWMEvent syswm; |
} SDL_Event; |
/* Function prototypes */ |
/* Pumps the event loop, gathering events from the input devices. |
This function updates the event queue and internal input device state. |
This should only be run in the thread that sets the video mode. |
*/ |
extern DECLSPEC void SDL_PumpEvents(void); |
/* Checks the event queue for messages and optionally returns them. |
If 'action' is SDL_ADDEVENT, up to 'numevents' events will be added to |
the back of the event queue. |
If 'action' is SDL_PEEKEVENT, up to 'numevents' events at the front |
of the event queue, matching 'mask', will be returned and will not |
be removed from the queue. |
If 'action' is SDL_GETEVENT, up to 'numevents' events at the front |
of the event queue, matching 'mask', will be returned and will be |
removed from the queue. |
This function returns the number of events actually stored, or -1 |
if there was an error. This function is thread-safe. |
*/ |
typedef enum { |
SDL_ADDEVENT, |
SDL_PEEKEVENT, |
SDL_GETEVENT |
} SDL_eventaction; |
/* */ |
extern DECLSPEC int SDL_PeepEvents(SDL_Event *events, int numevents, |
SDL_eventaction action, Uint32 mask); |
/* Polls for currently pending events, and returns 1 if there are any pending |
events, or 0 if there are none available. If 'event' is not NULL, the next |
event is removed from the queue and stored in that area. |
*/ |
extern DECLSPEC int SDL_PollEvent(SDL_Event *event); |
/* Waits indefinitely for the next available event, returning 1, or 0 if there |
was an error while waiting for events. If 'event' is not NULL, the next |
event is removed from the queue and stored in that area. |
*/ |
extern DECLSPEC int SDL_WaitEvent(SDL_Event *event); |
/* Add an event to the event queue. |
This function returns 0, or -1 if the event couldn't be added to |
the event queue. If the event queue is full, this function fails. |
*/ |
extern DECLSPEC int SDL_PushEvent(SDL_Event *event); |
/* |
This function sets up a filter to process all events before they |
change internal state and are posted to the internal event queue. |
The filter is protypted as: |
*/ |
typedef int (*SDL_EventFilter)(const SDL_Event *event); |
/* |
If the filter returns 1, then the event will be added to the internal queue. |
If it returns 0, then the event will be dropped from the queue, but the |
internal state will still be updated. This allows selective filtering of |
dynamically arriving events. |
WARNING: Be very careful of what you do in the event filter function, as |
it may run in a different thread! |
There is one caveat when dealing with the SDL_QUITEVENT event type. The |
event filter is only called when the window manager desires to close the |
application window. If the event filter returns 1, then the window will |
be closed, otherwise the window will remain open if possible. |
If the quit event is generated by an interrupt signal, it will bypass the |
internal queue and be delivered to the application at the next event poll. |
*/ |
extern DECLSPEC void SDL_SetEventFilter(SDL_EventFilter filter); |
/* |
Return the current event filter - can be used to "chain" filters. |
If there is no event filter set, this function returns NULL. |
*/ |
extern DECLSPEC SDL_EventFilter SDL_GetEventFilter(void); |
/* |
This function allows you to set the state of processing certain events. |
If 'state' is set to SDL_IGNORE, that event will be automatically dropped |
from the event queue and will not event be filtered. |
If 'state' is set to SDL_ENABLE, that event will be processed normally. |
If 'state' is set to SDL_QUERY, SDL_EventState() will return the |
current processing state of the specified event. |
*/ |
#define SDL_QUERY -1 |
#define SDL_IGNORE 0 |
#define SDL_DISABLE 0 |
#define SDL_ENABLE 1 |
extern DECLSPEC Uint8 SDL_EventState(Uint8 type, int state); |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_events_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_getenv.h |
---|
0,0 → 1,30 |
/* Not all environments have a working getenv()/putenv() */ |
#if defined(macintosh) || defined(_WIN32_WCE) |
#define NEED_SDL_GETENV |
#endif |
#ifdef NEED_SDL_GETENV |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* Put a variable of the form "name=value" into the environment */ |
extern DECLSPEC int SDL_putenv(const char *variable); |
// #define putenv(X) SDL_putenv(X) |
/* Retrieve a variable named "name" from the environment */ |
extern DECLSPEC char *SDL_getenv(const char *name); |
#define getenv(X) SDL_getenv(X) |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* NEED_GETENV */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_joystick.h |
---|
0,0 → 1,171 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_joystick.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* Include file for SDL joystick event handling */ |
#ifndef _SDL_joystick_h |
#define _SDL_joystick_h |
#include "SDL_types.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* In order to use these functions, SDL_Init() must have been called |
with the SDL_INIT_JOYSTICK flag. This causes SDL to scan the system |
for joysticks, and load appropriate drivers. |
*/ |
/* The joystick structure used to identify an SDL joystick */ |
struct _SDL_Joystick; |
typedef struct _SDL_Joystick SDL_Joystick; |
/* Function prototypes */ |
/* |
* Count the number of joysticks attached to the system |
*/ |
extern DECLSPEC int SDL_NumJoysticks(void); |
/* |
* Get the implementation dependent name of a joystick. |
* This can be called before any joysticks are opened. |
* If no name can be found, this function returns NULL. |
*/ |
extern DECLSPEC const char *SDL_JoystickName(int device_index); |
/* |
* Open a joystick for use - the index passed as an argument refers to |
* the N'th joystick on the system. This index is the value which will |
* identify this joystick in future joystick events. |
* |
* This function returns a joystick identifier, or NULL if an error occurred. |
*/ |
extern DECLSPEC SDL_Joystick *SDL_JoystickOpen(int device_index); |
/* |
* Returns 1 if the joystick has been opened, or 0 if it has not. |
*/ |
extern DECLSPEC int SDL_JoystickOpened(int device_index); |
/* |
* Get the device index of an opened joystick. |
*/ |
extern DECLSPEC int SDL_JoystickIndex(SDL_Joystick *joystick); |
/* |
* Get the number of general axis controls on a joystick |
*/ |
extern DECLSPEC int SDL_JoystickNumAxes(SDL_Joystick *joystick); |
/* |
* Get the number of trackballs on a joystick |
* Joystick trackballs have only relative motion events associated |
* with them and their state cannot be polled. |
*/ |
extern DECLSPEC int SDL_JoystickNumBalls(SDL_Joystick *joystick); |
/* |
* Get the number of POV hats on a joystick |
*/ |
extern DECLSPEC int SDL_JoystickNumHats(SDL_Joystick *joystick); |
/* |
* Get the number of buttons on a joystick |
*/ |
extern DECLSPEC int SDL_JoystickNumButtons(SDL_Joystick *joystick); |
/* |
* Update the current state of the open joysticks. |
* This is called automatically by the event loop if any joystick |
* events are enabled. |
*/ |
extern DECLSPEC void SDL_JoystickUpdate(void); |
/* |
* Enable/disable joystick event polling. |
* If joystick events are disabled, you must call SDL_JoystickUpdate() |
* yourself and check the state of the joystick when you want joystick |
* information. |
* The state can be one of SDL_QUERY, SDL_ENABLE or SDL_IGNORE. |
*/ |
extern DECLSPEC int SDL_JoystickEventState(int state); |
/* |
* Get the current state of an axis control on a joystick |
* The state is a value ranging from -32768 to 32767. |
* The axis indices start at index 0. |
*/ |
extern DECLSPEC Sint16 SDL_JoystickGetAxis(SDL_Joystick *joystick, int axis); |
/* |
* Get the current state of a POV hat on a joystick |
* The return value is one of the following positions: |
*/ |
#define SDL_HAT_CENTERED 0x00 |
#define SDL_HAT_UP 0x01 |
#define SDL_HAT_RIGHT 0x02 |
#define SDL_HAT_DOWN 0x04 |
#define SDL_HAT_LEFT 0x08 |
#define SDL_HAT_RIGHTUP (SDL_HAT_RIGHT|SDL_HAT_UP) |
#define SDL_HAT_RIGHTDOWN (SDL_HAT_RIGHT|SDL_HAT_DOWN) |
#define SDL_HAT_LEFTUP (SDL_HAT_LEFT|SDL_HAT_UP) |
#define SDL_HAT_LEFTDOWN (SDL_HAT_LEFT|SDL_HAT_DOWN) |
/* |
* The hat indices start at index 0. |
*/ |
extern DECLSPEC Uint8 SDL_JoystickGetHat(SDL_Joystick *joystick, int hat); |
/* |
* Get the ball axis change since the last poll |
* This returns 0, or -1 if you passed it invalid parameters. |
* The ball indices start at index 0. |
*/ |
extern DECLSPEC int SDL_JoystickGetBall(SDL_Joystick *joystick, int ball, int *dx, int *dy); |
/* |
* Get the current state of a button on a joystick |
* The button indices start at index 0. |
*/ |
extern DECLSPEC Uint8 SDL_JoystickGetButton(SDL_Joystick *joystick, int button); |
/* |
* Close a joystick previously opened with SDL_JoystickOpen() |
*/ |
extern DECLSPEC void SDL_JoystickClose(SDL_Joystick *joystick); |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_joystick_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_keyboard.h |
---|
0,0 → 1,124 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_keyboard.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* Include file for SDL keyboard event handling */ |
#ifndef _SDL_keyboard_h |
#define _SDL_keyboard_h |
#include "SDL_types.h" |
#include "SDL_keysym.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* Keysym structure |
- The scancode is hardware dependent, and should not be used by general |
applications. If no hardware scancode is available, it will be 0. |
- The 'unicode' translated character is only available when character |
translation is enabled by the SDL_EnableUNICODE() API. If non-zero, |
this is a UNICODE character corresponding to the keypress. If the |
high 9 bits of the character are 0, then this maps to the equivalent |
ASCII character: |
char ch; |
if ( (keysym.unicode & 0xFF80) == 0 ) { |
ch = keysym.unicode & 0x7F; |
} else { |
An international character.. |
} |
*/ |
typedef struct { |
Uint8 scancode; /* hardware specific scancode */ |
SDLKey sym; /* SDL virtual keysym */ |
SDLMod mod; /* current key modifiers */ |
Uint16 unicode; /* translated character */ |
} SDL_keysym; |
/* This is the mask which refers to all hotkey bindings */ |
#define SDL_ALL_HOTKEYS 0xFFFFFFFF |
/* Function prototypes */ |
/* |
* Enable/Disable UNICODE translation of keyboard input. |
* This translation has some overhead, so translation defaults off. |
* If 'enable' is 1, translation is enabled. |
* If 'enable' is 0, translation is disabled. |
* If 'enable' is -1, the translation state is not changed. |
* It returns the previous state of keyboard translation. |
*/ |
extern DECLSPEC int SDL_EnableUNICODE(int enable); |
/* |
* Enable/Disable keyboard repeat. Keyboard repeat defaults to off. |
* 'delay' is the initial delay in ms between the time when a key is |
* pressed, and keyboard repeat begins. |
* 'interval' is the time in ms between keyboard repeat events. |
*/ |
#define SDL_DEFAULT_REPEAT_DELAY 500 |
#define SDL_DEFAULT_REPEAT_INTERVAL 30 |
/* |
* If 'delay' is set to 0, keyboard repeat is disabled. |
*/ |
extern DECLSPEC int SDL_EnableKeyRepeat(int delay, int interval); |
/* |
* Get a snapshot of the current state of the keyboard. |
* Returns an array of keystates, indexed by the SDLK_* syms. |
* Used: |
* Uint8 *keystate = SDL_GetKeyState(NULL); |
* if ( keystate[SDLK_RETURN] ) ... <RETURN> is pressed. |
*/ |
extern DECLSPEC Uint8 * SDL_GetKeyState(int *numkeys); |
/* |
* Get the current key modifier state |
*/ |
extern DECLSPEC SDLMod SDL_GetModState(void); |
/* |
* Set the current key modifier state |
* This does not change the keyboard state, only the key modifier flags. |
*/ |
extern DECLSPEC void SDL_SetModState(SDLMod modstate); |
/* |
* Get the name of an SDL virtual keysym |
*/ |
extern DECLSPEC char * SDL_GetKeyName(SDLKey key); |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_keyboard_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_keysym.h |
---|
0,0 → 1,315 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_keysym.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
#ifndef _SDL_keysym_h |
#define _SDL_keysym_h |
/* What we really want is a mapping of every raw key on the keyboard. |
To support international keyboards, we use the range 0xA1 - 0xFF |
as international virtual keycodes. We'll follow in the footsteps of X11... |
The names of the keys |
*/ |
typedef enum { |
/* The keyboard syms have been cleverly chosen to map to ASCII */ |
SDLK_UNKNOWN = 0, |
SDLK_FIRST = 0, |
SDLK_BACKSPACE = 8, |
SDLK_TAB = 9, |
SDLK_CLEAR = 12, |
SDLK_RETURN = 13, |
SDLK_PAUSE = 19, |
SDLK_ESCAPE = 27, |
SDLK_SPACE = 32, |
SDLK_EXCLAIM = 33, |
SDLK_QUOTEDBL = 34, |
SDLK_HASH = 35, |
SDLK_DOLLAR = 36, |
SDLK_AMPERSAND = 38, |
SDLK_QUOTE = 39, |
SDLK_LEFTPAREN = 40, |
SDLK_RIGHTPAREN = 41, |
SDLK_ASTERISK = 42, |
SDLK_PLUS = 43, |
SDLK_COMMA = 44, |
SDLK_MINUS = 45, |
SDLK_PERIOD = 46, |
SDLK_SLASH = 47, |
SDLK_0 = 48, |
SDLK_1 = 49, |
SDLK_2 = 50, |
SDLK_3 = 51, |
SDLK_4 = 52, |
SDLK_5 = 53, |
SDLK_6 = 54, |
SDLK_7 = 55, |
SDLK_8 = 56, |
SDLK_9 = 57, |
SDLK_COLON = 58, |
SDLK_SEMICOLON = 59, |
SDLK_LESS = 60, |
SDLK_EQUALS = 61, |
SDLK_GREATER = 62, |
SDLK_QUESTION = 63, |
SDLK_AT = 64, |
/* |
Skip uppercase letters |
*/ |
SDLK_LEFTBRACKET = 91, |
SDLK_BACKSLASH = 92, |
SDLK_RIGHTBRACKET = 93, |
SDLK_CARET = 94, |
SDLK_UNDERSCORE = 95, |
SDLK_BACKQUOTE = 96, |
SDLK_a = 97, |
SDLK_b = 98, |
SDLK_c = 99, |
SDLK_d = 100, |
SDLK_e = 101, |
SDLK_f = 102, |
SDLK_g = 103, |
SDLK_h = 104, |
SDLK_i = 105, |
SDLK_j = 106, |
SDLK_k = 107, |
SDLK_l = 108, |
SDLK_m = 109, |
SDLK_n = 110, |
SDLK_o = 111, |
SDLK_p = 112, |
SDLK_q = 113, |
SDLK_r = 114, |
SDLK_s = 115, |
SDLK_t = 116, |
SDLK_u = 117, |
SDLK_v = 118, |
SDLK_w = 119, |
SDLK_x = 120, |
SDLK_y = 121, |
SDLK_z = 122, |
SDLK_DELETE = 127, |
/* End of ASCII mapped keysyms */ |
/* International keyboard syms */ |
SDLK_WORLD_0 = 160, /* 0xA0 */ |
SDLK_WORLD_1 = 161, |
SDLK_WORLD_2 = 162, |
SDLK_WORLD_3 = 163, |
SDLK_WORLD_4 = 164, |
SDLK_WORLD_5 = 165, |
SDLK_WORLD_6 = 166, |
SDLK_WORLD_7 = 167, |
SDLK_WORLD_8 = 168, |
SDLK_WORLD_9 = 169, |
SDLK_WORLD_10 = 170, |
SDLK_WORLD_11 = 171, |
SDLK_WORLD_12 = 172, |
SDLK_WORLD_13 = 173, |
SDLK_WORLD_14 = 174, |
SDLK_WORLD_15 = 175, |
SDLK_WORLD_16 = 176, |
SDLK_WORLD_17 = 177, |
SDLK_WORLD_18 = 178, |
SDLK_WORLD_19 = 179, |
SDLK_WORLD_20 = 180, |
SDLK_WORLD_21 = 181, |
SDLK_WORLD_22 = 182, |
SDLK_WORLD_23 = 183, |
SDLK_WORLD_24 = 184, |
SDLK_WORLD_25 = 185, |
SDLK_WORLD_26 = 186, |
SDLK_WORLD_27 = 187, |
SDLK_WORLD_28 = 188, |
SDLK_WORLD_29 = 189, |
SDLK_WORLD_30 = 190, |
SDLK_WORLD_31 = 191, |
SDLK_WORLD_32 = 192, |
SDLK_WORLD_33 = 193, |
SDLK_WORLD_34 = 194, |
SDLK_WORLD_35 = 195, |
SDLK_WORLD_36 = 196, |
SDLK_WORLD_37 = 197, |
SDLK_WORLD_38 = 198, |
SDLK_WORLD_39 = 199, |
SDLK_WORLD_40 = 200, |
SDLK_WORLD_41 = 201, |
SDLK_WORLD_42 = 202, |
SDLK_WORLD_43 = 203, |
SDLK_WORLD_44 = 204, |
SDLK_WORLD_45 = 205, |
SDLK_WORLD_46 = 206, |
SDLK_WORLD_47 = 207, |
SDLK_WORLD_48 = 208, |
SDLK_WORLD_49 = 209, |
SDLK_WORLD_50 = 210, |
SDLK_WORLD_51 = 211, |
SDLK_WORLD_52 = 212, |
SDLK_WORLD_53 = 213, |
SDLK_WORLD_54 = 214, |
SDLK_WORLD_55 = 215, |
SDLK_WORLD_56 = 216, |
SDLK_WORLD_57 = 217, |
SDLK_WORLD_58 = 218, |
SDLK_WORLD_59 = 219, |
SDLK_WORLD_60 = 220, |
SDLK_WORLD_61 = 221, |
SDLK_WORLD_62 = 222, |
SDLK_WORLD_63 = 223, |
SDLK_WORLD_64 = 224, |
SDLK_WORLD_65 = 225, |
SDLK_WORLD_66 = 226, |
SDLK_WORLD_67 = 227, |
SDLK_WORLD_68 = 228, |
SDLK_WORLD_69 = 229, |
SDLK_WORLD_70 = 230, |
SDLK_WORLD_71 = 231, |
SDLK_WORLD_72 = 232, |
SDLK_WORLD_73 = 233, |
SDLK_WORLD_74 = 234, |
SDLK_WORLD_75 = 235, |
SDLK_WORLD_76 = 236, |
SDLK_WORLD_77 = 237, |
SDLK_WORLD_78 = 238, |
SDLK_WORLD_79 = 239, |
SDLK_WORLD_80 = 240, |
SDLK_WORLD_81 = 241, |
SDLK_WORLD_82 = 242, |
SDLK_WORLD_83 = 243, |
SDLK_WORLD_84 = 244, |
SDLK_WORLD_85 = 245, |
SDLK_WORLD_86 = 246, |
SDLK_WORLD_87 = 247, |
SDLK_WORLD_88 = 248, |
SDLK_WORLD_89 = 249, |
SDLK_WORLD_90 = 250, |
SDLK_WORLD_91 = 251, |
SDLK_WORLD_92 = 252, |
SDLK_WORLD_93 = 253, |
SDLK_WORLD_94 = 254, |
SDLK_WORLD_95 = 255, /* 0xFF */ |
/* Numeric keypad */ |
SDLK_KP0 = 256, |
SDLK_KP1 = 257, |
SDLK_KP2 = 258, |
SDLK_KP3 = 259, |
SDLK_KP4 = 260, |
SDLK_KP5 = 261, |
SDLK_KP6 = 262, |
SDLK_KP7 = 263, |
SDLK_KP8 = 264, |
SDLK_KP9 = 265, |
SDLK_KP_PERIOD = 266, |
SDLK_KP_DIVIDE = 267, |
SDLK_KP_MULTIPLY = 268, |
SDLK_KP_MINUS = 269, |
SDLK_KP_PLUS = 270, |
SDLK_KP_ENTER = 271, |
SDLK_KP_EQUALS = 272, |
/* Arrows + Home/End pad */ |
SDLK_UP = 273, |
SDLK_DOWN = 274, |
SDLK_RIGHT = 275, |
SDLK_LEFT = 276, |
SDLK_INSERT = 277, |
SDLK_HOME = 278, |
SDLK_END = 279, |
SDLK_PAGEUP = 280, |
SDLK_PAGEDOWN = 281, |
/* Function keys */ |
SDLK_F1 = 282, |
SDLK_F2 = 283, |
SDLK_F3 = 284, |
SDLK_F4 = 285, |
SDLK_F5 = 286, |
SDLK_F6 = 287, |
SDLK_F7 = 288, |
SDLK_F8 = 289, |
SDLK_F9 = 290, |
SDLK_F10 = 291, |
SDLK_F11 = 292, |
SDLK_F12 = 293, |
SDLK_F13 = 294, |
SDLK_F14 = 295, |
SDLK_F15 = 296, |
/* Key state modifier keys */ |
SDLK_NUMLOCK = 300, |
SDLK_CAPSLOCK = 301, |
SDLK_SCROLLOCK = 302, |
SDLK_RSHIFT = 303, |
SDLK_LSHIFT = 304, |
SDLK_RCTRL = 305, |
SDLK_LCTRL = 306, |
SDLK_RALT = 307, |
SDLK_LALT = 308, |
SDLK_RMETA = 309, |
SDLK_LMETA = 310, |
SDLK_LSUPER = 311, /* Left "Windows" key */ |
SDLK_RSUPER = 312, /* Right "Windows" key */ |
SDLK_MODE = 313, /* "Alt Gr" key */ |
SDLK_COMPOSE = 314, /* Multi-key compose key */ |
/* Miscellaneous function keys */ |
SDLK_HELP = 315, |
SDLK_PRINT = 316, |
SDLK_SYSREQ = 317, |
SDLK_BREAK = 318, |
SDLK_MENU = 319, |
SDLK_POWER = 320, /* Power Macintosh power key */ |
SDLK_EURO = 321, /* Some european keyboards */ |
/* Add any other keys here */ |
SDLK_LAST |
} SDLKey; |
/* Enumeration of valid key mods (possibly OR'd together) */ |
typedef enum { |
KMOD_NONE = 0x0000, |
KMOD_LSHIFT= 0x0001, |
KMOD_RSHIFT= 0x0002, |
KMOD_LCTRL = 0x0040, |
KMOD_RCTRL = 0x0080, |
KMOD_LALT = 0x0100, |
KMOD_RALT = 0x0200, |
KMOD_LMETA = 0x0400, |
KMOD_RMETA = 0x0800, |
KMOD_NUM = 0x1000, |
KMOD_CAPS = 0x2000, |
KMOD_MODE = 0x4000, |
KMOD_RESERVED = 0x8000 |
} SDLMod; |
#define KMOD_CTRL (KMOD_LCTRL|KMOD_RCTRL) |
#define KMOD_SHIFT (KMOD_LSHIFT|KMOD_RSHIFT) |
#define KMOD_ALT (KMOD_LALT|KMOD_RALT) |
#define KMOD_META (KMOD_LMETA|KMOD_RMETA) |
#endif /* _SDL_keysym_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_main.h |
---|
0,0 → 1,97 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_main.h,v 1.3 2001/06/07 14:28:11 hercules Exp $"; |
#endif |
#ifndef _SDL_main_h |
#define _SDL_main_h |
/* Redefine main() on Win32 and MacOS so that it is called by winmain.c */ |
#if defined(WIN32UNDEFINED) || (defined(__MWERKS__) && !defined(__BEOS__)) || \ |
defined(macintosh) || defined(__APPLE__) |
#ifdef __cplusplus |
#define C_LINKAGE "C" |
#else |
#define C_LINKAGE |
#endif /* __cplusplus */ |
/* The application's main() function must be called with C linkage, |
and should be declared like this: |
#ifdef __cplusplus |
extern "C" |
#endif |
int main(int argc, char *argv[]) |
{ |
} |
*/ |
#define main SDL_main |
/* The prototype for the application's main() function */ |
extern C_LINKAGE int SDL_main(int argc, char *argv[]); |
/* From the SDL library code -- needed for registering the app on Win32 */ |
#if defined(WIN32UNDEFINED) |
#include "SDL_types.h" |
#include "begin_code.h" |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* This should be called from your WinMain() function, if any */ |
extern DECLSPEC int SDL_RegisterApp(char *name, Uint32 style, void *hInst); |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif |
/* From the SDL library code -- needed for registering QuickDraw on MacOS */ |
#if defined(macintosh) |
#include "begin_code.h" |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* Forward declaration so we don't need to include QuickDraw.h */ |
struct QDGlobals; |
/* This should be called from your main() function, if any */ |
extern DECLSPEC void SDL_InitQuickDraw(struct QDGlobals *the_qd); |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif |
#endif /* Need to redefine main()? */ |
#endif /* _SDL_main_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_mouse.h |
---|
0,0 → 1,136 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_mouse.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* Include file for SDL mouse event handling */ |
#ifndef _SDL_mouse_h |
#define _SDL_mouse_h |
#include "SDL_types.h" |
#include "SDL_video.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
typedef struct WMcursor WMcursor; /* Implementation dependent */ |
typedef struct { |
SDL_Rect area; /* The area of the mouse cursor */ |
Sint16 hot_x, hot_y; /* The "tip" of the cursor */ |
Uint8 *data; /* B/W cursor data */ |
Uint8 *mask; /* B/W cursor mask */ |
Uint8 *save[2]; /* Place to save cursor area */ |
WMcursor *wm_cursor; /* Window-manager cursor */ |
} SDL_Cursor; |
/* Function prototypes */ |
/* |
* Retrieve the current state of the mouse. |
* The current button state is returned as a button bitmask, which can |
* be tested using the SDL_BUTTON(X) macros, and x and y are set to the |
* current mouse cursor position. You can pass NULL for either x or y. |
*/ |
extern DECLSPEC Uint8 SDL_GetMouseState(int *x, int *y); |
/* |
* Retrieve the current state of the mouse. |
* The current button state is returned as a button bitmask, which can |
* be tested using the SDL_BUTTON(X) macros, and x and y are set to the |
* mouse deltas since the last call to SDL_GetRelativeMouseState(). |
*/ |
extern DECLSPEC Uint8 SDL_GetRelativeMouseState(int *x, int *y); |
/* |
* Set the position of the mouse cursor (generates a mouse motion event) |
*/ |
extern DECLSPEC void SDL_WarpMouse(Uint16 x, Uint16 y); |
/* |
* Create a cursor using the specified data and mask (in MSB format). |
* The cursor width must be a multiple of 8 bits. |
* |
* The cursor is created in black and white according to the following: |
* data mask resulting pixel on screen |
* 0 1 White |
* 1 1 Black |
* 0 0 Transparent |
* 1 0 Inverted color if possible, black if not. |
* |
* Cursors created with this function must be freed with SDL_FreeCursor(). |
*/ |
extern DECLSPEC SDL_Cursor *SDL_CreateCursor |
(Uint8 *data, Uint8 *mask, int w, int h, int hot_x, int hot_y); |
/* |
* Set the currently active cursor to the specified one. |
* If the cursor is currently visible, the change will be immediately |
* represented on the display. |
*/ |
extern DECLSPEC void SDL_SetCursor(SDL_Cursor *cursor); |
/* |
* Returns the currently active cursor. |
*/ |
extern DECLSPEC SDL_Cursor * SDL_GetCursor(void); |
/* |
* Deallocates a cursor created with SDL_CreateCursor(). |
*/ |
extern DECLSPEC void SDL_FreeCursor(SDL_Cursor *cursor); |
/* |
* Toggle whether or not the cursor is shown on the screen. |
* The cursor start off displayed, but can be turned off. |
* SDL_ShowCursor() returns 1 if the cursor was being displayed |
* before the call, or 0 if it was not. You can query the current |
* state by passing a 'toggle' value of -1. |
*/ |
extern DECLSPEC int SDL_ShowCursor(int toggle); |
/* Used as a mask when testing buttons in buttonstate |
Button 1: Left mouse button |
Button 2: Middle mouse button |
Button 3: Right mouse button |
*/ |
#define SDL_BUTTON(X) (SDL_PRESSED<<(X-1)) |
#define SDL_BUTTON_LEFT 1 |
#define SDL_BUTTON_MIDDLE 2 |
#define SDL_BUTTON_RIGHT 3 |
#define SDL_BUTTON_LMASK SDL_BUTTON(SDL_BUTTON_LEFT) |
#define SDL_BUTTON_MMASK SDL_BUTTON(SDL_BUTTON_MIDDLE) |
#define SDL_BUTTON_RMASK SDL_BUTTON(SDL_BUTTON_RIGHT) |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_mouse_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_mutex.h |
---|
0,0 → 1,163 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_mutex.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
#ifndef _SDL_mutex_h |
#define _SDL_mutex_h |
/* Functions to provide thread synchronization primitives |
These are independent of the other SDL routines. |
*/ |
#include "SDL_main.h" |
#include "SDL_types.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* Synchronization functions which can time out return this value |
if they time out. |
*/ |
#define SDL_MUTEX_TIMEDOUT 1 |
/* This is the timeout value which corresponds to never time out */ |
#define SDL_MUTEX_MAXWAIT (~(Uint32)0) |
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
/* Mutex functions */ |
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
/* The SDL mutex structure, defined in SDL_mutex.c */ |
struct SDL_mutex; |
typedef struct SDL_mutex SDL_mutex; |
/* Create a mutex, initialized unlocked */ |
extern DECLSPEC SDL_mutex * SDL_CreateMutex(void); |
/* Lock the mutex (Returns 0, or -1 on error) */ |
#define SDL_LockMutex(m) SDL_mutexP(m) |
extern DECLSPEC int SDL_mutexP(SDL_mutex *mutex); |
/* Unlock the mutex (Returns 0, or -1 on error) */ |
#define SDL_UnlockMutex(m) SDL_mutexV(m) |
extern DECLSPEC int SDL_mutexV(SDL_mutex *mutex); |
/* Destroy a mutex */ |
extern DECLSPEC void SDL_DestroyMutex(SDL_mutex *mutex); |
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
/* Semaphore functions */ |
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
/* The SDL semaphore structure, defined in SDL_sem.c */ |
struct SDL_semaphore; |
typedef struct SDL_semaphore SDL_sem; |
/* Create a semaphore, initialized with value, returns NULL on failure. */ |
extern DECLSPEC SDL_sem * SDL_CreateSemaphore(Uint32 initial_value); |
/* Destroy a semaphore */ |
extern DECLSPEC void SDL_DestroySemaphore(SDL_sem *sem); |
/* This function suspends the calling thread until the semaphore pointed |
* to by sem has a positive count. It then atomically decreases the semaphore |
* count. |
*/ |
extern DECLSPEC int SDL_SemWait(SDL_sem *sem); |
/* Non-blocking variant of SDL_SemWait(), returns 0 if the wait succeeds, |
SDL_MUTEX_TIMEDOUT if the wait would block, and -1 on error. |
*/ |
extern DECLSPEC int SDL_SemTryWait(SDL_sem *sem); |
/* Variant of SDL_SemWait() with a timeout in milliseconds, returns 0 if |
the wait succeeds, SDL_MUTEX_TIMEDOUT if the wait does not succeed in |
the allotted time, and -1 on error. |
On some platforms this function is implemented by looping with a delay |
of 1 ms, and so should be avoided if possible. |
*/ |
extern DECLSPEC int SDL_SemWaitTimeout(SDL_sem *sem, Uint32 ms); |
/* Atomically increases the semaphore's count (not blocking), returns 0, |
or -1 on error. |
*/ |
extern DECLSPEC int SDL_SemPost(SDL_sem *sem); |
/* Returns the current count of the semaphore */ |
extern DECLSPEC Uint32 SDL_SemValue(SDL_sem *sem); |
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
/* Condition variable functions */ |
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
/* The SDL condition variable structure, defined in SDL_cond.c */ |
struct SDL_cond; |
typedef struct SDL_cond SDL_cond; |
/* Create a condition variable */ |
extern DECLSPEC SDL_cond * SDL_CreateCond(void); |
/* Destroy a condition variable */ |
extern DECLSPEC void SDL_DestroyCond(SDL_cond *cond); |
/* Restart one of the threads that are waiting on the condition variable, |
returns 0 or -1 on error. |
*/ |
extern DECLSPEC int SDL_CondSignal(SDL_cond *cond); |
/* Restart all threads that are waiting on the condition variable, |
returns 0 or -1 on error. |
*/ |
extern DECLSPEC int SDL_CondBroadcast(SDL_cond *cond); |
/* Wait on the condition variable, unlocking the provided mutex. |
The mutex must be locked before entering this function! |
Returns 0 when it is signaled, or -1 on error. |
*/ |
extern DECLSPEC int SDL_CondWait(SDL_cond *cond, SDL_mutex *mut); |
/* Waits for at most 'ms' milliseconds, and returns 0 if the condition |
variable is signaled, SDL_MUTEX_TIMEDOUT if the condition is not |
signaled in the allotted time, and -1 on error. |
On some platforms this function is implemented by looping with a delay |
of 1 ms, and so should be avoided if possible. |
*/ |
extern DECLSPEC int SDL_CondWaitTimeout(SDL_cond *cond, SDL_mutex *mutex, Uint32 ms); |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_mutex_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_quit.h |
---|
0,0 → 1,52 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_quit.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* Include file for SDL quit event handling */ |
#ifndef _SDL_quit_h |
#define _SDL_quit_h |
/* |
An SDL_QUITEVENT is generated when the user tries to close the application |
window. If it is ignored or filtered out, the window will remain open. |
If it is not ignored or filtered, it is queued normally and the window |
is allowed to close. When the window is closed, screen updates will |
complete, but have no effect. |
SDL_Init() installs signal handlers for SIGINT (keyboard interrupt) |
and SIGTERM (system termination request), if handlers do not already |
exist, that generate SDL_QUITEVENT events as well. There is no way |
to determine the cause of an SDL_QUITEVENT, but setting a signal |
handler in your application will override the default generation of |
quit events for that signal. |
*/ |
/* There are no functions directly affecting the quit event */ |
#define SDL_QuitRequested() \ |
(SDL_PumpEvents(), SDL_PeepEvents(NULL,0,SDL_PEEKEVENT,SDL_QUITMASK)) |
#endif /* _SDL_quit_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_rwops.h |
---|
0,0 → 1,113 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_rwops.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* This file provides a general interface for SDL to read and write |
data sources. It can easily be extended to files, memory, etc. |
*/ |
#ifndef _SDL_RWops_h |
#define _SDL_RWops_h |
#include <stdio.h> |
#include "SDL_types.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* This is the read/write operation structure -- very basic */ |
typedef struct SDL_RWops { |
/* Seek to 'offset' relative to whence, one of stdio's whence values: |
SEEK_SET, SEEK_CUR, SEEK_END |
Returns the final offset in the data source. |
*/ |
int (*seek)(struct SDL_RWops *context, int offset, int whence); |
/* Read up to 'num' objects each of size 'objsize' from the data |
source to the area pointed at by 'ptr'. |
Returns the number of objects read, or -1 if the read failed. |
*/ |
int (*read)(struct SDL_RWops *context, void *ptr, int size, int maxnum); |
/* Write exactly 'num' objects each of size 'objsize' from the area |
pointed at by 'ptr' to data source. |
Returns 'num', or -1 if the write failed. |
*/ |
int (*write)(struct SDL_RWops *context, const void *ptr, int size, int num); |
/* Close and free an allocated SDL_FSops structure */ |
int (*close)(struct SDL_RWops *context); |
Uint32 type; |
union { |
struct { |
int autoclose; |
FILE *fp; |
} stdio; |
struct { |
Uint8 *base; |
Uint8 *here; |
Uint8 *stop; |
} mem; |
struct { |
void *data1; |
} unknown; |
} hidden; |
} SDL_RWops; |
/* Functions to create SDL_RWops structures from various data sources */ |
extern DECLSPEC SDL_RWops * SDL_RWFromFile(const char *file, const char *mode); |
extern DECLSPEC SDL_RWops * SDL_RWFromFP(FILE *fp, int autoclose); |
extern DECLSPEC SDL_RWops * SDL_RWFromMem(void *mem, int size); |
extern DECLSPEC SDL_RWops * SDL_AllocRW(void); |
extern DECLSPEC void SDL_FreeRW(SDL_RWops *area); |
/* Macros to easily read and write from an SDL_RWops structure */ |
#define SDL_RWseek(ctx, offset, whence) (ctx)->seek(ctx, offset, whence) |
#define SDL_RWtell(ctx) (ctx)->seek(ctx, 0, SEEK_CUR) |
#define SDL_RWread(ctx, ptr, size, n) (ctx)->read(ctx, ptr, size, n) |
#define SDL_RWwrite(ctx, ptr, size, n) (ctx)->write(ctx, ptr, size, n) |
#define SDL_RWclose(ctx) (ctx)->close(ctx) |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_RWops_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_syswm.h |
---|
0,0 → 1,165 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_syswm.h,v 1.5 2001/07/08 09:00:06 hercules Exp $"; |
#endif |
/* Include file for SDL custom system window manager hooks */ |
#ifndef _SDL_syswm_h |
#define _SDL_syswm_h |
#include "SDL_version.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* Your application has access to a special type of event 'SDL_SYSWMEVENT', |
which contains window-manager specific information and arrives whenever |
an unhandled window event occurs. This event is ignored by default, but |
you can enable it with SDL_EventState() |
*/ |
#ifdef SDL_PROTOTYPES_ONLY |
struct SDL_SysWMinfo; |
typedef struct SDL_SysWMinfo SDL_SysWMinfo; |
#else |
/* This is the structure for custom window manager events */ |
#if (defined(unix) || defined(__unix__) || defined(_AIX) || defined(__OpenBSD__)) && \ |
(!defined(DISABLE_X11) && !defined(__CYGWIN32__)) |
/* AIX is unix, of course, but the native compiler CSet doesn't define unix */ |
#include <X11/Xlib.h> |
#include <X11/Xatom.h> |
/* These are the various supported subsystems under UNIX */ |
typedef enum { |
SDL_SYSWM_X11 |
} SDL_SYSWM_TYPE; |
/* The UNIX custom event structure */ |
struct SDL_SysWMmsg { |
SDL_version version; |
SDL_SYSWM_TYPE subsystem; |
union { |
XEvent xevent; |
} event; |
}; |
/* The UNIX custom window manager information structure. |
When this structure is returned, it holds information about which |
low level system it is using, and will be one of SDL_SYSWM_TYPE. |
*/ |
typedef struct { |
SDL_version version; |
SDL_SYSWM_TYPE subsystem; |
union { |
struct { |
Display *display; /* The X11 display */ |
Window window; /* The X11 display window */ |
/* These locking functions should be called around |
any X11 functions using the display variable. |
They lock the event thread, so should not be |
called around event functions or from event filters. |
*/ |
void (*lock_func)(void); |
void (*unlock_func)(void); |
/* Introduced in SDL 1.0.2 */ |
Window fswindow; /* The X11 fullscreen window */ |
Window wmwindow; /* The X11 managed input window */ |
} x11; |
} info; |
} SDL_SysWMinfo; |
#elif defined(ENABLE_NANOX) |
#include <microwin/nano-X.h> |
/* The generic custom event structure */ |
struct SDL_SysWMmsg { |
SDL_version version; |
int data; |
}; |
/* The windows custom window manager information structure */ |
typedef struct { |
SDL_version version ; |
GR_WINDOW_ID window ; /* The display window */ |
} SDL_SysWMinfo; |
#elif defined(WIN32UNDEFINED) |
#include <windows.h> |
/* The windows custom event structure */ |
struct SDL_SysWMmsg { |
SDL_version version; |
HWND hwnd; /* The window for the message */ |
UINT msg; /* The type of message */ |
WPARAM wParam; /* WORD message parameter */ |
LPARAM lParam; /* LONG message parameter */ |
}; |
/* The windows custom window manager information structure */ |
typedef struct { |
SDL_version version; |
HWND window; /* The Win32 display window */ |
} SDL_SysWMinfo; |
#else |
/* The generic custom event structure */ |
struct SDL_SysWMmsg { |
SDL_version version; |
int data; |
}; |
/* The generic custom window manager information structure */ |
typedef struct { |
SDL_version version; |
int data; |
} SDL_SysWMinfo; |
#endif /* OS type */ |
#endif /* SDL_PROTOTYPES_ONLY */ |
/* Function prototypes */ |
/* |
* This function gives you custom hooks into the window manager information. |
* It fills the structure pointed to by 'info' with custom information and |
* returns 1 if the function is implemented. If it's not implemented, or |
* the version member of the 'info' structure is invalid, it returns 0. |
*/ |
extern DECLSPEC int SDL_GetWMInfo(SDL_SysWMinfo *info); |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_syswm_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_thread.h |
---|
0,0 → 1,79 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_thread.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
#ifndef _SDL_thread_h |
#define _SDL_thread_h |
/* Header for the SDL thread management routines |
These are independent of the other SDL routines. |
*/ |
#include "SDL_main.h" |
#include "SDL_types.h" |
/* Thread synchronization primitives */ |
#include "SDL_mutex.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* The SDL thread structure, defined in SDL_thread.c */ |
struct SDL_Thread; |
typedef struct SDL_Thread SDL_Thread; |
/* Create a thread */ |
extern DECLSPEC SDL_Thread * SDL_CreateThread(int (*fn)(void *), void *data); |
/* Get the 32-bit thread identifier for the current thread */ |
extern DECLSPEC Uint32 SDL_ThreadID(void); |
/* Get the 32-bit thread identifier for the specified thread, |
equivalent to SDL_ThreadID() if the specified thread is NULL. |
*/ |
extern DECLSPEC Uint32 SDL_GetThreadID(SDL_Thread *thread); |
/* Wait for a thread to finish. |
The return code for the thread function is placed in the area |
pointed to by 'status', if 'status' is not NULL. |
*/ |
extern DECLSPEC void SDL_WaitThread(SDL_Thread *thread, int *status); |
/* Forcefully kill a thread without worrying about its state */ |
extern DECLSPEC void SDL_KillThread(SDL_Thread *thread); |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_thread_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_timer.h |
---|
0,0 → 1,118 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_timer.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
#ifndef _SDL_timer_h |
#define _SDL_timer_h |
/* Header for the SDL time management routines */ |
#include "SDL_main.h" |
#include "SDL_types.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* This is the OS scheduler timeslice, in milliseconds */ |
#define SDL_TIMESLICE 10 |
/* This is the maximum resolution of the SDL timer on all platforms */ |
#define TIMER_RESOLUTION 10 /* Experimentally determined */ |
/* Get the number of milliseconds since the SDL library initialization. |
* Note that this value wraps if the program runs for more than ~49 days. |
*/ |
extern DECLSPEC Uint32 SDL_GetTicks(void); |
/* Wait a specified number of milliseconds before returning */ |
extern DECLSPEC void SDL_Delay(Uint32 ms); |
/* Function prototype for the timer callback function */ |
typedef Uint32 (*SDL_TimerCallback)(Uint32 interval); |
/* Set a callback to run after the specified number of milliseconds has |
* elapsed. The callback function is passed the current timer interval |
* and returns the next timer interval. If the returned value is the |
* same as the one passed in, the periodic alarm continues, otherwise a |
* new alarm is scheduled. If the callback returns 0, the periodic alarm |
* is cancelled. |
* |
* To cancel a currently running timer, call SDL_SetTimer(0, NULL); |
* |
* The timer callback function may run in a different thread than your |
* main code, and so shouldn't call any functions from within itself. |
* |
* The maximum resolution of this timer is 10 ms, which means that if |
* you request a 16 ms timer, your callback will run approximately 20 ms |
* later on an unloaded system. If you wanted to set a flag signaling |
* a frame update at 30 frames per second (every 33 ms), you might set a |
* timer for 30 ms: |
* SDL_SetTimer((33/10)*10, flag_update); |
* |
* If you use this function, you need to pass SDL_INIT_TIMER to SDL_Init(). |
* |
* Under UNIX, you should not use raise or use SIGALRM and this function |
* in the same program, as it is implemented using setitimer(). You also |
* should not use this function in multi-threaded applications as signals |
* to multi-threaded apps have undefined behavior in some implementations. |
*/ |
extern DECLSPEC int SDL_SetTimer(Uint32 interval, SDL_TimerCallback callback); |
/* New timer API, supports multiple timers |
* Written by Stephane Peter <megastep@lokigames.com> |
*/ |
/* Function prototype for the new timer callback function. |
* The callback function is passed the current timer interval and returns |
* the next timer interval. If the returned value is the same as the one |
* passed in, the periodic alarm continues, otherwise a new alarm is |
* scheduled. If the callback returns 0, the periodic alarm is cancelled. |
*/ |
typedef Uint32 (*SDL_NewTimerCallback)(Uint32 interval, void *param); |
/* Definition of the timer ID type */ |
typedef struct _SDL_TimerID *SDL_TimerID; |
/* Add a new timer to the pool of timers already running. |
Returns a timer ID, or NULL when an error occurs. |
*/ |
extern DECLSPEC SDL_TimerID SDL_AddTimer(Uint32 interval, SDL_NewTimerCallback callback, void *param); |
/* Remove one of the multiple timers knowing its ID. |
* Returns a boolean value indicating success. |
*/ |
extern DECLSPEC SDL_bool SDL_RemoveTimer(SDL_TimerID t); |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_timer_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_types.h |
---|
0,0 → 1,87 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_types.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* General data types used by the SDL library */ |
#ifndef _SDL_types_h |
#define _SDL_types_h |
/* The number of elements in a table */ |
#define SDL_TABLESIZE(table) (sizeof(table)/sizeof(table[0])) |
/* Basic data types */ |
typedef enum { |
SDL_FALSE = 0, |
SDL_TRUE = 1 |
} SDL_bool; |
typedef unsigned char Uint8; |
typedef signed char Sint8; |
typedef unsigned short Uint16; |
typedef signed short Sint16; |
typedef unsigned int Uint32; |
typedef signed int Sint32; |
/* Figure out how to support 64-bit datatypes */ |
#if !defined(__STRICT_ANSI__) |
#if defined(__GNUC__) || defined(__MWERKS__) /* MJS */ |
#define SDL_HAS_64BIT_TYPE long long |
#elif defined(_MSC_VER) /* VC++ */ |
#define SDL_HAS_64BIT_TYPE __int64 |
#endif |
#endif /* !__STRICT_ANSI__ */ |
/* The 64-bit datatype isn't supported on all platforms */ |
#ifdef SDL_HAS_64BIT_TYPE |
typedef unsigned SDL_HAS_64BIT_TYPE Uint64; |
typedef SDL_HAS_64BIT_TYPE Sint64; |
#else |
/* This is really just a hack to prevent the compiler from complaining */ |
typedef struct { |
Uint32 hi; |
Uint32 lo; |
} Uint64, Sint64; |
#endif |
/* Make sure the types really have the right sizes */ |
#define SDL_COMPILE_TIME_ASSERT(name, x) \ |
typedef int SDL_dummy_ ## name[(x) * 2 - 1] |
SDL_COMPILE_TIME_ASSERT(uint8, sizeof(Uint8) == 1); |
SDL_COMPILE_TIME_ASSERT(sint8, sizeof(Sint8) == 1); |
SDL_COMPILE_TIME_ASSERT(uint16, sizeof(Uint16) == 2); |
SDL_COMPILE_TIME_ASSERT(sint16, sizeof(Sint16) == 2); |
SDL_COMPILE_TIME_ASSERT(uint32, sizeof(Uint32) == 4); |
SDL_COMPILE_TIME_ASSERT(sint32, sizeof(Sint32) == 4); |
SDL_COMPILE_TIME_ASSERT(uint64, sizeof(Uint64) == 8); |
SDL_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8); |
#undef SDL_COMPILE_TIME_ASSERT |
/* General keyboard/mouse state definitions */ |
enum { SDL_PRESSED = 0x01, SDL_RELEASED = 0x00 }; |
#endif |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_version.h |
---|
0,0 → 1,90 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_version.h,v 1.3 2001/06/19 13:35:05 hercules Exp $"; |
#endif |
/* This header defines the current SDL version */ |
#ifndef _SDL_version_h |
#define _SDL_version_h |
#include "SDL_types.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL |
*/ |
#define SDL_MAJOR_VERSION 1 |
#define SDL_MINOR_VERSION 2 |
#define SDL_PATCHLEVEL 2 |
typedef struct { |
Uint8 major; |
Uint8 minor; |
Uint8 patch; |
} SDL_version; |
/* This macro can be used to fill a version structure with the compile-time |
* version of the SDL library. |
*/ |
#define SDL_VERSION(X) \ |
{ \ |
(X)->major = SDL_MAJOR_VERSION; \ |
(X)->minor = SDL_MINOR_VERSION; \ |
(X)->patch = SDL_PATCHLEVEL; \ |
} |
/* This macro turns the version numbers into a numeric value: |
(1,2,3) -> (1203) |
This assumes that there will never be more than 100 patchlevels |
*/ |
#define SDL_VERSIONNUM(X, Y, Z) \ |
(X)*1000 + (Y)*100 + (Z) |
/* This is the version number macro for the current SDL version */ |
#define SDL_COMPILEDVERSION \ |
SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL) |
/* This macro will evaluate to true if compiled with SDL at least X.Y.Z */ |
#define SDL_VERSION_ATLEAST(X, Y, Z) \ |
(SDL_COMPILEDVERSION >= SDL_VERSIONNUM(X, Y, Z)) |
/* This function gets the version of the dynamically linked SDL library. |
it should NOT be used to fill a version structure, instead you should |
use the SDL_Version() macro. |
*/ |
extern DECLSPEC const SDL_version * SDL_Linked_Version(void); |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_version_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/SDL_video.h |
---|
0,0 → 1,891 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_video.h,v 1.3 2001/06/07 14:28:11 hercules Exp $"; |
#endif |
/* Header file for access to the SDL raw framebuffer window */ |
#ifndef _SDL_video_h |
#define _SDL_video_h |
#include <stdio.h> |
#include "SDL_types.h" |
#include "SDL_mutex.h" |
#include "SDL_rwops.h" |
#include "begin_code.h" |
/* Set up for C function definitions, even when using C++ */ |
#ifdef __cplusplus |
extern "C" { |
#endif |
/* Transparency definitions: These define alpha as the opacity of a surface */ |
#define SDL_ALPHA_OPAQUE 255 |
#define SDL_ALPHA_TRANSPARENT 0 |
/* Useful data types */ |
typedef struct { |
Sint16 x, y; |
Uint16 w, h; |
} SDL_Rect; |
typedef struct { |
Uint8 r; |
Uint8 g; |
Uint8 b; |
Uint8 unused; |
} SDL_Color; |
typedef struct { |
int ncolors; |
SDL_Color *colors; |
} SDL_Palette; |
/* Everything in the pixel format structure is read-only */ |
typedef struct SDL_PixelFormat { |
SDL_Palette *palette; |
Uint8 BitsPerPixel; |
Uint8 BytesPerPixel; |
Uint8 Rloss; |
Uint8 Gloss; |
Uint8 Bloss; |
Uint8 Aloss; |
Uint8 Rshift; |
Uint8 Gshift; |
Uint8 Bshift; |
Uint8 Ashift; |
Uint32 Rmask; |
Uint32 Gmask; |
Uint32 Bmask; |
Uint32 Amask; |
/* RGB color key information */ |
Uint32 colorkey; |
/* Alpha value information (per-surface alpha) */ |
Uint8 alpha; |
} SDL_PixelFormat; |
/* typedef for private surface blitting functions */ |
struct SDL_Surface; |
typedef int (*SDL_blit)(struct SDL_Surface *src, SDL_Rect *srcrect, |
struct SDL_Surface *dst, SDL_Rect *dstrect); |
/* This structure should be treated as read-only, except for 'pixels', |
which, if not NULL, contains the raw pixel data for the surface. |
*/ |
typedef struct SDL_Surface { |
Uint32 flags; /* Read-only */ |
SDL_PixelFormat *format; /* Read-only */ |
int w, h; /* Read-only */ |
Uint16 pitch; /* Read-only */ |
void *pixels; /* Read-write */ |
int offset; /* Private */ |
/* Hardware-specific surface info */ |
struct private_hwdata *hwdata; |
/* clipping information */ |
SDL_Rect clip_rect; /* Read-only */ |
Uint32 unused1; /* for binary compatibility */ |
/* Allow recursive locks */ |
Uint32 locked; /* Private */ |
/* info for fast blit mapping to other surfaces */ |
struct SDL_BlitMap *map; /* Private */ |
/* format version, bumped at every change to invalidate blit maps */ |
unsigned int format_version; /* Private */ |
/* Reference count -- used when freeing surface */ |
int refcount; /* Read-mostly */ |
} SDL_Surface; |
/* These are the currently supported flags for the SDL_surface */ |
/* Available for SDL_CreateRGBSurface() or SDL_SetVideoMode() */ |
#define SDL_SWSURFACE 0x00000000 /* Surface is in system memory */ |
#define SDL_HWSURFACE 0x00000001 /* Surface is in video memory */ |
#define SDL_ASYNCBLIT 0x00000004 /* Use asynchronous blits if possible */ |
/* Available for SDL_SetVideoMode() */ |
#define SDL_ANYFORMAT 0x10000000 /* Allow any video depth/pixel-format */ |
#define SDL_HWPALETTE 0x20000000 /* Surface has exclusive palette */ |
#define SDL_DOUBLEBUF 0x40000000 /* Set up double-buffered video mode */ |
#define SDL_FULLSCREEN 0x80000000 /* Surface is a full screen display */ |
#define SDL_OPENGL 0x00000002 /* Create an OpenGL rendering context */ |
#define SDL_OPENGLBLIT 0x0000000A /* Create an OpenGL rendering context and use it for blitting */ |
#define SDL_RESIZABLE 0x00000010 /* This video mode may be resized */ |
#define SDL_NOFRAME 0x00000020 /* No window caption or edge frame */ |
/* Used internally (read-only) */ |
#define SDL_HWACCEL 0x00000100 /* Blit uses hardware acceleration */ |
#define SDL_SRCCOLORKEY 0x00001000 /* Blit uses a source color key */ |
#define SDL_RLEACCELOK 0x00002000 /* Private flag */ |
#define SDL_RLEACCEL 0x00004000 /* Surface is RLE encoded */ |
#define SDL_SRCALPHA 0x00010000 /* Blit uses source alpha blending */ |
#define SDL_PREALLOC 0x01000000 /* Surface uses preallocated memory */ |
/* Evaluates to true if the surface needs to be locked before access */ |
#define SDL_MUSTLOCK(surface) \ |
(surface->offset || \ |
((surface->flags & (SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_RLEACCEL)) != 0)) |
/* Useful for determining the video hardware capabilities */ |
typedef struct { |
Uint32 hw_available :1; /* Flag: Can you create hardware surfaces? */ |
Uint32 wm_available :1; /* Flag: Can you talk to a window manager? */ |
Uint32 UnusedBits1 :6; |
Uint32 UnusedBits2 :1; |
Uint32 blit_hw :1; /* Flag: Accelerated blits HW --> HW */ |
Uint32 blit_hw_CC :1; /* Flag: Accelerated blits with Colorkey */ |
Uint32 blit_hw_A :1; /* Flag: Accelerated blits with Alpha */ |
Uint32 blit_sw :1; /* Flag: Accelerated blits SW --> HW */ |
Uint32 blit_sw_CC :1; /* Flag: Accelerated blits with Colorkey */ |
Uint32 blit_sw_A :1; /* Flag: Accelerated blits with Alpha */ |
Uint32 blit_fill :1; /* Flag: Accelerated color fill */ |
Uint32 UnusedBits3 :16; |
Uint32 video_mem; /* The total amount of video memory (in K) */ |
SDL_PixelFormat *vfmt; /* Value: The format of the video surface */ |
} SDL_VideoInfo; |
/* The most common video overlay formats. |
For an explanation of these pixel formats, see: |
http://www.webartz.com/fourcc/indexyuv.htm |
For information on the relationship between color spaces, see: |
http://www.neuro.sfc.keio.ac.jp/~aly/polygon/info/color-space-faq.html |
*/ |
#define SDL_YV12_OVERLAY 0x32315659 /* Planar mode: Y + V + U (3 planes) */ |
#define SDL_IYUV_OVERLAY 0x56555949 /* Planar mode: Y + U + V (3 planes) */ |
#define SDL_YUY2_OVERLAY 0x32595559 /* Packed mode: Y0+U0+Y1+V0 (1 plane) */ |
#define SDL_UYVY_OVERLAY 0x59565955 /* Packed mode: U0+Y0+V0+Y1 (1 plane) */ |
#define SDL_YVYU_OVERLAY 0x55595659 /* Packed mode: Y0+V0+Y1+U0 (1 plane) */ |
/* The YUV hardware video overlay */ |
typedef struct SDL_Overlay { |
Uint32 format; /* Read-only */ |
int w, h; /* Read-only */ |
int planes; /* Read-only */ |
Uint16 *pitches; /* Read-only */ |
Uint8 **pixels; /* Read-write */ |
/* Hardware-specific surface info */ |
struct private_yuvhwfuncs *hwfuncs; |
struct private_yuvhwdata *hwdata; |
/* Special flags */ |
Uint32 hw_overlay :1; /* Flag: This overlay hardware accelerated? */ |
Uint32 UnusedBits :31; |
} SDL_Overlay; |
/* Public enumeration for setting the OpenGL window attributes. */ |
typedef enum { |
SDL_GL_RED_SIZE, |
SDL_GL_GREEN_SIZE, |
SDL_GL_BLUE_SIZE, |
SDL_GL_ALPHA_SIZE, |
SDL_GL_BUFFER_SIZE, |
SDL_GL_DOUBLEBUFFER, |
SDL_GL_DEPTH_SIZE, |
SDL_GL_STENCIL_SIZE, |
SDL_GL_ACCUM_RED_SIZE, |
SDL_GL_ACCUM_GREEN_SIZE, |
SDL_GL_ACCUM_BLUE_SIZE, |
SDL_GL_ACCUM_ALPHA_SIZE |
} SDL_GLattr; |
/* flags for SDL_SetPalette() */ |
#define SDL_LOGPAL 0x01 |
#define SDL_PHYSPAL 0x02 |
/* Function prototypes */ |
/* These functions are used internally, and should not be used unless you |
* have a specific need to specify the video driver you want to use. |
* You should normally use SDL_Init() or SDL_InitSubSystem(). |
* |
* SDL_VideoInit() initializes the video subsystem -- sets up a connection |
* to the window manager, etc, and determines the current video mode and |
* pixel format, but does not initialize a window or graphics mode. |
* Note that event handling is activated by this routine. |
* |
* If you use both sound and video in your application, you need to call |
* SDL_Init() before opening the sound device, otherwise under Win32 DirectX, |
* you won't be able to set full-screen display modes. |
*/ |
extern DECLSPEC int SDL_VideoInit(const char *driver_name, Uint32 flags); |
extern DECLSPEC void SDL_VideoQuit(void); |
/* This function fills the given character buffer with the name of the |
* video driver, and returns a pointer to it if the video driver has |
* been initialized. It returns NULL if no driver has been initialized. |
*/ |
extern DECLSPEC char *SDL_VideoDriverName(char *namebuf, int maxlen); |
/* |
* This function returns a pointer to the current display surface. |
* If SDL is doing format conversion on the display surface, this |
* function returns the publicly visible surface, not the real video |
* surface. |
*/ |
extern DECLSPEC SDL_Surface * SDL_GetVideoSurface(void); |
/* |
* This function returns a read-only pointer to information about the |
* video hardware. If this is called before SDL_SetVideoMode(), the 'vfmt' |
* member of the returned structure will contain the pixel format of the |
* "best" video mode. |
*/ |
extern DECLSPEC const SDL_VideoInfo * SDL_GetVideoInfo(void); |
/* |
* Check to see if a particular video mode is supported. |
* It returns 0 if the requested mode is not supported under any bit depth, |
* or returns the bits-per-pixel of the closest available mode with the |
* given width and height. If this bits-per-pixel is different from the |
* one used when setting the video mode, SDL_SetVideoMode() will succeed, |
* but will emulate the requested bits-per-pixel with a shadow surface. |
* |
* The arguments to SDL_VideoModeOK() are the same ones you would pass to |
* SDL_SetVideoMode() |
*/ |
extern DECLSPEC int SDL_VideoModeOK(int width, int height, int bpp, Uint32 flags); |
/* |
* Return a pointer to an array of available screen dimensions for the |
* given format and video flags, sorted largest to smallest. Returns |
* NULL if there are no dimensions available for a particular format, |
* or (SDL_Rect **)-1 if any dimension is okay for the given format. |
* |
* If 'format' is NULL, the mode list will be for the format given |
* by SDL_GetVideoInfo()->vfmt |
*/ |
extern DECLSPEC SDL_Rect ** SDL_ListModes(SDL_PixelFormat *format, Uint32 flags); |
/* |
* Set up a video mode with the specified width, height and bits-per-pixel. |
* |
* If 'bpp' is 0, it is treated as the current display bits per pixel. |
* |
* If SDL_ANYFORMAT is set in 'flags', the SDL library will try to set the |
* requested bits-per-pixel, but will return whatever video pixel format is |
* available. The default is to emulate the requested pixel format if it |
* is not natively available. |
* |
* If SDL_HWSURFACE is set in 'flags', the video surface will be placed in |
* video memory, if possible, and you may have to call SDL_LockSurface() |
* in order to access the raw framebuffer. Otherwise, the video surface |
* will be created in system memory. |
* |
* If SDL_ASYNCBLIT is set in 'flags', SDL will try to perform rectangle |
* updates asynchronously, but you must always lock before accessing pixels. |
* SDL will wait for updates to complete before returning from the lock. |
* |
* If SDL_HWPALETTE is set in 'flags', the SDL library will guarantee |
* that the colors set by SDL_SetColors() will be the colors you get. |
* Otherwise, in 8-bit mode, SDL_SetColors() may not be able to set all |
* of the colors exactly the way they are requested, and you should look |
* at the video surface structure to determine the actual palette. |
* If SDL cannot guarantee that the colors you request can be set, |
* i.e. if the colormap is shared, then the video surface may be created |
* under emulation in system memory, overriding the SDL_HWSURFACE flag. |
* |
* If SDL_FULLSCREEN is set in 'flags', the SDL library will try to set |
* a fullscreen video mode. The default is to create a windowed mode |
* if the current graphics system has a window manager. |
* If the SDL library is able to set a fullscreen video mode, this flag |
* will be set in the surface that is returned. |
* |
* If SDL_DOUBLEBUF is set in 'flags', the SDL library will try to set up |
* two surfaces in video memory and swap between them when you call |
* SDL_Flip(). This is usually slower than the normal single-buffering |
* scheme, but prevents "tearing" artifacts caused by modifying video |
* memory while the monitor is refreshing. It should only be used by |
* applications that redraw the entire screen on every update. |
* |
* If SDL_RESIZABLE is set in 'flags', the SDL library will allow the |
* window manager, if any, to resize the window at runtime. When this |
* occurs, SDL will send a SDL_VIDEORESIZE event to you application, |
* and you must respond to the event by re-calling SDL_SetVideoMode() |
* with the requested size (or another size that suits the application). |
* |
* If SDL_NOFRAME is set in 'flags', the SDL library will create a window |
* without any title bar or frame decoration. Fullscreen video modes have |
* this flag set automatically. |
* |
* This function returns the video framebuffer surface, or NULL if it fails. |
* |
* If you rely on functionality provided by certain video flags, check the |
* flags of the returned surface to make sure that functionality is available. |
* SDL will fall back to reduced functionality if the exact flags you wanted |
* are not available. |
*/ |
extern DECLSPEC SDL_Surface *SDL_SetVideoMode |
(int width, int height, int bpp, Uint32 flags); |
/* |
* Makes sure the given list of rectangles is updated on the given screen. |
* If 'x', 'y', 'w' and 'h' are all 0, SDL_UpdateRect will update the entire |
* screen. |
* These functions should not be called while 'screen' is locked. |
*/ |
extern DECLSPEC void SDL_UpdateRects |
(SDL_Surface *screen, int numrects, SDL_Rect *rects); |
extern DECLSPEC void SDL_UpdateRect |
(SDL_Surface *screen, Sint32 x, Sint32 y, Uint32 w, Uint32 h); |
/* |
* On hardware that supports double-buffering, this function sets up a flip |
* and returns. The hardware will wait for vertical retrace, and then swap |
* video buffers before the next video surface blit or lock will return. |
* On hardware that doesn not support double-buffering, this is equivalent |
* to calling SDL_UpdateRect(screen, 0, 0, 0, 0); |
* The SDL_DOUBLEBUF flag must have been passed to SDL_SetVideoMode() when |
* setting the video mode for this function to perform hardware flipping. |
* This function returns 0 if successful, or -1 if there was an error. |
*/ |
extern DECLSPEC int SDL_Flip(SDL_Surface *screen); |
/* |
* Set the gamma correction for each of the color channels. |
* The gamma values range (approximately) between 0.1 and 10.0 |
* |
* If this function isn't supported directly by the hardware, it will |
* be emulated using gamma ramps, if available. If successful, this |
* function returns 0, otherwise it returns -1. |
*/ |
extern DECLSPEC int SDL_SetGamma(float red, float green, float blue); |
/* |
* Set the gamma translation table for the red, green, and blue channels |
* of the video hardware. Each table is an array of 256 16-bit quantities, |
* representing a mapping between the input and output for that channel. |
* The input is the index into the array, and the output is the 16-bit |
* gamma value at that index, scaled to the output color precision. |
* |
* You may pass NULL for any of the channels to leave it unchanged. |
* If the call succeeds, it will return 0. If the display driver or |
* hardware does not support gamma translation, or otherwise fails, |
* this function will return -1. |
*/ |
extern DECLSPEC int SDL_SetGammaRamp(Uint16 *red, Uint16 *green, Uint16 *blue); |
/* |
* Retrieve the current values of the gamma translation tables. |
* |
* You must pass in valid pointers to arrays of 256 16-bit quantities. |
* Any of the pointers may be NULL to ignore that channel. |
* If the call succeeds, it will return 0. If the display driver or |
* hardware does not support gamma translation, or otherwise fails, |
* this function will return -1. |
*/ |
extern DECLSPEC int SDL_GetGammaRamp(Uint16 *red, Uint16 *green, Uint16 *blue); |
/* |
* Sets a portion of the colormap for the given 8-bit surface. If 'surface' |
* is not a palettized surface, this function does nothing, returning 0. |
* If all of the colors were set as passed to SDL_SetColors(), it will |
* return 1. If not all the color entries were set exactly as given, |
* it will return 0, and you should look at the surface palette to |
* determine the actual color palette. |
* |
* When 'surface' is the surface associated with the current display, the |
* display colormap will be updated with the requested colors. If |
* SDL_HWPALETTE was set in SDL_SetVideoMode() flags, SDL_SetColors() |
* will always return 1, and the palette is guaranteed to be set the way |
* you desire, even if the window colormap has to be warped or run under |
* emulation. |
*/ |
extern DECLSPEC int SDL_SetColors(SDL_Surface *surface, |
SDL_Color *colors, int firstcolor, int ncolors); |
/* |
* Sets a portion of the colormap for a given 8-bit surface. |
* 'flags' is one or both of: |
* SDL_LOGPAL -- set logical palette, which controls how blits are mapped |
* to/from the surface, |
* SDL_PHYSPAL -- set physical palette, which controls how pixels look on |
* the screen |
* Only screens have physical palettes. Separate change of physical/logical |
* palettes is only possible if the screen has SDL_HWPALETTE set. |
* |
* The return value is 1 if all colours could be set as requested, and 0 |
* otherwise. |
* |
* SDL_SetColors() is equivalent to calling this function with |
* flags = (SDL_LOGPAL|SDL_PHYSPAL). |
*/ |
extern DECLSPEC int SDL_SetPalette(SDL_Surface *surface, int flags, |
SDL_Color *colors, int firstcolor, |
int ncolors); |
/* |
* Maps an RGB triple to an opaque pixel value for a given pixel format |
*/ |
extern DECLSPEC Uint32 SDL_MapRGB |
(SDL_PixelFormat *format, Uint8 r, Uint8 g, Uint8 b); |
/* |
* Maps an RGBA quadruple to a pixel value for a given pixel format |
*/ |
extern DECLSPEC Uint32 SDL_MapRGBA(SDL_PixelFormat *format, |
Uint8 r, Uint8 g, Uint8 b, Uint8 a); |
/* |
* Maps a pixel value into the RGB components for a given pixel format |
*/ |
extern DECLSPEC void SDL_GetRGB(Uint32 pixel, SDL_PixelFormat *fmt, |
Uint8 *r, Uint8 *g, Uint8 *b); |
/* |
* Maps a pixel value into the RGBA components for a given pixel format |
*/ |
extern DECLSPEC void SDL_GetRGBA(Uint32 pixel, SDL_PixelFormat *fmt, |
Uint8 *r, Uint8 *g, Uint8 *b, Uint8 *a); |
/* |
* Allocate and free an RGB surface (must be called after SDL_SetVideoMode) |
* If the depth is 4 or 8 bits, an empty palette is allocated for the surface. |
* If the depth is greater than 8 bits, the pixel format is set using the |
* flags '[RGB]mask'. |
* If the function runs out of memory, it will return NULL. |
* |
* The 'flags' tell what kind of surface to create. |
* SDL_SWSURFACE means that the surface should be created in system memory. |
* SDL_HWSURFACE means that the surface should be created in video memory, |
* with the same format as the display surface. This is useful for surfaces |
* that will not change much, to take advantage of hardware acceleration |
* when being blitted to the display surface. |
* SDL_ASYNCBLIT means that SDL will try to perform asynchronous blits with |
* this surface, but you must always lock it before accessing the pixels. |
* SDL will wait for current blits to finish before returning from the lock. |
* SDL_SRCCOLORKEY indicates that the surface will be used for colorkey blits. |
* If the hardware supports acceleration of colorkey blits between |
* two surfaces in video memory, SDL will try to place the surface in |
* video memory. If this isn't possible or if there is no hardware |
* acceleration available, the surface will be placed in system memory. |
* SDL_SRCALPHA means that the surface will be used for alpha blits and |
* if the hardware supports hardware acceleration of alpha blits between |
* two surfaces in video memory, to place the surface in video memory |
* if possible, otherwise it will be placed in system memory. |
* If the surface is created in video memory, blits will be _much_ faster, |
* but the surface format must be identical to the video surface format, |
* and the only way to access the pixels member of the surface is to use |
* the SDL_LockSurface() and SDL_UnlockSurface() calls. |
* If the requested surface actually resides in video memory, SDL_HWSURFACE |
* will be set in the flags member of the returned surface. If for some |
* reason the surface could not be placed in video memory, it will not have |
* the SDL_HWSURFACE flag set, and will be created in system memory instead. |
*/ |
#define SDL_AllocSurface SDL_CreateRGBSurface |
extern DECLSPEC SDL_Surface *SDL_CreateRGBSurface |
(Uint32 flags, int width, int height, int depth, |
Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask); |
extern DECLSPEC SDL_Surface *SDL_CreateRGBSurfaceFrom(void *pixels, |
int width, int height, int depth, int pitch, |
Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask); |
extern DECLSPEC void SDL_FreeSurface(SDL_Surface *surface); |
/* |
* SDL_LockSurface() sets up a surface for directly accessing the pixels. |
* Between calls to SDL_LockSurface()/SDL_UnlockSurface(), you can write |
* to and read from 'surface->pixels', using the pixel format stored in |
* 'surface->format'. Once you are done accessing the surface, you should |
* use SDL_UnlockSurface() to release it. |
* |
* Not all surfaces require locking. If SDL_MUSTLOCK(surface) evaluates |
* to 0, then you can read and write to the surface at any time, and the |
* pixel format of the surface will not change. In particular, if the |
* SDL_HWSURFACE flag is not given when calling SDL_SetVideoMode(), you |
* will not need to lock the display surface before accessing it. |
* |
* No operating system or library calls should be made between lock/unlock |
* pairs, as critical system locks may be held during this time. |
* |
* SDL_LockSurface() returns 0, or -1 if the surface couldn't be locked. |
*/ |
extern DECLSPEC int SDL_LockSurface(SDL_Surface *surface); |
extern DECLSPEC void SDL_UnlockSurface(SDL_Surface *surface); |
/* |
* Load a surface from a seekable SDL data source (memory or file.) |
* If 'freesrc' is non-zero, the source will be closed after being read. |
* Returns the new surface, or NULL if there was an error. |
* The new surface should be freed with SDL_FreeSurface(). |
*/ |
extern DECLSPEC SDL_Surface * SDL_LoadBMP_RW(SDL_RWops *src, int freesrc); |
/* Convenience macro -- load a surface from a file */ |
#define SDL_LoadBMP(file) SDL_LoadBMP_RW(SDL_RWFromFile(file, "rb"), 1) |
/* |
* Save a surface to a seekable SDL data source (memory or file.) |
* If 'freedst' is non-zero, the source will be closed after being written. |
* Returns 0 if successful or -1 if there was an error. |
*/ |
extern DECLSPEC int SDL_SaveBMP_RW |
(SDL_Surface *surface, SDL_RWops *dst, int freedst); |
/* Convenience macro -- save a surface to a file */ |
#define SDL_SaveBMP(surface, file) \ |
SDL_SaveBMP_RW(surface, SDL_RWFromFile(file, "wb"), 1) |
/* |
* Sets the color key (transparent pixel) in a blittable surface. |
* If 'flag' is SDL_SRCCOLORKEY (optionally OR'd with SDL_RLEACCEL), |
* 'key' will be the transparent pixel in the source image of a blit. |
* SDL_RLEACCEL requests RLE acceleration for the surface if present, |
* and removes RLE acceleration if absent. |
* If 'flag' is 0, this function clears any current color key. |
* This function returns 0, or -1 if there was an error. |
*/ |
extern DECLSPEC int SDL_SetColorKey |
(SDL_Surface *surface, Uint32 flag, Uint32 key); |
/* |
* This function sets the alpha value for the entire surface, as opposed to |
* using the alpha component of each pixel. This value measures the range |
* of transparency of the surface, 0 being completely transparent to 255 |
* being completely opaque. An 'alpha' value of 255 causes blits to be |
* opaque, the source pixels copied to the destination (the default). Note |
* that per-surface alpha can be combined with colorkey transparency. |
* |
* If 'flag' is 0, alpha blending is disabled for the surface. |
* If 'flag' is SDL_SRCALPHA, alpha blending is enabled for the surface. |
* OR:ing the flag with SDL_RLEACCEL requests RLE acceleration for the |
* surface; if SDL_RLEACCEL is not specified, the RLE accel will be removed. |
*/ |
extern DECLSPEC int SDL_SetAlpha(SDL_Surface *surface, Uint32 flag, Uint8 alpha); |
/* |
* Sets the clipping rectangle for the destination surface in a blit. |
* |
* If the clip rectangle is NULL, clipping will be disabled. |
* If the clip rectangle doesn't intersect the surface, the function will |
* return SDL_FALSE and blits will be completely clipped. Otherwise the |
* function returns SDL_TRUE and blits to the surface will be clipped to |
* the intersection of the surface area and the clipping rectangle. |
* |
* Note that blits are automatically clipped to the edges of the source |
* and destination surfaces. |
*/ |
extern DECLSPEC SDL_bool SDL_SetClipRect(SDL_Surface *surface, SDL_Rect *rect); |
/* |
* Gets the clipping rectangle for the destination surface in a blit. |
* 'rect' must be a pointer to a valid rectangle which will be filled |
* with the correct values. |
*/ |
extern DECLSPEC void SDL_GetClipRect(SDL_Surface *surface, SDL_Rect *rect); |
/* |
* Creates a new surface of the specified format, and then copies and maps |
* the given surface to it so the blit of the converted surface will be as |
* fast as possible. If this function fails, it returns NULL. |
* |
* The 'flags' parameter is passed to SDL_CreateRGBSurface() and has those |
* semantics. You can also pass SDL_RLEACCEL in the flags parameter and |
* SDL will try to RLE accelerate colorkey and alpha blits in the resulting |
* surface. |
* |
* This function is used internally by SDL_DisplayFormat(). |
*/ |
extern DECLSPEC SDL_Surface *SDL_ConvertSurface |
(SDL_Surface *src, SDL_PixelFormat *fmt, Uint32 flags); |
/* |
* This performs a fast blit from the source surface to the destination |
* surface. It assumes that the source and destination rectangles are |
* the same size. If either 'srcrect' or 'dstrect' are NULL, the entire |
* surface (src or dst) is copied. The final blit rectangles are saved |
* in 'srcrect' and 'dstrect' after all clipping is performed. |
* If the blit is successful, it returns 0, otherwise it returns -1. |
* |
* The blit function should not be called on a locked surface. |
* |
* The blit semantics for surfaces with and without alpha and colorkey |
* are defined as follows: |
* |
* RGBA->RGB: |
* SDL_SRCALPHA set: |
* alpha-blend (using alpha-channel). |
* SDL_SRCCOLORKEY ignored. |
* SDL_SRCALPHA not set: |
* copy RGB. |
* if SDL_SRCCOLORKEY set, only copy the pixels matching the |
* RGB values of the source colour key, ignoring alpha in the |
* comparison. |
* |
* RGB->RGBA: |
* SDL_SRCALPHA set: |
* alpha-blend (using the source per-surface alpha value); |
* set destination alpha to opaque. |
* SDL_SRCALPHA not set: |
* copy RGB, set destination alpha to opaque. |
* both: |
* if SDL_SRCCOLORKEY set, only copy the pixels matching the |
* source colour key. |
* |
* RGBA->RGBA: |
* SDL_SRCALPHA set: |
* alpha-blend (using the source alpha channel) the RGB values; |
* leave destination alpha untouched. [Note: is this correct?] |
* SDL_SRCCOLORKEY ignored. |
* SDL_SRCALPHA not set: |
* copy all of RGBA to the destination. |
* if SDL_SRCCOLORKEY set, only copy the pixels matching the |
* RGB values of the source colour key, ignoring alpha in the |
* comparison. |
* |
* RGB->RGB: |
* SDL_SRCALPHA set: |
* alpha-blend (using the source per-surface alpha value). |
* SDL_SRCALPHA not set: |
* copy RGB. |
* both: |
* if SDL_SRCCOLORKEY set, only copy the pixels matching the |
* source colour key. |
* |
* If either of the surfaces were in video memory, and the blit returns -2, |
* the video memory was lost, so it should be reloaded with artwork and |
* re-blitted: |
while ( SDL_BlitSurface(image, imgrect, screen, dstrect) == -2 ) { |
while ( SDL_LockSurface(image) < 0 ) |
Sleep(10); |
-- Write image pixels to image->pixels -- |
SDL_UnlockSurface(image); |
} |
* This happens under DirectX 5.0 when the system switches away from your |
* fullscreen application. The lock will also fail until you have access |
* to the video memory again. |
*/ |
/* You should call SDL_BlitSurface() unless you know exactly how SDL |
blitting works internally and how to use the other blit functions. |
*/ |
#define SDL_BlitSurface SDL_UpperBlit |
/* This is the public blit function, SDL_BlitSurface(), and it performs |
rectangle validation and clipping before passing it to SDL_LowerBlit() |
*/ |
extern DECLSPEC int SDL_UpperBlit |
(SDL_Surface *src, SDL_Rect *srcrect, |
SDL_Surface *dst, SDL_Rect *dstrect); |
/* This is a semi-private blit function and it performs low-level surface |
blitting only. |
*/ |
extern DECLSPEC int SDL_LowerBlit |
(SDL_Surface *src, SDL_Rect *srcrect, |
SDL_Surface *dst, SDL_Rect *dstrect); |
/* |
* This function performs a fast fill of the given rectangle with 'color' |
* The given rectangle is clipped to the destination surface clip area |
* and the final fill rectangle is saved in the passed in pointer. |
* If 'dstrect' is NULL, the whole surface will be filled with 'color' |
* The color should be a pixel of the format used by the surface, and |
* can be generated by the SDL_MapRGB() function. |
* This function returns 0 on success, or -1 on error. |
*/ |
extern DECLSPEC int SDL_FillRect |
(SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color); |
/* |
* This function takes a surface and copies it to a new surface of the |
* pixel format and colors of the video framebuffer, suitable for fast |
* blitting onto the display surface. It calls SDL_ConvertSurface() |
* |
* If you want to take advantage of hardware colorkey or alpha blit |
* acceleration, you should set the colorkey and alpha value before |
* calling this function. |
* |
* If the conversion fails or runs out of memory, it returns NULL |
*/ |
extern DECLSPEC SDL_Surface * SDL_DisplayFormat(SDL_Surface *surface); |
/* |
* This function takes a surface and copies it to a new surface of the |
* pixel format and colors of the video framebuffer (if possible), |
* suitable for fast alpha blitting onto the display surface. |
* The new surface will always have an alpha channel. |
* |
* If you want to take advantage of hardware colorkey or alpha blit |
* acceleration, you should set the colorkey and alpha value before |
* calling this function. |
* |
* If the conversion fails or runs out of memory, it returns NULL |
*/ |
extern DECLSPEC SDL_Surface * SDL_DisplayFormatAlpha(SDL_Surface *surface); |
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
/* YUV video surface overlay functions */ |
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
/* This function creates a video output overlay |
Calling the returned surface an overlay is something of a misnomer because |
the contents of the display surface underneath the area where the overlay |
is shown is undefined - it may be overwritten with the converted YUV data. |
*/ |
extern DECLSPEC SDL_Overlay *SDL_CreateYUVOverlay(int width, int height, |
Uint32 format, SDL_Surface *display); |
/* Lock an overlay for direct access, and unlock it when you are done */ |
extern DECLSPEC int SDL_LockYUVOverlay(SDL_Overlay *overlay); |
extern DECLSPEC void SDL_UnlockYUVOverlay(SDL_Overlay *overlay); |
/* Blit a video overlay to the display surface. |
The contents of the video surface underneath the blit destination are |
not defined. |
The width and height of the destination rectangle may be different from |
that of the overlay, but currently only 2x scaling is supported. |
*/ |
extern DECLSPEC int SDL_DisplayYUVOverlay(SDL_Overlay *overlay, SDL_Rect *dstrect); |
/* Free a video overlay */ |
extern DECLSPEC void SDL_FreeYUVOverlay(SDL_Overlay *overlay); |
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
/* OpenGL support functions. */ |
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
/* |
* Dynamically load a GL driver, if SDL is built with dynamic GL. |
* |
* SDL links normally with the OpenGL library on your system by default, |
* but you can compile it to dynamically load the GL driver at runtime. |
* If you do this, you need to retrieve all of the GL functions used in |
* your program from the dynamic library using SDL_GL_GetProcAddress(). |
* |
* This is disabled in default builds of SDL. |
*/ |
extern DECLSPEC int SDL_GL_LoadLibrary(const char *path); |
/* |
* Get the address of a GL function (for extension functions) |
*/ |
extern DECLSPEC void *SDL_GL_GetProcAddress(const char* proc); |
/* |
* Set an attribute of the OpenGL subsystem before intialization. |
*/ |
extern DECLSPEC int SDL_GL_SetAttribute(SDL_GLattr attr, int value); |
/* |
* Get an attribute of the OpenGL subsystem from the windowing |
* interface, such as glX. This is of course different from getting |
* the values from SDL's internal OpenGL subsystem, which only |
* stores the values you request before initialization. |
* |
* Developers should track the values they pass into SDL_GL_SetAttribute |
* themselves if they want to retrieve these values. |
*/ |
extern DECLSPEC int SDL_GL_GetAttribute(SDL_GLattr attr, int* value); |
/* |
* Swap the OpenGL buffers, if double-buffering is supported. |
*/ |
extern DECLSPEC void SDL_GL_SwapBuffers(void); |
/* |
* Internal functions that should not be called unless you have read |
* and understood the source code for these functions. |
*/ |
extern DECLSPEC void SDL_GL_UpdateRects(int numrects, SDL_Rect* rects); |
extern DECLSPEC void SDL_GL_Lock(void); |
extern DECLSPEC void SDL_GL_Unlock(void); |
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
/* These functions allow interaction with the window manager, if any. */ |
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ |
/* |
* Sets/Gets the title and icon text of the display window |
*/ |
extern DECLSPEC void SDL_WM_SetCaption(const char *title, const char *icon); |
extern DECLSPEC void SDL_WM_GetCaption(char **title, char **icon); |
/* |
* Sets the icon for the display window. |
* This function must be called before the first call to SDL_SetVideoMode(). |
* It takes an icon surface, and a mask in MSB format. |
* If 'mask' is NULL, the entire icon surface will be used as the icon. |
*/ |
extern DECLSPEC void SDL_WM_SetIcon(SDL_Surface *icon, Uint8 *mask); |
/* |
* This function iconifies the window, and returns 1 if it succeeded. |
* If the function succeeds, it generates an SDL_APPACTIVE loss event. |
* This function is a noop and returns 0 in non-windowed environments. |
*/ |
extern DECLSPEC int SDL_WM_IconifyWindow(void); |
/* |
* Toggle fullscreen mode without changing the contents of the screen. |
* If the display surface does not require locking before accessing |
* the pixel information, then the memory pointers will not change. |
* |
* If this function was able to toggle fullscreen mode (change from |
* running in a window to fullscreen, or vice-versa), it will return 1. |
* If it is not implemented, or fails, it returns 0. |
* |
* The next call to SDL_SetVideoMode() will set the mode fullscreen |
* attribute based on the flags parameter - if SDL_FULLSCREEN is not |
* set, then the display will be windowed by default where supported. |
* |
* This is currently only implemented in the X11 video driver. |
*/ |
extern DECLSPEC int SDL_WM_ToggleFullScreen(SDL_Surface *surface); |
/* |
* This function allows you to set and query the input grab state of |
* the application. It returns the new input grab state. |
*/ |
typedef enum { |
SDL_GRAB_QUERY = -1, |
SDL_GRAB_OFF = 0, |
SDL_GRAB_ON = 1, |
SDL_GRAB_FULLSCREEN /* Used internally */ |
} SDL_GrabMode; |
/* |
* Grabbing means that the mouse is confined to the application window, |
* and nearly all keyboard input is passed directly to the application, |
* and not interpreted by a window manager, if any. |
*/ |
extern DECLSPEC SDL_GrabMode SDL_WM_GrabInput(SDL_GrabMode mode); |
/* Not in public API at the moment - do not use! */ |
extern DECLSPEC int SDL_SoftStretch(SDL_Surface *src, SDL_Rect *srcrect, |
SDL_Surface *dst, SDL_Rect *dstrect); |
/* Ends C function definitions when using C++ */ |
#ifdef __cplusplus |
} |
#endif |
#include "close_code.h" |
#endif /* _SDL_video_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/begin_code.h |
---|
0,0 → 1,91 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
/* This file sets things up for C dynamic library function definitions, |
static inlined functions, and structures aligned at 4-byte alignment. |
If you don't like ugly C preprocessor code, don't look at this file. :) |
*/ |
/* This shouldn't be nested -- included it around code only. */ |
#ifdef _begin_code_h |
#error Nested inclusion of begin_code.h |
#endif |
#define _begin_code_h |
/* Some compilers use a special export keyword */ |
#ifndef DECLSPEC |
# ifdef __BEOS__ |
# if defined(__GNUC__) |
# define DECLSPEC __declspec(dllexport) |
# else |
# define DECLSPEC __declspec(export) |
# endif |
# else |
# ifdef WIN32UNDEFINED |
# define DECLSPEC __declspec(dllexport) |
# else |
# define DECLSPEC |
# endif |
# endif |
#endif |
/* Force structure packing at 4 byte alignment. |
This is necessary if the header is included in code which has structure |
packing set to an alternate value, say for loading structures from disk. |
The packing is reset to the previous value in close_code.h |
*/ |
#if defined(_MSC_VER) || defined(__MWERKS__) || defined(__WATCOMC__) || defined(__BORLANDC__) |
#ifdef _MSC_VER |
#pragma warning(disable: 4103) |
#endif |
#ifdef __BORLANDC__ |
#pragma nopackwarning |
#endif |
#pragma pack(push,4) |
#endif /* Compiler needs structure packing set */ |
/* Set up compiler-specific options for inlining functions */ |
#ifndef SDL_INLINE_OKAY |
#ifdef __GNUC__ |
#define SDL_INLINE_OKAY |
#else |
/* Add any special compiler-specific cases here */ |
#if defined(_MSC_VER) |
#define __inline__ __inline |
#define SDL_INLINE_OKAY |
#else |
#if !defined(__MRC__) && !defined(_SGI_SOURCE) |
#define __inline__ inline |
#define SDL_INLINE_OKAY |
#endif /* Not a funky compiler */ |
#endif /* Visual C++ */ |
#endif /* GNU C */ |
#endif /* SDL_INLINE_OKAY */ |
/* If inlining isn't supported, remove "__inline__", turning static |
inlined functions into static functions (resulting in code bloat |
in all files which include the offending header files) |
*/ |
#ifndef SDL_INLINE_OKAY |
#define __inline__ |
#endif |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/include/close_code.h |
---|
0,0 → 1,36 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
/* This file reverses the effects of begin_code.h and should be included |
after you finish any function and structure declarations in your headers |
*/ |
#undef _begin_code_h |
/* Reset structure packing at previous byte alignment */ |
#if defined(_MSC_VER) || defined(__MWERKS__) || defined(__WATCOMC__) || defined(__BORLANDC__) |
#ifdef __BORLANDC__ |
#pragma nopackwarning |
#endif |
#pragma pack(pop) |
#endif /* Compiler needs structure packing set */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/src/Makefile |
---|
0,0 → 1,66 |
# SDL build makefile_test |
# writed by maxcodehack |
CC = kos32-gcc |
AR = kos32-ar |
LD = kos32-ld |
SDK_DIR:= $(abspath ../../..) |
endian_OBJS = endian/SDL_endian.o |
file_OBJS = file/SDL_rwops.o |
hermes_OBJS = hermes/mmxp2_32.o hermes/mmx_main.o hermes/x86p_16.o \ |
hermes/x86p_32.o hermes/x86_main.o |
thread_OBJS = thread/SDL_syscond.o thread/SDL_sysmutex.o thread/SDL_syssem.o \ |
thread/SDL_systhread.o thread/SDL_thread.o |
timer_OBJS = timer/SDL_timer.o timer/dummy/SDL_systimer.o |
event_OBJS = events/SDL_active.o events/SDL_events.o events/SDL_expose.o \ |
events/SDL_keyboard.o events/SDL_mouse.o events/SDL_quit.o \ |
events/SDL_resize.o |
video_OBJS = video/SDL_blit_0.o video/SDL_blit_1.o video/SDL_blit_A.o \ |
video/SDL_blit.o video/SDL_blit_N.o video/SDL_bmp.o \ |
video/SDL_cursor.o video/SDL_gamma.o video/SDL_pixels.o \ |
video/SDL_RLEaccel.o video/SDL_stretch.o video/SDL_surface.o \ |
video/SDL_video.o video/SDL_yuv.o video/SDL_yuv_mmx.o \ |
video/SDL_yuv_sw.o video/menuetos/SDL_menuetevents.o \ |
video/menuetos/SDL_menuetvideo.o |
audio_OBJS = audio/SDL_kolibri_audio.o |
curr_OBJS = SDL.o SDL_error.o SDL_fatal.o SDL_getenv.o |
OBJS = $(endian_OBJS) $(file_OBJS) $(hermes_OBJS) $(thread_OBJS) \ |
$(timer_OBJS) $(event_OBJS) $(video_OBJS) $(curr_OBJS) $(audio_OBJS) |
CFLAGS = -c -O2 -D_REENTRANT -I../include -I SYSCALL/include -I. -DPACKAGE=\"SDL\" -DVERSION=\"1.2.2\" \ |
-fexpensive-optimizations -Wall -DENABLE_AUDIO -UDISABLE_AUDIO -DDISABLE_JOYSTICK \ |
-DDISABLE_CDROM -DDISABLE_THREADS -DENABLE_TIMERS \ |
-DUSE_ASMBLIT -Ihermes -Iaudio -Ivideo -Ievents \ |
-Ijoystick -Icdrom -Ithread -Itimer -Iendian -Ifile -DENABLE_MENUETOS \ |
-DNO_SIGNAL_H -DDISABLE_STDIO -DNEED_SDL_GETENV -DENABLE_FILE -UDISABLE_FILE \ |
-D__MENUETOS__ -DDEBUG_VIDEO -UWIN32 -U_Win32 -U_WIN32 -U__MINGW32__ \ |
-I../../newlib/libc/include/ |
LDFLAGS = -shared -s -T../../newlib/libc/app.lds -nostdlib --image-base 0 -L /home/autobuild/tools/win32/mingw32/lib -lgcc -lz -ldll -lc.dll |
ARFLAGS = crs |
all: libSDL.a |
install: libSDL.a |
mv -f libSDL.a $(SDK_DIR)/lib |
libSDL.a: $(OBJS) |
$(AR) $(ARFLAGS) libSDL.a $(OBJS) SYSCALL/src/*.o |
%.o : %.asm Makefile |
nasm -f coff $< $ |
%.o : %.c Makefile |
$(CC) $(CFLAGS) -o $@ $< |
clean: |
rm -f */*.o \ rm *.o \ rm */*/*.o |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/src/SDL.c |
---|
0,0 → 1,232 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL.c,v 1.3 2001/05/23 23:35:09 hercules Exp $"; |
#endif |
/* Initialization code for SDL */ |
#include <stdlib.h> /* For getenv() */ |
#include "SDL.h" |
#include "SDL_endian.h" |
#include "SDL_fatal.h" |
#ifndef DISABLE_VIDEO |
#include "SDL_leaks.h" |
#endif |
/* Initialization/Cleanup routines */ |
#ifndef DISABLE_JOYSTICK |
extern int SDL_JoystickInit(void); |
extern void SDL_JoystickQuit(void); |
#endif |
#ifndef DISABLE_CDROM |
extern int SDL_CDROMInit(void); |
extern void SDL_CDROMQuit(void); |
#endif |
#ifndef DISABLE_TIMERS |
extern void SDL_StartTicks(void); |
extern int SDL_TimerInit(void); |
extern void SDL_TimerQuit(void); |
#endif |
/* The current SDL version */ |
static SDL_version version = |
{ SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL }; |
/* The initialized subsystems */ |
static Uint32 SDL_initialized = 0; |
static Uint32 ticks_started = 0; |
#ifdef CHECK_LEAKS |
int surfaces_allocated = 0; |
#endif |
int SDL_InitSubSystem(Uint32 flags) |
{ |
#ifndef DISABLE_VIDEO |
/* Initialize the video/event subsystem */ |
if ( (flags & SDL_INIT_VIDEO) && !(SDL_initialized & SDL_INIT_VIDEO) ) { |
if ( SDL_VideoInit(getenv("SDL_VIDEODRIVER"), |
(flags&SDL_INIT_EVENTTHREAD)) < 0 ) { |
return(-1); |
} |
SDL_initialized |= SDL_INIT_VIDEO; |
} |
#else |
if ( flags & SDL_INIT_VIDEO ) { |
SDL_SetError("SDL not built with video support"); |
return(-1); |
} |
#endif |
#ifndef DISABLE_AUDIO |
/* Initialize the audio subsystem */ |
if ( (flags & SDL_INIT_AUDIO) && !(SDL_initialized & SDL_INIT_AUDIO) ) { |
if ( SDL_AudioInit(getenv("SDL_AUDIODRIVER")) < 0 ) { |
return(-1); |
} |
SDL_initialized |= SDL_INIT_AUDIO; |
} |
#else |
if ( flags & SDL_INIT_AUDIO ) { |
SDL_SetError("SDL not built with audio support"); |
return(-1); |
} |
#endif |
#ifndef DISABLE_TIMERS |
/* Initialize the timer subsystem */ |
if ( ! ticks_started ) { |
SDL_StartTicks(); |
ticks_started = 1; |
} |
if ( (flags & SDL_INIT_TIMER) && !(SDL_initialized & SDL_INIT_TIMER) ) { |
if ( SDL_TimerInit() < 0 ) { |
return(-1); |
} |
SDL_initialized |= SDL_INIT_TIMER; |
} |
#else |
if ( flags & SDL_INIT_TIMER ) { |
SDL_SetError("SDL not built with timer support"); |
return(-1); |
} |
#endif |
#ifndef DISABLE_JOYSTICK |
/* Initialize the joystick subsystem */ |
if ( (flags & SDL_INIT_JOYSTICK) && |
!(SDL_initialized & SDL_INIT_JOYSTICK) ) { |
if ( SDL_JoystickInit() < 0 ) { |
return(-1); |
} |
SDL_initialized |= SDL_INIT_JOYSTICK; |
} |
#else |
if ( flags & SDL_INIT_JOYSTICK ) { |
SDL_SetError("SDL not built with joystick support"); |
return(-1); |
} |
#endif |
#ifndef DISABLE_CDROM |
/* Initialize the CD-ROM subsystem */ |
if ( (flags & SDL_INIT_CDROM) && !(SDL_initialized & SDL_INIT_CDROM) ) { |
if ( SDL_CDROMInit() < 0 ) { |
return(-1); |
} |
SDL_initialized |= SDL_INIT_CDROM; |
} |
#else |
if ( flags & SDL_INIT_CDROM ) { |
SDL_SetError("SDL not built with cdrom support"); |
return(-1); |
} |
#endif |
return(0); |
} |
int SDL_Init(Uint32 flags) |
{ |
/* Clear the error message */ |
SDL_ClearError(); |
/* Initialize the desired subsystems */ |
if ( SDL_InitSubSystem(flags) < 0 ) { |
return(-1); |
} |
/* Everything is initialized */ |
if ( !(flags & SDL_INIT_NOPARACHUTE) ) { |
SDL_InstallParachute(); |
} |
return(0); |
} |
void SDL_QuitSubSystem(Uint32 flags) |
{ |
/* Shut down requested initialized subsystems */ |
#ifndef DISABLE_CDROM |
if ( (flags & SDL_initialized & SDL_INIT_CDROM) ) { |
SDL_CDROMQuit(); |
SDL_initialized &= ~SDL_INIT_CDROM; |
} |
#endif |
#ifndef DISABLE_JOYSTICK |
if ( (flags & SDL_initialized & SDL_INIT_JOYSTICK) ) { |
SDL_JoystickQuit(); |
SDL_initialized &= ~SDL_INIT_JOYSTICK; |
} |
#endif |
#ifndef DISABLE_TIMERS |
if ( (flags & SDL_initialized & SDL_INIT_TIMER) ) { |
SDL_TimerQuit(); |
SDL_initialized &= ~SDL_INIT_TIMER; |
} |
#endif |
#ifndef DISABLE_AUDIO |
if ( (flags & SDL_initialized & SDL_INIT_AUDIO) ) { |
SDL_AudioQuit(); |
SDL_initialized &= ~SDL_INIT_AUDIO; |
} |
#endif |
#ifndef DISABLE_VIDEO |
if ( (flags & SDL_initialized & SDL_INIT_VIDEO) ) { |
SDL_VideoQuit(); |
SDL_initialized &= ~SDL_INIT_VIDEO; |
} |
#endif |
} |
Uint32 SDL_WasInit(Uint32 flags) |
{ |
if ( ! flags ) { |
flags = SDL_INIT_EVERYTHING; |
} |
return (SDL_initialized&flags); |
} |
void SDL_Quit(void) |
{ |
/* Quit all subsystems */ |
SDL_QuitSubSystem(SDL_INIT_EVERYTHING); |
#ifdef CHECK_LEAKS |
/* Print the number of surfaces not freed */ |
if ( surfaces_allocated != 0 ) { |
SDL_printf("SDL Warning: %d SDL surfaces extant\n", |
surfaces_allocated); |
} |
#endif |
/* Uninstall any parachute signal handlers */ |
SDL_UninstallParachute(); |
} |
/* Return the library version number */ |
const SDL_version * SDL_Linked_Version(void) |
{ |
return(&version); |
} |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/src/SDL_error.c |
---|
0,0 → 1,352 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_error.c,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* Simple error handling in SDL */ |
#include <stdio.h> |
#include <stdlib.h> |
#include <stdarg.h> |
#include <string.h> |
#include "SDL_types.h" |
#include "SDL_getenv.h" |
#include "SDL_error.h" |
#include "SDL_error_c.h" |
#ifndef DISABLE_THREADS |
#include "SDL_thread_c.h" |
#endif |
#ifdef DISABLE_THREADS |
/* The default (non-thread-safe) global error variable */ |
static SDL_error SDL_global_error; |
#define SDL_GetErrBuf() (&SDL_global_error) |
#endif /* DISABLE_THREADS */ |
#ifdef __CYGWIN__ |
#define DISABLE_STDIO |
#endif |
#define SDL_ERRBUFIZE 1024 |
/* Private functions */ |
static int vdprintf_help(unsigned c) |
{ |
int d0; |
if(c=='\n') |
{ |
c='\r'; |
__asm__ __volatile__("int $0x40":"=&a"(d0):"0"(63),"b"(1),"c"(c)); |
c='\n'; |
__asm__ __volatile__("int $0x40":"=&a"(d0):"0"(63),"b"(1),"c"(c)); |
return 0; |
} |
__asm__ __volatile__("int $0x40":"=&a"(d0):"0"(63),"b"(1),"c"(c)); |
return 0 ; |
} |
static void xputs(char * p) |
{ |
for(;*p;p++) vdprintf_help((*p)&0xff); |
} |
static char dbg_buf[1024]; |
void SDL_printf(const char * fmt,...) |
{ |
va_list ap; |
va_start(ap,fmt); |
vsprintf(dbg_buf,fmt,ap); |
va_end(ap); |
xputs(dbg_buf); |
} |
static void SDL_LookupString(const Uint8 *key, Uint16 *buf, int buflen) |
{ |
/* FIXME: Add code to lookup key in language string hash-table */ |
/* Key not found in language string hash-table */ |
while ( *key && (--buflen > 0) ) { |
*buf++ = *key++; |
} |
*buf = 0; /* NULL terminate string */ |
} |
/* Public functions */ |
void SDL_SetError (const char *fmt, ...) |
{ |
va_list ap; |
SDL_error *error; |
/* Copy in the key, mark error as valid */ |
error = SDL_GetErrBuf(); |
error->error = 1; |
strncpy((char *)error->key, fmt, sizeof(error->key)); |
error->key[sizeof(error->key)-1] = '\0'; |
va_start(ap, fmt); |
error->argc = 0; |
while ( *fmt ) { |
if ( *fmt++ == '%' ) { |
switch (*fmt++) { |
case 0: /* Malformed format string.. */ |
--fmt; |
break; |
#if 0 /* What is a character anyway? (UNICODE issues) */ |
case 'c': |
error->args[error->argc++].value_c = |
va_arg(ap, unsigned char); |
break; |
#endif |
case 'd': |
error->args[error->argc++].value_i = |
va_arg(ap, int); |
break; |
case 'f': |
error->args[error->argc++].value_f = |
va_arg(ap, double); |
break; |
case 'p': |
error->args[error->argc++].value_ptr = |
va_arg(ap, void *); |
break; |
case 's': |
{ |
int index = error->argc; |
strncpy((char *)error->args[index].buf, |
va_arg(ap, char *), ERR_MAX_STRLEN); |
error->args[index].buf[ERR_MAX_STRLEN-1] = 0; |
error->argc++; |
} |
break; |
default: |
break; |
} |
if ( error->argc >= ERR_MAX_ARGS ) { |
break; |
} |
} |
} |
va_end(ap); |
SDL_printf("SDL_SetError: %s\n", SDL_GetError()); |
} |
/* Print out an integer value to a UNICODE buffer */ |
static int PrintInt(Uint16 *str, unsigned int maxlen, int value) |
{ |
char tmp[128]; |
int len, i; |
sprintf(tmp, "%d", value); |
len = 0; |
if ( strlen(tmp) < maxlen ) { |
for ( i=0; tmp[i]; ++i ) { |
*str++ = tmp[i]; |
++len; |
} |
} |
return(len); |
} |
/* Print out a double value to a UNICODE buffer */ |
static int PrintDouble(Uint16 *str, unsigned int maxlen, double value) |
{ |
char tmp[128]; |
int len, i; |
sprintf(tmp, "%f", value); |
len = 0; |
if ( strlen(tmp) < maxlen ) { |
for ( i=0; tmp[i]; ++i ) { |
*str++ = tmp[i]; |
++len; |
} |
} |
return(len); |
} |
/* Print out a pointer value to a UNICODE buffer */ |
static int PrintPointer(Uint16 *str, unsigned int maxlen, void *value) |
{ |
char tmp[128]; |
int len, i; |
sprintf(tmp, "%p", value); |
len = 0; |
if ( strlen(tmp) < maxlen ) { |
for ( i=0; tmp[i]; ++i ) { |
*str++ = tmp[i]; |
++len; |
} |
} |
return(len); |
} |
/* This function has a bit more overhead than most error functions |
so that it supports internationalization and thread-safe errors. |
*/ |
Uint16 *SDL_GetErrorMsgUNICODE(Uint16 *errstr, unsigned int maxlen) |
{ |
SDL_error *error; |
/* Clear the error string */ |
*errstr = 0; --maxlen; |
/* Get the thread-safe error, and print it out */ |
error = SDL_GetErrBuf(); |
if ( error->error ) { |
Uint16 translated[ERR_MAX_STRLEN], *fmt, *msg; |
int len; |
int argi; |
/* Print out the UNICODE error message */ |
SDL_LookupString(error->key, translated, sizeof(translated)); |
msg = errstr; |
argi = 0; |
for ( fmt=translated; *fmt && (maxlen > 0); ) { |
if ( *fmt == '%' ) { |
switch (fmt[1]) { |
case 'S': /* Special SKIP operand */ |
argi += (fmt[2] - '0'); |
++fmt; |
break; |
case '%': |
*msg++ = '%'; |
maxlen -= 1; |
break; |
#if 0 /* What is a character anyway? (UNICODE issues) */ |
case 'c': |
*msg++ = (unsigned char) |
error->args[argi++].value_c; |
maxlen -= 1; |
break; |
#endif |
case 'd': |
len = PrintInt(msg, maxlen, |
error->args[argi++].value_i); |
msg += len; |
maxlen -= len; |
break; |
case 'f': |
len = PrintDouble(msg, maxlen, |
error->args[argi++].value_f); |
msg += len; |
maxlen -= len; |
break; |
case 'p': |
len = PrintPointer(msg, maxlen, |
error->args[argi++].value_ptr); |
msg += len; |
maxlen -= len; |
break; |
case 's': /* UNICODE string */ |
{ Uint16 buf[ERR_MAX_STRLEN], *str; |
SDL_LookupString(error->args[argi++].buf, buf, sizeof(buf)); |
str = buf; |
while ( *str && (maxlen > 0) ) { |
*msg++ = *str++; |
maxlen -= 1; |
} |
} |
break; |
} |
fmt += 2; |
} else { |
*msg++ = *fmt++; |
maxlen -= 1; |
} |
} |
*msg = 0; /* NULL terminate the string */ |
} |
return(errstr); |
} |
Uint8 *SDL_GetErrorMsg(Uint8 *errstr, unsigned int maxlen) |
{ |
Uint16 *errstr16; |
unsigned int i; |
/* Allocate the UNICODE buffer */ |
errstr16 = (Uint16 *)malloc(maxlen * (sizeof *errstr16)); |
if ( ! errstr16 ) { |
strncpy((char *)errstr, "Out of memory", maxlen); |
errstr[maxlen-1] = '\0'; |
return(errstr); |
} |
/* Get the error message */ |
SDL_GetErrorMsgUNICODE(errstr16, maxlen); |
/* Convert from UNICODE to Latin1 encoding */ |
for ( i=0; i<maxlen; ++i ) { |
errstr[i] = (Uint8)errstr16[i]; |
} |
/* Free UNICODE buffer (if necessary) */ |
free(errstr16); |
return(errstr); |
} |
/* Available for backwards compatibility */ |
char *SDL_GetError (void) |
{ |
static char errmsg[SDL_ERRBUFIZE]; |
return((char *)SDL_GetErrorMsg((unsigned char *)errmsg, SDL_ERRBUFIZE)); |
} |
void SDL_ClearError(void) |
{ |
SDL_error *error; |
error = SDL_GetErrBuf(); |
error->error = 0; |
} |
/* Very common errors go here */ |
void SDL_Error(SDL_errorcode code) |
{ |
switch (code) { |
case SDL_ENOMEM: |
SDL_SetError("Out of memory"); |
break; |
case SDL_EFREAD: |
SDL_SetError("Error reading from datastream"); |
break; |
case SDL_EFWRITE: |
SDL_SetError("Error writing to datastream"); |
break; |
case SDL_EFSEEK: |
SDL_SetError("Error seeking in datastream"); |
break; |
default: |
SDL_SetError("Unknown SDL error"); |
break; |
} |
} |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/src/SDL_error_c.h |
---|
0,0 → 1,62 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_error_c.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* This file defines a structure that carries language-independent |
error messages |
*/ |
#ifndef _SDL_error_c_h |
#define _SDL_error_c_h |
#define ERR_MAX_STRLEN 128 |
#define ERR_MAX_ARGS 5 |
typedef struct { |
/* This is a numeric value corresponding to the current error */ |
int error; |
/* This is a key used to index into a language hashtable containing |
internationalized versions of the SDL error messages. If the key |
is not in the hashtable, or no hashtable is available, the key is |
used directly as an error message format string. |
*/ |
unsigned char key[ERR_MAX_STRLEN]; |
/* These are the arguments for the error functions */ |
int argc; |
union { |
void *value_ptr; |
#if 0 /* What is a character anyway? (UNICODE issues) */ |
unsigned char value_c; |
#endif |
int value_i; |
double value_f; |
unsigned char buf[ERR_MAX_STRLEN]; |
} args[ERR_MAX_ARGS]; |
} SDL_error; |
#endif /* _SDL_error_c_h */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/src/SDL_fatal.c |
---|
0,0 → 1,46 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#include <stdlib.h> |
#include <stdio.h> |
#include <signal.h> |
#include <string.h> |
#include <stdarg.h> |
void SDL_printf_error(const char * fmt,...) |
{ |
int pid; |
va_list args; |
va_start(args,fmt); |
vprintf(fmt,args); |
exit(-1); |
} |
void SDL_InstallParachute(void) |
{ |
return; |
} |
void SDL_UninstallParachute(void) |
{ |
return; |
} |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/src/SDL_fatal.h |
---|
0,0 → 1,32 |
/* |
SDL - Simple DirectMedia Layer |
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga |
This library is free software; you can redistribute it and/or |
modify it under the terms of the GNU Library General Public |
License as published by the Free Software Foundation; either |
version 2 of the License, or (at your option) any later version. |
This library is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
Library General Public License for more details. |
You should have received a copy of the GNU Library General Public |
License along with this library; if not, write to the Free |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
Sam Lantinga |
slouken@devolution.com |
*/ |
#ifdef SAVE_RCSID |
static char rcsid = |
"@(#) $Id: SDL_fatal.h,v 1.2 2001/04/26 16:50:17 hercules Exp $"; |
#endif |
/* General fatal signal handling code for SDL */ |
extern void SDL_InstallParachute(void); |
extern void SDL_UninstallParachute(void); |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/src/SDL_getenv.c |
---|
0,0 → 1,171 |
/* Not all environments have a working getenv()/putenv() */ |
#ifdef TEST_MAIN |
#define NEED_SDL_GETENV |
#endif |
#include "SDL_getenv.h" |
#ifdef NEED_SDL_GETENV |
#include <stdlib.h> |
#include <string.h> |
static char **SDL_env = (char **)0; |
/* Put a variable of the form "name=value" into the environment */ |
int SDL_putenv(const char *variable) |
{ |
const char *name, *value; |
int added; |
int len, i; |
char **new_env; |
char *new_variable; |
/* A little error checking */ |
if ( ! variable ) { |
return(-1); |
} |
name = variable; |
for ( value=variable; *value && (*value != '='); ++value ) { |
/* Keep looking for '=' */ ; |
} |
if ( *value ) { |
++value; |
} else { |
return(-1); |
} |
/* Allocate memory for the variable */ |
new_variable = (char *)malloc(strlen(variable)+1); |
if ( ! new_variable ) { |
return(-1); |
} |
strcpy(new_variable, variable); |
/* Actually put it into the environment */ |
added = 0; |
i = 0; |
if ( SDL_env ) { |
/* Check to see if it's already there... */ |
len = (value - name); |
for ( ; SDL_env[i]; ++i ) { |
if ( strncmp(SDL_env[i], name, len) == 0 ) { |
break; |
} |
} |
/* If we found it, just replace the entry */ |
if ( SDL_env[i] ) { |
free(SDL_env[i]); |
SDL_env[i] = new_variable; |
added = 1; |
} |
} |
/* Didn't find it in the environment, expand and add */ |
if ( ! added ) { |
new_env = realloc(SDL_env, (i+2)*sizeof(char *)); |
if ( new_env ) { |
SDL_env = new_env; |
SDL_env[i++] = new_variable; |
SDL_env[i++] = (char *)0; |
added = 1; |
} else { |
free(new_variable); |
} |
} |
return (added ? 0 : -1); |
} |
/* Retrieve a variable named "name" from the environment */ |
char *SDL_getenv(const char *name) |
{ |
int len, i; |
char *value; |
value = (char *)0; |
if ( SDL_env ) { |
len = strlen(name); |
for ( i=0; SDL_env[i] && !value; ++i ) { |
if ( (strncmp(SDL_env[i], name, len) == 0) && |
(SDL_env[i][len] == '=') ) { |
value = &SDL_env[i][len+1]; |
} |
} |
} |
return value; |
} |
#endif /* NEED_GETENV */ |
#ifdef TEST_MAIN |
#include <stdio.h> |
int main(int argc, char *argv[]) |
{ |
char *value; |
printf("Checking for non-existent variable... "); |
fflush(stdout); |
if ( ! getenv("EXISTS") ) { |
printf("okay\n"); |
} else { |
printf("failed\n"); |
} |
printf("Setting FIRST=VALUE1 in the environment... "); |
fflush(stdout); |
if ( putenv("FIRST=VALUE1") == 0 ) { |
printf("okay\n"); |
} else { |
printf("failed\n"); |
} |
printf("Getting FIRST from the environment... "); |
fflush(stdout); |
value = getenv("FIRST"); |
if ( value && (strcmp(value, "VALUE1") == 0) ) { |
printf("okay\n"); |
} else { |
printf("failed\n"); |
} |
printf("Setting SECOND=VALUE2 in the environment... "); |
fflush(stdout); |
if ( putenv("SECOND=VALUE2") == 0 ) { |
printf("okay\n"); |
} else { |
printf("failed\n"); |
} |
printf("Getting SECOND from the environment... "); |
fflush(stdout); |
value = getenv("SECOND"); |
if ( value && (strcmp(value, "VALUE2") == 0) ) { |
printf("okay\n"); |
} else { |
printf("failed\n"); |
} |
printf("Setting FIRST=NOVALUE in the environment... "); |
fflush(stdout); |
if ( putenv("FIRST=NOVALUE") == 0 ) { |
printf("okay\n"); |
} else { |
printf("failed\n"); |
} |
printf("Getting FIRST from the environment... "); |
fflush(stdout); |
value = getenv("FIRST"); |
if ( value && (strcmp(value, "NOVALUE") == 0) ) { |
printf("okay\n"); |
} else { |
printf("failed\n"); |
} |
printf("Checking for non-existent variable... "); |
fflush(stdout); |
if ( ! getenv("EXISTS") ) { |
printf("okay\n"); |
} else { |
printf("failed\n"); |
} |
return(0); |
} |
#endif /* TEST_MAIN */ |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/SDL-1.2.2_newlib/src/compile.sh |
---|
0,0 → 1,5 |
cd SYSCALL/src |
make |
cd ../.. |
make install |
make clean |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |