WebSVN – Kolibri OS – Path Comparison – / – /contrib Rev 8208 and /contrib Rev 8209

Regard whitespace Rev 8208 → Rev 8209

 /contrib/sdk/sources/SDL-1.2.2_newlib/fire-1.0/Makefile
 ,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 → 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[]={
+,1,1,1,2,2,2,2,2,3,3,3,3,3,3,3,
+,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,
+,5,5,5,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,
+,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,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,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,
+,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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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:
+1   2
+0   3
+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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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 → 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

Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 8208 → Rev 8209