/*
 * gauche-sdl.c - Gauche SDL binding
 *
 *  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: gauche-sdl.c,v 1.5 2003/09/10 17:21:40 mikiso Exp $
 */

#include <gauche.h>
#include <gauche/extend.h>
#include "gauche-sdl.h"

/*****************************************************************************
 * Video
 */

/* Rect */

static void sdl_rect_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-rect %d %d %d %d>",
              SCM_SDL_RECT(obj)->x,
              SCM_SDL_RECT(obj)->y,
              SCM_SDL_RECT(obj)->w,
              SCM_SDL_RECT(obj)->h);
}

static int sdl_rect_compare(ScmObj x, ScmObj y, int equalp)
{
   if (equalp) {
      if (SCM_SDL_RECT(x)->x == SCM_SDL_RECT(y)->x
          && SCM_SDL_RECT(x)->y == SCM_SDL_RECT(y)->y
          && SCM_SDL_RECT(x)->w == SCM_SDL_RECT(y)->w
          && SCM_SDL_RECT(x)->h == SCM_SDL_RECT(y)->h) {
         return 0;
      } else {
         return -1;
      }
   } else {
      Scm_Error("can't order %S and %S", x, y);
      return 0;               /* dummy */
   }
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlRectClass,
                         sdl_rect_print, sdl_rect_compare, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);

/* Color */

static void sdl_color_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-color %d %d %d>",
              SCM_SDL_COLOR(obj)->r,
              SCM_SDL_COLOR(obj)->g,
              SCM_SDL_COLOR(obj)->b);
}

static int sdl_color_compare(ScmObj x, ScmObj y, int equalp)
{
   if (equalp) {
      if (SCM_SDL_COLOR(x)->r == SCM_SDL_COLOR(y)->r
          && SCM_SDL_COLOR(x)->g == SCM_SDL_COLOR(y)->g
          && SCM_SDL_COLOR(x)->b == SCM_SDL_COLOR(y)->b) {
         return 0;
      } else {
         return -1;
      }
   } else {
      Scm_Error("can't order %S and %S", x, y);
      return 0;               /* dummy */
   }
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlColorClass,
                         sdl_color_print, sdl_color_compare, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);

/* Palette */

static void sdl_palette_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-palette>");
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlPaletteClass,
                         sdl_palette_print, NULL, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);

/* PixelFormat */

static void sdl_pixel_format_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-pixel-format>");
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlPixelFormatClass,
                         sdl_pixel_format_print, NULL, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);

/* Surface */
void sdl_surface_finalize(ScmObj obj, void *data)
{
   SDL_FreeSurface(SCM_SDL_SURFACE(obj));
}

static void sdl_surface_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-surface %d %d %d>",
              SCM_SDL_SURFACE(obj)->w,
              SCM_SDL_SURFACE(obj)->h,
              SCM_SDL_SURFACE(obj)->flags);
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlSurfaceClass,
                         sdl_surface_print, NULL, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);

/* VideoInfo */
static void sdl_video_info_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-video-info>");
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlVideoInfoClass,
                         sdl_video_info_print, NULL, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);

/* Overlay */
void sdl_overlay_finalize(ScmObj obj, void *data)
{
   SDL_FreeYUVOverlay(SCM_SDL_OVERLAY(obj));
}

static void sdl_overlay_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-overlay %d %d>",
              SCM_SDL_OVERLAY(obj)->w,
              SCM_SDL_OVERLAY(obj)->h);
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlOverlayClass,
                         sdl_overlay_print, NULL, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);


/*****************************************************************************
 * Mouse
 */

/* Cursor */
void sdl_cursor_finalize(ScmObj obj, void *data)
{
   SDL_FreeCursor(SCM_SDL_CURSOR(obj));
}

static void sdl_cursor_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-cursor>");
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlCursorClass,
                         sdl_cursor_print, NULL, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);


/*****************************************************************************
 * Event
 */

/* Event */
static void sdl_event_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-event>");
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlEventClass,
                         sdl_event_print, NULL, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);


/*****************************************************************************
 * Joystick
 */

/* Joystick */
static void sdl_joystick_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-joystick>");
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlJoystickClass,
                         sdl_joystick_print, NULL, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);


/*****************************************************************************
 * Audio
 */

/* AudioSpec */
static void sdl_audio_spec_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-audio-spec>");
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlAudioSpecClass,
                         sdl_audio_spec_print, NULL, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);


/* AudioCVT */
static void sdl_audio_cvt_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-audio-cvt>");
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlAudioCVTClass,
                         sdl_audio_cvt_print, NULL, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);

/* Wav */
void sdl_wav_finalize(ScmObj obj, void *data)
{
   SDL_FreeWAV(SCM_U8VECTOR_ELEMENTS(SCM_SDL_WAV(obj)));
}

static void sdl_wav_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-wav>");
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlWAVClass,
                         sdl_wav_print, NULL, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);


/*****************************************************************************
 * CD
 */

/* CD */
static void sdl_cd_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-cd>");
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlCDClass,
                         sdl_cd_print, NULL, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);


/* CDtrack */
static void sdl_cd_track_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-cd-track>");
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlCDtrackClass,
                         sdl_cd_track_print, NULL, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);


/*****************************************************************************
 * Time
 */

static void sdl_timer_id_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-timer-id>");
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlTimerIdClass,
                         sdl_timer_id_print, NULL, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);


/*****************************************************************************
 * RWops
 */

/* RWops */
void sdl_rwops_finalize(ScmObj obj, void *data)
{
   SDL_FreeRW(SCM_SDL_RWOPS(obj));
}

static void sdl_rwops_print(ScmObj obj, ScmPort *out, ScmWriteContext *ctx)
{
   Scm_Printf(out, "#<sdl-rwops>");
}

SCM_DEFINE_BUILTIN_CLASS(Scm_SdlRWopsClass,
                         sdl_rwops_print, NULL, NULL, NULL,
                         SCM_CLASS_DEFAULT_CPL);


/*****************************************************************************
 * Initialization
 */

extern void Scm_Init_sdl_lib(ScmModule *mod);
extern void Scm_Init_sdl_syms(ScmModule *mod);

void Scm_Init_gauche_sdl(void)
{
   ScmModule *mod;
   SCM_INIT_EXTENSION(gauche_sdl);
   mod = SCM_MODULE(SCM_FIND_MODULE("sdl", TRUE));
   Scm_InitBuiltinClass(&Scm_SdlRectClass, "<sdl-rect>",
                        NULL, sizeof(Scm_SdlRectClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlColorClass, "<sdl-color>",
                        NULL, sizeof(Scm_SdlColorClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlPaletteClass, "<sdl-palette>",
                        NULL, sizeof(Scm_SdlPaletteClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlPixelFormatClass, "<sdl-pixel-format>",
                        NULL, sizeof(Scm_SdlPixelFormatClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlSurfaceClass, "<sdl-surface>",
                        NULL, sizeof(Scm_SdlSurfaceClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlVideoInfoClass, "<sdl-video-info>",
                        NULL, sizeof(Scm_SdlVideoInfoClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlOverlayClass, "<sdl-overlay>",
                        NULL, sizeof(Scm_SdlOverlayClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlSurfaceClass, "<sdl-surface>",
                        NULL, sizeof(Scm_SdlSurfaceClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlCursorClass, "<sdl-cursor>",
                        NULL, sizeof(Scm_SdlCursorClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlEventClass, "<sdl-event>",
                        NULL, sizeof(Scm_SdlEventClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlJoystickClass, "<sdl-joystick>",
                        NULL, sizeof(Scm_SdlJoystickClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlAudioSpecClass, "<sdl-audio-spec>",
                        NULL, sizeof(Scm_SdlAudioSpecClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlAudioCVTClass, "<sdl-Audio-cvt>",
                        NULL, sizeof(Scm_SdlAudioCVTClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlWAVClass, "<sdl-wav>",
                        NULL, sizeof(Scm_SdlWAVClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlCDClass, "<sdl-cd>",
                        NULL, sizeof(Scm_SdlCDClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlCDtrackClass, "<sdl-cd-track>",
                        NULL, sizeof(Scm_SdlCDtrackClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlTimerIdClass, "<sdl-timer-id>",
                        NULL, sizeof(Scm_SdlTimerIdClass)/sizeof(ScmObj),
                        mod);
   Scm_InitBuiltinClass(&Scm_SdlRWopsClass, "<sdl-rwops>",
                        NULL, sizeof(Scm_SdlRWopsClass)/sizeof(ScmObj),
                        mod);
   Scm_Init_sdl_lib(mod);
   Scm_Init_sdl_syms(mod);
}