rubysdl 2.0.1 → 2.1.0

data/rubysdl_joystick.c

@@ -144,7 +144,6 @@ static VALUE Joystick_close(VALUE self)
   joy->joystick = NULL;
   return Qnil;
 }
-  
 static VALUE Joystick_index(VALUE self)
 {
   SDL_Joystick* joystick;

data/rubysdl_kanji.c

@@ -24,19 +24,84 @@
 static VALUE cKanjiFont;
 typedef int (*Drawer)(Kanji_Font*, int, int, SDL_Surface*, const char*, SDL_Color);
 
-DEFINE_GET_STRUCT(Kanji_Font, Get_Kanji_Font, cKanjiFont, "SDL::Kanji::Font");
-     
+typedef struct {
+  Kanji_Font* font;
+} KFont;
+
+DEFINE_GET_STRUCT(KFont, Get_KFont, cKanjiFont, "SDL::Kanji::Font");
+static Kanji_Font* Get_Kanji_Font(VALUE obj)
+{
+  KFont* kfont = Get_KFont(obj);
+  if (kfont->font == NULL)
+    rb_raise(eSDLError, "Kanji Font data is already disposed");
+  return kfont->font;
+}
+static void Font_free(KFont* kfont)
+{
+  if (kfont->font)
+    Kanji_CloseFont(kfont->font);
+  free(kfont);
+}
+static VALUE Font_s_alloc(VALUE klass)
+{
+  KFont* kfont = ALLOC(KFont);
+  kfont->font = NULL;
+  return Data_Wrap_Struct(klass, 0, Font_free, kfont);
+}
+static VALUE Font_create(Kanji_Font* font)
+{
+  VALUE newobj = Font_s_alloc(cKanjiFont);
+  Get_KFont(newobj)->font = font;
+  return newobj;
+}
+
+#ifdef ENABLE_M17N
+static rb_encoding* get_enc(Kanji_Font* font)
+{
+  switch (font->sys) {
+  case KANJI_JIS:
+    return iso2022jp_enc;
+    break;
+  case KANJI_EUC:
+    return eucjp_enc;
+    break;
+  case KANJI_SJIS:
+    return sjis_enc;
+    break;
+  default:
+    rb_raise(eSDLError, "Unsupported Kanji encoding");
+    return NULL;
+    break;
+  }
+}
+#endif
+
 static VALUE Font_s_open(VALUE klass, VALUE filename, VALUE size)
 {
   Kanji_Font* font;
 
   rb_secure(4);
-  SafeStringValue(filename);
+  ExportFilenameStringValue(filename);
   
   font = Kanji_OpenFont(RSTRING_PTR(filename), NUM2INT(size));
   if(font == NULL)
     rb_raise(eSDLError,"Couldn't open bdf font: %s", RSTRING_PTR(filename));
-  return Data_Wrap_Struct(cKanjiFont, 0, Kanji_CloseFont, font);
+  return Font_create(font);
+}
+static VALUE Font_close(VALUE self)
+{
+  KFont* kfont;
+  
+  rb_secure(4);
+  kfont = Get_KFont(self);
+  if (kfont->font)
+    Kanji_CloseFont(kfont->font);
+  kfont->font = NULL;
+  return Qnil;
+}
+static VALUE Font_closed(VALUE self)
+{
+  return INT2BOOL(Get_KFont(self)->font == NULL);
 }
 
 static VALUE Font_setCodingSystem(VALUE self, VALUE sys)
@@ -44,11 +109,15 @@ static VALUE Font_setCodingSystem(VALUE self, VALUE sys)
   Kanji_SetCodingSystem(Get_Kanji_Font(self), NUM2INT(sys));
   return Qnil;
 }
-                        
+static VALUE Font_getCodingSystem(VALUE self)
+{
+  return INT2NUM(Get_Kanji_Font(self)->sys);
+}
+
 static VALUE Font_add(VALUE self, VALUE filename)
 {
   rb_secure(4);
-  SafeStringValue(filename);
+  ExportFilenameStringValue(filename);
   if(Kanji_AddFont(Get_Kanji_Font(self), RSTRING_PTR(filename)) == -1)
     rb_raise(eSDLError, "Couldn't use font: %s", RSTRING_PTR(filename));
   return Qnil;
@@ -56,8 +125,11 @@ static VALUE Font_add(VALUE self, VALUE filename)
 
 static VALUE Font_textwidth(VALUE self, VALUE text)
 {
-  StringValue(text);
-  return INT2FIX(Kanji_FontWidth(Get_Kanji_Font(self), RSTRING_PTR(text)));
+  Kanji_Font* font;
+  rb_secure(4);
+  font = Get_Kanji_Font(self);
+  ExportStringValueToEnc(text, get_enc(font));
+  return INT2FIX(Kanji_FontWidth(font, RSTRING_PTR(text)));
 }
 
 static VALUE Font_width(VALUE self)
@@ -75,10 +147,10 @@ static void Font_put(VALUE self, VALUE surface, VALUE text,
                      VALUE r, VALUE g, VALUE b, Drawer draw)
 {
   SDL_Color color;
-
+  Kanji_Font* font;
   rb_secure(4);
-  SafeStringValue(text);
-  
+  font = Get_Kanji_Font(self);
+  ExportStringValueToEnc(text, get_enc(font));
   color.r = NUM2INT(r);color.g = NUM2INT(g); color.b = NUM2INT(b);
   
   draw(Get_Kanji_Font(self), NUM2INT(x), NUM2INT(y),
@@ -107,8 +179,11 @@ void rubysdl_init_Kanji(VALUE mSDL)
   rb_undef_alloc_func(cKanjiFont);
   
   rb_define_singleton_method(cKanjiFont, "open", Font_s_open, 2);
+  rb_define_method(cKanjiFont, "close", Font_close, 0);
+  rb_define_method(cKanjiFont, "closed?", Font_closed, 0);
   rb_define_method(cKanjiFont, "add", Font_add, 1);
   rb_define_method(cKanjiFont, "setCodingSystem", Font_setCodingSystem, 1);
+  rb_define_method(cKanjiFont, "getCodingSystem", Font_getCodingSystem, 0);
   rb_define_method(cKanjiFont, "textwidth", Font_textwidth, 1);
   rb_define_method(cKanjiFont, "width", Font_width, 0);
   rb_define_method(cKanjiFont, "height", Font_height, 0);

data/rubysdl_main.c

@@ -88,7 +88,14 @@ void Init_sdl()
 {
   VALUE mSDL = rb_define_module("SDL");
   VALUE cSurface;
-  
+
+#ifdef ENABLE_M17N
+  utf8_enc = rb_utf8_encoding();
+  eucjp_enc = rb_enc_find("EUC-JP");
+  iso2022jp_enc = rb_enc_find("ISO-2022-JP");
+  sjis_enc = rb_enc_find("SJIS");
+#endif
+
   eSDLError = rb_define_class_under(mSDL, "Error", rb_eStandardError);
   rb_define_module_function(mSDL, "init", sdl_s_init, 1);
   rb_define_module_function(mSDL, "initedSystem", sdl_s_inited_system, 1);

data/rubysdl_mixer.c

@@ -56,6 +56,7 @@ static void Wave_free(Wave* wave)
     Mix_FreeChunk(wave->chunk);
   free(wave);
 }
+
 static VALUE Wave_s_alloc(VALUE klass)
 {
   Wave* wave = ALLOC(Wave);
@@ -243,7 +244,7 @@ static VALUE Wave_s_load(VALUE class, VALUE filename)
   Mix_Chunk *chunk;
   
   rb_secure(4);
-  SafeStringValue(filename);
+  ExportFilenameStringValue(filename);
   
   chunk = Mix_LoadWAV(RSTRING_PTR(filename));
   if( chunk == NULL ){
@@ -400,7 +401,7 @@ static VALUE Music_s_load(VALUE class, VALUE filename)
   Mix_Music* music;
   
   rb_secure(4);
-  SafeStringValue(filename);
+  ExportFilenameStringValue(filename);
   
   music = Mix_LoadMUS(RSTRING_PTR(filename));
   if( music == NULL )
@@ -442,6 +443,11 @@ static VALUE Wave_destroy(VALUE self)
   }
   return Qnil;
 }
+static VALUE Wave_destroyed(VALUE self)
+{
+  Wave* wave = GetWave(self);
+  return INT2BOOL(wave->chunk == NULL);
+}
 
 static VALUE Music_destroy(VALUE self)
 {
@@ -452,6 +458,11 @@ static VALUE Music_destroy(VALUE self)
   }
   return Qnil;
 }
+static VALUE Music_destroyed(VALUE self)
+{
+  Music* mus = GetMusic(self);
+  return INT2BOOL(mus->music == NULL);
+}
 
 void rubysdl_init_Mixer(VALUE mSDL)
 {
@@ -462,7 +473,7 @@ void rubysdl_init_Mixer(VALUE mSDL)
   rb_define_module_function(mMixer, "driverName", Mixer_s_driverName, 0);
   rb_define_module_function(mMixer, "playChannel", Mixer_s_playChannel, 3);
   rb_define_module_function(mMixer, "playChannelTimed", Mixer_s_playChannelTimed, 4);
-  rb_define_module_function(mMixer, "fadeInChannel", Mixer_s_playChannel, 4);
+  rb_define_module_function(mMixer, "fadeInChannel", Mixer_s_fadeInChannel, 4);
   rb_define_module_function(mMixer, "fadeInChannelTimed", Mixer_s_fadeInChannelTimed, 5);
   
   rb_define_module_function(mMixer, "play?", Mixer_s_play_p, 1);
@@ -503,8 +514,10 @@ void rubysdl_init_Mixer(VALUE mSDL)
                              Mixer_s_loadMusFromString,1);
 #endif
   rb_define_method(cWave, "destroy", Wave_destroy, 0);
+  rb_define_method(cWave, "destroyed_", Wave_destroyed, 0);
   rb_define_method(cMusic, "destroy", Music_destroy, 0);
-
+  rb_define_method(cMusic, "destroyed?", Music_destroyed, 0);
+  
   /* to avoid to do garbage collect when playing */
   rb_global_variable( &playing_wave );
   rb_global_variable( &playing_music );

data/rubysdl_sdlskk.c

@@ -100,8 +100,27 @@ static VALUE Context_input(VALUE self, VALUE event)
 static VALUE Context_str(VALUE self)
 {
   char cstr[10000];
+#ifdef ENABLE_M17N
+  rb_encoding* enc;
+  switch (SDLSKK_get_encoding()) {
+  case SDLSKK_UTF8:
+    enc = utf8_enc;
+  case SDLSKK_EUCJP:
+    enc = eucjp_enc;
+    break;
+  case SDLSKK_SJIS:
+    enc = sjis_enc;
+    break;
+  default:
+    rb_raise(eSDLError, "SDLSKK encoding error");
+  }
+#endif
   SDLSKK_Context_get_str(Get_SDLSKK_Context(self), cstr, sizeof(cstr));
+#ifdef ENABLE_M17N
+  return ENC_STR_NEW2(cstr, enc);
+#else
   return rb_str_new2(cstr);
+#endif
 }
 
 static VALUE render_str(VALUE self, VALUE font, VALUE r, VALUE g, VALUE b,

data/rubysdl_sge_video.c

@@ -25,9 +25,34 @@
 static VALUE cCollisionMap = Qnil;
 static VALUE cBMFont = Qnil;
 
-DEFINE_GET_STRUCT(sge_bmpFont, Get_sge_bmpFont, cBMFont, "SDL::BMFont");
+typedef struct {
+  sge_bmpFont* font;
+} BmpFont;
+
+DEFINE_GET_STRUCT(BmpFont, Get_BmpFont, cBMFont, "SDL::BMFont");
 DEFINE_GET_STRUCT(sge_cdata, Get_sge_cdata, cCollisionMap, "SDL::CollisionMap");
 
+static sge_bmpFont* Get_sge_bmpFont(VALUE obj)
+{
+  BmpFont* bfont = Get_BmpFont(obj);
+  if (bfont->font == NULL)
+    rb_raise(eSDLError, "Bitmap font is already closed");
+  return bfont->font;
+}
+static void BMFont_free(BmpFont* bfont)
+{
+  if (!rubysdl_is_quit() && bfont->font)
+    sge_BF_CloseFont(bfont->font);
+  free(bfont);
+}
+
+static VALUE BMFont_create(sge_bmpFont* font)
+{
+  BmpFont* bfont = ALLOC(BmpFont);
+  bfont->font = font;
+  return Data_Wrap_Struct(cBMFont, 0, BMFont_free, bfont);
+}
+
 static VALUE Surface_s_autoLock_p(VALUE klass)
 {
   rb_secure(4);
@@ -380,25 +405,31 @@ static VALUE CollisionMap_h(VALUE self)
 }
 
 /* bitmap font */
-static void bf_close(sge_bmpFont* font)
-{
-  if(!rubysdl_is_quit()){
-    sge_BF_CloseFont(font);
-  }
-}
 
 static VALUE BMFont_open(VALUE klass,  VALUE file,  VALUE flags)
 
 {
   sge_bmpFont* font;
   rb_secure(4);
-  SafeStringValue(file);
+  ExportFilenameStringValue(file);
   
   font = sge_BF_OpenFont(RSTRING_PTR(file), NUM2UINT(flags));
   if(font == NULL)
     rb_raise(eSDLError, "Couldn't open font: %s", RSTRING_PTR(file));
   
-  return Data_Wrap_Struct(cBMFont, 0, bf_close, font);
+  return BMFont_create(font);
+}
+static VALUE BMFont_close(VALUE self)
+{
+  BmpFont* bfont = Get_BmpFont(self);
+  if (!rubysdl_is_quit() && bfont->font)
+    sge_BF_CloseFont(bfont->font);
+  bfont->font = NULL;
+  return Qnil;
+}
+static VALUE BMFont_closed(VALUE self)
+{
+  return INT2BOOL(Get_BmpFont(self)->font == NULL);
 }
 
 static VALUE BMFont_setColor(VALUE self, VALUE r, VALUE g, VALUE b)
@@ -421,7 +452,7 @@ static VALUE BMFont_getWidth(VALUE self)
 static VALUE BMFont_textSize(VALUE self, VALUE text)
 {
   SDL_Rect rect;
-  StringValue(text);
+  SafeStringValue(text);
   rect = sge_BF_TextSize(Get_sge_bmpFont(self),
                          RSTRING_PTR(text));
   return rb_ary_new3(2, INT2FIX(rect.w), INT2FIX(rect.h));
@@ -433,7 +464,7 @@ static VALUE BMFont_textout(VALUE self,
 
 {
   rb_secure(4);
-  StringValue(string);
+  SafeStringValue(string);
   
   sge_BF_textout(Get_SDL_Surface(surface), Get_sge_bmpFont(self),
                  RSTRING_PTR(string), NUM2INT(x), NUM2INT(y));
@@ -483,7 +514,8 @@ void rubysdl_init_sge(VALUE mSDL, VALUE cSurface)
   rb_undef_alloc_func(cBMFont);
     
   rb_define_singleton_method(cBMFont, "open", BMFont_open, 2);
-
+  rb_define_method(cBMFont, "close", BMFont_close, 0);
+  rb_define_method(cBMFont, "closed?", BMFont_closed, 0);
   rb_define_method(cBMFont, "setColor", BMFont_setColor, 3);
   rb_define_method(cBMFont, "height", BMFont_getHeight, 0);
   rb_define_method(cBMFont, "width", BMFont_getWidth, 0);

data/rubysdl_smpeg.c

@@ -81,10 +81,14 @@ static VALUE MPEG_delete(VALUE self)
   return Qnil;
 }
 
+static VALUE MPEG_deleted(VALUE self)
+{
+  return INT2BOOL(Get_MPEG(self)->smpeg == NULL);
+}
+
 static VALUE MPEG_s_load(VALUE klass, VALUE filename)
 {
   SMPEG *smpeg;
-  VALUE mpeg;
   char error_msg[2048];
   
   rb_secure(4);
@@ -307,6 +311,7 @@ void rubysdl_init_MPEG(VALUE mSDL)
 
   rb_define_method(cMPEG, "info", MPEG_info, 0);
   rb_define_method(cMPEG, "delete", MPEG_delete, 0);
+  rb_define_method(cMPEG, "deleted?", MPEG_deleted, 0);
   rb_define_method(cMPEG, "enableAudio", MPEG_enableAudio, 1);
   rb_define_method(cMPEG, "enableVideo", MPEG_enableVideo, 1);
   rb_define_method(cMPEG, "status", MPEG_status, 0);
@@ -315,7 +320,7 @@ void rubysdl_init_MPEG(VALUE mSDL)
   rb_define_method(cMPEG, "setLoop", MPEG_setLoop, 1);
   rb_define_method(cMPEG, "scaleXY", MPEG_scaleXY, 2);
   rb_define_method(cMPEG, "scale", MPEG_scale, 1);
-  rb_define_method(cMPEG, "move", MPEG_move, 1);
+  rb_define_method(cMPEG, "move", MPEG_move, 2);
   rb_define_method(cMPEG, "setDisplayRegion", MPEG_setDisplayRegion, 4);
   rb_define_method(cMPEG, "play", MPEG_play, 0);
   rb_define_method(cMPEG, "pause", MPEG_pause, 0);

data/rubysdl_time.c

@@ -23,9 +23,21 @@ static VALUE sdl_getTicks(VALUE mod)
 {
   return UINT2NUM(SDL_GetTicks());
 }
+
+static VALUE delay(void* t)
+{
+  SDL_Delay(*((Uint32*)t));
+  return Qnil;
+}
+
 static VALUE sdl_delay(VALUE mod,VALUE ms)
 {
-  SDL_Delay(NUM2UINT(ms));
+  Uint32 t = NUM2UINT(ms);
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+  rb_thread_blocking_region(delay, &t, RUBY_UBF_IO, NULL);
+#else
+  SDL_Delay(t);
+#endif
   return Qnil;
 }
 

data/rubysdl_ttf.c

@@ -21,18 +21,44 @@
 #include "rubysdl.h"
 #include <SDL_ttf.h>
 
+typedef struct {
+  TTF_Font* font;
+} TTFont;
+  
 typedef SDL_Surface* (*RenderFunc)(TTF_Font *,const char *,SDL_Color,SDL_Color);
 
 static int ttf_init = 0;
 static VALUE cTTFFont = Qnil;
 
-static void Font_free(TTF_Font *font)
+static void Font_free(TTFont *f)
+{
+  if(!rubysdl_is_quit() && f->font)
+    TTF_CloseFont(f->font);
+  free(f);
+}
+
+DEFINE_GET_STRUCT(TTFont, Get_TTFont, cTTFFont, "SDL::TT::Font");
+
+TTF_Font* Get_TTF_Font(VALUE obj)
 {
-  if(!rubysdl_is_quit())
-    TTF_CloseFont(font);
+  TTFont* f = Get_TTFont(obj);
+  if (f->font == NULL)
+    rb_raise(eSDLError, "TTF is alreadly closed");
+  return f->font;
 }
 
-GLOBAL_DEFINE_GET_STRUCT(TTF_Font, Get_TTF_Font, cTTFFont, "SDL::TT::Font");
+static VALUE TTF_s_alloc(VALUE klass)
+{
+  TTFont* f = ALLOC(TTFont);
+  f->font = NULL;
+  return Data_Wrap_Struct(klass, 0, Font_free, f);
+}
+static VALUE TTF_create(TTF_Font* font)
+{
+  VALUE newobj = TTF_s_alloc(cTTFFont);
+  Get_TTFont(newobj)->font = font;
+  return newobj;
+}
 
 static VALUE TTF_s_init(VALUE klass)
 {
@@ -67,7 +93,7 @@ static VALUE Font_s_open(int argc, VALUE *argv, VALUE class)
   if(font == NULL)
     rb_raise(eSDLError,"Couldn't open font %s: %s",
              RSTRING_PTR(filename), TTF_GetError());
-  return Data_Wrap_Struct(class, 0, Font_free, font);
+  return TTF_create(font);
 }
 
 static VALUE Font_style(VALUE self)
@@ -112,8 +138,11 @@ static VALUE Font_styleName(VALUE self)
 static VALUE Font_textSize(VALUE self, VALUE text)
 {
   int w,h;
-  
+
   StringValue(text);
+#ifdef ENABLE_M17N
+  text = rb_str_export_to_enc(text, utf8_enc);
+#endif
   TTF_SizeUTF8(Get_TTF_Font(self), RSTRING_PTR(text), &w, &h);
   return rb_ary_new3(2, INT2FIX(w), INT2FIX(h));
 }
@@ -151,13 +180,17 @@ static SDL_Color rgb_to_SDL_Color(VALUE r, VALUE g, VALUE b)
 static VALUE render(VALUE self, VALUE text,
                     VALUE fgr,VALUE fgg,VALUE fgb,
                     VALUE bgr,VALUE bgg,VALUE bgb,
+                    int convert_enc,
                     RenderFunc renderer)
 {
   SDL_Surface *surface;
   
   rb_secure(4);
   StringValue(text);
-
+#ifdef ENABLE_M17N
+  if (convert_enc)
+    text = rb_str_export_to_enc(text, utf8_enc);
+#endif
   surface = renderer(Get_TTF_Font(self),
                      RSTRING_PTR(text),
                      rgb_to_SDL_Color(fgr, fgg, fgb),
@@ -191,23 +224,64 @@ static VALUE Font_renderSolidUTF8(VALUE self, VALUE text,
                                   VALUE r, VALUE g, VALUE b)
 				     
 {
-  return render(self, text, r, g, b, 1, 1, 1,wrap_RenderUTF8_Solid);
+  return render(self, text, r, g, b, 1, 1, 1, 0,
+                wrap_RenderUTF8_Solid);
 }
 
 static VALUE Font_renderBlendedUTF8(VALUE self, VALUE text,
                                     VALUE r, VALUE g, VALUE b)
 				     
 {
-  return render(self, text, r, g, b, 1, 1, 1, wrap_RenderUTF8_Blended);
+  return render(self, text, r, g, b, 1, 1, 1, 0,
+                wrap_RenderUTF8_Blended);
 }
 
 static VALUE Font_renderShadedUTF8(VALUE self, VALUE text,
-				      VALUE fgr,VALUE fgg,VALUE fgb,
-				      VALUE bgr,VALUE bgg,VALUE bgb)
+                                   VALUE fgr,VALUE fgg,VALUE fgb,
+                                   VALUE bgr,VALUE bgg,VALUE bgb)
+{
+  return render(self, text, fgr, fgg, fgb, bgr, bgg, bgb, 0,
+                TTF_RenderUTF8_Shaded);
+}
+
+static VALUE Font_renderSolid(VALUE self, VALUE text,
+                              VALUE r, VALUE g, VALUE b)
+				     
 {
-  return render(self, text, fgr, fgg, fgb, bgr, bgg, bgb, TTF_RenderUTF8_Shaded);
+  return render(self, text, r, g, b, 1, 1, 1, 1,
+                wrap_RenderUTF8_Solid);
 }
 
+static VALUE Font_renderBlended(VALUE self, VALUE text,
+                                VALUE r, VALUE g, VALUE b)
+				     
+{
+  return render(self, text, r, g, b, 1, 1, 1, 1,
+                wrap_RenderUTF8_Blended);
+}
+
+static VALUE Font_renderShaded(VALUE self, VALUE text,
+                               VALUE fgr,VALUE fgg,VALUE fgb,
+                               VALUE bgr,VALUE bgg,VALUE bgb)
+{
+  return render(self, text, fgr, fgg, fgb, bgr, bgg, bgb, 1,
+                TTF_RenderUTF8_Shaded);
+}
+
+static VALUE Font_close(VALUE self)
+{
+  TTFont* f = Get_TTFont(self);
+  if(!rubysdl_is_quit() && f->font)
+    TTF_CloseFont(f->font);
+  f->font = NULL;
+  
+  return Qnil;
+}
+static VALUE Font_closed(VALUE self)
+{
+  return INT2BOOL(Get_TTFont(self)->font == NULL);
+}
+                       
 void rubysdl_init_TTF(VALUE mSDL)
 {
   cTTFFont = rb_define_class_under(mSDL, "TTF", rb_cObject);
@@ -234,7 +308,12 @@ void rubysdl_init_TTF(VALUE mSDL)
   rb_define_method(cTTFFont,"renderSolidUTF8",Font_renderSolidUTF8,4);
   rb_define_method(cTTFFont,"renderBlendedUTF8",Font_renderBlendedUTF8,4);
   rb_define_method(cTTFFont,"renderShadedUTF8",Font_renderShadedUTF8,7);
-
+  rb_define_method(cTTFFont,"renderSolid",Font_renderSolid,4);
+  rb_define_method(cTTFFont,"renderBlended",Font_renderBlended,4);
+  rb_define_method(cTTFFont,"renderShaded",Font_renderShaded,7);
+  rb_define_method(cTTFFont,"close", Font_close, 0);
+  rb_define_method(cTTFFont,"closed?", Font_closed, 0);
+  
   rb_define_const(cTTFFont,"STYLE_NORMAL",UINT2NUM(TTF_STYLE_NORMAL));
   rb_define_const(cTTFFont,"STYLE_BOLD",UINT2NUM(TTF_STYLE_BOLD));
   rb_define_const(cTTFFont,"STYLE_ITALIC",UINT2NUM(TTF_STYLE_ITALIC));