;;;
;;; sdl-lib.stub - glue functions for SDL
;;;
;;;  Copyright(C) 2003 by Michael Vess (mvess@michaelvess.com)
;;;
;;;  Permission to use, copy, modify, distribute this software and
;;;  accompanying documentation for any purpose is hereby granted,
;;;  provided that existing copyright notices are retained in all
;;;  copies and that this notice is included verbatim in all
;;;  distributions.
;;;  This software is provided as is, without express or implied
;;;  warranty.  In no circumstances the author(s) shall be liable
;;;  for any damages arising out of the use of this software.
;;;
;;;  $Id: sdl-lib.stub,v 1.15 2003/09/10 17:23:47 mikiso Exp $
;;;

"
#include \"gauche-sdl.h\"
"

;;=============================================================
;; Miscellaneous
;;

(define-type <u8vector> "ScmU8Vector*" "u8vector"
  "SCM_U8VECTORP" "SCM_U8VECTOR")

(define-type <u8vector>-or-null "ScmU8Vector*" "u8vector"
  "SCM_U8VECTOR_OR_NULL_P" "SCM_U8VECTOR_OR_NULL")

(define-type <u16vector> "ScmU16Vector*" "u16vector"
  "SCM_U16VECTORP" "SCM_U16VECTOR")

;;=============================================================
;; Rects
;;

(define-type <sdl-rect> "SDL_Rect*" #f
  "SCM_SDL_RECT_P" "SCM_SDL_RECT")

(define-type <sdl-rect>-or-null "SDL_Rect*" #f
  "SCM_SDL_RECT_OR_NULL_P" "SCM_SDL_RECT_OR_NULL")

(define-cproc sdl-rect? (obj)
  (return <boolean> "SCM_SDL_RECT_P"))

(define-cproc sdl-make-rect (&optional (x::<int> 0) (y::<int> 0) (w::<uint> 0) (h::<uint> 0))
  "ScmSdlRect *r = SCM_NEW(ScmSdlRect);
   SCM_SET_CLASS(r, SCM_CLASS_SDL_RECT);
   r->rect.x = x;
   r->rect.y = y;
   r->rect.w = w;
   r->rect.h = h;
   SCM_RETURN(SCM_OBJ(r));")

(define-cproc sdl-rect-x (r::<sdl-rect>)
  "SCM_RETURN(SCM_MAKE_INT(r->x));")

(define-cproc sdl-rect-x-set! (r::<sdl-rect> n::<int>)
  "r->x = n;
   SCM_RETURN(SCM_UNDEFINED);")

(define-cproc sdl-rect-y (r::<sdl-rect>)
  "SCM_RETURN(SCM_MAKE_INT(r->y));")

(define-cproc sdl-rect-y-set! (r::<sdl-rect> n::<int>)
  "r->y = n;
   SCM_RETURN(SCM_UNDEFINED);")

(define-cproc sdl-rect-w (r::<sdl-rect>)
  "SCM_RETURN(SCM_MAKE_INT(r->w));")

(define-cproc sdl-rect-w-set! (r::<sdl-rect> n::<uint>)
  "r->w = n;
   SCM_RETURN(SCM_UNDEFINED);")

(define-cproc sdl-rect-h (r::<sdl-rect>)
  "SCM_RETURN(SCM_MAKE_INT(r->h));")

(define-cproc sdl-rect-h-set! (r::<sdl-rect> n::<uint>)
  "r->h = n;
   SCM_RETURN(SCM_UNDEFINED);")


;;=============================================================
;; Color
;;

(define-type <sdl-color> "SDL_Color*" #f
  "SCM_SDL_COLOR_P" "SCM_SDL_COLOR")

(define-type <sdl-color>-or-null "SDL_Color*" #f
  "SCM_SDL_COLOR_OR_NULL_P" "SCM_SDL_COLOR_OR_NULL")

(define-cproc sdl-color? (obj)
  (return <boolean> "SCM_SDL_COLOR_P"))

(define-cproc sdl-make-color (r::<int> g::<int> b::<int>)
  "ScmSdlColor *c = SCM_NEW(ScmSdlColor);
   SCM_SET_CLASS(c, SCM_CLASS_SDL_COLOR);
   c->color.r = r;
   c->color.g = g;
   c->color.b = b;
   SCM_RETURN(SCM_OBJ(c));")

(define-cproc sdl-color-r (c::<sdl-color>)
  "SCM_RETURN(SCM_MAKE_INT(c->r));")

(define-cproc sdl-color-r-set! (c::<sdl-color> r::<int>)
  "c->r = r;
   SCM_RETURN(SCM_UNDEFINED);")

(define-cproc sdl-color-g (c::<sdl-color>)
  "SCM_RETURN(SCM_MAKE_INT(c->g));")

(define-cproc sdl-color-g-set! (c::<sdl-color> g::<int>)
  "c->g = g;
   SCM_RETURN(SCM_UNDEFINED);")

(define-cproc sdl-color-b (c::<sdl-color>)
  "SCM_RETURN(SCM_MAKE_INT(c->b));")

(define-cproc sdl-color-b-set! (c::<sdl-color> b::<int>)
  "c->b = b;
   SCM_RETURN(SCM_UNDEFINED);")


;;=============================================================
;; Palette
;;

(define-type <sdl-palette> "SDL_Palette*" #f
  "SCM_SDL_PALETTE_P" "SCM_SDL_PALETTE")

(define-type <sdl-palette>-or-null "SDL_Palette*" #f
  "SCM_SDL_PALETTE_OR_NULL_P" "SCM_SDL_PALETTE_OR_NULL")

(define-cproc sdl-palette? (obj)
  (return <boolean> "SCM_SDL_PALETTE_P"))

(define-cproc sdl-palette-ncolors (p::<sdl-palette>)
  "SCM_RETURN(SCM_MAKE_INT(p->ncolors));")

(define-cproc sdl-palette-color-ref (p::<sdl-palette> i::<int>)
  "ScmSdlColor *c = SCM_NEW(ScmSdlColor);
   SCM_SET_CLASS(c, SCM_CLASS_SDL_COLOR);
   c->color = p->colors[i];
   SCM_RETURN(SCM_OBJ(c));")


;;=============================================================
;; Pixel-Format
;;

(define-type <sdl-pixel-format> "SDL_PixelFormat*" #f
  "SCM_SDL_PIXEL_FORMAT_P" "SCM_SDL_PIXEL_FORMAT")

(define-type <sdl-pixel-format>-or-null "SDL_PixelFormat*" #f
  "SCM_SDL_PIXEL_FORMAT_OR_NULL_P" "SCM_SDL_PIXEL_FORMAT_OR_NULL")

(define-cproc sdl-pixel-format? (obj)
  (return <boolean> "SCM_SDL_PIXEL_FORMAT_P"))

(define-cproc sdl-pixel-format-palette (pf::<sdl-pixel-format>)
  "ScmSdlPalette *p = SCM_NEW(ScmSdlPalette);
   SCM_SET_CLASS(p, SCM_CLASS_SDL_PALETTE);
   p->palette = *(pf->palette);
   SCM_RETURN(SCM_OBJ(p));")

(define-cproc sdl-pixel-format-bits-per-pixel (pf::<sdl-pixel-format>)
  "SCM_RETURN(SCM_MAKE_INT(pf->BitsPerPixel));")

(define-cproc sdl-pixel-format-bytes-per-pixel (pf::<sdl-pixel-format>)
  "SCM_RETURN(SCM_MAKE_INT(pf->BytesPerPixel));")

(define-cproc sdl-pixel-format-rmask (pf::<sdl-pixel-format>)
  "SCM_RETURN(SCM_MAKE_INT(pf->Rmask));")

(define-cproc sdl-pixel-format-gmask (pf::<sdl-pixel-format>)
  "SCM_RETURN(SCM_MAKE_INT(pf->Gmask));")

(define-cproc sdl-pixel-format-bmask (pf::<sdl-pixel-format>)
  "SCM_RETURN(SCM_MAKE_INT(pf->Bmask));")

(define-cproc sdl-pixel-format-amask (pf::<sdl-pixel-format>)
  "SCM_RETURN(SCM_MAKE_INT(pf->Amask));")

(define-cproc sdl-pixel-format-gshift (pf::<sdl-pixel-format>)
  "SCM_RETURN(SCM_MAKE_INT(pf->Gshift));")

(define-cproc sdl-pixel-format-bshift (pf::<sdl-pixel-format>)
  "SCM_RETURN(SCM_MAKE_INT(pf->Bshift));")

(define-cproc sdl-pixel-format-ashift (pf::<sdl-pixel-format>)
  "SCM_RETURN(SCM_MAKE_INT(pf->Ashift));")

(define-cproc sdl-pixel-format-gloss (pf::<sdl-pixel-format>)
  "SCM_RETURN(SCM_MAKE_INT(pf->Gloss));")

(define-cproc sdl-pixel-format-bloss (pf::<sdl-pixel-format>)
  "SCM_RETURN(SCM_MAKE_INT(pf->Bloss));")

(define-cproc sdl-pixel-format-aloss (pf::<sdl-pixel-format>)
  "SCM_RETURN(SCM_MAKE_INT(pf->Aloss));")

(define-cproc sdl-pixel-format-color-key (pf::<sdl-pixel-format>)
  "SCM_RETURN(SCM_MAKE_INT(pf->colorkey));")

(define-cproc sdl-pixel-format-alpha (pf::<sdl-pixel-format>)
  "SCM_RETURN(SCM_MAKE_INT(pf->alpha));")



;;=============================================================
;; Surface
;;

(define-type <sdl-surface> "SDL_Surface*" #f
  "SCM_SDL_SURFACE_P" "SCM_SDL_SURFACE")

(define-type <sdl-surface>-or-null "SDL_Surface*" #f
  "SCM_SDL_SURFACE_OR_NULL_P" "SCM_SDL_SURFACE_OR_NULL")

(define-cproc sdl-surface? (obj)
  (return <boolean> "SCM_SDL_SURFACE_P"))

(define-cproc sdl-surface-flags (s::<sdl-surface>)
  "SCM_RETURN(SCM_MAKE_INT(s->flags));")

(define-cproc sdl-surface-pixel-format (s::<sdl-surface>)
  "ScmSdlPixelFormat *pf = SCM_NEW(ScmSdlPixelFormat);
   SCM_SET_CLASS(pf, SCM_CLASS_SDL_PIXEL_FORMAT);
   pf->format = s->format;
   SCM_RETURN(SCM_OBJ(pf));")

(define-cproc sdl-surface-w (s::<sdl-surface>)
  "SCM_RETURN(SCM_MAKE_INT(s->w));")

(define-cproc sdl-surface-h (s::<sdl-surface>)
  "SCM_RETURN(SCM_MAKE_INT(s->h));")

(define-cproc sdl-surface-pitch (s::<sdl-surface>)
  "SCM_RETURN(SCM_MAKE_INT(s->pitch));")

(define-cproc sdl-surface-pixels (s::<sdl-surface>)
  "int size = s->w * s->h * s->format->BytesPerPixel;
   SCM_RETURN(Scm_MakeU8VectorFromArrayShared(size, s->pixels));")

(define-cproc sdl-surface-clip-rect (s::<sdl-surface>)
  "ScmSdlRect *r = SCM_NEW(ScmSdlRect);
   SCM_SET_CLASS(r, SCM_CLASS_SDL_RECT);
   r->rect = s->clip_rect;
   SCM_RETURN(SCM_OBJ(r));")


;;=============================================================
;; VideoInfo
;;

(define-type <sdl-video-info> "SDL_VideoInfo*" #f
  "SCM_SDL_VIDEO_INFO_P" "SCM_SDL_VIDEO_INFO")

(define-cproc sdl-video-info? (obj)
  (return <boolean> "SCM_SDL_VIDEO_INFO_P"))

(define-cproc sdl-video-info-hw-available (i::<sdl-video-info>)
  "SCM_RETURN(SCM_MAKE_INT(i->hw_available));")

(define-cproc sdl-video-info-wm-available (i::<sdl-video-info>)
  "SCM_RETURN(SCM_MAKE_INT(i->wm_available));")

(define-cproc sdl-video-info-blit-hw (i::<sdl-video-info>)
  "SCM_RETURN(SCM_MAKE_INT(i->blit_hw));")

(define-cproc sdl-video-info-blit-hw-cc (i::<sdl-video-info>)
  "SCM_RETURN(SCM_MAKE_INT(i->blit_hw_CC));")

(define-cproc sdl-video-info-blit-hw-a (i::<sdl-video-info>)
  "SCM_RETURN(SCM_MAKE_INT(i->blit_hw_A));")

(define-cproc sdl-video-info-blit-sw (i::<sdl-video-info>)
  "SCM_RETURN(SCM_MAKE_INT(i->blit_sw));")

(define-cproc sdl-video-info-blit-sw-cc (i::<sdl-video-info>)
  "SCM_RETURN(SCM_MAKE_INT(i->blit_sw_CC));")

(define-cproc sdl-video-info-blit-sw-a (i::<sdl-video-info>)
  "SCM_RETURN(SCM_MAKE_INT(i->blit_sw_A));")

(define-cproc sdl-video-info-blit-fill (i::<sdl-video-info>)
  "SCM_RETURN(SCM_MAKE_INT(i->blit_fill));")

(define-cproc sdl-video-info-video-mem (i::<sdl-video-info>)
  "SCM_RETURN(SCM_MAKE_INT(i->video_mem));")

(define-cproc sdl-video-vfmt (i::<sdl-video-info>)
  "ScmSdlPixelFormat *pf = SCM_NEW(ScmSdlPixelFormat);
   SCM_SET_CLASS(pf, SCM_CLASS_SDL_PIXEL_FORMAT);
   pf->format = i->vfmt;
   SCM_RETURN(SCM_OBJ(pf));")


;;=============================================================
;; Overlay
;;

(define-type <sdl-overlay> "SDL_Overlay*" #f
  "SCM_SDL_OVERLAY_P" "SCM_SDL_OVERLAY")

(define-type <sdl-overlay>-or-null "SDL_Overlay*" #f
  "SCM_SDL_OVERLAY_OR_NULL_P" "SCM_SDL_OVERLAY_OR_NULL")

(define-cproc sdl-overlay? (obj)
  (return <boolean> "SCM_SDL_OVERLAY_P"))

(define-cproc sdl-overlay-format (s::<sdl-overlay>)
  "SCM_RETURN(SCM_MAKE_INT(s->format));")

(define-cproc sdl-overlay-w (s::<sdl-overlay>)
  "SCM_RETURN(SCM_MAKE_INT(s->w));")

(define-cproc sdl-overlay-h (s::<sdl-overlay>)
  "SCM_RETURN(SCM_MAKE_INT(s->h));")

(define-cproc sdl-overlay-planes (s::<sdl-overlay>)
  "SCM_RETURN(SCM_MAKE_INT(s->planes));")

(define-cproc sdl-overlay-hw-overlay (s::<sdl-overlay>)
  "SCM_RETURN(SCM_MAKE_INT(s->hw_overlay));")


;;=============================================================
;; Cursor
;;

(define-type <sdl-cursor> "SDL_Cursor*" #f
  "SCM_SDL_CURSOR_P" "SCM_SDL_CURSOR")

(define-type <sdl-cursor>-or-null "SDL_Cursor*" #f
  "SCM_SDL_CURSOR_OR_NULL_P" "SCM_SDL_CURSOR_OR_NULL")

(define-cproc sdl-cursor? (obj)
  (return <boolean> "SCM_SDL_CURSOR_P"))

(define-cproc sdl-cursor-area (c::<sdl-cursor>)
  "ScmSdlRect *r = SCM_NEW(ScmSdlRect);
   SCM_SET_CLASS(r, SCM_CLASS_SDL_RECT);
   r->rect = c->area;
   SCM_RETURN(SCM_OBJ(r));")

(define-cproc sdl-cursor-hot-x (c::<sdl-cursor>)
  "SCM_RETURN(SCM_MAKE_INT(c->hot_x));")

(define-cproc sdl-cursor-hot-y (c::<sdl-cursor>)
  "SCM_RETURN(SCM_MAKE_INT(c->hot_y));")


;;=============================================================
;; Event
;;

(define-type <sdl-event> "SDL_Event*" #f
  "SCM_SDL_EVENT_P" "SCM_SDL_EVENT")

(define-type <sdl-event>-or-null "SDL_Event*" #f
  "SCM_SDL_EVENT_OR_NULL_P" "SCM_SDL_EVENT_OR_NULL")

(define-cproc sdl-event? (obj)
  (return <boolean> "SCM_SDL_EVENT_P"))

(define-cproc sdl-make-event (&optional (type::<int> 0))
  "ScmSdlEvent *e = SCM_NEW(ScmSdlEvent);
   SCM_SET_CLASS(e, SCM_CLASS_SDL_EVENT);
   e->event.type = type;
   SCM_RETURN(SCM_OBJ(e));")

(define-cproc sdl-event-type (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->type));")

(define-cproc sdl-event-active-type (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->active.type));")

(define-cproc sdl-event-active-gain (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->active.gain));")

(define-cproc sdl-event-active-state (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->active.state));")

(define-cproc sdl-event-key-type (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->key.type));")

(define-cproc sdl-event-key-state (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->key.state));")

(define-cproc sdl-event-key-keysym-scancode (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->key.keysym.scancode));")

(define-cproc sdl-event-key-keysym-sym (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->key.keysym.sym));")

(define-cproc sdl-event-key-keysym-mod (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->key.keysym.mod));")

(define-cproc sdl-event-key-keysym-unicode (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->key.keysym.unicode));")

(define-cproc sdl-event-motion-type (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->motion.type));")

(define-cproc sdl-event-motion-state (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->motion.state));")

(define-cproc sdl-event-motion-state-set! (e::<sdl-event> state::<int>)
  "e->motion.state = state;
   SCM_RETURN(SCM_UNDEFINED);")

(define-cproc sdl-event-motion-x (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->motion.x));")

(define-cproc sdl-event-motion-x-set! (e::<sdl-event> x::<int>)
  "e->motion.x = x;
   SCM_RETURN(SCM_UNDEFINED);")

(define-cproc sdl-event-motion-y (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->motion.y));")

(define-cproc sdl-event-motion-y-set! (e::<sdl-event> y::<int>)
  "e->motion.y = y;
   SCM_RETURN(SCM_UNDEFINED);")

(define-cproc sdl-event-motion-xrel (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->motion.xrel));")

(define-cproc sdl-event-motion-yrel (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->motion.yrel));")

(define-cproc sdl-event-button-type (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->button.type));")

(define-cproc sdl-event-button-button (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->button.button));")

(define-cproc sdl-event-button-state (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->button.state));")

(define-cproc sdl-event-button-x (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->button.x));")

(define-cproc sdl-event-button-y (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->button.y));")

(define-cproc sdl-event-jaxis-type (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jaxis.type));")

(define-cproc sdl-event-jaxis-which (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jaxis.which));")

(define-cproc sdl-event-jaxis-axis (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jaxis.axis));")

(define-cproc sdl-event-jaxis-value (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jaxis.value));")

(define-cproc sdl-event-jball-type (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jball.type));")

(define-cproc sdl-event-jball-which (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jball.which));")

(define-cproc sdl-event-jball-ball (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jball.ball));")

(define-cproc sdl-event-jball-xrel (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jball.xrel));")

(define-cproc sdl-event-jball-yrel (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jball.yrel));")

(define-cproc sdl-event-jhat-type (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jhat.type));")

(define-cproc sdl-event-jhat-which (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jhat.which));")

(define-cproc sdl-event-jhat-hat (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jhat.hat));")

(define-cproc sdl-event-jhat-value (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jhat.value));")

(define-cproc sdl-event-jbutton-type (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jbutton.type));")

(define-cproc sdl-event-jbutton-which (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jbutton.which));")

(define-cproc sdl-event-jbutton-button (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jbutton.button));")

(define-cproc sdl-event-jbutton-state (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->jbutton.state));")

(define-cproc sdl-event-resize-type (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->resize.type));")

(define-cproc sdl-event-resize-w (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->resize.w));")

(define-cproc sdl-event-resize-h (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->resize.h));")

(define-cproc sdl-event-expose-type (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->expose.type));")

(define-cproc sdl-event-quit-type (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->quit.type));")

(define-cproc sdl-event-user-type (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->user.type));")

(define-cproc sdl-event-user-code (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->user.code));")

;;(define-cproc sdl-event-user-data1 (e::<sdl-event>)
;;  "SCM_RETURN(e->user.data1);")

;;(define-cproc sdl-event-user-data2 (e::<sdl-event>)
;;  "SCM_RETURN(e->user.data2);")

(define-cproc sdl-event-syswm-type (e::<sdl-event>)
  "SCM_RETURN(SCM_MAKE_INT(e->syswm.type));")



;;=============================================================
;; Joystick
;;

(define-type <sdl-joystick> "SDL_Joystick*" #f
  "SCM_SDL_JOYSTICK_P" "SCM_SDL_JOYSTICK")

(define-type <sdl-joystick>-or-null "SDL_Joystick*" #f
  "SCM_SDL_JOYSTICK_OR_NULL_P" "SCM_SDL_JOYSTICK_OR_NULL")

(define-cproc sdl-joystick? (obj)
  (return <boolean> "SCM_SDL_JOYSTICK_P"))


;;=============================================================
;; AudioSpec
;;

(define-type <sdl-audio-spec> "SDL_AudioSpec*" #f
  "SCM_SDL_AUDIO_SPEC_P" "SCM_SDL_AUDIO_SPEC")

(define-type <sdl-audio-spec>-or-null "SDL_AudioSpec*" #f
  "SCM_SDL_AUDIO_SPEC_OR_NULL_P" "SCM_SDL_AUDIO_SPEC_OR_NULL")

(define-cproc sdl-audio-spec? (obj)
  (return <boolean> "SCM_SDL_AUDIO_SPEC_P"))


;;=============================================================
;; AudioCVT
;;

(define-type <sdl-audio-cvt> "SDL_AudioCVT*" #f
  "SCM_SDL_AUDIO_CVT_P" "SCM_SDL_AUDIO_CVT")

(define-type <sdl-audio-cvt>-or-null "SDL_AudioCVT*" #f
  "SCM_SDL_AUDIO_CVT_OR_NULL_P" "SCM_SDL_AUDIO_CVT_OR_NULL")

(define-cproc sdl-audio-cvt? (obj)
  (return <boolean> "SCM_SDL_AUDIO_CVT_P"))


;;=============================================================
;; Wav
;;

(define-type <sdl-wav> "ScmSdlWAV*" #f
  "SCM_SDL_WAV_P" "SCM_SDL_WAV")

(define-cproc sdl-wav? (obj)
  (return <boolean> "SCM_SDL_WAV_P"))

(define-cproc sdl-wav-audio-spec (w::<sdl-wav>)
  "ScmSdlAudioSpec *as = SCM_NEW(ScmSdlAudioSpec);
   SCM_SET_CLASS(as, SCM_CLASS_SDL_AUDIO_SPEC);

   as->audio = SCM_SDL_WAV_SPEC(w);

   SCM_RETURN(SCM_OBJ(as));")

(define-cproc sdl-wav-buffer (w::<sdl-wav>)
  "SCM_RETURN(SCM_SDL_WAV_BUFFER(w));")


;;=============================================================
;; CD
;;

(define-type <sdl-cd> "SDL_CD*" #f
  "SCM_SDL_CD_P" "SCM_SDL_CD")

(define-type <sdl-cd>-or-null "SDL_CD*" #f
  "SCM_SDL_CD_OR_NULL_P" "SCM_SDL_CD_OR_NULL")

(define-cproc sdl-cd? (obj)
  (return <boolean> "SCM_SDL_CD_P"))


;;=============================================================
;; CDtrack
;;

(define-type <sdl-cd-track> "SDL_CDtrack*" #f
  "SCM_SDL_CD_TRACK_P" "SCM_SDL_CD_TRACK")

(define-type <sdl-cd-track>-or-null "SDL_CDtrack*" #f
  "SCM_SDL_CD_TRACK_OR_NULL_P" "SCM_SDL_CD_TRACK_OR_NULL")

(define-cproc sdl-cd-track? (obj)
  (return <boolean> "SCM_SDL_CD_TRACK_P"))


;;=============================================================
;; RWops
;;

(define-type <sdl-rwops> "SDL_RWops*" #f
  "SCM_SDL_RWOPS_P" "SCM_SDL_RWOPS")

(define-type <sdl-rwops>-or-null "SDL_RWops*" #f
  "SCM_SDL_RWOPS_OR_NULL_P" "SCM_SDL_RWOPS_OR_NULL")

(define-cproc sdl-rwops? (obj)
  (return <boolean> "SCM_SDL_RWOPS_P"))


;;=============================================================
;; General
;;

(define-cproc sdl-init (flags::<uint>)
  (return <int> "SDL_Init"))

(define-cproc sdl-init-subsystem (flags::<uint>)
  (return <int> "SDL_InitSubSystem"))

(define-cproc sdl-quit ()
  (return <void> "SDL_Quit"))

(define-cproc sdl-quit-subsystem (flags::<uint>)
  (return <void> "SDL_QuitSubSystem"))

(define-cproc sdl-was-init (flags::<uint>)
  (return <uint> "SDL_WasInit"))

(define-cproc sdl-get-error ()
  "SCM_RETURN(SCM_MAKE_STR(SDL_GetError()));")


;;=============================================================
;; Video
;;

(define-cproc sdl-get-video-surface ()
  "ScmSdlSurface *s = SCM_NEW(ScmSdlSurface);
   SCM_SET_CLASS(s, SCM_CLASS_SDL_SURFACE);
   s->surface = SDL_GetVideoSurface();
   SCM_RETURN(SCM_OBJ(s));")

(define-cproc sdl-get-video-info ()
  "ScmSdlVideoInfo *i = SCM_NEW(ScmSdlVideoInfo);
   SCM_SET_CLASS(i, SCM_CLASS_SDL_VIDEO_INFO);
   i->info = (SDL_VideoInfo*)SDL_GetVideoInfo();
   SCM_RETURN(SCM_OBJ(i));")

(define-cproc sdl-video-driver-name ()
  "char name[129]; ScmObj s;
   SDL_VideoDriverName(name, 128);
   s = Scm_MakeString(name, -1, -1, 0);
   SCM_RETURN(SCM_OBJ(s));")

(define-cproc sdl-list-modes (format::<sdl-pixel-format>-or-null flags::<uint>)
  "int i;
   ScmSdlRect *r;
   ScmObj list = SCM_NIL;
   SDL_Rect **modes = SDL_ListModes(format, flags);

   if (modes == NULL) SCM_RETURN(SCM_NIL);

   if (modes == (SDL_Rect**)-1) SCM_RETURN(SCM_MAKE_INT(-1));

   for (i = 0; modes[i]; i++) {
     r = SCM_NEW(ScmSdlRect);
     SCM_SET_CLASS(r, SCM_CLASS_SDL_RECT);
     r->rect.w = modes[i]->w;
     r->rect.h = modes[i]->h;
     list = Scm_Cons(SCM_OBJ(r), list);
   }

   SCM_RETURN(SCM_OBJ(list));")

(define-cproc sdl-video-mode-ok (width::<int> height::<int> bpp::<int>
                                 flags::<int>)
  (return <int> "SDL_VideoModeOK"))

(define-cproc sdl-set-video-mode (width::<int> height::<int> bpp::<int>
                                  flags::<int>)
  "ScmSdlSurface *s = SCM_NEW(ScmSdlSurface);
   SCM_SET_CLASS(s, SCM_CLASS_SDL_SURFACE);
   s->surface = SDL_SetVideoMode(width, height, bpp, flags);
   SCM_RETURN(SCM_OBJ(s));")

(define-cproc sdl-update-rect (screen::<sdl-surface> x::<int> y::<int>
                               w::<int> h::<int>)
  (return <void> "SDL_UpdateRect"))

(define-cproc sdl-update-rects (screen::<sdl-surface> numrects::<int>
                                rects::<list>)
  "ScmObj list = rects;
   SDL_Rect temp_rects[numrects];
   int i;

   for (i = 0; i < numrects; i++) {
     temp_rects[i] = *(SCM_SDL_RECT(SCM_CAR(list)));
     list = SCM_CDR(list);
   }

   SDL_UpdateRects(screen, numrects, temp_rects);

   SCM_RETURN(SCM_UNDEFINED);")

(define-cproc sdl-flip (screen::<sdl-surface>)
  (return <int> "SDL_Flip"))

(define-cproc sdl-set-colors (surface::<sdl-surface> colors::<list>
                              firstcolor::<int> ncolors::<int>)
  "ScmObj list = colors;
   SDL_Color temp_colors[ncolors];
   int i;

   for (i = 0; i < ncolors; i++) {
     temp_colors[i] = *(SCM_SDL_COLOR(SCM_CAR(list)));
     list = SCM_CDR(list);
   }

   SCM_RETURN(SCM_MAKE_INT(SDL_SetColors(surface, temp_colors, firstcolor,
                           ncolors)));")

(define-cproc sdl-set-palette (surface::<sdl-surface> flags::<int>
                               colors::<list> firstcolor::<int>
                               ncolors::<int>)
  "ScmObj list = colors;
   SDL_Color temp_colors[ncolors];
   int i;

   for (i = 0; i < ncolors; i++) {
     temp_colors[i] = *(SCM_SDL_COLOR(SCM_CAR(list)));
     list = SCM_CDR(list);
   }

   SCM_RETURN(SCM_MAKE_INT(SDL_SetPalette(surface, flags, temp_colors, firstcolor, ncolors)));")


(define-cproc sdl-set-gamma (redgamma::<float> greengamma::<float>
                             bluegamma::<float>)
  (return <int> "SDL_SetGamma"))

(define-cproc sdl-get-gamma-ramp (redtable::<u16vector> greentable::<u16vector>
                                  bluetable::<u16vector>)
  "int result;
   if (SCM_U16VECTOR_SIZE(redtable) != 256) {
     Scm_Error(\"u16vector of size 256 required, but got %S\", redtable);
   }
   if (SCM_U16VECTOR_SIZE(greentable) != 256) {
     Scm_Error(\"u16vector of size 256 requigreen, but got %S\", greentable);
   }
   if (SCM_U16VECTOR_SIZE(bluetable) != 256) {
     Scm_Error(\"u16vector of size 256 requiblue, but got %S\", bluetable);
   }

   result = SDL_GetGammaRamp(SCM_U16VECTOR_ELEMENTS(redtable),
                             SCM_U16VECTOR_ELEMENTS(greentable),
                             SCM_U16VECTOR_ELEMENTS(bluetable));

   SCM_RETURN(SCM_MAKE_INT(result));")

(define-cproc sdl-set-gamma-ramp (redtable::<u16vector> greentable::<u16vector>
                                  bluetable::<u16vector>)
  "int result;
   if (SCM_U16VECTOR_SIZE(redtable) != 256) {
     Scm_Error(\"u16vector of size 256 required, but got %S\", redtable);
   }
   if (SCM_U16VECTOR_SIZE(greentable) != 256) {
     Scm_Error(\"u16vector of size 256 requigreen, but got %S\", greentable);
   }
   if (SCM_U16VECTOR_SIZE(bluetable) != 256) {
     Scm_Error(\"u16vector of size 256 requiblue, but got %S\", bluetable);
   }

   result = SDL_SetGammaRamp(SCM_U16VECTOR_ELEMENTS(redtable),
                             SCM_U16VECTOR_ELEMENTS(greentable),
                             SCM_U16VECTOR_ELEMENTS(bluetable));

   SCM_RETURN(SCM_MAKE_INT(result));")

(define-cproc sdl-map-rgb (pf::<sdl-pixel-format> r::<int> g::<int> b::<int>)
  (return <int> "SDL_MapRGB"))

(define-cproc sdl-map-rgba (pf::<sdl-pixel-format> r::<int> g::<int> b::<int>
                            a::<int>)
  (return <int> "SDL_MapRGBA"))

(define-cproc sdl-get-rgb (pixel::<uint> format::<sdl-pixel-format>)
  "unsigned char r, g, b;

   SDL_GetRGB(pixel, format, &r, &g, &b);

   SCM_RETURN(SCM_LIST3(SCM_MAKE_INT(r), SCM_MAKE_INT(g), SCM_MAKE_INT(b)));")

(define-cproc sdl-get-rgba (pixel::<uint> format::<sdl-pixel-format>)
  "unsigned char r, g, b, a;

   SDL_GetRGBA(pixel, format, &r, &g, &b, &a);

   SCM_RETURN(SCM_LIST4(SCM_MAKE_INT(r), SCM_MAKE_INT(g), SCM_MAKE_INT(b),
                        SCM_MAKE_INT(a)));")

(define-cproc sdl-create-rgb-surface (flags::<uint> width::<int> height::<int>
                                      depth::<int> Rmask::<uint> Gmask::<uint>
                                      Bmask::<uint> Amask::<uint>)
  "ScmSdlSurface *s = SCM_NEW(ScmSdlSurface);
   SCM_SET_CLASS(s, SCM_CLASS_SDL_SURFACE);
   s->surface = SDL_CreateRGBSurface(flags, width, height, depth, Rmask, Gmask,
                                     Bmask, Amask);
   Scm_RegisterFinalizer(SCM_OBJ(s), sdl_surface_finalize, NULL);
   SCM_RETURN(SCM_OBJ(s));")

(define-cproc sdl-create-rgb-surface-from (pixels::<u8vector> width::<int>
                                           height::<int> depth::<int>
                                           pitch::<int> Rmask::<uint>
                                           Gmask::<uint> Bmask::<uint>
                                           Amask::<uint>)
  "ScmSdlSurface *s = SCM_NEW(ScmSdlSurface);
   SCM_SET_CLASS(s, SCM_CLASS_SDL_SURFACE);
   s->surface = SDL_CreateRGBSurfaceFrom(SCM_U8VECTOR_ELEMENTS(pixels), width,
                                         height, depth, pitch, Rmask, Gmask,
                                         Bmask, Amask);
   Scm_RegisterFinalizer(SCM_OBJ(s), sdl_surface_finalize, NULL);
   SCM_RETURN(SCM_OBJ(s));")

(define-cproc sdl-must-lock (src::<sdl-surface>)
  "if (SDL_MUSTLOCK(src))
     SCM_RETURN(SCM_TRUE);
   else
     SCM_RETURN(SCM_FALSE);")

(define-cproc sdl-lock-surface (src::<sdl-surface>)
  (return <int> "SDL_LockSurface"))

(define-cproc sdl-unlock-surface (src::<sdl-surface>)
  (return <void> "SDL_UnlockSurface"))

(define-cproc sdl-load-bmp (file::<string>)
  "ScmSdlSurface *s = SCM_NEW(ScmSdlSurface);
   SCM_SET_CLASS(s, SCM_CLASS_SDL_SURFACE);
   s->surface = SDL_LoadBMP((const char *)(SCM_STRING_START(file)));

   if (s->surface == NULL) SCM_RETURN(SCM_UNDEFINED);

   Scm_RegisterFinalizer(SCM_OBJ(s), sdl_surface_finalize, NULL);
   SCM_RETURN(SCM_OBJ(s));")

(define-cproc sdl-save-bmp (surface::<sdl-surface> file::<string>)
  "int result = SDL_SaveBMP(surface, (const char *)(SCM_STRING_START(file)));
   SCM_RETURN(SCM_MAKE_INT(result));")

(define-cproc sdl-set-color-key (surface::<sdl-surface> flag::<uint> key::<uint>)
  (return <int> "SDL_SetColorKey"))

(define-cproc sdl-set-alpha (surface::<sdl-surface> flag::<uint> alpha::<uint>)
  (return <int> "SDL_SetAlpha"))

(define-cproc sdl-set-clip-rect (surface::<sdl-surface> rect::<sdl-rect>-or-null)
  (return <void> "SDL_SetClipRect"))

(define-cproc sdl-get-clip-rect (surface::<sdl-surface> rect::<sdl-rect>)
  (return <void> "SDL_GetClipRect"))

(define-cproc sdl-convert-surface (src::<sdl-surface> fmt::<sdl-pixel-format> flags::<uint>)
  "ScmSdlSurface *s = SCM_NEW(ScmSdlSurface);
   SCM_SET_CLASS(s, SCM_CLASS_SDL_SURFACE);
   s->surface = SDL_ConvertSurface(src, fmt, flags);
   Scm_RegisterFinalizer(SCM_OBJ(s), sdl_surface_finalize, NULL);
   SCM_RETURN(SCM_OBJ(s));")


(define-cproc sdl-blit-surface (src::<sdl-surface>
                                srcrect::<sdl-rect>-or-null
                                dst::<sdl-surface>
                                dstrect::<sdl-rect>-or-null)
  (return <int> "SDL_BlitSurface"))

(define-cproc sdl-fill-rect (dst::<sdl-surface> dstrect::<sdl-rect>-or-null color::<uint>)
  (return <int> "SDL_FillRect"))

(define-cproc sdl-display-format (surface::<sdl-surface>)
  "ScmSdlSurface *s = SCM_NEW(ScmSdlSurface);
   SCM_SET_CLASS(s, SCM_CLASS_SDL_SURFACE);
   s->surface = SDL_DisplayFormat(surface);
   Scm_RegisterFinalizer(SCM_OBJ(s), sdl_surface_finalize, NULL);
   SCM_RETURN(SCM_OBJ(s));")

(define-cproc sdl-display-format-alpha (surface::<sdl-surface>)
  "ScmSdlSurface *s = SCM_NEW(ScmSdlSurface);
   SCM_SET_CLASS(s, SCM_CLASS_SDL_SURFACE);
   s->surface = SDL_DisplayFormatAlpha(surface);
   Scm_RegisterFinalizer(SCM_OBJ(s), sdl_surface_finalize, NULL);
   SCM_RETURN(SCM_OBJ(s));")

(define-cproc sdl-warp-mouse (x::<uint> y::<uint>)
  (return <void> "SDL_WarpMouse"))

(define-cproc sdl-create-cursor (data::<u8vector> mask::<u8vector> w::<int>
                                 h::<int> hot_x::<int> hot_y::<int>)
  "ScmSdlCursor *c = SCM_NEW(ScmSdlCursor);
   SCM_SET_CLASS(c, SCM_CLASS_SDL_CURSOR);
   c->cursor = SDL_CreateCursor(SCM_U8VECTOR_ELEMENTS(data),
                                SCM_U8VECTOR_ELEMENTS(mask), w, h, hot_x,
                                hot_y);
   Scm_RegisterFinalizer(SCM_OBJ(c), sdl_cursor_finalize, NULL);
   SCM_RETURN(SCM_OBJ(c));")


(define-cproc sdl-set-cursor (cursor::<sdl-cursor>)
  (return <void> "SDL_SetCursor"))

(define-cproc sdl-get-cursor ()
  "ScmSdlCursor *c = SCM_NEW(ScmSdlCursor);
   SCM_SET_CLASS(c, SCM_CLASS_SDL_CURSOR);
   c->cursor = SDL_GetCursor();
   Scm_RegisterFinalizer(SCM_OBJ(c), sdl_cursor_finalize, NULL);
   SCM_RETURN(SCM_OBJ(c));")

(define-cproc sdl-show-cursor (toggle::<int>)
  (return <int> "SDL_ShowCursor"))

(define-cproc sdl-gl-load-library (path::<string>)
  "int result = SDL_GL_LoadLibrary((const char *)(SCM_STRING_START(path)));
   SCM_RETURN(SCM_MAKE_INT(result));")

;; MISSING:
;; MISSING: SDL_GL_GetProcAddress
;; MISSING:

(define-cproc sdl-gl-get-attribute (attr::<int>)
  "int value;
   if (SDL_GL_GetAttribute(attr, &value) < 0) {
     SCM_RETURN(SCM_UNDEFINED);
   }
   SCM_RETURN(SCM_MAKE_INT(value));")

(define-cproc sdl-gl-set-attribute (attr::<int> value::<int>)
  (return <int> "SDL_GL_SetAttribute"))


(define-cproc sdl-gl-swap-buffers ()
  (return <void> "SDL_GL_SwapBuffers"))

(define-cproc sdl-create-yuv-overlay (width::<int> height::<int>
                                       format::<uint> display::<sdl-surface>)
  "ScmSdlOverlay *s = SCM_NEW(ScmSdlOverlay);
   SCM_SET_CLASS(s, SCM_CLASS_SDL_OVERLAY);
   s->overlay = SDL_CreateYUVOverlay(width, height, format, display);
   Scm_RegisterFinalizer(SCM_OBJ(s), sdl_overlay_finalize, NULL);
   SCM_RETURN(SCM_OBJ(s));")

(define-cproc sdl-lock-yuv-overlay (overlay::<sdl-overlay>)
  (return <int> "SDL_LockYUVOverlay"))

(define-cproc sdl-unlock-yuv-overlay (overlay::<sdl-overlay>)
  (return <void> "SDL_UnlockYUVOverlay"))

(define-cproc sdl-display-yuv-overlay (overlay::<sdl-overlay> dstrect::<sdl-rect>)
  (return <void> "SDL_DisplayYUVOverlay"))


;;=============================================================
;; Video (Pixel)
;;

(define-cproc get-pixel (surface::<sdl-surface> x::<int> y::<int>)
  "int bpp = surface->format->BytesPerPixel;
   Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

   switch(bpp) {
   case 1:
     SCM_RETURN(SCM_MAKE_INT(*p));

   case 2:
     SCM_RETURN(SCM_MAKE_INT(*(Uint16 *)p));

   case 3:
     if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
       SCM_RETURN(SCM_MAKE_INT(p[0] << 16 | p[1] << 8 | p[2]));
     else
       SCM_RETURN(SCM_MAKE_INT(p[0] | p[1] << 8 | p[2] << 16));

   case 4:
     SCM_RETURN(SCM_MAKE_INT(*(Uint32 *)p));

   default:
     SCM_RETURN(SCM_MAKE_INT(0));
   }")

(define-cproc put-pixel (surface::<sdl-surface> x::<int> y::<int> pixel::<uint>)
  "int bpp = surface->format->BytesPerPixel;
   Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

    switch(bpp) {
    case 1:
      *p = pixel;
      break;

    case 2:
      *(Uint16 *)p = pixel;
      break;

    case 3:
      if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
        p[0] = (pixel >> 16) & 0xff;
        p[1] = (pixel >> 8) & 0xff;
        p[2] = pixel & 0xff;
      } else {
        p[0] = pixel & 0xff;
        p[1] = (pixel >> 8) & 0xff;
        p[2] = (pixel >> 16) & 0xff;
      }
      break;

    case 4:
      *(Uint32 *)p = pixel;
      break;
    }

    SCM_RETURN(SCM_UNDEFINED);")


;;=============================================================
;; Window Management
;;

(define-cproc sdl-wm-set-caption (title::<string> icon::<string>)
  "SDL_WM_SetCaption((const char *)(SCM_STRING_START(title)),
                     (const char *)(SCM_STRING_START(icon)));
   SCM_RETURN(SCM_UNDEFINED);")

(define-cproc sdl-wm-get-caption ()
  "char *title, *icon;

   SDL_WM_GetCaption(&title, &icon);

   SCM_RETURN(SCM_LIST2(SCM_MAKE_STR(title), SCM_MAKE_STR(icon)));")

(define-cproc sdl-wm-set-icon (icon::<sdl-surface> mask::<u8vector>-or-null)
  "if (SCM_U8VECTORP(mask)) {
     SDL_WM_SetIcon(icon, SCM_U8VECTOR_ELEMENTS(mask));
   } else {
     SDL_WM_SetIcon(icon, NULL);
   }
   SCM_RETURN(SCM_UNDEFINED);")

(define-cproc sdl-wm-iconify-window ()
  (return <int> "SDL_WM_IconifyWindow"))

(define-cproc sdl-wm-toggle-full-screen (surface::<sdl-surface>)
  (return <int> "SDL_WM_ToggleFullScreen"))

(define-cproc sdl-wm-grab-input (mode::<int>)
  (return <int> "SDL_WM_GrabInput"))


;;=============================================================
;; Events
;;

(define-cproc sdl-pump-events ()
  (return <void> "SDL_PumpEvents"))

(define-cproc sdl-peep-events (numevents::<int> action::<int> mask::<uint>)
  "ScmSdlEvent *e;
   ScmObj list = SCM_NIL;
   SDL_Event events[numevents];
   int i;
   int result = SDL_PeepEvents(events, numevents, action, mask);

   if (result < 0) SCM_RETURN(SCM_UNDEFINED);

   for (i = 0; i < result; i++)
   {
     e = SCM_NEW(ScmSdlEvent);
     SCM_SET_CLASS(e, SCM_CLASS_SDL_EVENT);

     list = Scm_Cons(SCM_OBJ(e), list);
   }

   SCM_RETURN(SCM_OBJ(list));")

(define-cproc sdl-poll-event (event::<sdl-event>-or-null)
  (return <int> "SDL_PollEvent"))

(define-cproc sdl-wait-event (event::<sdl-event>-or-null)
  (return <int> "SDL_WaitEvent"))

(define-cproc sdl-push-event (event::<sdl-event>-or-null)
  (return <int> "SDL_PushEvent"))

;; MISSING:
;; MISSING: SDL_SetEventFilter
;; MISSING:

;; MISSING:
;; MISSING: SDL_GetEventFilter
;; MISSING:

(define-cproc sdl-event-state (type::<int> state::<int>)
  (return <int> "SDL_EventState"))

(define-cproc sdl-get-key-state (numkeys)
  "Uint8 *keys;
   int num;

   if (SCM_FALSEP(numkeys)) {
     keys = SDL_GetKeyState(NULL);
   } else if (SCM_INTP(numkeys)) {
     num = SCM_INT_VALUE(numkeys);
     keys = SDL_GetKeyState(&num);
   } else {
     Scm_Error(\"<integer> or #f required, but got %S\", numkeys);
   }
   SCM_RETURN(Scm_MakeU8VectorFromArrayShared(SDLK_LAST, keys));")

(define-cproc sdl-get-mod-state ()
  (return <int> "SDL_GetModState"))

(define-cproc sdl-set-mod-state (modstate::<int>)
  (return <void> "SDL_SetModState"))

(define-cproc sdl-get-key-name (key::<int>)
  "char *name;

   name = SDL_GetKeyName(key);

   SCM_RETURN(SCM_MAKE_STR(name));")

(define-cproc sdl-enable-unicode (enable::<int>)
  (return <int> "SDL_EnableUNICODE"))

(define-cproc sdl-enable-key-repeat (delay::<int> interval::<int>)
  (return <int> "SDL_EnableKeyRepeat"))

(define-cproc sdl-get-mouse-state ()
  "int x, y;
   Uint8 button = SDL_GetMouseState(&x, &y);

   SCM_RETURN(SCM_LIST3(SCM_MAKE_INT(button), SCM_MAKE_INT(x),
                        SCM_MAKE_INT(y)));")

(define-cproc sdl-get-relative-mouse-state ()
  "int x, y;
   Uint8 button = SDL_GetRelativeMouseState(&x, &y);

   SCM_RETURN(SCM_LIST3(SCM_MAKE_INT(button), SCM_MAKE_INT(x),
                        SCM_MAKE_INT(y)));")

(define-cproc sdl-get-app-state ()
  (return <int> "SDL_GetAppState"))

(define-cproc sdl-joystick-event-state (state::<int>)
  (return <int> "SDL_JoystickEventState"))


;;=============================================================
;; Joystick
;;

(define-cproc sdl-num-joysticks ()
  (return <int> "SDL_NumJoysticks"))

(define-cproc sdl-joystick-name (index::<int>)
  "const char *name = SDL_JoystickName(index);

   SCM_RETURN(SCM_MAKE_STR(name));")

(define-cproc sdl-joystick-open (index::<int>)
  (return <sdl-joystick> "SDL_JoystickOpen"))

(define-cproc sdl-joystick-opened (index::<int>)
  (return <int> "SDL_JoystickOpened"))

(define-cproc sdl-joystick-index (joystick::<sdl-joystick>)
  (return <int> "SDL_JoystickIndex"))

(define-cproc sdl-joystick-num-axes (joystick::<sdl-joystick>)
  (return <int> "SDL_JoystickNumAxes"))

(define-cproc sdl-joystick-num-balls (joystick::<sdl-joystick>)
  (return <int> "SDL_JoystickNumBalls"))

(define-cproc sdl-joystick-num-hats (joystick::<sdl-joystick>)
  (return <int> "SDL_JoystickNumHats"))

(define-cproc sdl-joystick-num-buttons (joystick::<sdl-joystick>)
  (return <int> "SDL_JoystickNumButtons"))

(define-cproc sdl-joystick-update ()
  (return <void> "SDL_JoystickUpdate"))

(define-cproc sdl-joystick-get-axis (joystick::<sdl-joystick> axis::<int>)
  (return <int> "SDL_JoystickGetAxis"))

(define-cproc sdl-joystick-get-hat (joystick::<sdl-joystick> hat::<int>)
  (return <int> "SDL_JoystickGetHat"))

(define-cproc sdl-joystick-get-button (joystick::<sdl-joystick> button::<int>)
  (return <int> "SDL_JoystickGetButton"))

(define-cproc sdl-joystick-get-ball (joystick::<sdl-joystick> ball::<int>)
  "int x, y;
   int result = SDL_JoystickGetBall(joystick, ball, &x, &y);

   if (result < 0) SCM_RETURN(SCM_UNDEFINED);

   SCM_RETURN(SCM_LIST2(SCM_MAKE_INT(x), SCM_MAKE_INT(y)));")

(define-cproc sdl-joystick-close (joystick::<sdl-joystick>)
  (return <void> "SDL_JoystickClose"))


;;=============================================================
;; Audio
;;

(define-cproc sdl-open-audio (desired::<sdl-audio-spec>)
  "ScmSdlAudioSpec *as = SCM_NEW(ScmSdlAudioSpec);
   int result = SDL_OpenAudio(desired, &(as->audio));

   if (result < 0) SCM_RETURN(SCM_UNDEFINED);

   SCM_SET_CLASS(as, SCM_CLASS_SDL_AUDIO_SPEC);

   SCM_RETURN(SCM_OBJ(as));")

(define-cproc sdl-pause-audio (pause_on::<int>)
  (return <void> "SDL_PauseAudio"))

(define-cproc sdl-get-audio-status ()
  (return <int> "SDL_GetAudioStatus"))

(define-cproc sdl-load-wav (file::<string>)
  "ScmSdlWAV *w = SCM_NEW(ScmSdlWAV);
   Uint8 *buffer;
   Uint32 len;
   SDL_AudioSpec *spec;
   SCM_SET_CLASS(w, SCM_CLASS_SDL_WAV);
   spec = &(SCM_SDL_WAV_SPEC(w));

   spec = SDL_LoadWAV((const char *)(SCM_STRING_START(file)), spec, &buffer,
                      &len);

   SCM_SDL_WAV_BUFFER(w) = Scm_MakeU8VectorFromArrayShared(len, buffer);

   if (spec == NULL) SCM_RETURN(SCM_UNDEFINED);

   Scm_RegisterFinalizer(SCM_OBJ(w), sdl_wav_finalize, NULL);
   SCM_RETURN(SCM_OBJ(w));")

(define-cproc sdl-build-audio-cvt (cvt::<sdl-audio-cvt> src_format::<int>
                                   src_channels::<int> src_rate::<int>
                                   dst_format::<int> dst_channels::<int>
                                   dst_rate::<int>)
  (return <int> "SDL_BuildAudioCVT"))

(define-cproc sdl-convert-audio (cvt::<sdl-audio-cvt>)
  (return <int> "SDL_ConvertAudio"))

(define-cproc sdl-mix-audio (dst::<u8vector> src::<u8vector> len::<uint>
                             volume::<int>)
  "SDL_MixAudio(SCM_U8VECTOR_ELEMENTS(dst), SCM_U8VECTOR_ELEMENTS(src), len,
                volume);

   SCM_RETURN(SCM_UNDEFINED);")

(define-cproc sdl-lock-audio ()
  (return <void> "SDL_LockAudio"))

(define-cproc sdl-unlock-audio ()
  (return <void> "SDL_UnlockAudio"))

(define-cproc sdl-close-audio ()
  (return <void> "SDL_CloseAudio"))


;;=============================================================
;; CD-Rom
;;

(define-cproc sdl-cd-num-drives ()
  (return <int> "SDL_CDNumDrives"))

(define-cproc sdl-cd-name (drive::<int>)
  "const char *name = SDL_CDName(drive);

   SCM_RETURN(SCM_MAKE_STR(name));")

(define-cproc sdl-cd-open (drive::<int>)
  "ScmSdlCD *cd = SCM_NEW(ScmSdlCD);
   SCM_SET_CLASS(cd, SCM_CLASS_SDL_CD);

   cd->cd = SDL_CDOpen(drive);

   if (cd->cd == NULL) SCM_RETURN(SCM_UNDEFINED);

   SCM_RETURN(SCM_OBJ(cd));")

(define-cproc sdl-cd-status (cdrom::<sdl-cd>)
  (return <int> "SDL_CDStatus"))

(define-cproc sdl-cd-play (cdrom::<sdl-cd> start::<int> length::<int>)
  (return <int> "SDL_CDPlay"))

(define-cproc sdl-cd-play-tracks (cdrom::<sdl-cd> start_track::<int>
                                  start_frame::<int> ntracks::<int>
                                  nframes::<int>)
  (return <int> "SDL_CDPlayTracks"))

(define-cproc sdl-cd-pause (cdrom::<sdl-cd>)
  (return <int> "SDL_CDPause"))

(define-cproc sdl-cd-resume (cdrom::<sdl-cd>)
  (return <int> "SDL_CDResume"))

(define-cproc sdl-cd-stop (cdrom::<sdl-cd>)
  (return <int> "SDL_CDStop"))

(define-cproc sdl-cd-eject (cdrom::<sdl-cd>)
  (return <int> "SDL_CDEject"))

(define-cproc sdl-cd-close (cdrom::<sdl-cd>)
  (return <void> "SDL_CDClose"))


;;=============================================================
;; Time
;;

(define-type <sdl-timer-id> "SDL_TimerID" #f
  "SCM_SDL_TIMER_ID_P" "SCM_SDL_TIMER_ID")

(define-cproc sdl-get-ticks ()
  (return <uint> "SDL_GetTicks"))

(define-cproc sdl-delay (ms::<uint>)
  (return <void> "SDL_Delay"))

;; MISSING:
;; MISSING: SDL_AddTimer
;; MISSING:

;; MISSING:
;; MISSING: SDL_RemoveTimer
;; MISSING:

;;
;; Callbacks cannot be closures, therefore use a wrapper
;;
"static ScmObj set_timer_fn = SCM_FALSE;

Uint32 set_timer_callback(Uint32 interval)
{
   if (SCM_PROCEDUREP(set_timer_fn))
   {
      Scm_Apply(set_timer_fn, SCM_LIST1(SCM_MAKE_INT(interval)));
   }

   return interval;
}"

(define-cproc sdl-set-timer (interval::<uint> callback)
  "int r;

   set_timer_fn = callback;
   if (SCM_PROCEDUREP(set_timer_fn)) {
      r = SDL_SetTimer(interval, set_timer_callback);
   } else {
      r = SDL_SetTimer(0, NULL);
   }
   SCM_RETURN(SCM_MAKE_INT(r));")


;;=============================================================
;; RWops
;;

(define-cproc sdl-rw-from-file (file::<string> mode::<string>)
  "ScmSdlRWops *rw = SCM_NEW(ScmSdlRWops);
   SCM_SET_CLASS(rw, SCM_CLASS_SDL_RWOPS);
   rw->rwops = SDL_RWFromFile((const char *)(SCM_STRING_START(file)),
                              (const char *)(SCM_STRING_START(mode)));

   if (rw->rwops == NULL) SCM_RETURN(SCM_UNDEFINED);

   Scm_RegisterFinalizer(SCM_OBJ(rw), sdl_rwops_finalize, NULL);
   SCM_RETURN(SCM_OBJ(rw));")

;; MISSING:
;; MISSING: SDL_RWFromFP
;; MISSING:

(define-cproc sdl-rw-from-mem (mem::<u8vector>)
  "ScmSdlRWops *rw = SCM_NEW(ScmSdlRWops);
   SCM_SET_CLASS(rw, SCM_CLASS_SDL_RWOPS);
   rw->rwops = SDL_RWFromMem(SCM_U8VECTOR_ELEMENTS(mem),
                             SCM_U8VECTOR_SIZE(mem));

   if (rw->rwops == NULL) SCM_RETURN(SCM_UNDEFINED);

   Scm_RegisterFinalizer(SCM_OBJ(rw), sdl_rwops_finalize, NULL);
   SCM_RETURN(SCM_OBJ(rw));")

(define-cproc sdl-alloc-rw ()
  "ScmSdlRWops *rw = SCM_NEW(ScmSdlRWops);
   SCM_SET_CLASS(rw, SCM_CLASS_SDL_RWOPS);
   rw->rwops = SDL_AllocRW();

   if (rw->rwops == NULL) SCM_RETURN(SCM_UNDEFINED);

   Scm_RegisterFinalizer(SCM_OBJ(rw), sdl_rwops_finalize, NULL);
   SCM_RETURN(SCM_OBJ(rw));")

(define-cproc sdl-rw-seek (ctx::<sdl-rwops> offset::<int> whence::<int>)
  (return <int> "SDL_RWseek"))

(define-cproc sdl-rw-tell (ctx::<sdl-rwops>)
  (return <int> "SDL_RWtell"))

(define-cproc sdl-rw-read (ctx::<sdl-rwops> size::<int> n::<int>)
  "char buffer[size * n];
   int result = SDL_RWread(ctx, buffer, size, n);

   if (result < 0) SCM_RETURN(SCM_UNDEFINED);

   SCM_RETURN(Scm_MakeU8VectorFromArray(size * result, buffer));")

(define-cproc sdl-rw-write (ctx::<sdl-rwops> ptr::<u8vector> size::<int>
                            n::<int>)
  "SCM_RETURN(SCM_MAKE_INT(SDL_RWread(ctx, SCM_U8VECTOR_ELEMENTS(ptr), size,
                                      n)));")

(define-cproc sdl-rw-close (ctx::<sdl-rwops>)
  (return <int> "SDL_RWclose"))


;; Local variables:
;; mode: scheme
;; end: