rubysdl 1.3.1 → 2.0

data/rubysdl_video.c

@@ -19,17 +19,76 @@
   */
 #include "rubysdl.h"
 
-void sdl_freeSurface(SDL_Surface* surface)
+static VALUE cScreen = Qnil;
+static VALUE cPixelFormat = Qnil;
+static VALUE cVideoInfo = Qnil;
+static VALUE cSurface = Qnil;
+
+typedef struct {
+  SDL_Surface* surface;
+} Surface;
+
+DEFINE_GET_STRUCT(Surface, GetSurface, cSurface, "SDL::Surface");
+DEFINE_GET_STRUCT(SDL_PixelFormat, Get_PixelFormat, cPixelFormat, "SDL::PixelFormat");
+
+SDL_Surface* Get_SDL_Surface(VALUE obj)
 {
-  if( !rubysdl_is_quit() ){
-    SDL_FreeSurface(surface);
+  Surface* sur = GetSurface(obj);
+  if(sur->surface == NULL)
+    rb_raise(eSDLError, "Surface is already destroyed");
+  return sur->surface;
+}
+
+SDL_PixelFormat* Get_SDL_PixelFormat(VALUE obj)
+{
+  if(rb_obj_is_kind_of(obj, cSurface)){
+    return Get_SDL_Surface(obj)->format;
+  }else{
+    return Get_PixelFormat(obj);
   }
 }
+  
+static void Surface_free(Surface* sur)
+{
+  if(!rubysdl_is_quit() && sur->surface)
+    SDL_FreeSurface(sur->surface);
+  free(sur);
+}
+
+static void PixelFormat_free(SDL_PixelFormat* format)
+{
+  if(format->palette){
+    free(format->palette->colors);
+    free(format->palette);
+  }
+  free(format);
+}
+
+static VALUE Surface_s_alloc(VALUE klass)
+{
+  Surface* sur = ALLOC(Surface);
+  sur->surface = NULL;
+  return Data_Wrap_Struct(klass, 0, Surface_free, sur);
+}
+
+VALUE Surface_create(SDL_Surface* surface)
+{
+  VALUE newobj = Surface_s_alloc(cSurface);
+  GetSurface(newobj)->surface = surface;
+  return newobj;
+}
+
+static VALUE Screen_create(SDL_Surface* surface)
+{
+  VALUE newobj = Surface_s_alloc(cScreen);
+  GetSurface(newobj)->surface = surface;
+  return newobj;
+}
 
 Uint32 VALUE2COLOR(VALUE color,SDL_PixelFormat *format)
 {
   if( rb_obj_is_kind_of( color, rb_cArray ) ){
-    switch( RARRAY(color)->len ){
+    switch( RARRAY_LEN(color) ){
     case 3:
       return SDL_MapRGB(format,
 			NUM2UINT(rb_ary_entry(color,0)),
@@ -49,31 +108,34 @@ Uint32 VALUE2COLOR(VALUE color,SDL_PixelFormat *format)
   }
 }
 
-static VALUE sdl_getVideoSurface(VALUE mod)
+static VALUE Screen_s_get(VALUE klass)
 {
   SDL_Surface *surface;
+  rb_secure(4);
   surface = SDL_GetVideoSurface();
   if(surface==NULL)
     rb_raise(eSDLError,"Couldn't get video surface: %s",SDL_GetError());
-  return Data_Wrap_Struct(cSurface,0,0,surface);
+  return Screen_create(surface);
 }
 
-static VALUE sdl_videoDriverName(VALUE mod)
+static VALUE Screen_s_driverName(VALUE klass)
 {
   char namebuf[256];
+  rb_secure(4);
   if(SDL_VideoDriverName(namebuf, sizeof(namebuf)) == NULL) {
     rb_raise(eSDLError, "SDL is not initialized yet: %s", SDL_GetError());
   }
   return rb_str_new2( namebuf );
 }
 
-static VALUE sdl_listModes(VALUE mod,VALUE flags)
+static VALUE Screen_s_listModes(VALUE klass,VALUE flags)
 {
   SDL_Rect **modes;
   int i;
-  VALUE modesArray;
-  
-  modes=SDL_ListModes(NULL,NUM2UINT(flags));
+  VALUE array;
+
+  rb_secure(4);
+  modes = SDL_ListModes(NULL,NUM2UINT(flags));
 
   if( modes == NULL )
     return Qnil;/* no modes available */
@@ -81,61 +143,62 @@ static VALUE sdl_listModes(VALUE mod,VALUE flags)
     return Qtrue;/* all resolutions available */
 
   /* available modes into modesArray */
-  modesArray=rb_ary_new();
+  array = rb_ary_new();
   
   for(i=0;modes[i]!=NULL;++i){
-    rb_ary_push( modesArray,
-		 rb_ary_new3( 2, INT2NUM(modes[i]->w), INT2NUM(modes[i]->h)) );
+    rb_ary_push(array,
+                rb_ary_new3(2, INT2NUM(modes[i]->w), INT2NUM(modes[i]->h)));
   }
-  return modesArray;
+  return array;
 }
 
-static VALUE sdl_checkVideoMode(VALUE mod,VALUE w,VALUE h,VALUE bpp,
-				VALUE flags)
+static VALUE Screen_s_checkMode(VALUE klass,VALUE w,VALUE h,VALUE bpp,
+                                VALUE flags)
 {
-  return INT2FIX( SDL_VideoModeOK(NUM2INT(w),NUM2INT(h),NUM2INT(bpp),
-				  NUM2UINT(flags)) );
+  rb_secure(4);
+  return INT2FIX(SDL_VideoModeOK(NUM2INT(w),NUM2INT(h),NUM2INT(bpp),
+                                 NUM2UINT(flags)));
 }
-static VALUE sdl_getVideoInfo(VALUE mod)
+
+static VALUE Screen_s_info(VALUE klass)
 {
   const SDL_VideoInfo *info;
   VALUE obj;
+  rb_secure(4);
+  
   info = SDL_GetVideoInfo();
   if(info==NULL)
     rb_raise(eSDLError,"Couldn't get video information");
   obj=rb_obj_alloc(cVideoInfo);
-  rb_iv_set(obj,"@hw_available",BOOL(info->hw_available));
-  rb_iv_set(obj,"@wm_available",BOOL(info->wm_available));
-  rb_iv_set(obj,"@blit_hw",BOOL(info->blit_hw));
-  rb_iv_set(obj,"@blit_hw_CC",BOOL(info->blit_hw_CC));
-  rb_iv_set(obj,"@blit_hw_A",BOOL(info->blit_hw_A));
-  rb_iv_set(obj,"@blit_sw",BOOL(info->blit_sw));
-  rb_iv_set(obj,"@blit_sw_CC",BOOL(info->blit_sw_CC));
-  rb_iv_set(obj,"@blit_sw_A",BOOL(info->blit_sw_A));
-  rb_iv_set(obj,"@blit_fill",BOOL(info->blit_fill));
+  rb_iv_set(obj,"@hw_available",INT2BOOL(info->hw_available));
+  rb_iv_set(obj,"@wm_available",INT2BOOL(info->wm_available));
+  rb_iv_set(obj,"@blit_hw",INT2BOOL(info->blit_hw));
+  rb_iv_set(obj,"@blit_hw_CC",INT2BOOL(info->blit_hw_CC));
+  rb_iv_set(obj,"@blit_hw_A",INT2BOOL(info->blit_hw_A));
+  rb_iv_set(obj,"@blit_sw",INT2BOOL(info->blit_sw));
+  rb_iv_set(obj,"@blit_sw_CC",INT2BOOL(info->blit_sw_CC));
+  rb_iv_set(obj,"@blit_sw_A",INT2BOOL(info->blit_sw_A));
+  rb_iv_set(obj,"@blit_fill",INT2BOOL(info->blit_fill));
   rb_iv_set(obj,"@video_mem",UINT2NUM(info->video_mem));
   rb_iv_set(obj,"@bpp",UINT2NUM(info->vfmt->BitsPerPixel));
   return obj;
 }
 
 
-static VALUE sdl_updateRect(VALUE obj,VALUE x,VALUE y,VALUE w,VALUE h)
+static VALUE Screen_updateRect(VALUE self,VALUE x,VALUE y,VALUE w,VALUE h)
 {
-  SDL_Surface *screen;
-  Data_Get_Struct(obj,SDL_Surface,screen);
-  SDL_UpdateRect(screen,NUM2INT(x),NUM2INT(y),NUM2INT(w),NUM2INT(h));
+  rb_secure(4);
+  SDL_UpdateRect(Get_SDL_Surface(self),
+                 NUM2INT(x),NUM2INT(y),NUM2INT(w),NUM2INT(h));
   return Qnil;
 }
 
-static VALUE sdl_updateRects(int argc, VALUE *argv, VALUE obj)
+static VALUE Screen_updateRects(int argc, VALUE *argv, VALUE self)
 {
-  SDL_Surface *screen;
   SDL_Rect* rects;
   int i;
-  
-  Data_Get_Struct(obj,SDL_Surface,screen);
-  rects = ALLOCA_N(SDL_Rect, argc);
 
+  rects = ALLOCA_N(SDL_Rect, argc);
   for (i=0; i<argc; i++) {
     rects[i].x = NUM2INT(rb_ary_entry(argv[i], 0));
     rects[i].y = NUM2INT(rb_ary_entry(argv[i], 1));
@@ -143,54 +206,56 @@ static VALUE sdl_updateRects(int argc, VALUE *argv, VALUE obj)
     rects[i].h = NUM2INT(rb_ary_entry(argv[i], 3));
   }
 
-  SDL_UpdateRects(screen, argc, rects);
+  SDL_UpdateRects(Get_SDL_Surface(self), argc, rects);
   return Qnil;
 }
 
-static VALUE sdl_flip(VALUE obj)
+static VALUE Screen_flip(VALUE self)
 {
-  SDL_Surface *screen;
-  Data_Get_Struct(obj,SDL_Surface,screen);
-  if( SDL_Flip(screen) < 0 ){
-    rb_raise( eSDLError,"flip fail : %s",SDL_GetError() );
+  rb_secure(4);
+  if( SDL_Flip(Get_SDL_Surface(self)) < 0 ){
+    rb_raise(eSDLError,"flip fail : %s",SDL_GetError());
   }
   return Qnil;
 }
 
-static VALUE sdl_toggleFullScreen(VALUE obj)
+static VALUE Screen_toggleFullScreen(VALUE self)
 {
-  SDL_Surface *screen;
-  Data_Get_Struct(obj,SDL_Surface,screen);
-  if( SDL_WM_ToggleFullScreen(screen)==0 ){
+  rb_secure(4);
+  if( SDL_WM_ToggleFullScreen(Get_SDL_Surface(self)) == 0 ){
     rb_raise( eSDLError,"toggle full screen fail : %s", SDL_GetError() );
   }
   return Qnil;
 }
 
-static VALUE sdl_setVideoMode(VALUE mod,VALUE w,VALUE h,VALUE bpp,
-       VALUE flags)
+static VALUE Screen_s_open(VALUE klass,VALUE w,VALUE h,VALUE bpp,
+                           VALUE flags)
 {
   SDL_Surface *screen;
+  rb_secure(4);
   screen=SDL_SetVideoMode(NUM2INT(w),NUM2INT(h),NUM2INT(bpp),
 			  NUM2UINT(flags));
   if( screen==NULL ){
     rb_raise(eSDLError,"Cound't set %dx%d %d bpp video mode: %s",
 	     NUM2INT(w),NUM2INT(h),NUM2INT(bpp),SDL_GetError());
   }  
-  return Data_Wrap_Struct(cScreen,0,0,screen);
+  return Screen_create(screen);
 }
-static VALUE sdl_setGamma(VALUE mod,VALUE rgamma,VALUE ggamma,VALUE bgamma)
+
+static VALUE Screen_s_setGamma(VALUE klass,VALUE rgamma,VALUE ggamma,VALUE bgamma)
 {
+  rb_secure(4);
   if(SDL_SetGamma(NUM2DBL(rgamma),NUM2DBL(ggamma),NUM2DBL(bgamma))==-1)
     rb_raise(eSDLError,"set gamma failed: %s",SDL_GetError());
   return Qnil;
 }
 
-static VALUE sdl_getGammaRamp(VALUE mod)
+static VALUE Screen_s_getGammaRamp(VALUE klass)
 {
   Uint16 table[3][256];
   VALUE ary_table, ary_subtable;
   int i,j;
+  rb_secure(4);
   
   if( SDL_GetGammaRamp( table[0], table[1], table[2] ) == -1 ){
     rb_raise(eSDLError,"cannot get gamma lookup table: %s",SDL_GetError());
@@ -207,53 +272,54 @@ static VALUE sdl_getGammaRamp(VALUE mod)
   return ary_table;
 }
 
-static VALUE sdl_setGammaRamp(VALUE mod, VALUE ary_table)
+static VALUE Screen_s_setGammaRamp(VALUE klass, VALUE ary_table)
 {
   Uint16 table[3][256];
-  VALUE ary_subtable;
+  VALUE subtable;
   int i,j;
-
+  
+  rb_secure(4);
+  Check_Type(ary_table, T_ARRAY);
+  
   for( i=0; i<3; ++i ){
-    ary_subtable = rb_ary_entry( ary_table, i );
+    subtable = rb_ary_entry(ary_table, i);
+    Check_Type(subtable, T_ARRAY);
     for( j=0; j<256; ++j ){
-      table[i][j] = NUM2INT( rb_ary_entry( ary_subtable, j ) );
+      table[i][j] = NUM2INT(rb_ary_entry(subtable, j));
     }
   }
-  if( SDL_SetGammaRamp( table[0], table[1], table[2] )==-1 ){
+  if(SDL_SetGammaRamp(table[0], table[1], table[2]) == -1){
     rb_raise(eSDLError,"cannot set gamma lookup table: %s",SDL_GetError());
   }
   return Qnil;
 }
 
-static VALUE sdl_createSurface(VALUE class,VALUE flags,VALUE w,VALUE h,
-			       VALUE format)
+static VALUE Surface_s_create(VALUE klass,VALUE flags,VALUE w,VALUE h,
+                              VALUE pixel_format)
 {
-  SDL_Surface *newSurface;
-  SDL_Surface *formatSurface;
-  SDL_PixelFormat *pixFormat;
-  if( rb_obj_is_kind_of( format,cSurface ) ){
-    Data_Get_Struct(format,SDL_Surface,formatSurface);
-  }else{
-    rb_raise( rb_eArgError,"type mismatch(expect Surface)" );
-  }
-  pixFormat = formatSurface->format;
-  newSurface = SDL_CreateRGBSurface( NUM2UINT(flags),NUM2INT(w),NUM2INT(h),
-				     pixFormat->BitsPerPixel,
-				     pixFormat->Rmask,pixFormat->Gmask,
-				     pixFormat->Bmask,pixFormat->Amask );
-  if( newSurface==NULL ){
-    rb_raise( eSDLError,"Couldn't Create Surface: %s",SDL_GetError() );
-  }
-  return Data_Wrap_Struct(class,0,sdl_freeSurface,newSurface);
+  SDL_Surface* surface;
+  SDL_PixelFormat* format;
+
+  rb_secure(4);
+  format = Get_SDL_PixelFormat(pixel_format);
+  surface = SDL_CreateRGBSurface(NUM2UINT(flags),NUM2INT(w),NUM2INT(h),
+                                 format->BitsPerPixel,
+                                 format->Rmask,format->Gmask,
+                                 format->Bmask,format->Amask);
+  if(surface == NULL)
+    rb_raise(eSDLError,"Couldn't Create Surface: %s",SDL_GetError());
+
+  return Surface_create(surface);
 }
 
-static VALUE sdl_createSurfaceWithFormat(VALUE class,VALUE flags,VALUE w,
-                                         VALUE h,VALUE depth,VALUE Rmask,
-                                         VALUE Gmask,VALUE Bmask,
-                                         VALUE Amask)
+static VALUE Surface_s_createWithFormat(VALUE klass,VALUE flags,VALUE w,
+                                      VALUE h,VALUE depth,VALUE Rmask,
+                                      VALUE Gmask,VALUE Bmask,
+                                      VALUE Amask)
 {
   SDL_Surface *surface;
 
+  rb_secure(4);
   surface = SDL_CreateRGBSurface(NUM2UINT(flags),NUM2INT(w),NUM2INT(h),
                                  NUM2UINT(depth),NUM2UINT(Rmask),
                                  NUM2UINT(Gmask),NUM2UINT(Bmask),
@@ -261,21 +327,21 @@ static VALUE sdl_createSurfaceWithFormat(VALUE class,VALUE flags,VALUE w,
   if( surface == NULL ){
     rb_raise(eSDLError,"Couldn't Create Surface: %s",SDL_GetError());
   }
-  return Data_Wrap_Struct(class,0,sdl_freeSurface,surface);
+  return Surface_create(surface);
 }
 
 
-static VALUE sdl_createSurfaceFrom(VALUE class,VALUE pixels,VALUE w,
-                                   VALUE h,VALUE depth,VALUE pitch,
-                                   VALUE Rmask,VALUE Gmask,VALUE Bmask,
-                                   VALUE Amask)
+static VALUE Surface_s_createFrom(VALUE klass,VALUE pixels,VALUE w,
+                                  VALUE h,VALUE depth,VALUE pitch,
+                                  VALUE Rmask,VALUE Gmask,VALUE Bmask,
+                                  VALUE Amask)
 {
   SDL_Surface *surface;
   void* pixel_data;
   
   StringValue(pixels);
-  pixel_data = ALLOC_N(char, RSTRING(pixels)->len);
-  memcpy(pixel_data,RSTRING(pixels)->ptr,RSTRING(pixels)->len);
+  pixel_data = ALLOC_N(char, RSTRING_LEN(pixels));
+  memcpy(pixel_data,RSTRING_PTR(pixels),RSTRING_LEN(pixels));
   
   surface = SDL_CreateRGBSurfaceFrom(pixel_data,NUM2INT(w),NUM2INT(h),
                                      NUM2UINT(depth),NUM2INT(pitch),
@@ -285,21 +351,24 @@ static VALUE sdl_createSurfaceFrom(VALUE class,VALUE pixels,VALUE w,
     rb_raise(eSDLError,"Couldn't Create Surface: %s",SDL_GetError());
   }
   surface->flags &= ~SDL_PREALLOC;
-  return Data_Wrap_Struct(class,0,sdl_freeSurface,surface);
+  return Surface_create(surface);
 }
 
-static VALUE sdl_loadBMP(VALUE class,VALUE filename)
+static VALUE Surface_s_loadBMP(VALUE klass,VALUE filename)
 {
   SDL_Surface *image;
-  image=SDL_LoadBMP(GETCSTR(filename));
-  if( image==NULL ){
+  rb_secure(4);
+  SafeStringValue(filename);
+  
+  image = SDL_LoadBMP(RSTRING_PTR(filename));
+  if(image == NULL){
     rb_raise(eSDLError,"Couldn't Load BMP file %s : %s",
-	     GETCSTR(filename),SDL_GetError());
+	     RSTRING_PTR(filename),SDL_GetError());
   }
-  return Data_Wrap_Struct(class,0,sdl_freeSurface,image);
+  return Surface_create(image);
 }
 
-static VALUE sdl_loadBMPFromIO(VALUE class, VALUE io)
+static VALUE Surface_s_loadBMPFromIO(VALUE class, VALUE io)
 {
   volatile VALUE guard = io;
   SDL_Surface* image;
@@ -307,45 +376,94 @@ static VALUE sdl_loadBMPFromIO(VALUE class, VALUE io)
   if(image == NULL)
     rb_raise(eSDLError, "Couldn't Load BMP file from IO : %s",
              SDL_GetError());
-  return Data_Wrap_Struct(class,0,sdl_freeSurface,image);
+  return Surface_create(image);
 }
 
-static VALUE sdl_saveBMP(VALUE obj,VALUE filename)
+static VALUE Surface_s_loadBMPFromString(VALUE class, VALUE str)
 {
-  SDL_Surface *image;
-  Data_Get_Struct( obj, SDL_Surface, image );
-  if( SDL_SaveBMP( image, GETCSTR(filename) )==-1 ){
-    rb_raise(eSDLError,"cannot save %s: %s",GETCSTR(filename),SDL_GetError());
+  SDL_Surface* image;
+  rb_secure(4);
+  SafeStringValue(str);
+  
+  image = SDL_LoadBMP_RW(SDL_RWFromConstMem(RSTRING_PTR(str),
+                                            RSTRING_LEN(str)),
+                         1);
+  if(image == NULL)
+    rb_raise(eSDLError, "Couldn't Load BMP file from String : %s",
+             SDL_GetError());
+  return Surface_create(image);
+}
+
+static VALUE Surface_saveBMP(VALUE self,VALUE filename)
+{
+  rb_secure(4);
+  SafeStringValue(filename);
+  if( SDL_SaveBMP(Get_SDL_Surface(self), RSTRING_PTR(filename))==-1 ){
+    rb_raise(eSDLError,"cannot save %s: %s",RSTRING_PTR(filename),SDL_GetError());
   }
   return Qnil;
 }
+
+static VALUE Surface_destroy(VALUE self)
+{
+  Surface* sur = GetSurface(self);
+  if(!rubysdl_is_quit() && sur->surface)
+    SDL_FreeSurface(sur->surface);
+  sur->surface = NULL;
+  return Qnil;
+}
+
+static VALUE Surface_format(VALUE self)
+{
+  SDL_Surface* surface = Get_SDL_Surface(self);
+  SDL_PixelFormat* format = ALLOC(SDL_PixelFormat);
+  SDL_Palette* palette;
   
-static VALUE sdl_displayFormat(VALUE obj)
+  if(surface->format->palette){
+    palette = ALLOC(SDL_Palette);
+    palette->ncolors = surface->format->palette->ncolors;
+    palette->colors = ALLOC_N(SDL_Color, surface->format->palette->ncolors);
+    memcpy(palette->colors, surface->format->palette->colors,
+           surface->format->palette->ncolors * sizeof(SDL_Color));
+  }else{
+    palette = NULL;
+  }
+  
+  *format = *(surface->format);
+  format->palette = palette;
+
+  return Data_Wrap_Struct(cPixelFormat,0,PixelFormat_free,format);
+}
+
+static VALUE Surface_displayFormat(VALUE self)
 {
-  SDL_Surface *srcImage,*destImage;
-  Data_Get_Struct(obj,SDL_Surface,srcImage);
-  destImage=SDL_DisplayFormat(srcImage);
-  if( destImage==NULL ){
+  SDL_Surface *result;
+
+  rb_secure(4);
+  result = SDL_DisplayFormat(Get_SDL_Surface(self));
+  if(result==NULL){
     rb_raise(eSDLError,"Couldn't convert surface format: %s",SDL_GetError());
   }
-  return Data_Wrap_Struct(cSurface,0,sdl_freeSurface,destImage);
+  return Surface_create(result);
 }
 
-static VALUE sdl_displayFormatAlpha(VALUE obj)
+static VALUE Surface_displayFormatAlpha(VALUE self)
 {
-  SDL_Surface *srcImage,*destImage;
-  Data_Get_Struct(obj,SDL_Surface,srcImage);
-  destImage=SDL_DisplayFormatAlpha(srcImage);
-  if( destImage==NULL ){
+  SDL_Surface *result;
+
+  rb_secure(4);
+  result = SDL_DisplayFormatAlpha(Get_SDL_Surface(self));
+  if(result==NULL){
     rb_raise(eSDLError,"Couldn't convert surface format: %s",SDL_GetError());
   }
-  return Data_Wrap_Struct(cSurface,0,sdl_freeSurface,destImage);
+  return Surface_create(result);
 }
 
-static VALUE sdl_setColorKey(VALUE obj,VALUE flag,VALUE key)
+static VALUE Surface_setColorKey(VALUE self,VALUE flag,VALUE key)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
+  SDL_Surface *surface = Get_SDL_Surface(self);
+  rb_secure(4);
+  
   if( SDL_SetColorKey(surface,NUM2UINT(flag),VALUE2COLOR(key,surface->format))
       < 0 ){
     rb_raise(eSDLError,"setColorKey failed: %s",SDL_GetError());
@@ -353,117 +471,112 @@ static VALUE sdl_setColorKey(VALUE obj,VALUE flag,VALUE key)
   return Qnil;
 }
 
+static VALUE zero_rect_p(SDL_Rect rect)
+{
+  return rect.x == 0 && rect.y == 0 && rect.w == 0 && rect.h == 0;
+}
+
 /* return 0 if succeed, return -2 video memory lost (on Direct X)*/
-static VALUE sdl_blitSurface(VALUE obj,VALUE src,VALUE srcX,VALUE srcY,
-			     VALUE srcW,VALUE srcH,VALUE dest,VALUE destX,
-			     VALUE destY)
+static VALUE Surface_s_blit(VALUE klass,VALUE src,VALUE srcX,VALUE srcY,
+                            VALUE srcW,VALUE srcH,VALUE dst,VALUE destX,
+                            VALUE destY)
 {
-  SDL_Surface *srcSurface,*destSurface;
-  SDL_Rect srcRect,destRect;
+  SDL_Surface *src_surface,*dst_surface;
+  SDL_Rect src_rect,dst_rect;
+  SDL_Rect *sr, *dr;
   int result;
 
-  if( !rb_obj_is_kind_of(src,cSurface) ||
-      !rb_obj_is_kind_of(dest,cSurface) ){
-    rb_raise(rb_eArgError,"type mismatch");
-  }
-  Data_Get_Struct(src,SDL_Surface,srcSurface);
-  Data_Get_Struct(dest,SDL_Surface,destSurface);
-
-  if (NUM2INT(srcX)==0&&NUM2INT(srcY)==0&&NUM2INT(srcW)==0&&NUM2INT(srcH)==0){
-    if (NUM2INT(destX)==0&&NUM2INT(destY)==0&&NUM2INT(srcW)==0&&NUM2INT(srcH)==0){
-      result = SDL_BlitSurface(srcSurface,NULL,destSurface,NULL);
-    }else{
-      SetRect(destRect,destX,destY,srcW,srcH);
-      result = SDL_BlitSurface(srcSurface,NULL,destSurface,&destRect);
-    }
-  }else{
-    SetRect(srcRect,srcX,srcY,srcW,srcH);
-    if (NUM2INT(destX)==0&&NUM2INT(destY)==0&&NUM2INT(srcW)==0&&NUM2INT(srcH)==0){
-      result = SDL_BlitSurface(srcSurface,&srcRect,destSurface,NULL);
-    }else{
-      SetRect(destRect,destX,destY,srcW,srcH);
-      result = SDL_BlitSurface(srcSurface,&srcRect,destSurface,&destRect);
-    }
-  }
+  rb_secure(4);
+  SetRect(dst_rect,destX,destY,srcW,srcH);
+  SetRect(src_rect,srcX,srcY,srcW,srcH);
+
+  src_surface = Get_SDL_Surface(src);
+  dst_surface = Get_SDL_Surface(dst);
 
+  sr = (zero_rect_p(src_rect))?NULL:&src_rect;
+  dr = (zero_rect_p(dst_rect))?NULL:&dst_rect;
+  
+  result = SDL_BlitSurface(src_surface, sr, dst_surface, dr);
+  
   if( result == -1 ){
-    rb_raise(eSDLError,"SDL_BlitSurface fail: %s",SDL_GetError());
+    rb_raise(eSDLError,"SDL::Surface.blit fail: %s",SDL_GetError());
   }
   return INT2NUM(result);
 }
 
-static VALUE sdl_setAlpha(VALUE obj,VALUE flag,VALUE alpha)
+static VALUE Surface_setAlpha(VALUE self,VALUE flag,VALUE alpha)
 {
-  SDL_Surface *surface;
-
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  SDL_SetAlpha(surface,NUM2UINT(flag),NUM2INT(alpha));
+  rb_secure(4);
+  SDL_SetAlpha(Get_SDL_Surface(self),NUM2UINT(flag),NUM2INT(alpha));
   return Qnil;
 }
 
-static VALUE sdl_setClipRect(VALUE obj,VALUE x,VALUE y,VALUE w,VALUE h)
+static VALUE Surface_setClipRect(VALUE self,VALUE x,VALUE y,VALUE w,VALUE h)
 {
-  SDL_Surface *surface;
   SDL_Rect rect;
 
-  Data_Get_Struct(obj,SDL_Surface,surface);
+  rb_secure(4);
   SetRect(rect,x,y,w,h);
-  SDL_SetClipRect(surface,&rect);
+  SDL_SetClipRect(Get_SDL_Surface(self),&rect);
   return Qnil;
 }
 
-static VALUE sdl_getClipRect(VALUE obj)
+static VALUE Surface_getClipRect(VALUE self)
 {
-  SDL_Surface *surface;
   SDL_Rect rect;
-  VALUE ary_rect;
-  
-  Data_Get_Struct( obj, SDL_Surface, surface );
-  SDL_GetClipRect( surface, &rect );
-  
-  ary_rect = rb_ary_new();
-  rb_ary_push( ary_rect, INT2FIX(rect.x) );
-  rb_ary_push( ary_rect, INT2FIX(rect.y) );
-  rb_ary_push( ary_rect, INT2FIX(rect.w) );
-  rb_ary_push( ary_rect, INT2FIX(rect.h) );
-  
-  return ary_rect;
+
+  rb_secure(4);
+  SDL_GetClipRect( Get_SDL_Surface(self), &rect );
+  return rb_ary_new3(INT2FIX(rect.x),INT2FIX(rect.y),
+                     INT2FIX(rect.w),INT2FIX(rect.h));
 }
 
-static VALUE sdl_fillRect(VALUE obj,VALUE x,VALUE y,VALUE w,VALUE h,
-		      VALUE color)
+static VALUE Surface_fillRect(VALUE self,VALUE x,VALUE y,VALUE w,VALUE h,
+                              VALUE color)
 {
-  SDL_Surface *surface;
+  SDL_Surface *surface = Get_SDL_Surface(self);
   SDL_Rect rect;
-  
+
+  rb_secure(4);
   SetRect(rect,x,y,w,h);
-  Data_Get_Struct(obj,SDL_Surface,surface);
   if( SDL_FillRect(surface,&rect,VALUE2COLOR(color,surface->format)) < 0 ){
     rb_raise(eSDLError,"fillRect fail: %s",SDL_GetError());
   }
   return Qnil;
 }
 
-static VALUE sdl_surfaceH(VALUE obj)
+static VALUE Surface_h(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return INT2NUM( surface->h );
+  return INT2NUM(Get_SDL_Surface(self)->h);
 }
-static VALUE sdl_surfaceW(VALUE obj)
+
+static VALUE Surface_w(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return INT2NUM( surface->w );
+  return INT2NUM(Get_SDL_Surface(self)->w);
+}
+
+static VALUE Surface_getPixel(VALUE self, VALUE x, VALUE y)
+{
+  return UINT2NUM(rubysdl_getPixel(Get_SDL_Surface(self),
+                                   NUM2INT(x), NUM2INT(y)));
+}
+static VALUE Surface_putPixel(VALUE self, VALUE x, VALUE y, VALUE color)
+{
+  SDL_Surface* surface = Get_SDL_Surface(self);
+  rubysdl_putPixel(surface,
+                   NUM2INT(x), NUM2INT(y), VALUE2COLOR(color,surface->format));
+  return Qnil;
 }
 
 /* palette and colormap methods */
-static void check_given_colors(VALUE colors,VALUE firstcolor)
+static void check_colors(VALUE colors,VALUE firstcolor)
 {
   if( NUM2INT(firstcolor)<0 || NUM2INT(firstcolor)>255 )
     rb_raise(eSDLError,"firstcolor must be more than 0,less than 255");
+  
   Check_Type(colors,T_ARRAY);
-  if( RARRAY(colors)->len+NUM2INT(firstcolor) > 256 )
+  
+  if( RARRAY_LEN(colors)+NUM2INT(firstcolor) > 256 )
     rb_raise(eSDLError,"colors is too large");
 }
 static void set_colors_to_array(VALUE colors,SDL_Color palette[])
@@ -471,10 +584,10 @@ static void set_colors_to_array(VALUE colors,SDL_Color palette[])
   VALUE color;
   int i;
   
-  for( i=0; i < RARRAY(colors)->len; ++i){
+  for( i=0; i < RARRAY_LEN(colors); ++i){
     color = rb_ary_entry(colors,i);
     Check_Type(color,T_ARRAY);
-    if( RARRAY(color)->len != 3)
+    if( RARRAY_LEN(color) != 3)
       rb_raise(rb_eArgError,"a color must be array that has 3 length");
     palette[i].r = NUM2INT(rb_ary_entry(color,0));
     palette[i].g = NUM2INT(rb_ary_entry(color,1));
@@ -483,229 +596,281 @@ static void set_colors_to_array(VALUE colors,SDL_Color palette[])
   
 }
 
-static VALUE sdl_setPalette(VALUE obj,VALUE flags,VALUE colors,VALUE firstcolor)
+static VALUE Surface_setPalette(VALUE self,VALUE flags,
+                                VALUE colors,VALUE firstcolor)
 {
-  SDL_Surface *surface;
   SDL_Color palette[256];
   
-  check_given_colors(colors,firstcolor);
-  
-  Data_Get_Struct(obj,SDL_Surface,surface);
-
+  check_colors(colors,firstcolor);
   set_colors_to_array(colors,palette);
-  
-  return BOOL(SDL_SetPalette( surface, NUM2UINT(flags), palette,
-			      NUM2INT(firstcolor), RARRAY(colors)->len));
+
+  rb_secure(4);
+  return INT2BOOL(SDL_SetPalette(Get_SDL_Surface(self), NUM2UINT(flags), palette,
+                                 NUM2INT(firstcolor), RARRAY_LEN(colors)));
 }
 
-static VALUE sdl_setColors(VALUE obj,VALUE colors,VALUE firstcolor)
+static VALUE Surface_setColors(VALUE self,VALUE colors,VALUE firstcolor)
 {
-  SDL_Surface *surface;
   SDL_Color palette[256];
 
-  check_given_colors(colors,firstcolor);
-  Data_Get_Struct(obj,SDL_Surface,surface);
+  rb_secure(4);
+  check_colors(colors,firstcolor);
   set_colors_to_array(colors,palette);
-  return BOOL(SDL_SetColors( surface, palette,
-			     NUM2INT(firstcolor), RARRAY(colors)->len));
+  return INT2BOOL(SDL_SetColors(Get_SDL_Surface(self), palette,
+                                NUM2INT(firstcolor), RARRAY_LEN(colors)));
 }
 
-static VALUE sdl_getPalette(VALUE obj)
+static VALUE PixelFormat_pallete(VALUE self)
 {
-  SDL_Surface *surface;
+  SDL_PixelFormat* format = Get_SDL_PixelFormat(self);
   int i;
   VALUE palette;
   SDL_Color *colors;
   VALUE color;
-  
-  Data_Get_Struct(obj,SDL_Surface,surface);
 
-  if( surface->format->palette == NULL )
+  if(format->palette == NULL)
     return Qnil;
 
   palette = rb_ary_new();
-  colors = surface->format->palette->colors;
-  
-  for( i=0; i < surface->format->palette->ncolors; ++i ){
-    color = rb_ary_new3( 3, INT2NUM(colors[i].r), INT2NUM(colors[i].g), INT2NUM(colors[i].b) );
-    rb_ary_push( palette, color );
+  colors = format->palette->colors;
+
+  for( i=0; i < format->palette->ncolors; ++i ){
+    color = rb_ary_new3(3, INT2NUM(colors[i].r), INT2NUM(colors[i].g), INT2NUM(colors[i].b));
+    rb_ary_push(palette, color);
   }
   return palette;
 }
 
 /* surface lock methods */
-static VALUE sdl_mustlock(VALUE obj)
+static VALUE Surface_mustlock_p(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return BOOL( SDL_MUSTLOCK(surface) );
+  rb_secure(4);
+  return INT2BOOL(SDL_MUSTLOCK(Get_SDL_Surface(self)));
 }
-static VALUE sdl_lockSurface(VALUE obj)
+static VALUE Surface_lock(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return INT2FIX(SDL_LockSurface(surface));
+  rb_secure(4);
+  return INT2FIX(SDL_LockSurface(Get_SDL_Surface(self)));
 }
-static VALUE sdl_unlockSurface(VALUE obj)
+static VALUE Surface_unlock(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  SDL_UnlockSurface(surface);
+  rb_secure(4);
+  SDL_UnlockSurface(Get_SDL_Surface(self));
   return Qnil;
 }
 
 /* methods to get infomation from SDL_PixelFormat */
-static VALUE sdl_mapRGB(VALUE obj,VALUE r,VALUE g,VALUE b)
+static VALUE PixelFormat_mapRGB(VALUE self,VALUE r,VALUE g,VALUE b)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM( SDL_MapRGB( surface->format,NUM2INT(r),NUM2INT(g),
-			       NUM2INT(b) ) );
+  return UINT2NUM(SDL_MapRGB(Get_SDL_PixelFormat(self),NUM2INT(r),NUM2INT(g),
+                             NUM2INT(b)));
 }
-static VALUE sdl_mapRGBA(VALUE obj,VALUE r,VALUE g,VALUE b,VALUE a)
+static VALUE PixelFormat_mapRGBA(VALUE self,VALUE r,VALUE g,VALUE b,VALUE a)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM( SDL_MapRGBA( surface->format,NUM2INT(r),NUM2INT(g),NUM2INT(b),
-				NUM2INT(a) ) );
+  return UINT2NUM(SDL_MapRGBA(Get_SDL_PixelFormat(self),NUM2INT(r),NUM2INT(g),
+                              NUM2INT(b),NUM2INT(a)));
 }
-static VALUE sdl_getRGB(VALUE obj,VALUE pixel)
+static VALUE PixelFormat_getRGB(VALUE self,VALUE pixel)
 {
-  SDL_Surface *surface;
   Uint8 r,g,b;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  SDL_GetRGB(NUM2UINT(pixel),surface->format,&r,&g,&b);
-  return rb_ary_new3( 3,UINT2NUM(r),UINT2NUM(g),UINT2NUM(b) );
+  SDL_GetRGB(NUM2UINT(pixel),Get_SDL_PixelFormat(self),&r,&g,&b);
+  return rb_ary_new3(3,UINT2NUM(r),UINT2NUM(g),UINT2NUM(b));
 }
-static VALUE sdl_getRGBA(VALUE obj,VALUE pixel)
+static VALUE PixelFormat_getRGBA(VALUE self,VALUE pixel)
 {
-  SDL_Surface *surface;
   Uint8 r,g,b,a;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  SDL_GetRGBA(NUM2UINT(pixel),surface->format,&r,&g,&b,&a);
-  return rb_ary_new3( 4,UINT2NUM(r),UINT2NUM(g),UINT2NUM(b),UINT2NUM(a) );
+  SDL_GetRGBA(NUM2UINT(pixel),Get_SDL_PixelFormat(self),&r,&g,&b,&a);
+  return rb_ary_new3(4,UINT2NUM(r),UINT2NUM(g),UINT2NUM(b),UINT2NUM(a));
 }
-static VALUE sdl_getBpp(VALUE obj)
+static VALUE PixelFormat_bpp(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return INT2FIX(surface->format->BitsPerPixel);
+  return INT2FIX(Get_SDL_PixelFormat(self)->BitsPerPixel);
 }
-static VALUE sdl_getColorkey(VALUE obj)
+
+static VALUE PixelFormat_colorkey(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->format->colorkey);
+  return UINT2NUM(Get_SDL_PixelFormat(self)->colorkey);
 }
-static VALUE sdl_getAlpha(VALUE obj)
+
+static VALUE PixelFormat_alpha(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->format->alpha);
+  return UINT2NUM(Get_SDL_PixelFormat(self)->alpha);
 }
-static VALUE sdl_getFlags(VALUE obj)
+
+static VALUE Surface_flags(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->flags);
+  return UINT2NUM(Get_SDL_Surface(self)->flags);
 }
-static VALUE sdl_surface_rmask(VALUE obj)
+
+static VALUE PixelFormat_rmask(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->format->Rmask);
+  return UINT2NUM(Get_SDL_PixelFormat(self)->Rmask);
 }
-static VALUE sdl_surface_gmask(VALUE obj)
+
+static VALUE PixelFormat_gmask(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->format->Gmask);
+  return UINT2NUM(Get_SDL_PixelFormat(self)->Gmask);
 }
-static VALUE sdl_surface_bmask(VALUE obj)
+
+static VALUE PixelFormat_bmask(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->format->Bmask);
+  return UINT2NUM(Get_SDL_PixelFormat(self)->Bmask);
 }
-static VALUE sdl_surface_amask(VALUE obj)
+
+static VALUE PixelFormat_amask(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->format->Amask);
+  return UINT2NUM(Get_SDL_PixelFormat(self)->Amask);
 }
-static VALUE sdl_surface_rloss(VALUE obj)
+
+static VALUE PixelFormat_Rloss(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->format->Rloss);
+  return UINT2NUM(Get_SDL_PixelFormat(self)->Rloss);
 }
-static VALUE sdl_surface_gloss(VALUE obj)
+static VALUE PixelFormat_Gloss(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->format->Gloss);
+  return UINT2NUM(Get_SDL_PixelFormat(self)->Gloss);
 }
-static VALUE sdl_surface_bloss(VALUE obj)
+static VALUE PixelFormat_Bloss(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->format->Bloss);
+  return UINT2NUM(Get_SDL_PixelFormat(self)->Rloss);
 }
-static VALUE sdl_surface_aloss(VALUE obj)
+static VALUE PixelFormat_Aloss(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->format->Aloss);
+  return UINT2NUM(Get_SDL_PixelFormat(self)->Aloss);
 }
-static VALUE sdl_surface_rshift(VALUE obj)
+
+static VALUE PixelFormat_Rshift(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->format->Rshift);
+  return UINT2NUM(Get_SDL_PixelFormat(self)->Rshift);
 }
-static VALUE sdl_surface_gshift(VALUE obj)
+static VALUE PixelFormat_Gshift(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->format->Gshift);
+  return UINT2NUM(Get_SDL_PixelFormat(self)->Gshift);
 }
-static VALUE sdl_surface_bshift(VALUE obj)
+static VALUE PixelFormat_Bshift(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->format->Bshift);
+  return UINT2NUM(Get_SDL_PixelFormat(self)->Bshift);
 }
-static VALUE sdl_surface_ashift(VALUE obj)
+static VALUE PixelFormat_Ashift(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->format->Ashift);
+  return UINT2NUM(Get_SDL_PixelFormat(self)->Ashift);
 }
 
-static VALUE sdl_surface_pitch(VALUE obj)
+static VALUE Surface_pitch(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->pitch);
+  return UINT2NUM(Get_SDL_Surface(self)->pitch);
 }
-static VALUE sdl_surface_bytes_per_pixel(VALUE obj)
+static VALUE PixelFormat_bytesPerPixel(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
-  return UINT2NUM(surface->format->BytesPerPixel);
+  return UINT2NUM(Get_SDL_PixelFormat(self)->BytesPerPixel);
 }
 
-static VALUE sdl_surface_pixels(VALUE obj)
+static VALUE Surface_pixels(VALUE self)
 {
-  SDL_Surface *surface;
-  Data_Get_Struct(obj,SDL_Surface,surface);
+  SDL_Surface *surface = Get_SDL_Surface(self);
   return rb_str_new(surface->pixels,
                     surface->h * surface->pitch);
 }
 
-static void defineConstForVideo()
+VALUE rubysdl_init_video(VALUE mSDL)
 {
-  /* Available for Screen.setVideoMode */
+  cSurface = rb_define_class_under(mSDL,"Surface",rb_cObject);
+  cScreen = rb_define_class_under(mSDL,"Screen",cSurface);
+  cPixelFormat = rb_define_class_under(mSDL, "PixelFormat", rb_cObject);
+  
+  rb_define_alloc_func(cSurface, Surface_s_alloc);
+  rb_undef_alloc_func(cPixelFormat);
+  
+  rb_define_singleton_method(cScreen, "get", Screen_s_get, 0);
+  rb_define_singleton_method(cScreen, "driverName", Screen_s_driverName, 0);
+  rb_define_singleton_method(cSurface, "blit", Surface_s_blit, 8);
+
+  rb_define_singleton_method(cScreen, "open", Screen_s_open, 4);
+  rb_define_singleton_method(cScreen, "checkMode", Screen_s_checkMode, 4);
+  rb_define_singleton_method(cScreen, "listModes", Screen_s_listModes, 1);
+  rb_define_singleton_method(cScreen, "setGamma", Screen_s_setGamma, 3);
+  rb_define_singleton_method(cScreen, "getGammaRamp", Screen_s_getGammaRamp, 0);
+  rb_define_singleton_method(cScreen, "setGammaRamp", Screen_s_setGammaRamp, 1);
+  
+  cVideoInfo=rb_define_class_under(mSDL,"VideoInfo",rb_cObject);
+  rb_define_attr(cVideoInfo,"hw_available",1,0);
+  rb_define_attr(cVideoInfo,"wm_available",1,0);
+  rb_define_attr(cVideoInfo,"blit_hw",1,0);
+  rb_define_attr(cVideoInfo,"blit_hw_CC",1,0);
+  rb_define_attr(cVideoInfo,"blit_hw_A",1,0);
+  rb_define_attr(cVideoInfo,"blit_sw",1,0);
+  rb_define_attr(cVideoInfo,"blit_sw_CC",1,0);
+  rb_define_attr(cVideoInfo,"blit_sw_A",1,0);
+  rb_define_attr(cVideoInfo,"blit_fill",1,0);
+  rb_define_attr(cVideoInfo,"video_mem",1,0);
+  rb_define_attr(cVideoInfo,"bpp",1,0);
+
+  rb_define_singleton_method(cScreen, "info", Screen_s_info, 0);
+
+  rb_define_singleton_method(cSurface,"create",Surface_s_create,4);
+  rb_define_singleton_method(cSurface,"createWithFormat",Surface_s_createWithFormat,8);
+  rb_define_singleton_method(cSurface,"new_from",Surface_s_createFrom,9);
+  rb_define_singleton_method(cSurface,"loadBMP",Surface_s_loadBMP,1);
+  rb_define_singleton_method(cSurface,"loadBMPFromIO",Surface_s_loadBMPFromIO,1);
+  rb_define_singleton_method(cSurface,"loadBMPFromString",Surface_s_loadBMPFromString,1);
+  
+  rb_define_method(cSurface,"saveBMP",Surface_saveBMP,1);
+  rb_define_method(cSurface,"destroy",Surface_destroy,0);
+  rb_define_method(cSurface,"displayFormat",Surface_displayFormat,0);
+  rb_define_method(cSurface,"displayFormatAlpha",Surface_displayFormatAlpha,0);
+  rb_define_method(cSurface,"setColorKey",Surface_setColorKey,2);
+  rb_define_method(cSurface,"fillRect",Surface_fillRect,5);
+  rb_define_method(cSurface,"setClipRect",Surface_setClipRect,4);
+  rb_define_method(cSurface,"getClipRect",Surface_getClipRect,0);
+  rb_define_method(cSurface,"setAlpha",Surface_setAlpha,2);
+  rb_define_method(cSurface,"h",Surface_h,0);
+  rb_define_method(cSurface,"w",Surface_w,0);
+  rb_define_method(cSurface,"flags",Surface_flags,0);
+
+  rb_define_method(cSurface,"getPixel",Surface_getPixel,2);
+  rb_define_method(cSurface,"putPixel",Surface_putPixel,3);
+  rb_define_method(cSurface,"[]",Surface_getPixel,2);
+  rb_define_method(cSurface,"[]=",Surface_putPixel,3);
+
+  rb_define_method(cSurface,"setPalette",Surface_setPalette,3);
+  rb_define_method(cSurface,"setColors",Surface_setColors,2);
+  rb_define_method(cPixelFormat,"palette",PixelFormat_pallete,0);
+  
+  rb_define_method(cSurface,"mustLock?",Surface_mustlock_p,0);
+  rb_define_method(cSurface,"lock",Surface_lock,0);
+  rb_define_method(cSurface,"unlock",Surface_unlock,0);
+
+  rb_define_method(cSurface,"format",Surface_format,0);
+  rb_define_method(cPixelFormat,"mapRGB",PixelFormat_mapRGB,3);
+  rb_define_method(cPixelFormat,"mapRGBA",PixelFormat_mapRGBA,4);
+  rb_define_method(cPixelFormat,"getRGB",PixelFormat_getRGB,1);
+  rb_define_method(cPixelFormat,"getRGBA",PixelFormat_getRGBA,1);
+  rb_define_method(cPixelFormat,"bpp",PixelFormat_bpp,0);
+  rb_define_method(cPixelFormat,"bytesPerPixel",PixelFormat_bytesPerPixel,0);
+  rb_define_method(cPixelFormat,"colorkey",PixelFormat_colorkey,0);
+  rb_define_method(cPixelFormat,"alpha",PixelFormat_alpha,0);
+  rb_define_method(cPixelFormat,"Rmask",PixelFormat_rmask,0);
+  rb_define_method(cPixelFormat,"Gmask",PixelFormat_gmask,0);
+  rb_define_method(cPixelFormat,"Bmask",PixelFormat_bmask,0);
+  rb_define_method(cPixelFormat,"Amask",PixelFormat_amask,0);
+  rb_define_method(cPixelFormat,"Rloss",PixelFormat_Rloss,0);
+  rb_define_method(cPixelFormat,"Gloss",PixelFormat_Gloss,0);
+  rb_define_method(cPixelFormat,"Bloss",PixelFormat_Bloss,0);
+  rb_define_method(cPixelFormat,"Aloss",PixelFormat_Aloss,0);
+  rb_define_method(cPixelFormat,"Rshift",PixelFormat_Rshift,0);
+  rb_define_method(cPixelFormat,"Gshift",PixelFormat_Gshift,0);
+  rb_define_method(cPixelFormat,"Bshift",PixelFormat_Bshift,0);
+  rb_define_method(cPixelFormat,"Ashift",PixelFormat_Ashift,0);
+  rb_define_method(cSurface,"pixels",Surface_pixels,0);
+  rb_define_method(cSurface,"pitch",Surface_pitch,0);
+  
+  rb_define_method(cScreen,"updateRect",Screen_updateRect,4);
+  rb_define_method(cScreen,"updateRects",Screen_updateRects,-1);
+  rb_define_method(cScreen,"flip",Screen_flip,0);
+  rb_define_method(cScreen,"toggleFullScreen",Screen_toggleFullScreen,0);
+
+
+  /* Available for Screen.open */
   rb_define_const(mSDL,"SWSURFACE",UINT2NUM(SDL_SWSURFACE));
   rb_define_const(mSDL,"HWSURFACE",UINT2NUM(SDL_HWSURFACE));
   rb_define_const(mSDL,"ASYNCBLIT",UINT2NUM(SDL_ASYNCBLIT));
@@ -731,90 +896,6 @@ static void defineConstForVideo()
   /* flags for SDL::Surface.setPalette */
   rb_define_const(mSDL,"LOGPAL",INT2NUM(SDL_LOGPAL));
   rb_define_const(mSDL,"PHYSPAL",INT2NUM(SDL_PHYSPAL));
-}
-
-void init_video()
-{
-  rb_define_module_function(mSDL,"getVideoSurface",sdl_getVideoSurface,0);
-  rb_define_module_function(mSDL,"videoDriverName",sdl_videoDriverName,0);
-  rb_define_module_function(mSDL,"blitSurface",sdl_blitSurface,8);
-  rb_define_module_function(mSDL,"setVideoMode",sdl_setVideoMode,4);
-  rb_define_module_function(mSDL,"checkVideoMode",sdl_checkVideoMode,4);
-  rb_define_module_function(mSDL,"listModes",sdl_listModes,1);
-  rb_define_module_function(mSDL,"setGamma",sdl_setGamma,3);
-  rb_define_module_function(mSDL,"getGammaRamp",sdl_getGammaRamp,0);
-  rb_define_module_function(mSDL,"setGammaRamp",sdl_setGammaRamp,1);
-  cVideoInfo=rb_define_class_under(mSDL,"VideoInfo",rb_cObject);
-  rb_define_attr(cVideoInfo,"hw_available",1,0);
-  rb_define_attr(cVideoInfo,"wm_available",1,0);
-  rb_define_attr(cVideoInfo,"blit_hw",1,0);
-  rb_define_attr(cVideoInfo,"blit_hw_CC",1,0);
-  rb_define_attr(cVideoInfo,"blit_hw_A",1,0);
-  rb_define_attr(cVideoInfo,"blit_sw",1,0);
-  rb_define_attr(cVideoInfo,"blit_sw_CC",1,0);
-  rb_define_attr(cVideoInfo,"blit_sw_A",1,0);
-  rb_define_attr(cVideoInfo,"blit_fill",1,0);
-  rb_define_attr(cVideoInfo,"video_mem",1,0);
-  rb_define_attr(cVideoInfo,"bpp",1,0);
-
-  
-  rb_define_module_function(mSDL,"videoInfo",sdl_getVideoInfo,0);
-  
-  cSurface = rb_define_class_under(mSDL,"Surface",rb_cObject);
 
-  rb_define_singleton_method(cSurface,"create",sdl_createSurface,4);
-  rb_define_singleton_method(cSurface,"createWithFormat",sdl_createSurfaceWithFormat,8);
-  rb_define_singleton_method(cSurface,"new_from",sdl_createSurfaceFrom,9);
-  rb_define_singleton_method(cSurface,"loadBMP",sdl_loadBMP,1);
-  rb_define_singleton_method(cSurface,"loadBMPFromIO",sdl_loadBMPFromIO,1);
-  rb_define_method(cSurface,"saveBMP",sdl_saveBMP,1);
-  rb_define_method(cSurface,"displayFormat",sdl_displayFormat,0);
-  rb_define_method(cSurface,"displayFormatAlpha",sdl_displayFormatAlpha,0);
-  rb_define_method(cSurface,"setColorKey",sdl_setColorKey,2);
-  rb_define_method(cSurface,"fillRect",sdl_fillRect,5);
-  rb_define_method(cSurface,"setClipRect",sdl_setClipRect,4);
-  rb_define_method(cSurface,"getClipRect",sdl_getClipRect,0);
-  rb_define_method(cSurface,"setAlpha",sdl_setAlpha,2);
-  rb_define_method(cSurface,"h",sdl_surfaceH,0);
-  rb_define_method(cSurface,"w",sdl_surfaceW,0);
-  rb_define_method(cSurface,"flags",sdl_getFlags,0);
-  
-  rb_define_method(cSurface,"setPalette",sdl_setPalette,3);
-  rb_define_method(cSurface,"setColors",sdl_setColors,2);
-  rb_define_method(cSurface,"getPalette",sdl_getPalette,0);
-  
-  rb_define_method(cSurface,"mustLock?",sdl_mustlock,0);
-  rb_define_method(cSurface,"lock",sdl_lockSurface,0);
-  rb_define_method(cSurface,"unlock",sdl_unlockSurface,0);
-
-  rb_define_method(cSurface,"mapRGB",sdl_mapRGB,3);
-  rb_define_method(cSurface,"mapRGBA",sdl_mapRGBA,4);
-  rb_define_method(cSurface,"getRGB",sdl_getRGB,1);
-  rb_define_method(cSurface,"getRGBA",sdl_getRGBA,1);
-  rb_define_method(cSurface,"bpp",sdl_getBpp,0);
-  rb_define_method(cSurface,"colorkey",sdl_getColorkey,0);
-  rb_define_method(cSurface,"alpha",sdl_getAlpha,0);
-  rb_define_method(cSurface,"Rmask",sdl_surface_rmask,0);
-  rb_define_method(cSurface,"Gmask",sdl_surface_gmask,0);
-  rb_define_method(cSurface,"Bmask",sdl_surface_bmask,0);
-  rb_define_method(cSurface,"Amask",sdl_surface_amask,0);
-  rb_define_method(cSurface,"Rloss",sdl_surface_rloss,0);
-  rb_define_method(cSurface,"Gloss",sdl_surface_gloss,0);
-  rb_define_method(cSurface,"Bloss",sdl_surface_bloss,0);
-  rb_define_method(cSurface,"Aloss",sdl_surface_aloss,0);
-  rb_define_method(cSurface,"Rshift",sdl_surface_rshift,0);
-  rb_define_method(cSurface,"Gshift",sdl_surface_gshift,0);
-  rb_define_method(cSurface,"Bshift",sdl_surface_bshift,0);
-  rb_define_method(cSurface,"Ashift",sdl_surface_ashift,0);
-  rb_define_method(cSurface,"pixels",sdl_surface_pixels,0);
-  rb_define_method(cSurface,"pitch",sdl_surface_pitch,0);
-  rb_define_method(cSurface,"BytesPerPixel",sdl_surface_bytes_per_pixel,0);
-  
-  cScreen = rb_define_class_under(mSDL,"Screen",cSurface);
-  rb_define_method(cScreen,"updateRect",sdl_updateRect,4);
-  rb_define_method(cScreen,"updateRects",sdl_updateRects, -1);
-  rb_define_method(cScreen,"flip",sdl_flip,0);
-  rb_define_method(cScreen,"toggleFullScreen",sdl_toggleFullScreen,0);
-  defineConstForVideo();
-  return;
+  return cSurface;
 }