rubysdl 1.3.1 → 2.0

data/lib/sdl.rb

@@ -17,62 +17,32 @@
 require 'sdl.so'
 require 'forwardable'
 
-if !defined?(block_given?) then
-  alias block_given? iterator?
-end
-
 module SDL
-  
-  VERSION = "1.3.1"
-
-  class PixelFormat
-
-    extend Forwardable
-    
-    def initialize(surface)
-      @surface = surface
-    end
-
-    def_delegators( :@surface, :mapRGB, :mapRGBA, :getRGB, :getRGBA, :bpp,
-		    :colorkey, :alpha )
-  end
+  VERSION = "2.0 alpha1"
 
   class Surface
     def put(surface,x,y)
-      SDL::blitSurface(surface,0,0,surface.w,surface.h,self,x,y)
-    end
-
-    def format
-      return PixelFormat.new(self)
-    end
-
-    if method_defined?(:rotateScaledSurface) then
-      def rotateSurface(angle,bgcolor)
-	rotateScaledSurface(angle,1.0,bgcolor)
-      end
+      SDL::Surface.blit(surface,0,0,surface.w,surface.h,self,x,y)
     end
 
     def copyRect(x,y,w,h)
+      format = self.format
       flagbase=SDL::SWSURFACE|SDL::HWSURFACE|SDL::SRCCOLORKEY|SDL::SRCALPHA
       alpha_flag = self.flags & (SDL::SRCCOLORKEY|SDL::RLEACCEL)
-      self.setAlpha(0,self.alpha)
+      self.setAlpha(0,format.alpha)
       begin
         new_surface=Surface.new(flagbase&self.flags,w,h,self)
       ensure
-        self.setAlpha(alpha_flag,self.alpha)
+        self.setAlpha(alpha_flag,format.alpha)
       end
       SDL.blitSurface(self,x,y,w,h,new_surface,0,0)
       new_surface.setColorKey(self.flags & (SDL::SRCCOLORKEY|SDL::RLEACCEL),
-                              self.colorkey )
+                              format.colorkey )
       new_surface.setAlpha(self.flags & (SDL::SRCALPHA|SDL::RLEACCEL),
-                           self.alpha )
+                           format.alpha )
       return new_surface
     end
     
-    def self.blit(src, srcX, srcY, srcW, srcH, dst, dstX, dstY)
-      SDL.blitSurface(src, srcX, srcY, srcW, srcH, dst, dstX, dstY)
-    end
-    
     def self.new(*args)
       case args.size
       when 4
@@ -83,12 +53,10 @@ module SDL
         raise ArgumentError,"must be SDL::Surface.new(flags,w,h,surface) or SDL::Surface.new(flags,w,h,depth,Rmask,Gmask,Bmask,Amask)"
       end
     end
-  end
 
-  class Screen
-    def self.open(*args); SDL.setVideoMode(*args) end
+    
   end
-  
+
   def color2int(color,format)
     case color
     when Integer
@@ -120,14 +88,14 @@ module SDL
       i=-1
       for y in 0..(bitmap.h-1)
 	for x in 0..(bitmap.w-1)
-	  if x%8 != 0 then
+	  if x%8 == 0 then
+            i+=1
+	    data[i]=mask[i]=0
+          else
 	    data[i] <<= 1
 	    mask[i] <<= 1
-	  else
-	    i+=1
-	    data[i]=mask[i]=0
 	  end
-	  
+
 	  case bitmap.getPixel(x,y)
 	  when white
 	    mask[i] |= 0x01
@@ -139,7 +107,6 @@ module SDL
 	  when inverted
 	    data[i] |= 0x01
 	  end
-
 	end
       end
 
@@ -148,6 +115,26 @@ module SDL
     
   end # of module Mouse
 
+  if defined?(CollisionMap)
+    def Surface.transformBlit(src, dst, angle, xscale, yscale,
+                              px, py, qx, qy, flags)
+      transformed = src.transformSurface(src.colorkey, angle,
+                                         xscale, yscale, flags)
+      transformed.setColorKey(src.flags & (SDL::SRCCOLORKEY|SDL::RLEACCEL),
+                              src.colorkey )
+      transformed.setAlpha(src.flags & (SDL::SRCALPHA|SDL::RLEACCEL),
+                           src.alpha )
+      rad = Math::PI*angle / 180.0
+      x = px - src.w/2.0 ; y = py - src.h/2.0
+        x *= xscale ; y *= yscale
+      dst_x = x*Math.cos(rad)-y*Math.sin(rad) 
+      dst_y = x*Math.sin(rad)+y*Math.cos(rad) 
+      dst_x += transformed.w / 2
+      dst_y += transformed.h / 2
+      Surface.blit(transformed, 0, 0, 0, 0, dst, qx-dst_x, qy-dst_y)
+    end
+  end
+  
   class CD
     def in_drive?
       status > 0
@@ -156,49 +143,6 @@ module SDL
   
   module_function
 
-  if defined?(rotateXYScaled) then
-    def rotateScaled(src,dst,x,y,angle,scale)
-      rotateXYScaled(src,dst,x,y,angle,scale,scale)
-    end
-    def rotate(src,dst,x,y,angle)
-      rotateXYScaled(src,dst,x,y,angle,1,1)
-    end
-
-    def rotateBlit(src,dst,x,y,angle)
-      rotateScaledBlit(src,dst,x,y,angle,1)
-    end
-
-    def autoLock?
-      autoLock
-    end
-    
-    def autoLockON
-      self.autoLock = true
-    end
-    def autoLockOFF
-      self.autoLock =false
-    end
-  end
-
-  if defined?(transform) then
-    def transformBlit(src,dst,angle,xscale,yscale,px,py,qx,qy,flags)
-      transformed = src.transformSurface( src.colorkey, angle,
-					 xscale, yscale, flags )
-      transformed.setColorKey( src.flags & (SDL::SRCCOLORKEY|SDL::RLEACCEL),
-			      src.colorkey )
-      transformed.setAlpha( src.flags & (SDL::SRCALPHA|SDL::RLEACCEL),
-			    src.alpha )
-      rad = Math::PI*angle/180.0
-      x = px - src.w/2.0 ; y = py - src.h/2.0
-      x *= xscale ; y *= yscale
-      dst_x = x*Math.cos(rad)-y*Math.sin(rad) 
-      dst_y = x*Math.sin(rad)+y*Math.cos(rad) 
-      dst_x += transformed.w/2
-      dst_y += transformed.h/2
-      blitSurface( transformed, 0, 0, 0, 0, dst, qx-dst_x, qy-dst_y )
-    end      
-  end
-
   Rect = Struct.new( :x, :y, :w, :h )
   
   def convertRect(rect)
@@ -211,7 +155,8 @@ module SDL
       return rect
     end
   end
-  
+
+  # FIX:
   def blitSurface2(src,srcRect,dst,dstRect)
     srcR = convertRect(srcRect)
     dstR = convertRect(dstRect)
@@ -246,7 +191,27 @@ module SDL
       end
     end
   end
-  
+  if defined?(TTF)
+    class TTF
+      def drawSolidUTF8(dst, text, x, y, r, g, b)
+        image = renderSolidUTF8(text, r, g, b)
+        dst.put(image, x, y)
+        image.destroy
+      end
+      
+      def drawBlendedUTF8(dst, text, x, y, r, g, b)
+        image = renderBlendedUTF8(text, r, g, b)
+        dst.put(image, x, y)
+        image.destroy
+      end
+      
+      def drawShadedUTF8(dst, text, fg_r, fg_g, fg_b, bg_r, bg_g, bg_b)
+        image = renderSolidUTF8(text, fg_r, fg_g, fg_b, bg_r, bg_g, bg_b)
+        dst.put(image, x, y)
+        image.destroy
+      end
+    end
+  end
 end
 
 if defined?(GL) then
@@ -269,3 +234,4 @@ if defined?(GL) then
 end
 
 require 'rubysdl_aliases.rb'
+require 'rubysdl_compatible_ver1.rb'

data/rubysdl.h

@@ -21,69 +21,23 @@
 #include <SDL.h>
 #include <ruby.h>
 #include <stdio.h>
-#ifndef UINT2NUM
-#define UINT2NUM(v) INT2NUM(v)
-#endif
-
-#ifdef DEF_GLOBAL
-#define GLOBAL
-#else
-#define GLOBAL extern
-#endif
 
-#ifdef StringValuePtr
-#define GETCSTR(v) StringValuePtr(v)
-#else
-#define GETCSTR(v) STR2CSTR(v)
-#endif
-
-GLOBAL VALUE mSDL;
-GLOBAL VALUE eSDLError;
-GLOBAL VALUE cVideoInfo;
-GLOBAL VALUE cSurface;
-GLOBAL VALUE cScreen;
-GLOBAL VALUE cEvent;
-GLOBAL VALUE mKey;
-GLOBAL VALUE mMixer;
-GLOBAL VALUE cWave;
-GLOBAL VALUE cMusic;
-GLOBAL VALUE mWM;
-GLOBAL VALUE mMouse;
-GLOBAL VALUE cTTF;
-GLOBAL VALUE cJoystick;
-GLOBAL VALUE cCD;
-GLOBAL VALUE cMPEG;
-GLOBAL VALUE cMPEGInfo;
-GLOBAL VALUE mSDLSKK;
-GLOBAL VALUE cContext;
-GLOBAL VALUE cDictionary;
-GLOBAL VALUE cRomKanaRuleTable;
-GLOBAL VALUE cKeybind;
-
-#ifdef HAVE_SGE
-GLOBAL VALUE cCollisionMap;
-GLOBAL VALUE cBMFont;
-#endif /* ifdef HAVE_SGE */
-
-#ifdef DEF_EVENT2
-GLOBAL VALUE cEvent2;
-GLOBAL VALUE cActiveEvent;
-GLOBAL VALUE cKeyDownEvent;
-GLOBAL VALUE cKeyUpEvent;
-GLOBAL VALUE cMouseMotionEvent;
-GLOBAL VALUE cMouseButtonDownEvent;
-GLOBAL VALUE cMouseButtonUpEvent;
-GLOBAL VALUE cJoyAxisEvent;
-GLOBAL VALUE cJoyBallEvent;
-GLOBAL VALUE cJoyHatEvent;
-GLOBAL VALUE cJoyButtonUpEvent;
-GLOBAL VALUE cJoyButtonDownEvent;
-GLOBAL VALUE cQuitEvent;
-GLOBAL VALUE cSysWMEvent;
-GLOBAL VALUE cVideoResizeEvent;
-GLOBAL VALUE cVideoExposeEvent;
-#endif
+/* Macros */
+#define GLOBAL_DEFINE_GET_STRUCT(struct_name, fun, klass, klassstr) \
+struct_name* fun(VALUE obj) \
+{ \
+  struct_name* st; \
+  \
+  if(!rb_obj_is_kind_of(obj, klass)){ \
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected " klassstr ")", \
+             rb_obj_classname(obj)); \
+  } \
+  Data_Get_Struct(obj, struct_name, st); \
+  return st; \
+} 
 
+#define DEFINE_GET_STRUCT(struct_name, fun, klass, klassstr) \
+static GLOBAL_DEFINE_GET_STRUCT(struct_name, fun, klass, klassstr)
 #define SetRect(Rect,X,Y,W,H) \
 do{ \
   Rect.x=NUM2INT(X); \
@@ -92,18 +46,55 @@ do{ \
   Rect.h=NUM2INT(H); \
 }while(0) \
 
-#define BOOL(x) (x)?Qtrue:Qfalse
+#define INT2BOOL(x) ((x)?Qtrue:Qfalse)
 
-#ifndef SDL_VERSION_ATLEAST
-#define SDL_COMPILEDVERSION SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL)
-     
-#define SDL_VERSION_ATLEAST(X, Y, Z) (SDL_COMPILEDVERSION >= SDL_VERSIONNUM(X, Y, Z))
-     
+/* Global variables */
+#define eSDLError rubysdl_eSDLError
+#ifdef DEF_GLOBAL
+VALUE eSDLError;
+#else
+extern VALUE eSDLError;
 #endif
 
+/* Global functions */
+#define VALUE2COLOR rubysdl_VALUE2COLOR
 Uint32 VALUE2COLOR(VALUE color,SDL_PixelFormat *format);
+
 void rubysdl_putPixel(SDL_Surface *surface, Sint16 x, Sint16 y, Uint32 color);
 Uint32 rubysdl_getPixel(SDL_Surface *surface, Sint16 x, Sint16 y);
-void sdl_freeSurface(SDL_Surface* surface);
 int rubysdl_is_quit(void);
+
 SDL_RWops* rubysdl_RWops_from_ruby_obj(VALUE obj);
+
+#define Surface_create rubysdl_Surface_create
+VALUE Surface_create(SDL_Surface* surface);
+
+#define Get_SDL_Surface rubysdl_Get_SDL_Surface
+SDL_Surface* Get_SDL_Surface(VALUE obj);
+
+#ifdef HAVE_SDLSKK
+#include <SDL_ttf.h>
+#define Get_TTF_Font rubysdl_Get_TTF_Font
+TTF_Font* Get_TTF_Font(VALUE obj);
+#endif
+
+/* declaration of initialize functions */
+VALUE rubysdl_init_video(VALUE mSDL);
+void rubysdl_init_sge(VALUE mSDL, VALUE cSurface);
+void rubysdl_init_GL(VALUE mSDL);
+void rubysdl_init_image(VALUE mSDL, VALUE cSurface);
+void rubysdl_init_Event(VALUE mSDL);
+void rubysdl_init_Key(VALUE mSDL);
+void rubysdl_init_Mouse(VALUE mSDL);
+void rubysdl_init_Joystick(VALUE mSDL);
+void rubysdl_init_CD(VALUE mSDL);
+void rubysdl_init_time(VALUE mSDL);
+void rubysdl_init_WM(VALUE mSDL);
+void rubysdl_init_Kanji(VALUE mSDL);
+void rubysdl_init_TTF(VALUE mSDL);
+void rubysdl_quit_TTF(void);
+void rubysdl_init_Mixer(VALUE mSDL);
+void rubysdl_quit_Mixer(void);
+void rubysdl_init_MPEG(VALUE mSDL);
+void rubysdl_init_SKK(VALUE mSDL);
+

data/rubysdl_cdrom.c

@@ -19,158 +19,181 @@
   */
 #include "rubysdl.h"
 
-static VALUE sdl_cd_numDrive(VALUE class)
+static VALUE cCD;
+
+typedef struct{
+  SDL_CD* cd;
+} CD;
+
+DEFINE_GET_STRUCT(CD, GetCD, cCD, "SDL::CD");
+
+static SDL_CD* Get_SDL_CD(VALUE obj)
+{
+  CD* cd = GetCD(obj);
+  if(cd->cd == NULL)
+    rb_raise(rb_eRuntimeError, "CD is closed");
+  return cd->cd;
+}
+
+static void CD_free(CD* cd)
 {
+  if( !rubysdl_is_quit() && cd->cd )
+    SDL_CDClose(cd->cd);
+  free(cd);
+}
+
+static VALUE CD_s_alloc(VALUE klass)
+{
+  CD* cd = ALLOC(CD);
+  cd->cd = NULL;
+  return Data_Wrap_Struct(cCD, 0, CD_free, cd);
+}
+
+static VALUE CD_initialize(VALUE self, VALUE drive)
+{
+  CD* cd = GetCD(self);
+  rb_secure(4);
+  
+  cd->cd = SDL_CDOpen(NUM2INT(drive));
+  if(cd->cd == NULL)
+    rb_raise(eSDLError, "Couldn't open drive %d: %s", 
+	     NUM2INT(drive), SDL_GetError());
+  return Qnil;
+}
+
+static VALUE CD_s_numDrive(VALUE klass)
+{
+  rb_secure(4);
   return INT2FIX(SDL_CDNumDrives());
 }
-static VALUE sdl_cd_name(VALUE class,VALUE drive)
+static VALUE CD_s_name(VALUE klass, VALUE drive)
 {
+  rb_secure(4);
   return rb_str_new2(SDL_CDName(NUM2INT(drive)));
 }
-static VALUE sdl_cd_open(VALUE class,VALUE drive)
+static VALUE CD_s_open(VALUE klass, VALUE drive)
 {
-  SDL_CD *cd;
-  cd=SDL_CDOpen(NUM2INT(drive));
-  if(cd==NULL)
-    rb_raise(eSDLError,"Couldn't open drive %d: %s",
-	     NUM2INT(drive),SDL_GetError());
-  return Data_Wrap_Struct(class,0,SDL_CDClose,cd);
+  VALUE newobj = CD_s_alloc(klass);
+  CD_initialize(newobj, drive);
+  return newobj;
 }
-static VALUE sdl_cd_status(VALUE obj)
+static VALUE CD_status(VALUE self)
 {
-  SDL_CD *cd;
-  Data_Get_Struct(obj,SDL_CD,cd);
-  return INT2FIX(SDL_CDStatus(cd));
+  rb_secure(4);
+  return INT2FIX(SDL_CDStatus(Get_SDL_CD(self)));
 }
-static VALUE sdl_cd_play(VALUE obj,VALUE start,VALUE length)
+static VALUE CD_play(VALUE self, VALUE start, VALUE length)
 {
-  SDL_CD *cd;
-  Data_Get_Struct(obj,SDL_CD,cd);
-  if( SDL_CDPlay(cd,NUM2INT(start),NUM2INT(length))==-1 )
-    rb_raise(eSDLError,"Couldn't play cd :%s",SDL_GetError() );
+  rb_secure(4);
+  if( SDL_CDPlay(Get_SDL_CD(self), NUM2INT(start), NUM2INT(length))==-1 )
+    rb_raise(eSDLError, "Couldn't play cd :%s", SDL_GetError() );
   return Qnil;
 }
-static VALUE sdl_cd_playTracks(VALUE obj,VALUE start_track,VALUE start_frame,
-			       VALUE ntracks,VALUE nframes)
+static VALUE CD_playTracks(VALUE self, VALUE start_track, VALUE start_frame, 
+			       VALUE ntracks, VALUE nframes)
 {
-  SDL_CD *cd;
-  Data_Get_Struct(obj,SDL_CD,cd);
-  if( SDL_CDPlayTracks(cd,NUM2INT(start_track),NUM2INT(start_frame),
-		       NUM2INT(ntracks),NUM2INT(nframes))==-1 )
-    rb_raise(eSDLError,"Couldn't play cd :%s",SDL_GetError() );
+  rb_secure(4);
+  if( SDL_CDPlayTracks(Get_SDL_CD(self), NUM2INT(start_track),
+                       NUM2INT(start_frame), NUM2INT(ntracks),
+		       NUM2INT(nframes))==-1 )
+    rb_raise(eSDLError, "Couldn't play cd :%s", SDL_GetError() );
   return Qnil;
 }
-static VALUE sdl_cd_pause(VALUE obj)
+static VALUE CD_pause(VALUE self)
 {
-  SDL_CD *cd;
-  Data_Get_Struct(obj,SDL_CD,cd);
-  if( SDL_CDPause(cd)==-1 )
-    rb_raise(eSDLError,"cd pause failed :%s",SDL_GetError());
+  rb_secure(4);
+  if( SDL_CDPause(Get_SDL_CD(self))==-1 )
+    rb_raise(eSDLError, "cd pause failed :%s", SDL_GetError());
   return Qnil;
 }
-static VALUE sdl_cd_resume(VALUE obj)
+static VALUE CD_resume(VALUE self)
 {
-  SDL_CD *cd;
-  Data_Get_Struct(obj,SDL_CD,cd);
-  if( SDL_CDResume(cd)==-1 )
-    rb_raise(eSDLError,"cd resume failed :%s",SDL_GetError());
+  rb_secure(4);
+  if( SDL_CDResume(Get_SDL_CD(self))==-1 )
+    rb_raise(eSDLError, "cd resume failed :%s", SDL_GetError());
   return Qnil;
 }
-static VALUE sdl_cd_stop(VALUE obj)
+static VALUE CD_stop(VALUE self)
 {
-  SDL_CD *cd;
-  Data_Get_Struct(obj,SDL_CD,cd);
-  if( SDL_CDStop(cd)==-1 )
-    rb_raise(eSDLError,"cd pause failed :%s",SDL_GetError());
+  rb_secure(4);
+  if( SDL_CDStop(Get_SDL_CD(self))==-1 )
+    rb_raise(eSDLError, "cd pause failed :%s", SDL_GetError());
   return Qnil;
 }
-static VALUE sdl_cd_eject(VALUE obj)
+static VALUE CD_eject(VALUE self)
 {
-  SDL_CD *cd;
-  Data_Get_Struct(obj,SDL_CD,cd);
-  if( SDL_CDEject(cd)==-1 )
-    rb_raise(eSDLError,"cd eject failed :%s",SDL_GetError());
+  rb_secure(4);
+  if( SDL_CDEject(Get_SDL_CD(self))==-1 )
+    rb_raise(eSDLError, "cd eject failed :%s", SDL_GetError());
   return Qnil;
 }
 
-static VALUE sdl_cd_numTracks(VALUE obj)
+static VALUE CD_numTracks(VALUE self)
 {
-  SDL_CD *cd;
-  Data_Get_Struct(obj,SDL_CD,cd);
-  return INT2NUM(cd->numtracks);
+  return INT2NUM(Get_SDL_CD(self)->numtracks);
 }
-static VALUE sdl_cd_currentTrack(VALUE obj)
+static VALUE CD_currentTrack(VALUE self)
 {
-  SDL_CD *cd;
-  Data_Get_Struct(obj,SDL_CD,cd);
-  return INT2NUM(cd->cur_track);
+  return INT2NUM(Get_SDL_CD(self)->cur_track);
 }
-static VALUE sdl_cd_currentFrame(VALUE obj)
+static VALUE CD_currentFrame(VALUE self)
 {
-  SDL_CD *cd;
-  Data_Get_Struct(obj,SDL_CD,cd);
-  return INT2NUM(cd->cur_frame);
+  return INT2NUM(Get_SDL_CD(self)->cur_frame);
 }
-static VALUE sdl_cd_trackType(VALUE obj,VALUE track)
+static VALUE CD_trackType(VALUE self, VALUE track)
 {
-  SDL_CD *cd;
-  int index=NUM2INT(track);
-  Data_Get_Struct(obj,SDL_CD,cd);
-  return INT2FIX(cd->track[index].type);
+  return INT2FIX(Get_SDL_CD(self)->track[NUM2INT(track)].type);
 }
-static VALUE sdl_cd_trackLength(VALUE obj,VALUE track)
+static VALUE CD_trackLength(VALUE self, VALUE track)
 {
-  SDL_CD *cd;
-  int index=NUM2INT(track);
-  Data_Get_Struct(obj,SDL_CD,cd);
-  return INT2FIX(cd->track[index].length);
+  return INT2FIX(Get_SDL_CD(self)->track[NUM2INT(track)].length);
 }
 
-static VALUE sdl_cd_framesToMSF(VALUE class, VALUE frames)
+static VALUE CD_s_framesToMSF(VALUE klass, VALUE frames)
 {
   int m, s, f;
   FRAMES_TO_MSF(NUM2INT(frames), &m, &s, &f);
   return rb_ary_new3(3, INT2FIX(m), INT2FIX(s), INT2FIX(f));
 }
-static VALUE sdl_cd_MSFToFrames(VALUE class, VALUE m, VALUE s, VALUE f)
+static VALUE CD_s_MSFToFrames(VALUE klass, VALUE m, VALUE s, VALUE f)
 {
   return INT2FIX(MSF_TO_FRAMES(NUM2INT(m),NUM2INT(s),NUM2INT(f)));
 }
 
-static void defineConstForCDROM()
+void rubysdl_init_CD(VALUE mSDL)
 {
-  rb_define_const(cCD,"TRAYEMPTY",INT2NUM(CD_TRAYEMPTY));
-  rb_define_const(cCD,"STOPPED",INT2NUM(CD_STOPPED));
-  rb_define_const(cCD,"PLAYING",INT2NUM(CD_PLAYING));
-  rb_define_const(cCD,"PAUSED",INT2NUM(CD_PAUSED));
-  rb_define_const(cCD,"ERROR",INT2NUM(CD_ERROR));
+  cCD = rb_define_class_under(mSDL, "CD", rb_cObject);
+  
+  rb_define_alloc_func(cCD, CD_s_alloc);
+  rb_define_private_method(cCD, "initialize", CD_initialize, 1);
+  
+  rb_define_singleton_method(cCD, "numDrive", CD_s_numDrive, 0);
+  rb_define_singleton_method(cCD, "indexName", CD_s_name, 1);
+  rb_define_singleton_method(cCD, "open", CD_s_open, 1);
+  rb_define_singleton_method(cCD, "framesToMSF", CD_s_framesToMSF,1);
+  rb_define_singleton_method(cCD,"MSFToFrames",CD_s_MSFToFrames,3);
+  rb_define_method(cCD, "status", CD_status, 0);
+  rb_define_method(cCD, "play", CD_play, 2);
+  rb_define_method(cCD, "playTracks", CD_playTracks, 4);
+  rb_define_method(cCD, "pause", CD_pause, 0);
+  rb_define_method(cCD, "resume", CD_resume, 0);
+  rb_define_method(cCD, "stop", CD_stop, 0);
+  rb_define_method(cCD, "eject", CD_eject, 0);
+
+  rb_define_method(cCD, "numTracks", CD_numTracks, 0);
+  rb_define_method(cCD, "currentTrack", CD_currentTrack, 0);
+  rb_define_method(cCD, "currentFrame", CD_currentFrame, 0);
+  rb_define_method(cCD, "trackType", CD_trackType, 1);
+  rb_define_method(cCD, "trackLength", CD_trackLength, 1);
+
   
-  rb_define_const(cCD,"AUDIO_TRACK",UINT2NUM(SDL_AUDIO_TRACK));
-  rb_define_const(cCD,"DATA_TRACK",UINT2NUM(SDL_DATA_TRACK));
-
-  rb_define_const(cCD,"FPS", UINT2NUM(CD_FPS));
-}
-void init_cdrom()
-{
-  cCD=rb_define_class_under(mSDL,"CD",rb_cObject);
-  rb_define_singleton_method(cCD,"numDrive",sdl_cd_numDrive,0);
-  rb_define_singleton_method(cCD,"indexName",sdl_cd_name,1);
-  rb_define_singleton_method(cCD,"open",sdl_cd_open,1);
-  rb_define_singleton_method(cCD,"framesToMSF",sdl_cd_framesToMSF,1);
-  rb_define_singleton_method(cCD,"MSFToFrames",sdl_cd_MSFToFrames,3);
-  rb_define_method(cCD,"status",sdl_cd_status,0);
-  rb_define_method(cCD,"play",sdl_cd_play,2);
-  rb_define_method(cCD,"playTracks",sdl_cd_playTracks,4);
-  rb_define_method(cCD,"pause",sdl_cd_pause,0);
-  rb_define_method(cCD,"resume",sdl_cd_resume,0);
-  rb_define_method(cCD,"stop",sdl_cd_stop,0);
-  rb_define_method(cCD,"eject",sdl_cd_eject,0);
-
-  rb_define_method(cCD,"numTracks",sdl_cd_numTracks,0);
-  rb_define_method(cCD,"currentTrack",sdl_cd_currentTrack,0);
-  rb_define_method(cCD,"currentFrame",sdl_cd_currentFrame,0);
-  rb_define_method(cCD,"trackType",sdl_cd_trackType,1);
-  rb_define_method(cCD,"trackLength",sdl_cd_trackLength,1);
+  rb_define_const(cCD, "TRAYEMPTY", INT2NUM(CD_TRAYEMPTY));
+  rb_define_const(cCD, "STOPPED", INT2NUM(CD_STOPPED));
+  rb_define_const(cCD, "PLAYING", INT2NUM(CD_PLAYING));
+  rb_define_const(cCD, "PAUSED", INT2NUM(CD_PAUSED));
+  rb_define_const(cCD, "ERROR", INT2NUM(CD_ERROR));
   
-  defineConstForCDROM();
+  rb_define_const(cCD, "AUDIO_TRACK", UINT2NUM(SDL_AUDIO_TRACK));
+  rb_define_const(cCD, "DATA_TRACK", UINT2NUM(SDL_DATA_TRACK));
+  rb_define_const(cCD, "FPS", UINT2NUM(CD_FPS));
 }