gosu 0.8.7.2 → 0.9.0.pre1

data/README.txt

@@ -0,0 +1,25 @@
+ Moin and welcome to Gosu!
+
+ Gosu's main website is http://www.libgosu.org/, which always has the latest
+links to all relevant information.
+
+ The actual source code, wiki, issue tracker etc. are all hosted on GitHub:
+
+    http://github.com/jlnr/gosu/
+
+ The best entry point into Gosu's documentation is the wiki home page:
+
+    http://github.com/jlnr/gosu/wiki
+
+ Try doing the tutorial there if you don't know how to start out. Or look at
+one of the games in the Gosu Users board.
+
+ Remember that Gosu is licensed under the MIT license and feel invited to fork,
+port and transmogrify all parts of it. The only license that may affect you by
+indirection is libogg's (BSD-style). If you release a Gosu game in any common
+binary form, you will need to mention use of libogg and libvorbis somewhere.
+ 
+ Complaints, questions, feedback?
+* Visit the boards,                         http://www.libgosu.org/
+* try your luck in the chat,              irc://irc.freenode.org/gosu
+* or e-mail me. Have fun, write games!         julian@raschke.de

data/ext/gosu/gosu_wrap.cxx

@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 3.0.2
+ * Version 3.0.5
  *
  * This file is not intended to be easily readable and contains a number of
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -2113,24 +2113,22 @@ namespace Swig {
 
 /* -------- TYPES TABLE (BEGIN) -------- */
 
-#define SWIGTYPE_p_Channel swig_types[0]
-#define SWIGTYPE_p_Gosu__Button swig_types[1]
-#define SWIGTYPE_p_Gosu__Color swig_types[2]
-#define SWIGTYPE_p_Gosu__Font swig_types[3]
-#define SWIGTYPE_p_Gosu__GLTexInfo swig_types[4]
-#define SWIGTYPE_p_Gosu__Image swig_types[5]
-#define SWIGTYPE_p_Gosu__ImageData swig_types[6]
-#define SWIGTYPE_p_Gosu__Sample swig_types[7]
-#define SWIGTYPE_p_Gosu__SampleInstance swig_types[8]
-#define SWIGTYPE_p_Gosu__Song swig_types[9]
-#define SWIGTYPE_p_Gosu__TextInput swig_types[10]
-#define SWIGTYPE_p_Gosu__Window swig_types[11]
-#define SWIGTYPE_p_char swig_types[12]
-#define SWIGTYPE_p_double swig_types[13]
-#define SWIGTYPE_p_std__tr1__arrayT_double_16_t swig_types[14]
-#define SWIGTYPE_p_std__wstring swig_types[15]
-static swig_type_info *swig_types[17];
-static swig_module_info swig_module = {swig_types, 16, 0, 0, 0, 0};
+#define SWIGTYPE_p_Gosu__Button swig_types[0]
+#define SWIGTYPE_p_Gosu__Color swig_types[1]
+#define SWIGTYPE_p_Gosu__Font swig_types[2]
+#define SWIGTYPE_p_Gosu__GLTexInfo swig_types[3]
+#define SWIGTYPE_p_Gosu__Image swig_types[4]
+#define SWIGTYPE_p_Gosu__Sample swig_types[5]
+#define SWIGTYPE_p_Gosu__SampleInstance swig_types[6]
+#define SWIGTYPE_p_Gosu__Song swig_types[7]
+#define SWIGTYPE_p_Gosu__TextInput swig_types[8]
+#define SWIGTYPE_p_Gosu__Window swig_types[9]
+#define SWIGTYPE_p_char swig_types[10]
+#define SWIGTYPE_p_double swig_types[11]
+#define SWIGTYPE_p_std__tr1__arrayT_double_16_t swig_types[12]
+#define SWIGTYPE_p_std__wstring swig_types[13]
+static swig_type_info *swig_types[15];
+static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -2145,7 +2143,7 @@ static VALUE mGosu;
 #define SWIG_RUBY_THREAD_END_BLOCK
 
 
-#define SWIGVERSION 0x030002 
+#define SWIGVERSION 0x030005 
 #define SWIG_VERSION SWIGVERSION
 
 
@@ -2174,10 +2172,6 @@ static VALUE mGosu;
 #undef int64_t
 #undef uint64_t
 
-//#ifndef WIN32
-//#include <Gosu/Async.hpp>
-//#endif
-
 #include <Gosu/Gosu.hpp>
 #ifdef GOSU_IS_WIN
 #include <FreeImage.h>
@@ -2194,7 +2188,7 @@ namespace Gosu {
 #include <ctime>
 #include <sstream>
 
-// Preprocessor check for 1.9 (thanks banister)
+// Preprocessor check for 1.9 or higher (thanks banister)
 #if defined(ROBJECT_EMBED_LEN_MAX)
 #define FIX_ENCODING(var) \
     rb_funcall(var, rb_intern("force_encoding"), 1, rb_str_new2("UTF-8"));
@@ -2230,8 +2224,7 @@ namespace Gosu
     #ifdef GOSU_IS_WIN
     void requireFreeImageFor(const char* filename)
     {
-        // Copied and pasted from MSDN.
-        // TODO: Remove duplication, this is also in AudioAudiere.cpp
+        // Catch lazy loading errors on Windows; from MSDN.
         #define FACILITY_VISUALCPP  ((LONG)0x6d)
         #define VcppException(sev,err)  ((sev) | (FACILITY_VISUALCPP<<16) | err)
         #define BAD_MOD VcppException(ERROR_SEVERITY_ERROR, ERROR_MOD_NOT_FOUND)
@@ -2307,12 +2300,117 @@ namespace Gosu
             throw std::logic_error("Blob length mismatch!");
     }
     
-    const char* cstrFromSymbol(VALUE symbol) {
-        if (TYPE(symbol) != T_SYMBOL)
-            return 0; // to be caught by the caller
+    const char* cstrFromSymbol(VALUE symbol)
+    {
+        Check_Type(symbol, T_SYMBOL);
         return rb_id2name(SYM2ID(symbol));
     }
 }
+    
+// Global input functions
+
+namespace Gosu {
+    Gosu::Button charToButtonId(wchar_t ch) {
+        return Gosu::Input::charToId(ch);
+    }
+    wchar_t buttonIdToChar(Gosu::Button btn) {
+        return Gosu::Input::idToChar(btn);
+    }
+    bool isButtonDown(Gosu::Button btn) {
+        return Gosu::Input::down(btn);
+    }
+}
+
+// Global graphics functions
+namespace Gosu {
+    void drawLine(double x1, double y1, Gosu::Color c1,
+                  double x2, double y2, Gosu::Color c2,
+                  Gosu::ZPos z = 0, Gosu::AlphaMode mode = Gosu::amDefault) {
+        Gosu::Graphics::drawLine(x1, y1, c1, x2, y2, c2,
+                                   z, mode);
+    }
+    void drawTriangle(double x1, double y1, Gosu::Color c1,
+                      double x2, double y2, Gosu::Color c2,
+                      double x3, double y3, Gosu::Color c3,
+                      Gosu::ZPos z = 0, Gosu::AlphaMode mode = Gosu::amDefault) {
+        Gosu::Graphics::drawTriangle(x1, y1, c1, x2, y2, c2, x3, y3, c3,
+                                       z, mode);
+    }
+    void drawQuad(double x1, double y1, Gosu::Color c1,
+                  double x2, double y2, Gosu::Color c2,
+                  double x3, double y3, Gosu::Color c3,
+                  double x4, double y4, Gosu::Color c4,
+                  Gosu::ZPos z = 0, Gosu::AlphaMode mode = Gosu::amDefault) {
+        Gosu::Graphics::drawQuad(x1, y1, c1, x2, y2, c2,
+                                 x3, y3, c3, x4, y4, c4,
+                                 z, mode);
+    }
+    void drawRect(double x, double y, double width, double height, Gosu::Color c,
+                  Gosu::ZPos z = 0, Gosu::AlphaMode mode = Gosu::amDefault) {
+        Gosu::Graphics::drawQuad(x, y, c, x + width, y, c,
+                                 x, y + height, c, x + width, y + height, c,
+                                 z, mode);
+    }
+    void flush() {
+        return Gosu::Graphics::flush();
+    }
+    void unsafe_gl() {
+        Gosu::Graphics::beginGL();
+        rb_yield(Qnil);
+        Gosu::Graphics::endGL();
+    }
+    void unsafe_gl(Gosu::ZPos z) {
+        Gosu::Graphics::scheduleGL(std::tr1::bind(callRubyBlock, rb_block_proc()), z);
+    }
+    void clipTo(double x, double y, double width, double height) {
+        Gosu::Graphics::beginClipping(x, y, width, height);
+        rb_yield(Qnil);
+        Gosu::Graphics::endClipping();
+    }
+    Gosu::Image* record(int width, int height) {
+        Gosu::Graphics::beginRecording();
+        rb_yield(Qnil);
+        return new Gosu::Image(Gosu::Graphics::endRecording(width, height));
+    }
+    
+    // This method cannot be called "transform" because then it would be an ambiguous overload of Gosu::Transform Gosu::transform(...).
+    // So it has to be renamed via %rename below... :( - same for the other transformations.
+    
+    void transformForRuby(double m0, double m1, double m2, double m3, double m4, double m5, double m6, double m7,
+        double m8, double m9, double m10, double m11, double m12, double m13, double m14, double m15) {
+        Gosu::Transform transform = {
+            m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15
+        };
+        Gosu::Graphics::pushTransform(transform);
+        rb_yield(Qnil);
+        Gosu::Graphics::popTransform();
+    }
+    void rotateForRuby(double angle, double aroundX = 0, double aroundY = 0) {
+        Gosu::Graphics::pushTransform(Gosu::rotate(angle, aroundX, aroundY));
+        rb_yield(Qnil);
+        Gosu::Graphics::popTransform();
+    }
+    void scaleForRuby(double factor) {
+        Gosu::Graphics::pushTransform(Gosu::scale(factor));
+        rb_yield(Qnil);
+        Gosu::Graphics::popTransform();
+    }
+    void scaleForRuby(double factorX, double factorY) {
+        Gosu::Graphics::pushTransform(Gosu::scale(factorX, factorY));
+        rb_yield(Qnil);
+        Gosu::Graphics::popTransform();
+    }
+    void scaleForRuby(double factorX, double factorY, double aroundX, double aroundY) {
+        Gosu::Graphics::pushTransform(Gosu::scale(factorX, factorY, aroundX, aroundY));
+        rb_yield(Qnil);
+        Gosu::Graphics::popTransform();
+    }
+    void translateForRuby(double x, double y) {
+        Gosu::Graphics::pushTransform(Gosu::translate(x, y));
+        rb_yield(Qnil);
+        Gosu::Graphics::popTransform();
+    }
+}
 
 
 #include <limits.h>
@@ -2386,7 +2484,7 @@ SWIG_ruby_failed(void)
 } 
 
 
-/*@SWIG:/usr/local/Cellar/swig/3.0.2/share/swig/3.0.2/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+/*@SWIG:/usr/local/Cellar/swig/3.0.5/share/swig/3.0.5/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
 {
   VALUE obj = args[0];
@@ -2428,7 +2526,7 @@ SWIG_From_unsigned_SS_int  (unsigned int value)
 #include <string>
 
 
-/*@SWIG:/usr/local/Cellar/swig/3.0.2/share/swig/3.0.2/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+/*@SWIG:/usr/local/Cellar/swig/3.0.5/share/swig/3.0.5/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
 {
   VALUE obj = args[0];
@@ -2498,13 +2596,10 @@ SWIGINTERN Gosu::Color Gosu_Color_argb__SWIG_2(std::tr1::uint32_t argb){
 SWIGINTERN Gosu::Color Gosu_Color_dup(Gosu::Color const *self){
         return *self;
     }
-SWIGINTERN std::string Gosu_Color_toS(Gosu::Color const *self){
-        std::ostringstream stream;
-        stream << "(ARGB: " << static_cast<int>(self->alpha())
-               << "/" << static_cast<int>(self->red()) 
-               << "/" << static_cast<int>(self->green())
-               << "/" << static_cast<int>(self->blue()) << ")";
-        return stream.str();
+SWIGINTERN std::string Gosu_Color_inspect(Gosu::Color const *self){
+        char buffer[31];
+        std::snprintf(buffer, sizeof buffer, "#<Gosu::Color:ARGB=0x%08x>", self->argb());
+        return buffer;
     }
 
 SWIGINTERNINLINE VALUE
@@ -2528,7 +2623,7 @@ SWIG_From_bool  (bool value)
 }
 
 
-/*@SWIG:/usr/local/Cellar/swig/3.0.2/share/swig/3.0.2/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+/*@SWIG:/usr/local/Cellar/swig/3.0.5/share/swig/3.0.5/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
 {
   VALUE obj = args[0];
@@ -2572,16 +2667,45 @@ SWIG_AsVal_int (VALUE obj, int *val)
   return res;
 }
 
-SWIGINTERN Gosu::Font *new_Gosu_Font(Gosu::Window &window,std::wstring const &fontName,unsigned int height){
-        return new Gosu::Font(window.graphics(), fontName, height);
+SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_0(Gosu::Window &window,std::wstring const &fontName,unsigned int height){
+        return new Gosu::Font(height, fontName);
+    }
+SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_1(unsigned int height,VALUE options=0){
+        std::wstring fontName = Gosu::defaultFontName();
+        
+        if (options) {
+            Check_Type(options, T_HASH);
+            
+            VALUE keys = rb_funcall(options, rb_intern("keys"), 0, NULL);
+            int keysSize = NUM2INT(rb_funcall(keys, rb_intern("size"), 0, NULL));
+            
+            for (int i = 0; i < keysSize; ++i) {
+                VALUE key = rb_ary_entry(keys, i);
+                const char* keyString = Gosu::cstrFromSymbol(key);
+                
+                VALUE value = rb_hash_aref(options, key);
+                if (!strcmp(keyString, "name")) {
+                    VALUE rbString = rb_obj_as_string(value);
+                    char* utf8String = StringValueCStr(rbString);
+                    fontName = Gosu::utf8ToWstring(utf8String);
+                }
+                // TODO - would be nice & trivial to support :bold => false and :italic => true here
+                else {
+                    static bool issuedWarning = false;
+                    if (!issuedWarning) {
+                        issuedWarning = true;
+                        rb_warn("Unknown keyword argument: :%s", keyString);
+                    }
+                }
+            }
+        }
+        
+        return new Gosu::Font(height, fontName);
     }
 SWIGINTERN void Gosu_Font_set_image(Gosu::Font *self,wchar_t wc,VALUE source){
-        // TODO: Super super super ugly hack that relies on the layout of std::tr1::shared_ptr.
-        // To be removed once Image creation does not require a Graphics anymore.
-        Gosu::Graphics& graphics = ***reinterpret_cast<Gosu::Graphics***>(self);
         Gosu::Bitmap bitmap;
         Gosu::loadBitmap(bitmap, source);
-        self->setImage(wc, Gosu::Image(graphics, bitmap, false));
+        self->setImage(wc, Gosu::Image(bitmap, Gosu::ifSmooth));
     }
 
 #include <float.h>
@@ -2633,6 +2757,52 @@ SWIG_From_float  (float value)
   return SWIG_From_double  (value);
 }
 
+SWIGINTERN Gosu::Image *new_Gosu_Image__SWIG_0(VALUE source,VALUE options=0){
+        Gosu::Bitmap bmp;
+        Gosu::loadBitmap(bmp, source);
+        
+        unsigned srcX = 0, srcY = 0, srcWidth = bmp.width(), srcHeight = bmp.height();
+        unsigned flags = 0;
+        
+        if (options) {
+            Check_Type(options, T_HASH);
+            
+            VALUE keys = rb_funcall(options, rb_intern("keys"), 0, NULL);
+            int keysSize = NUM2INT(rb_funcall(keys, rb_intern("size"), 0, NULL));
+            
+            for (int i = 0; i < keysSize; ++i) {
+                VALUE key = rb_ary_entry(keys, i);
+                const char* keyString = Gosu::cstrFromSymbol(key);
+                
+                VALUE value = rb_hash_aref(options, key);
+                if (!strcmp(keyString, "tileable")) {
+                    if (RTEST(value))
+                        flags |= Gosu::ifTileable;
+                }
+                else if (!strcmp(keyString, "rect")) {
+                    Check_Type(value, T_ARRAY);
+                    
+                    int rectSize = NUM2INT(rb_funcall(value, rb_intern("size"), 0, NULL));
+                    if (rectSize != 4)
+                        rb_raise(rb_eArgError, "Argument passed to :rect must be a four-element Array (x, y, width, height)");
+                    
+                    srcX = NUM2INT(rb_ary_entry(value, 0));
+                    srcY = NUM2INT(rb_ary_entry(value, 1));
+                    srcWidth = NUM2INT(rb_ary_entry(value, 2));
+                    srcHeight = NUM2INT(rb_ary_entry(value, 3));
+                }
+                else {
+                    static bool issuedWarning = false;
+                    if (!issuedWarning) {
+                        issuedWarning = true;
+                        rb_warn("Unknown keyword argument: :%s", keyString);
+                    }
+                }
+            }
+        }
+        
+        return new Gosu::Image(bmp, srcX, srcY, srcWidth, srcHeight, flags);
+    }
 
 SWIGINTERN int
 SWIG_AsVal_bool (VALUE obj, bool *val)
@@ -2653,16 +2823,16 @@ SWIG_AsVal_bool (VALUE obj, bool *val)
   return SWIG_TypeError;
 }
 
-SWIGINTERN Gosu::Image *new_Gosu_Image__SWIG_0(Gosu::Window &window,VALUE source,bool tileable=false){
+SWIGINTERN Gosu::Image *new_Gosu_Image__SWIG_1(Gosu::Window &window,VALUE source,bool tileable=false){
         Gosu::Bitmap bmp;
         Gosu::loadBitmap(bmp, source);
-        return new Gosu::Image(window.graphics(), bmp, tileable);
+        return new Gosu::Image(bmp, tileable ? Gosu::ifTileable : Gosu::ifSmooth);
     }
-SWIGINTERN Gosu::Image *new_Gosu_Image__SWIG_1(Gosu::Window &window,VALUE source,bool tileable,unsigned int srcX,unsigned int srcY,unsigned int srcWidth,unsigned int srcHeight){
+SWIGINTERN Gosu::Image *new_Gosu_Image__SWIG_2(Gosu::Window &window,VALUE source,bool tileable,unsigned int srcX,unsigned int srcY,unsigned int srcWidth,unsigned int srcHeight){
         Gosu::Bitmap bmp;
         Gosu::loadBitmap(bmp, source);
-        return new Gosu::Image(window.graphics(), bmp,
-            srcX, srcY, srcWidth, srcHeight, tileable);
+        return new Gosu::Image(bmp, srcX, srcY, srcWidth, srcHeight,
+            tileable ? Gosu::ifTileable : Gosu::ifSmooth);
     }
 SWIGINTERN void Gosu_Image_drawAsQuad(Gosu::Image *self,double x1,double y1,Gosu::Color c1,double x2,double y2,Gosu::Color c2,double x3,double y3,Gosu::Color c3,double x4,double y4,Gosu::Color c4,Gosu::ZPos z,Gosu::AlphaMode mode=Gosu::amDefault){
         self->getData().draw(x1, y1, c1, x2, y2, c2, x3, y3, c3, x4, y4, c4, z, mode);
@@ -2678,22 +2848,99 @@ SWIGINTERN Gosu::Image *Gosu_Image_subimage(Gosu::Image *self,int x,int y,int w,
         std::auto_ptr<Gosu::ImageData> imageData = self->getData().subimage(x, y, w, h);
         return imageData.get() ? new Gosu::Image(imageData) : 0;
     }
-SWIGINTERN Gosu::Image *Gosu_Image_fromText4(Gosu::Window &window,std::wstring const &text,std::wstring const &fontName,unsigned int fontHeight){
-        Gosu::Bitmap bmp = Gosu::createText(text, fontName, fontHeight);
-        return new Gosu::Image(window.graphics(), bmp);
+SWIGINTERN Gosu::Image *Gosu_Image_fromText(std::wstring const &text,unsigned int fontHeight,VALUE options=0){
+        std::wstring font = Gosu::defaultFontName();
+        unsigned width = 0xfefefefe;
+        unsigned spacing = 0;
+        Gosu::TextAlign align = align;
+        
+        if (options) {
+            Check_Type(options, T_HASH);
+            
+            VALUE keys = rb_funcall(options, rb_intern("keys"), 0, NULL);
+            int keysSize = NUM2INT(rb_funcall(keys, rb_intern("size"), 0, NULL));
+            
+            for (int i = 0; i < keysSize; ++i) {
+                VALUE key = rb_ary_entry(keys, i);
+                const char* keyString = Gosu::cstrFromSymbol(key);
+                
+                VALUE value = rb_hash_aref(options, key);
+                if (!strcmp(keyString, "font")) {
+                    const char* fontUTF8 = StringValuePtr(value);
+                    font = Gosu::utf8ToWstring(fontUTF8);
+                }
+                else if (!strcmp(keyString, "align")) {
+                    const char* cstr = Gosu::cstrFromSymbol(value);
+
+                    if (!strcmp(cstr, "left"))
+                        align = Gosu::taLeft;
+                    else if (!strcmp(cstr, "center"))
+                        align = Gosu::taCenter;
+                    else if (!strcmp(cstr, "right"))
+                        align = Gosu::taRight;
+                    else if (!strcmp(cstr, "justify"))
+                        align = Gosu::taJustify;
+                    else
+                        rb_raise(rb_eArgError, "Argument passed to :align must be a valid text alignment (:left, :center, :right, :justify)");
+                }
+                else if (!strcmp(keyString, "width")) {
+                    width = NUM2INT(value);
+                }
+                else if (!strcmp(keyString, "spacing")) {
+                    spacing = NUM2INT(value);
+                }
+                else {
+                    static bool issuedWarning = false;
+                    if (!issuedWarning) {
+                        issuedWarning = true;
+                        rb_warn("Unknown keyword argument: :%s", keyString);
+                    }
+                }
+            }
+        }
+        
+        if (width == 0xfefefefe)
+            return new Gosu::Image(Gosu::createText(text, font, fontHeight));
+        else
+            return new Gosu::Image(Gosu::createText(text, font, fontHeight, spacing, width, align));
     }
-SWIGINTERN Gosu::Image *Gosu_Image_fromText7(Gosu::Window &window,std::wstring const &text,std::wstring const &fontName,unsigned int fontHeight,int lineSpacing,unsigned int width,Gosu::TextAlign align){
-        Gosu::Bitmap bmp = Gosu::createText(text, fontName, fontHeight, lineSpacing, width, align);
-        return new Gosu::Image(window.graphics(), bmp);
+SWIGINTERN std::vector< Gosu::Image > Gosu_Image_loadTiles__SWIG_0(VALUE source,int tileWidth,int tileHeight,VALUE options=0){
+        Gosu::Bitmap bmp;
+        Gosu::loadBitmap(bmp, source);
+        
+        unsigned flags = 0;
+        
+        if (options) {
+            Check_Type(options, T_HASH);
+            
+            VALUE keys = rb_funcall(options, rb_intern("keys"), 0, NULL);
+            int keysSize = NUM2INT(rb_funcall(keys, rb_intern("size"), 0, NULL));
+            
+            for (int i = 0; i < keysSize; ++i) {
+                VALUE key = rb_ary_entry(keys, i);
+                const char* keyString = Gosu::cstrFromSymbol(key);
+                
+                VALUE value = rb_hash_aref(options, key);
+                if (!strcmp(keyString, "tileable")) {
+                    if (RTEST(value))
+                        flags |= Gosu::ifTileable;
+                }
+                else {
+                    static bool issuedWarning = false;
+                    if (!issuedWarning) {
+                        issuedWarning = true;
+                        rb_warn("Unknown keyword argument: :%s", keyString);
+                    }
+                }
+            }
+        }
+        return Gosu::loadTiles(bmp, tileWidth, tileHeight, flags);
     }
-SWIGINTERN std::vector< Gosu::Image * > Gosu_Image_loadTiles(Gosu::Window &window,VALUE source,int tileWidth,int tileHeight,bool tileable){
-        std::vector<Gosu::Image*> vec;
-        // TODO: const correctness (<- did I mean exception safety?)
+SWIGINTERN std::vector< Gosu::Image > Gosu_Image_loadTiles__SWIG_1(Gosu::Window &window,VALUE source,int tileWidth,int tileHeight,bool tileable){
         Gosu::Bitmap bmp;
         Gosu::loadBitmap(bmp, source);
-        Gosu::imagesFromTiledBitmap(window.graphics(), bmp,
-            tileWidth, tileHeight, tileable, vec);
-        return vec;        
+        
+        return Gosu::loadTiles(bmp, tileWidth, tileHeight, tileable ? Gosu::ifTileable : Gosu::ifSmooth);
     }
 SWIGINTERN std::string Gosu_Image_toBlob(Gosu::Image const *self){
         // TODO: Optimize with direct copy into a Ruby string
@@ -2723,31 +2970,6 @@ SWIGINTERN unsigned int Gosu_TextInput_selection_start(Gosu::TextInput const *se
         return RUBY_18_19(Gosu::wstringToUTF8(self->text().substr(0, self->selectionStart())).size(),
             self->selectionStart());
     }
-SWIGINTERN void Gosu_Window_drawLine(Gosu::Window *self,double x1,double y1,Gosu::Color c1,double x2,double y2,Gosu::Color c2,Gosu::ZPos z=0,Gosu::AlphaMode mode=Gosu::amDefault){
-        self->graphics().drawLine(x1, y1, c1, x2, y2, c2,
-                                   z, mode);
-    }
-SWIGINTERN void Gosu_Window_drawTriangle(Gosu::Window *self,double x1,double y1,Gosu::Color c1,double x2,double y2,Gosu::Color c2,double x3,double y3,Gosu::Color c3,Gosu::ZPos z=0,Gosu::AlphaMode mode=Gosu::amDefault){
-        self->graphics().drawTriangle(x1, y1, c1, x2, y2, c2, x3, y3, c3,
-                                       z, mode);
-    }
-SWIGINTERN void Gosu_Window_drawQuad(Gosu::Window *self,double x1,double y1,Gosu::Color c1,double x2,double y2,Gosu::Color c2,double x3,double y3,Gosu::Color c3,double x4,double y4,Gosu::Color c4,Gosu::ZPos z=0,Gosu::AlphaMode mode=Gosu::amDefault){
-        self->graphics().drawQuad(x1, y1, c1, x2, y2, c2,
-                                   x3, y3, c3, x4, y4, c4,
-                                   z, mode);
-    }
-SWIGINTERN void Gosu_Window_flush(Gosu::Window *self){
-        return self->graphics().flush();
-    }
-SWIGINTERN bool Gosu_Window_isButtonDown(Gosu::Window const *self,Gosu::Button btn){
-        return self->input().down(btn);
-    }
-SWIGINTERN Gosu::Button Gosu_Window_charToButtonId(wchar_t ch){
-        return Gosu::Input::charToId(ch);
-    }
-SWIGINTERN wchar_t Gosu_Window_buttonIdToChar(Gosu::Button btn){
-        return Gosu::Input::idToChar(btn);
-    }
 SWIGINTERN Gosu::TextInput *Gosu_Window_textInput(Gosu::Window const *self){
         return self->input().textInput();
     }
@@ -2778,57 +3000,6 @@ SWIGINTERN int Gosu_Window_height(Gosu::Window const *self){
 SWIGINTERN bool Gosu_Window_fullscreen(Gosu::Window const *self){
         return self->graphics().fullscreen();
     }
-SWIGINTERN void Gosu_Window_unsafe_gl__SWIG_0(Gosu::Window *self){
-        self->graphics().beginGL();
-        rb_yield(Qnil);
-        self->graphics().endGL();
-    }
-SWIGINTERN void Gosu_Window_unsafe_gl__SWIG_1(Gosu::Window *self,Gosu::ZPos z){
-        self->graphics().scheduleGL(std::tr1::bind(callRubyBlock, rb_block_proc()), z);
-    }
-SWIGINTERN void Gosu_Window_clipTo(Gosu::Window *self,double x,double y,double width,double height){
-        self->graphics().beginClipping(x, y, width, height);
-        rb_yield(Qnil);
-        self->graphics().endClipping();
-    }
-SWIGINTERN Gosu::Image *Gosu_Window_record(Gosu::Window *self,int width,int height){
-        self->graphics().beginRecording();
-        rb_yield(Qnil);
-        return new Gosu::Image(self->graphics().endRecording(width, height));
-    }
-SWIGINTERN void Gosu_Window_transform(Gosu::Window *self,double m0,double m1,double m2,double m3,double m4,double m5,double m6,double m7,double m8,double m9,double m10,double m11,double m12,double m13,double m14,double m15){
-        Gosu::Transform transform = {
-            m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15
-        };
-        self->graphics().pushTransform(transform);
-        rb_yield(Qnil);
-        self->graphics().popTransform();
-    }
-SWIGINTERN void Gosu_Window_rotate(Gosu::Window *self,double angle,double aroundX=0,double aroundY=0){
-        self->graphics().pushTransform(Gosu::rotate(angle, aroundX, aroundY));
-        rb_yield(Qnil);
-        self->graphics().popTransform();
-    }
-SWIGINTERN void Gosu_Window_scale__SWIG_0(Gosu::Window *self,double factor){
-        self->graphics().pushTransform(Gosu::scale(factor));
-        rb_yield(Qnil);
-        self->graphics().popTransform();
-    }
-SWIGINTERN void Gosu_Window_scale__SWIG_1(Gosu::Window *self,double factorX,double factorY){
-        self->graphics().pushTransform(Gosu::scale(factorX, factorY));
-        rb_yield(Qnil);
-        self->graphics().popTransform();
-    }
-SWIGINTERN void Gosu_Window_scale__SWIG_2(Gosu::Window *self,double factorX,double factorY,double aroundX,double aroundY){
-        self->graphics().pushTransform(Gosu::scale(factorX, factorY, aroundX, aroundY));
-        rb_yield(Qnil);
-        self->graphics().popTransform();
-    }
-SWIGINTERN void Gosu_Window_translate(Gosu::Window *self,double x,double y){
-        self->graphics().pushTransform(Gosu::translate(x, y));
-        rb_yield(Qnil);
-        self->graphics().popTransform();
-    }
 
     static void markWindow(void* window) {
         #ifndef __MACRUBY__
@@ -4681,8 +4852,17 @@ fail:
 }
 
 
+
+/*
+  Document-method: Gosu::Color.inspect
+
+  call-seq:
+    inspect -> std::string
+
+Inspect class and its contents.
+*/
 SWIGINTERN VALUE
-_wrap_Color_to_s(int argc, VALUE *argv, VALUE self) {
+_wrap_Color_inspect(int argc, VALUE *argv, VALUE self) {
   Gosu::Color *arg1 = (Gosu::Color *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -4694,12 +4874,12 @@ _wrap_Color_to_s(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Color, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color const *","toS", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color const *","inspect", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   {
     try {
-      result = Gosu_Color_toS((Gosu::Color const *)arg1);
+      result = Gosu_Color_inspect((Gosu::Color const *)arg1);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -4988,9 +5168,7 @@ _wrap_Font_draw(int argc, VALUE *argv, VALUE self) {
     {
       const char* cstr = Gosu::cstrFromSymbol(argv[7]);
       
-      if (!cstr)
-      SWIG_exception_fail(SWIG_ValueError, "alpha mode must be a symbol");
-      else if (!strcmp(cstr, "default"))
+      if (!strcmp(cstr, "default"))
       arg9 = Gosu::amDefault;
       else if (!strcmp(cstr, "add"))
       arg9 = Gosu::amAdditive;
@@ -5119,9 +5297,7 @@ _wrap_Font_draw_rel(int argc, VALUE *argv, VALUE self) {
     {
       const char* cstr = Gosu::cstrFromSymbol(argv[9]);
       
-      if (!cstr)
-      SWIG_exception_fail(SWIG_ValueError, "alpha mode must be a symbol");
-      else if (!strcmp(cstr, "default"))
+      if (!strcmp(cstr, "default"))
       arg11 = Gosu::amDefault;
       else if (!strcmp(cstr, "add"))
       arg11 = Gosu::amAdditive;
@@ -5242,9 +5418,7 @@ _wrap_Font_draw_rot(int argc, VALUE *argv, VALUE self) {
     {
       const char* cstr = Gosu::cstrFromSymbol(argv[8]);
       
-      if (!cstr)
-      SWIG_exception_fail(SWIG_ValueError, "alpha mode must be a symbol");
-      else if (!strcmp(cstr, "default"))
+      if (!strcmp(cstr, "default"))
       arg10 = Gosu::amDefault;
       else if (!strcmp(cstr, "add"))
       arg10 = Gosu::amAdditive;
@@ -5269,25 +5443,8 @@ fail:
 }
 
 
-#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
-SWIGINTERN VALUE
-_wrap_Font_allocate(VALUE self) {
-#else
-  SWIGINTERN VALUE
-  _wrap_Font_allocate(int argc, VALUE *argv, VALUE self) {
-#endif
-    
-    
-    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Gosu__Font);
-#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
-    rb_obj_call_init(vresult, argc, argv);
-#endif
-    return vresult;
-  }
-  
-
 SWIGINTERN VALUE
-_wrap_new_Font(int argc, VALUE *argv, VALUE self) {
+_wrap_new_Font__SWIG_0(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = 0 ;
   std::wstring *arg2 = 0 ;
   unsigned int arg3 ;
@@ -5322,7 +5479,59 @@ _wrap_new_Font(int argc, VALUE *argv, VALUE self) {
   arg3 = static_cast< unsigned int >(val3);
   {
     try {
-      result = (Gosu::Font *)new_Gosu_Font(*arg1,(std::wstring const &)*arg2,arg3);
+      result = (Gosu::Font *)new_Gosu_Font__SWIG_0(*arg1,(std::wstring const &)*arg2,arg3);
+      DATA_PTR(self) = result;
+      SWIG_RubyAddTracking(result, self);
+    } catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+SWIGINTERN VALUE
+_wrap_Font_allocate(VALUE self) {
+#else
+  SWIGINTERN VALUE
+  _wrap_Font_allocate(int argc, VALUE *argv, VALUE self) {
+#endif
+    
+    
+    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Gosu__Font);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_obj_call_init(vresult, argc, argv);
+#endif
+    return vresult;
+  }
+  
+
+SWIGINTERN VALUE
+_wrap_new_Font__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  unsigned int arg1 ;
+  VALUE arg2 = (VALUE) 0 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  const char *classname SWIGUNUSED = "Gosu::Font";
+  Gosu::Font *result = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","Font", 1, argv[0] ));
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  if (argc > 1) {
+    arg2 = argv[1];
+  }
+  {
+    try {
+      result = (Gosu::Font *)new_Gosu_Font__SWIG_1(arg1,arg2);
       DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
     } catch (const std::exception& e) {
@@ -5335,6 +5544,62 @@ fail:
 }
 
 
+SWIGINTERN VALUE _wrap_new_Font(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 3) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 1) && (argc <= 2)) {
+    int _v;
+    {
+      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_Font__SWIG_1(nargs, args, self);
+      }
+      _v = (argv[1] != 0);
+      if (_v) {
+        return _wrap_new_Font__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Window, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__wstring, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_Font__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "Font.new", 
+    "    Font.new(Gosu::Window &window, std::wstring const &fontName, unsigned int height)\n"
+    "    Font.new(unsigned int height, VALUE options)\n");
+  
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Font_set_image(int argc, VALUE *argv, VALUE self) {
   Gosu::Font *arg1 = (Gosu::Font *) 0 ;
@@ -5838,9 +6103,7 @@ _wrap_Image_draw(int argc, VALUE *argv, VALUE self) {
     {
       const char* cstr = Gosu::cstrFromSymbol(argv[6]);
       
-      if (!cstr)
-      SWIG_exception_fail(SWIG_ValueError, "alpha mode must be a symbol");
-      else if (!strcmp(cstr, "default"))
+      if (!strcmp(cstr, "default"))
       arg8 = Gosu::amDefault;
       else if (!strcmp(cstr, "add"))
       arg8 = Gosu::amAdditive;
@@ -5988,9 +6251,7 @@ _wrap_Image_draw_mod(int argc, VALUE *argv, VALUE self) {
     {
       const char* cstr = Gosu::cstrFromSymbol(argv[9]);
       
-      if (!cstr)
-      SWIG_exception_fail(SWIG_ValueError, "alpha mode must be a symbol");
-      else if (!strcmp(cstr, "default"))
+      if (!strcmp(cstr, "default"))
       arg11 = Gosu::amDefault;
       else if (!strcmp(cstr, "add"))
       arg11 = Gosu::amAdditive;
@@ -6124,9 +6385,7 @@ _wrap_Image_draw_rot(int argc, VALUE *argv, VALUE self) {
     {
       const char* cstr = Gosu::cstrFromSymbol(argv[9]);
       
-      if (!cstr)
-      SWIG_exception_fail(SWIG_ValueError, "alpha mode must be a symbol");
-      else if (!strcmp(cstr, "default"))
+      if (!strcmp(cstr, "default"))
       arg11 = Gosu::amDefault;
       else if (!strcmp(cstr, "add"))
       arg11 = Gosu::amAdditive;
@@ -6152,37 +6411,36 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Image_get_data(int argc, VALUE *argv, VALUE self) {
-  Gosu::Image *arg1 = (Gosu::Image *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  Gosu::ImageData *result = 0 ;
-  VALUE vresult = Qnil;
+_wrap_new_Image__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  VALUE arg1 = (VALUE) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  const char *classname SWIGUNUSED = "Gosu::Image";
+  Gosu::Image *result = 0 ;
   
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Image, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Image const *","getData", 1, self )); 
+  arg1 = argv[0];
+  if (argc > 1) {
+    arg2 = argv[1];
   }
-  arg1 = reinterpret_cast< Gosu::Image * >(argp1);
   {
     try {
-      result = (Gosu::ImageData *) &((Gosu::Image const *)arg1)->getData();
+      result = (Gosu::Image *)new_Gosu_Image__SWIG_0(arg1,arg2);
+      DATA_PTR(self) = result;
+      SWIG_RubyAddTracking(result, self);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gosu__ImageData, 0 |  0 );
-  return vresult;
+  return self;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_new_Image__SWIG_0(int argc, VALUE *argv, VALUE self) {
+_wrap_new_Image__SWIG_1(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = 0 ;
   VALUE arg2 = (VALUE) 0 ;
   bool arg3 = (bool) false ;
@@ -6214,7 +6472,7 @@ _wrap_new_Image__SWIG_0(int argc, VALUE *argv, VALUE self) {
   }
   {
     try {
-      result = (Gosu::Image *)new_Gosu_Image__SWIG_0(*arg1,arg2,arg3);
+      result = (Gosu::Image *)new_Gosu_Image__SWIG_1(*arg1,arg2,arg3);
       DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
     } catch (const std::exception& e) {
@@ -6245,7 +6503,7 @@ _wrap_Image_allocate(VALUE self) {
   
 
 SWIGINTERN VALUE
-_wrap_new_Image__SWIG_1(int argc, VALUE *argv, VALUE self) {
+_wrap_new_Image__SWIG_2(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = 0 ;
   VALUE arg2 = (VALUE) 0 ;
   bool arg3 ;
@@ -6307,7 +6565,7 @@ _wrap_new_Image__SWIG_1(int argc, VALUE *argv, VALUE self) {
   arg7 = static_cast< unsigned int >(val7);
   {
     try {
-      result = (Gosu::Image *)new_Gosu_Image__SWIG_1(*arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+      result = (Gosu::Image *)new_Gosu_Image__SWIG_2(*arg1,arg2,arg3,arg4,arg5,arg6,arg7);
       DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
     } catch (const std::exception& e) {
@@ -6330,23 +6588,36 @@ SWIGINTERN VALUE _wrap_new_Image(int nargs, VALUE *args, VALUE self) {
   for (ii = 0; (ii < argc); ++ii) {
     argv[ii] = args[ii];
   }
-  if ((argc >= 2) && (argc <= 3)) {
+  if ((argc >= 1) && (argc <= 2)) {
     int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Window, 0);
-    _v = SWIG_CheckState(res);
+    _v = (argv[0] != 0);
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_Image__SWIG_0(nargs, args, self);
+      }
+      _v = (argv[1] != 0);
+      if (_v) {
+        return _wrap_new_Image__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 3)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Window, 0);
+    _v = SWIG_CheckState(res);
     if (_v) {
       _v = (argv[1] != 0);
       if (_v) {
         if (argc <= 2) {
-          return _wrap_new_Image__SWIG_0(nargs, args, self);
+          return _wrap_new_Image__SWIG_1(nargs, args, self);
         }
         {
           int res = SWIG_AsVal_bool(argv[2], NULL);
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_new_Image__SWIG_0(nargs, args, self);
+          return _wrap_new_Image__SWIG_1(nargs, args, self);
         }
       }
     }
@@ -6384,7 +6655,7 @@ SWIGINTERN VALUE _wrap_new_Image(int nargs, VALUE *args, VALUE self) {
                   _v = SWIG_CheckState(res);
                 }
                 if (_v) {
-                  return _wrap_new_Image__SWIG_1(nargs, args, self);
+                  return _wrap_new_Image__SWIG_2(nargs, args, self);
                 }
               }
             }
@@ -6396,6 +6667,7 @@ SWIGINTERN VALUE _wrap_new_Image(int nargs, VALUE *args, VALUE self) {
   
 fail:
   Ruby_Format_OverloadedError( argc, 7, "Image.new", 
+    "    Image.new(VALUE source, VALUE options)\n"
     "    Image.new(Gosu::Window &window, VALUE source, bool tileable)\n"
     "    Image.new(Gosu::Window &window, VALUE source, bool tileable, unsigned int srcX, unsigned int srcY, unsigned int srcWidth, unsigned int srcHeight)\n");
   
@@ -6558,9 +6830,7 @@ _wrap_Image_draw_as_quad(int argc, VALUE *argv, VALUE self) {
     {
       const char* cstr = Gosu::cstrFromSymbol(argv[13]);
       
-      if (!cstr)
-      SWIG_exception_fail(SWIG_ValueError, "alpha mode must be a symbol");
-      else if (!strcmp(cstr, "default"))
+      if (!strcmp(cstr, "default"))
       arg15 = Gosu::amDefault;
       else if (!strcmp(cstr, "add"))
       arg15 = Gosu::amAdditive;
@@ -6678,49 +6948,35 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Image_from_text4(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = 0 ;
-  std::wstring *arg2 = 0 ;
-  std::wstring *arg3 = 0 ;
-  unsigned int arg4 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  std::wstring temp2 ;
-  std::wstring temp3 ;
-  unsigned int val4 ;
-  int ecode4 = 0 ;
+_wrap_Image_from_text(int argc, VALUE *argv, VALUE self) {
+  std::wstring *arg1 = 0 ;
+  unsigned int arg2 ;
+  VALUE arg3 = (VALUE) 0 ;
+  std::wstring temp1 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
   Gosu::Image *result = 0 ;
   VALUE vresult = Qnil;
   
-  if ((argc < 4) || (argc > 4)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Gosu__Window,  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window &","Gosu_Image_fromText4", 1, argv[0] )); 
-  }
-  if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Gosu::Window &","Gosu_Image_fromText4", 1, argv[0])); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  {
-    VALUE localTemporary = rb_obj_as_string(argv[1]);
-    temp2 = Gosu::utf8ToWstring(StringValueCStr(localTemporary));
-    arg2 = &temp2;
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
   {
-    VALUE localTemporary = rb_obj_as_string(argv[2]);
-    temp3 = Gosu::utf8ToWstring(StringValueCStr(localTemporary));
-    arg3 = &temp3;
+    VALUE localTemporary = rb_obj_as_string(argv[0]);
+    temp1 = Gosu::utf8ToWstring(StringValueCStr(localTemporary));
+    arg1 = &temp1;
   }
-  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","Gosu_Image_fromText4", 4, argv[3] ));
+  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","Gosu_Image_fromText", 2, argv[1] ));
   } 
-  arg4 = static_cast< unsigned int >(val4);
+  arg2 = static_cast< unsigned int >(val2);
+  if (argc > 2) {
+    arg3 = argv[2];
+  }
   {
     try {
-      result = (Gosu::Image *)Gosu_Image_fromText4(*arg1,(std::wstring const &)*arg2,(std::wstring const &)*arg3,arg4);
+      result = (Gosu::Image *)Gosu_Image_fromText((std::wstring const &)*arg1,arg2,arg3);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -6733,87 +6989,49 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Image_from_text7(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = 0 ;
-  std::wstring *arg2 = 0 ;
-  std::wstring *arg3 = 0 ;
-  unsigned int arg4 ;
-  int arg5 ;
-  unsigned int arg6 ;
-  Gosu::TextAlign arg7 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  std::wstring temp2 ;
-  std::wstring temp3 ;
-  unsigned int val4 ;
-  int ecode4 = 0 ;
-  int val5 ;
-  int ecode5 = 0 ;
-  unsigned int val6 ;
-  int ecode6 = 0 ;
-  Gosu::Image *result = 0 ;
+_wrap_Image_load_tiles__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  VALUE arg1 = (VALUE) 0 ;
+  int arg2 ;
+  int arg3 ;
+  VALUE arg4 = (VALUE) 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  SwigValueWrapper< std::vector< Gosu::Image > > result;
   VALUE vresult = Qnil;
   
-  if ((argc < 7) || (argc > 7)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Gosu__Window,  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window &","Gosu_Image_fromText7", 1, argv[0] )); 
-  }
-  if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Gosu::Window &","Gosu_Image_fromText7", 1, argv[0])); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  {
-    VALUE localTemporary = rb_obj_as_string(argv[1]);
-    temp2 = Gosu::utf8ToWstring(StringValueCStr(localTemporary));
-    arg2 = &temp2;
-  }
-  {
-    VALUE localTemporary = rb_obj_as_string(argv[2]);
-    temp3 = Gosu::utf8ToWstring(StringValueCStr(localTemporary));
-    arg3 = &temp3;
+  if ((argc < 3) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
   }
-  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","Gosu_Image_fromText7", 4, argv[3] ));
-  } 
-  arg4 = static_cast< unsigned int >(val4);
-  ecode5 = SWIG_AsVal_int(argv[4], &val5);
-  if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","Gosu_Image_fromText7", 5, argv[4] ));
+  arg1 = argv[0];
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Gosu_Image_loadTiles__SWIG_0", 2, argv[1] ));
   } 
-  arg5 = static_cast< int >(val5);
-  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[5], &val6);
-  if (!SWIG_IsOK(ecode6)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "unsigned int","Gosu_Image_fromText7", 6, argv[5] ));
+  arg2 = static_cast< int >(val2);
+  ecode3 = SWIG_AsVal_int(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Gosu_Image_loadTiles__SWIG_0", 3, argv[2] ));
   } 
-  arg6 = static_cast< unsigned int >(val6);
-  {
-    const char* cstr = Gosu::cstrFromSymbol(argv[6]);
-    
-    if (!cstr)
-    SWIG_exception_fail(SWIG_ValueError, "text align must be a symbol");
-    else if (!strcmp(cstr, "left"))
-    arg7 = Gosu::taLeft;
-    else if (!strcmp(cstr, "center"))
-    arg7 = Gosu::taCenter;
-    else if (!strcmp(cstr, "right"))
-    arg7 = Gosu::taRight;
-    else if (!strcmp(cstr, "justify"))
-    arg7 = Gosu::taJustify;
-    else
-    SWIG_exception_fail(SWIG_ValueError, "invalid text align");
+  arg3 = static_cast< int >(val3);
+  if (argc > 3) {
+    arg4 = argv[3];
   }
   {
     try {
-      result = (Gosu::Image *)Gosu_Image_fromText7(*arg1,(std::wstring const &)*arg2,(std::wstring const &)*arg3,arg4,arg5,arg6,arg7);
+      result = Gosu_Image_loadTiles__SWIG_0(arg1,arg2,arg3,arg4);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gosu__Image, SWIG_POINTER_OWN |  0 );
+  {
+    vresult = rb_ary_new2((&result)->size());
+    for (unsigned i = 0; i < (&result)->size(); i++) {
+      VALUE image = SWIG_NewPointerObj(SWIG_as_voidptr(new Gosu::Image((*&result)[i])), SWIGTYPE_p_Gosu__Image, SWIG_POINTER_OWN);
+      rb_ary_store(vresult, i, image);
+    }
+  }
   return vresult;
 fail:
   return Qnil;
@@ -6821,7 +7039,7 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Image_load_tiles(int argc, VALUE *argv, VALUE self) {
+_wrap_Image_load_tiles__SWIG_1(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = 0 ;
   VALUE arg2 = (VALUE) 0 ;
   int arg3 ;
@@ -6835,7 +7053,7 @@ _wrap_Image_load_tiles(int argc, VALUE *argv, VALUE self) {
   int ecode4 = 0 ;
   bool val5 ;
   int ecode5 = 0 ;
-  SwigValueWrapper< std::vector< Gosu::Image * > > result;
+  SwigValueWrapper< std::vector< Gosu::Image > > result;
   VALUE vresult = Qnil;
   
   if ((argc < 5) || (argc > 5)) {
@@ -6843,31 +7061,31 @@ _wrap_Image_load_tiles(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Gosu__Window,  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window &","Gosu_Image_loadTiles", 1, argv[0] )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window &","Gosu_Image_loadTiles__SWIG_1", 1, argv[0] )); 
   }
   if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Gosu::Window &","Gosu_Image_loadTiles", 1, argv[0])); 
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Gosu::Window &","Gosu_Image_loadTiles__SWIG_1", 1, argv[0])); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   arg2 = argv[1];
   ecode3 = SWIG_AsVal_int(argv[2], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Gosu_Image_loadTiles", 3, argv[2] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Gosu_Image_loadTiles__SWIG_1", 3, argv[2] ));
   } 
   arg3 = static_cast< int >(val3);
   ecode4 = SWIG_AsVal_int(argv[3], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Gosu_Image_loadTiles", 4, argv[3] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Gosu_Image_loadTiles__SWIG_1", 4, argv[3] ));
   } 
   arg4 = static_cast< int >(val4);
   ecode5 = SWIG_AsVal_bool(argv[4], &val5);
   if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Gosu_Image_loadTiles", 5, argv[4] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Gosu_Image_loadTiles__SWIG_1", 5, argv[4] ));
   } 
   arg5 = static_cast< bool >(val5);
   {
     try {
-      result = Gosu_Image_loadTiles(*arg1,arg2,arg3,arg4,arg5);
+      result = Gosu_Image_loadTiles__SWIG_1(*arg1,arg2,arg3,arg4,arg5);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -6875,8 +7093,8 @@ _wrap_Image_load_tiles(int argc, VALUE *argv, VALUE self) {
   {
     vresult = rb_ary_new2((&result)->size());
     for (unsigned i = 0; i < (&result)->size(); i++) {
-      VALUE curImg = SWIG_NewPointerObj(SWIG_as_voidptr((*&result)[i]), SWIGTYPE_p_Gosu__Image, SWIG_POINTER_OWN);
-      rb_ary_store(vresult, i, curImg);
+      VALUE image = SWIG_NewPointerObj(SWIG_as_voidptr(new Gosu::Image((*&result)[i])), SWIGTYPE_p_Gosu__Image, SWIG_POINTER_OWN);
+      rb_ary_store(vresult, i, image);
     }
   }
   return vresult;
@@ -6885,6 +7103,81 @@ fail:
 }
 
 
+SWIGINTERN VALUE _wrap_Image_load_tiles(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 5) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 3) && (argc <= 4)) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_Image_load_tiles__SWIG_0(nargs, args, self);
+          }
+          _v = (argv[3] != 0);
+          if (_v) {
+            return _wrap_Image_load_tiles__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Window, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      _v = (argv[1] != 0);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_int(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_int(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_bool(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              return _wrap_Image_load_tiles__SWIG_1(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "load_tiles", 
+    "    std::vector< Gosu::Image > load_tiles(VALUE source, int tileWidth, int tileHeight, VALUE options)\n"
+    "    std::vector< Gosu::Image > load_tiles(Gosu::Window &window, VALUE source, int tileWidth, int tileHeight, bool tileable)\n");
+  
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Image_to_blob(int argc, VALUE *argv, VALUE self) {
   Gosu::Image *arg1 = (Gosu::Image *) 0 ;
@@ -8338,7 +8631,7 @@ _wrap_new_Window(int argc, VALUE *argv, VALUE self) {
   VALUE arg1 = (VALUE) 0 ;
   unsigned int arg2 ;
   unsigned int arg3 ;
-  bool arg4 ;
+  bool arg4 = (bool) false ;
   double arg5 = (double) 16.666666 ;
   unsigned int val2 ;
   int ecode2 = 0 ;
@@ -8351,8 +8644,8 @@ _wrap_new_Window(int argc, VALUE *argv, VALUE self) {
   const char *classname SWIGUNUSED = "Gosu::Window";
   Gosu::Window *result = 0 ;
   
-  if ((argc < 3) || (argc > 4)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  if ((argc < 2) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
   arg1 = self;
   ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
@@ -8365,11 +8658,13 @@ _wrap_new_Window(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","Window", 3, argv[1] ));
   } 
   arg3 = static_cast< unsigned int >(val3);
-  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
-  if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Window", 4, argv[2] ));
-  } 
-  arg4 = static_cast< bool >(val4);
+  if (argc > 2) {
+    ecode4 = SWIG_AsVal_bool(argv[2], &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Window", 4, argv[2] ));
+    } 
+    arg4 = static_cast< bool >(val4);
+  }
   if (argc > 3) {
     ecode5 = SWIG_AsVal_double(argv[3], &val5);
     if (!SWIG_IsOK(ecode5)) {
@@ -8896,267 +9191,169 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_draw_line(int argc, VALUE *argv, VALUE self) {
+_wrap_Window_text_input(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  double arg2 ;
-  double arg3 ;
-  Gosu::Color arg4 ;
-  double arg5 ;
-  double arg6 ;
-  Gosu::Color arg7 ;
-  Gosu::ZPos arg8 = (Gosu::ZPos) 0 ;
-  Gosu::AlphaMode arg9 = (Gosu::AlphaMode) Gosu::amDefault ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  double val2 ;
-  int ecode2 = 0 ;
-  double val3 ;
-  int ecode3 = 0 ;
-  double val5 ;
-  int ecode5 = 0 ;
-  double val6 ;
-  int ecode6 = 0 ;
-  double val8 ;
-  int ecode8 = 0 ;
+  Swig::Director *director = 0;
+  Gosu::TextInput *result = 0 ;
+  VALUE vresult = Qnil;
   
-  if ((argc < 6) || (argc > 8)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","drawLine", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","textInput", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  ecode2 = SWIG_AsVal_double(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","drawLine", 2, argv[0] ));
-  } 
-  arg2 = static_cast< double >(val2);
-  ecode3 = SWIG_AsVal_double(argv[1], &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","drawLine", 3, argv[1] ));
-  } 
-  arg3 = static_cast< double >(val3);
   {
-    if (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM)
-    arg4 = Gosu::Color(NUM2ULONG(argv[2]));
-    else
-    {
-      void* ptr;
-      int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_Gosu__Color, 0);
-      if (!SWIG_IsOK(res))
-      SWIG_exception_fail(SWIG_ValueError, "invalid value");
-      else if (!ptr)
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
-      else
-      arg4 = *reinterpret_cast<Gosu::Color*>(ptr);
+    try {
+      result = (Gosu::TextInput *)Gosu_Window_textInput((Gosu::Window const *)arg1);
+    } catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  ecode5 = SWIG_AsVal_double(argv[3], &val5);
-  if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","drawLine", 5, argv[3] ));
-  } 
-  arg5 = static_cast< double >(val5);
-  ecode6 = SWIG_AsVal_double(argv[4], &val6);
-  if (!SWIG_IsOK(ecode6)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","drawLine", 6, argv[4] ));
-  } 
-  arg6 = static_cast< double >(val6);
-  {
-    if (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM)
-    arg7 = Gosu::Color(NUM2ULONG(argv[5]));
-    else
-    {
-      void* ptr;
-      int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_Gosu__Color, 0);
-      if (!SWIG_IsOK(res))
-      SWIG_exception_fail(SWIG_ValueError, "invalid value");
-      else if (!ptr)
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
-      else
-      arg7 = *reinterpret_cast<Gosu::Color*>(ptr);
-    }
+  director = dynamic_cast<Swig::Director *>(result);
+  if (director) {
+    vresult = director->swig_get_self();
+  } else {
+    vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gosu__TextInput, 0 |  0 );
   }
-  if (argc > 6) {
-    ecode8 = SWIG_AsVal_double(argv[6], &val8);
-    if (!SWIG_IsOK(ecode8)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Gosu::ZPos","drawLine", 8, argv[6] ));
-    } 
-    arg8 = static_cast< Gosu::ZPos >(val8);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Window_text_inpute___(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  Gosu::TextInput *arg2 = (Gosu::TextInput *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  if (argc > 7) {
-    {
-      const char* cstr = Gosu::cstrFromSymbol(argv[7]);
-      
-      if (!cstr)
-      SWIG_exception_fail(SWIG_ValueError, "alpha mode must be a symbol");
-      else if (!strcmp(cstr, "default"))
-      arg9 = Gosu::amDefault;
-      else if (!strcmp(cstr, "add"))
-      arg9 = Gosu::amAdditive;
-      else if (!strcmp(cstr, "additive"))
-      arg9 = Gosu::amAdditive;
-      else if (!strcmp(cstr, "multiply"))
-      arg9 = Gosu::amMultiply;
-      else
-      SWIG_exception_fail(SWIG_ValueError, "invalid alpha mode");
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","setTextInput", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Gosu__TextInput, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Gosu::TextInput *","setTextInput", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< Gosu::TextInput * >(argp2);
+  {
+    try {
+      Gosu_Window_setTextInput(arg1,arg2);
+    } catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Window_mouse_x(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","mouseX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      Gosu_Window_drawLine(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+      result = (double)Gosu_Window_mouseX((Gosu::Window const *)arg1);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
   return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Window_mouse_y(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","mouseY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  {
+    try {
+      result = (double)Gosu_Window_mouseY((Gosu::Window const *)arg1);
+    } catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Window_draw_triangle(int argc, VALUE *argv, VALUE self) {
+_wrap_Window_set_mouse_position(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
   double arg2 ;
   double arg3 ;
-  Gosu::Color arg4 ;
-  double arg5 ;
-  double arg6 ;
-  Gosu::Color arg7 ;
-  double arg8 ;
-  double arg9 ;
-  Gosu::Color arg10 ;
-  Gosu::ZPos arg11 = (Gosu::ZPos) 0 ;
-  Gosu::AlphaMode arg12 = (Gosu::AlphaMode) Gosu::amDefault ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
   double val3 ;
   int ecode3 = 0 ;
-  double val5 ;
-  int ecode5 = 0 ;
-  double val6 ;
-  int ecode6 = 0 ;
-  double val8 ;
-  int ecode8 = 0 ;
-  double val9 ;
-  int ecode9 = 0 ;
-  double val11 ;
-  int ecode11 = 0 ;
   
-  if ((argc < 9) || (argc > 11)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","drawTriangle", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","setMousePosition", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","drawTriangle", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","setMousePosition", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
   ecode3 = SWIG_AsVal_double(argv[1], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","drawTriangle", 3, argv[1] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","setMousePosition", 3, argv[1] ));
   } 
   arg3 = static_cast< double >(val3);
-  {
-    if (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM)
-    arg4 = Gosu::Color(NUM2ULONG(argv[2]));
-    else
-    {
-      void* ptr;
-      int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_Gosu__Color, 0);
-      if (!SWIG_IsOK(res))
-      SWIG_exception_fail(SWIG_ValueError, "invalid value");
-      else if (!ptr)
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
-      else
-      arg4 = *reinterpret_cast<Gosu::Color*>(ptr);
-    }
-  }
-  ecode5 = SWIG_AsVal_double(argv[3], &val5);
-  if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","drawTriangle", 5, argv[3] ));
-  } 
-  arg5 = static_cast< double >(val5);
-  ecode6 = SWIG_AsVal_double(argv[4], &val6);
-  if (!SWIG_IsOK(ecode6)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","drawTriangle", 6, argv[4] ));
-  } 
-  arg6 = static_cast< double >(val6);
-  {
-    if (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM)
-    arg7 = Gosu::Color(NUM2ULONG(argv[5]));
-    else
-    {
-      void* ptr;
-      int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_Gosu__Color, 0);
-      if (!SWIG_IsOK(res))
-      SWIG_exception_fail(SWIG_ValueError, "invalid value");
-      else if (!ptr)
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
-      else
-      arg7 = *reinterpret_cast<Gosu::Color*>(ptr);
-    }
-  }
-  ecode8 = SWIG_AsVal_double(argv[6], &val8);
-  if (!SWIG_IsOK(ecode8)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","drawTriangle", 8, argv[6] ));
-  } 
-  arg8 = static_cast< double >(val8);
-  ecode9 = SWIG_AsVal_double(argv[7], &val9);
-  if (!SWIG_IsOK(ecode9)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "double","drawTriangle", 9, argv[7] ));
-  } 
-  arg9 = static_cast< double >(val9);
-  {
-    if (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM)
-    arg10 = Gosu::Color(NUM2ULONG(argv[8]));
-    else
-    {
-      void* ptr;
-      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_Gosu__Color, 0);
-      if (!SWIG_IsOK(res))
-      SWIG_exception_fail(SWIG_ValueError, "invalid value");
-      else if (!ptr)
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
-      else
-      arg10 = *reinterpret_cast<Gosu::Color*>(ptr);
-    }
-  }
-  if (argc > 9) {
-    ecode11 = SWIG_AsVal_double(argv[9], &val11);
-    if (!SWIG_IsOK(ecode11)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Gosu::ZPos","drawTriangle", 11, argv[9] ));
-    } 
-    arg11 = static_cast< Gosu::ZPos >(val11);
-  }
-  if (argc > 10) {
-    {
-      const char* cstr = Gosu::cstrFromSymbol(argv[10]);
-      
-      if (!cstr)
-      SWIG_exception_fail(SWIG_ValueError, "alpha mode must be a symbol");
-      else if (!strcmp(cstr, "default"))
-      arg12 = Gosu::amDefault;
-      else if (!strcmp(cstr, "add"))
-      arg12 = Gosu::amAdditive;
-      else if (!strcmp(cstr, "additive"))
-      arg12 = Gosu::amAdditive;
-      else if (!strcmp(cstr, "multiply"))
-      arg12 = Gosu::amMultiply;
-      else
-      SWIG_exception_fail(SWIG_ValueError, "invalid alpha mode");
-    }
-  }
   {
     try {
-      Gosu_Window_drawTriangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+      Gosu_Window_setMousePosition(arg1,arg2,arg3);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -9168,242 +9365,154 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_draw_quad(int argc, VALUE *argv, VALUE self) {
+_wrap_Window_mouse_xe___(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
   double arg2 ;
-  double arg3 ;
-  Gosu::Color arg4 ;
-  double arg5 ;
-  double arg6 ;
-  Gosu::Color arg7 ;
-  double arg8 ;
-  double arg9 ;
-  Gosu::Color arg10 ;
-  double arg11 ;
-  double arg12 ;
-  Gosu::Color arg13 ;
-  Gosu::ZPos arg14 = (Gosu::ZPos) 0 ;
-  Gosu::AlphaMode arg15 = (Gosu::AlphaMode) Gosu::amDefault ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
-  double val3 ;
-  int ecode3 = 0 ;
-  double val5 ;
-  int ecode5 = 0 ;
-  double val6 ;
-  int ecode6 = 0 ;
-  double val8 ;
-  int ecode8 = 0 ;
-  double val9 ;
-  int ecode9 = 0 ;
-  double val11 ;
-  int ecode11 = 0 ;
-  double val12 ;
-  int ecode12 = 0 ;
-  double val14 ;
-  int ecode14 = 0 ;
   
-  if ((argc < 12) || (argc > 14)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 12)",argc); SWIG_fail;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","drawQuad", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","setMouseX", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","drawQuad", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","setMouseX", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
-  ecode3 = SWIG_AsVal_double(argv[1], &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","drawQuad", 3, argv[1] ));
-  } 
-  arg3 = static_cast< double >(val3);
   {
-    if (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM)
-    arg4 = Gosu::Color(NUM2ULONG(argv[2]));
-    else
-    {
-      void* ptr;
-      int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_Gosu__Color, 0);
-      if (!SWIG_IsOK(res))
-      SWIG_exception_fail(SWIG_ValueError, "invalid value");
-      else if (!ptr)
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
-      else
-      arg4 = *reinterpret_cast<Gosu::Color*>(ptr);
+    try {
+      Gosu_Window_setMouseX(arg1,arg2);
+    } catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  ecode5 = SWIG_AsVal_double(argv[3], &val5);
-  if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","drawQuad", 5, argv[3] ));
-  } 
-  arg5 = static_cast< double >(val5);
-  ecode6 = SWIG_AsVal_double(argv[4], &val6);
-  if (!SWIG_IsOK(ecode6)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","drawQuad", 6, argv[4] ));
-  } 
-  arg6 = static_cast< double >(val6);
-  {
-    if (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM)
-    arg7 = Gosu::Color(NUM2ULONG(argv[5]));
-    else
-    {
-      void* ptr;
-      int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_Gosu__Color, 0);
-      if (!SWIG_IsOK(res))
-      SWIG_exception_fail(SWIG_ValueError, "invalid value");
-      else if (!ptr)
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
-      else
-      arg7 = *reinterpret_cast<Gosu::Color*>(ptr);
-    }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Window_mouse_ye___(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  ecode8 = SWIG_AsVal_double(argv[6], &val8);
-  if (!SWIG_IsOK(ecode8)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","drawQuad", 8, argv[6] ));
-  } 
-  arg8 = static_cast< double >(val8);
-  ecode9 = SWIG_AsVal_double(argv[7], &val9);
-  if (!SWIG_IsOK(ecode9)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "double","drawQuad", 9, argv[7] ));
-  } 
-  arg9 = static_cast< double >(val9);
-  {
-    if (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM)
-    arg10 = Gosu::Color(NUM2ULONG(argv[8]));
-    else
-    {
-      void* ptr;
-      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_Gosu__Color, 0);
-      if (!SWIG_IsOK(res))
-      SWIG_exception_fail(SWIG_ValueError, "invalid value");
-      else if (!ptr)
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
-      else
-      arg10 = *reinterpret_cast<Gosu::Color*>(ptr);
-    }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","setMouseY", 1, self )); 
   }
-  ecode11 = SWIG_AsVal_double(argv[9], &val11);
-  if (!SWIG_IsOK(ecode11)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "double","drawQuad", 11, argv[9] ));
-  } 
-  arg11 = static_cast< double >(val11);
-  ecode12 = SWIG_AsVal_double(argv[10], &val12);
-  if (!SWIG_IsOK(ecode12)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "double","drawQuad", 12, argv[10] ));
+  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","setMouseY", 2, argv[0] ));
   } 
-  arg12 = static_cast< double >(val12);
+  arg2 = static_cast< double >(val2);
   {
-    if (TYPE(argv[11]) == T_FIXNUM || TYPE(argv[11]) == T_BIGNUM)
-    arg13 = Gosu::Color(NUM2ULONG(argv[11]));
-    else
-    {
-      void* ptr;
-      int res = SWIG_ConvertPtr(argv[11], &ptr, SWIGTYPE_p_Gosu__Color, 0);
-      if (!SWIG_IsOK(res))
-      SWIG_exception_fail(SWIG_ValueError, "invalid value");
-      else if (!ptr)
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
-      else
-      arg13 = *reinterpret_cast<Gosu::Color*>(ptr);
+    try {
+      Gosu_Window_setMouseY(arg1,arg2);
+    } catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  if (argc > 12) {
-    ecode14 = SWIG_AsVal_double(argv[12], &val14);
-    if (!SWIG_IsOK(ecode14)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "Gosu::ZPos","drawQuad", 14, argv[12] ));
-    } 
-    arg14 = static_cast< Gosu::ZPos >(val14);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Window_width(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  if (argc > 13) {
-    {
-      const char* cstr = Gosu::cstrFromSymbol(argv[13]);
-      
-      if (!cstr)
-      SWIG_exception_fail(SWIG_ValueError, "alpha mode must be a symbol");
-      else if (!strcmp(cstr, "default"))
-      arg15 = Gosu::amDefault;
-      else if (!strcmp(cstr, "add"))
-      arg15 = Gosu::amAdditive;
-      else if (!strcmp(cstr, "additive"))
-      arg15 = Gosu::amAdditive;
-      else if (!strcmp(cstr, "multiply"))
-      arg15 = Gosu::amMultiply;
-      else
-      SWIG_exception_fail(SWIG_ValueError, "invalid alpha mode");
-    }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","width", 1, self )); 
   }
+  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      Gosu_Window_drawQuad(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
+      result = (int)Gosu_Window_width((Gosu::Window const *)arg1);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  return Qnil;
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Window_flush(int argc, VALUE *argv, VALUE self) {
+_wrap_Window_height(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","flush", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","height", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      Gosu_Window_flush(arg1);
+      result = (int)Gosu_Window_height((Gosu::Window const *)arg1);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  return Qnil;
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Window_button_downq___(int argc, VALUE *argv, VALUE self) {
+_wrap_Window_fullscreenq___(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  Gosu::Button arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   bool result;
   VALUE vresult = Qnil;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","isButtonDown", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","fullscreen", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  {
-    if (NIL_P(argv[0]))
-    arg2 = Gosu::noButton;
-    else
-    arg2 = Gosu::Button(NUM2LONG(argv[0]));
-  }
   {
     try {
-      result = (bool)Gosu_Window_isButtonDown((Gosu::Window const *)arg1,arg2);
+      result = (bool)Gosu_Window_fullscreen((Gosu::Window const *)arg1);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -9416,7 +9525,32 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_char_to_button_id(int argc, VALUE *argv, VALUE self) {
+_wrap_disown_Window(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","disown_Window", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  {
+    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_char_to_button_id(int argc, VALUE *argv, VALUE self) {
   wchar_t arg1 ;
   Gosu::Button result;
   VALUE vresult = Qnil;
@@ -9437,7 +9571,7 @@ _wrap_Window_char_to_button_id(int argc, VALUE *argv, VALUE self) {
   }
   {
     try {
-      result = Gosu_Window_charToButtonId(arg1);
+      result = Gosu::charToButtonId(arg1);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -9455,7 +9589,7 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_button_id_to_char(int argc, VALUE *argv, VALUE self) {
+_wrap_button_id_to_char(int argc, VALUE *argv, VALUE self) {
   Gosu::Button arg1 ;
   wchar_t result;
   VALUE vresult = Qnil;
@@ -9471,7 +9605,7 @@ _wrap_Window_button_id_to_char(int argc, VALUE *argv, VALUE self) {
   }
   {
     try {
-      result = (wchar_t)Gosu_Window_buttonIdToChar(arg1);
+      result = (wchar_t)Gosu::buttonIdToChar(arg1);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -9492,35 +9626,28 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_text_input(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  Swig::Director *director = 0;
-  Gosu::TextInput *result = 0 ;
+_wrap_button_downq___(int argc, VALUE *argv, VALUE self) {
+  Gosu::Button arg1 ;
+  bool result;
   VALUE vresult = Qnil;
   
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","textInput", 1, self )); 
+  {
+    if (NIL_P(argv[0]))
+    arg1 = Gosu::noButton;
+    else
+    arg1 = Gosu::Button(NUM2LONG(argv[0]));
   }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      result = (Gosu::TextInput *)Gosu_Window_textInput((Gosu::Window const *)arg1);
+      result = (bool)Gosu::isButtonDown(arg1);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  director = dynamic_cast<Swig::Director *>(result);
-  if (director) {
-    vresult = director->swig_get_self();
-  } else {
-    vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gosu__TextInput, 0 |  0 );
-  }
+  vresult = SWIG_From_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
@@ -9528,168 +9655,421 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_text_inpute___(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  Gosu::TextInput *arg2 = (Gosu::TextInput *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  void *argp2 = 0 ;
-  int res2 = 0 ;
+_wrap_draw_line(int argc, VALUE *argv, VALUE self) {
+  double arg1 ;
+  double arg2 ;
+  Gosu::Color arg3 ;
+  double arg4 ;
+  double arg5 ;
+  Gosu::Color arg6 ;
+  Gosu::ZPos arg7 = (Gosu::ZPos) 0 ;
+  Gosu::AlphaMode arg8 = (Gosu::AlphaMode) Gosu::amDefault ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val5 ;
+  int ecode5 = 0 ;
+  double val7 ;
+  int ecode7 = 0 ;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","setTextInput", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Gosu__TextInput, 0 |  0 );
-  if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Gosu::TextInput *","setTextInput", 2, argv[0] )); 
+  if ((argc < 6) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
   }
-  arg2 = reinterpret_cast< Gosu::TextInput * >(argp2);
-  {
-    try {
-      Gosu_Window_setTextInput(arg1,arg2);
-    } catch (const std::exception& e) {
-      SWIG_exception(SWIG_RuntimeError, e.what());
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::drawLine", 1, argv[0] ));
+  } 
+  arg1 = static_cast< double >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::drawLine", 2, argv[1] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  {
+    if (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM)
+    arg3 = Gosu::Color(NUM2ULONG(argv[2]));
+    else
+    {
+      void* ptr;
+      int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+      if (!SWIG_IsOK(res))
+      SWIG_exception_fail(SWIG_ValueError, "invalid value");
+      else if (!ptr)
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
+      else
+      arg3 = *reinterpret_cast<Gosu::Color*>(ptr);
     }
   }
-  return Qnil;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_Window_mouse_x(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  double result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  ecode4 = SWIG_AsVal_double(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","Gosu::drawLine", 4, argv[3] ));
+  } 
+  arg4 = static_cast< double >(val4);
+  ecode5 = SWIG_AsVal_double(argv[4], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","Gosu::drawLine", 5, argv[4] ));
+  } 
+  arg5 = static_cast< double >(val5);
+  {
+    if (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM)
+    arg6 = Gosu::Color(NUM2ULONG(argv[5]));
+    else
+    {
+      void* ptr;
+      int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+      if (!SWIG_IsOK(res))
+      SWIG_exception_fail(SWIG_ValueError, "invalid value");
+      else if (!ptr)
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
+      else
+      arg6 = *reinterpret_cast<Gosu::Color*>(ptr);
+    }
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","mouseX", 1, self )); 
+  if (argc > 6) {
+    ecode7 = SWIG_AsVal_double(argv[6], &val7);
+    if (!SWIG_IsOK(ecode7)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Gosu::ZPos","Gosu::drawLine", 7, argv[6] ));
+    } 
+    arg7 = static_cast< Gosu::ZPos >(val7);
+  }
+  if (argc > 7) {
+    {
+      const char* cstr = Gosu::cstrFromSymbol(argv[7]);
+      
+      if (!strcmp(cstr, "default"))
+      arg8 = Gosu::amDefault;
+      else if (!strcmp(cstr, "add"))
+      arg8 = Gosu::amAdditive;
+      else if (!strcmp(cstr, "additive"))
+      arg8 = Gosu::amAdditive;
+      else if (!strcmp(cstr, "multiply"))
+      arg8 = Gosu::amMultiply;
+      else
+      SWIG_exception_fail(SWIG_ValueError, "invalid alpha mode");
+    }
   }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      result = (double)Gosu_Window_mouseX((Gosu::Window const *)arg1);
+      Gosu::drawLine(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_double(static_cast< double >(result));
-  return vresult;
+  return Qnil;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Window_mouse_y(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  double result;
-  VALUE vresult = Qnil;
+_wrap_draw_triangle(int argc, VALUE *argv, VALUE self) {
+  double arg1 ;
+  double arg2 ;
+  Gosu::Color arg3 ;
+  double arg4 ;
+  double arg5 ;
+  Gosu::Color arg6 ;
+  double arg7 ;
+  double arg8 ;
+  Gosu::Color arg9 ;
+  Gosu::ZPos arg10 = (Gosu::ZPos) 0 ;
+  Gosu::AlphaMode arg11 = (Gosu::AlphaMode) Gosu::amDefault ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val5 ;
+  int ecode5 = 0 ;
+  double val7 ;
+  int ecode7 = 0 ;
+  double val8 ;
+  int ecode8 = 0 ;
+  double val10 ;
+  int ecode10 = 0 ;
   
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  if ((argc < 9) || (argc > 11)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","mouseY", 1, self )); 
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::drawTriangle", 1, argv[0] ));
+  } 
+  arg1 = static_cast< double >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::drawTriangle", 2, argv[1] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  {
+    if (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM)
+    arg3 = Gosu::Color(NUM2ULONG(argv[2]));
+    else
+    {
+      void* ptr;
+      int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+      if (!SWIG_IsOK(res))
+      SWIG_exception_fail(SWIG_ValueError, "invalid value");
+      else if (!ptr)
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
+      else
+      arg3 = *reinterpret_cast<Gosu::Color*>(ptr);
+    }
+  }
+  ecode4 = SWIG_AsVal_double(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","Gosu::drawTriangle", 4, argv[3] ));
+  } 
+  arg4 = static_cast< double >(val4);
+  ecode5 = SWIG_AsVal_double(argv[4], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","Gosu::drawTriangle", 5, argv[4] ));
+  } 
+  arg5 = static_cast< double >(val5);
+  {
+    if (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM)
+    arg6 = Gosu::Color(NUM2ULONG(argv[5]));
+    else
+    {
+      void* ptr;
+      int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+      if (!SWIG_IsOK(res))
+      SWIG_exception_fail(SWIG_ValueError, "invalid value");
+      else if (!ptr)
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
+      else
+      arg6 = *reinterpret_cast<Gosu::Color*>(ptr);
+    }
+  }
+  ecode7 = SWIG_AsVal_double(argv[6], &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","Gosu::drawTriangle", 7, argv[6] ));
+  } 
+  arg7 = static_cast< double >(val7);
+  ecode8 = SWIG_AsVal_double(argv[7], &val8);
+  if (!SWIG_IsOK(ecode8)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","Gosu::drawTriangle", 8, argv[7] ));
+  } 
+  arg8 = static_cast< double >(val8);
+  {
+    if (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM)
+    arg9 = Gosu::Color(NUM2ULONG(argv[8]));
+    else
+    {
+      void* ptr;
+      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+      if (!SWIG_IsOK(res))
+      SWIG_exception_fail(SWIG_ValueError, "invalid value");
+      else if (!ptr)
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
+      else
+      arg9 = *reinterpret_cast<Gosu::Color*>(ptr);
+    }
+  }
+  if (argc > 9) {
+    ecode10 = SWIG_AsVal_double(argv[9], &val10);
+    if (!SWIG_IsOK(ecode10)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "Gosu::ZPos","Gosu::drawTriangle", 10, argv[9] ));
+    } 
+    arg10 = static_cast< Gosu::ZPos >(val10);
+  }
+  if (argc > 10) {
+    {
+      const char* cstr = Gosu::cstrFromSymbol(argv[10]);
+      
+      if (!strcmp(cstr, "default"))
+      arg11 = Gosu::amDefault;
+      else if (!strcmp(cstr, "add"))
+      arg11 = Gosu::amAdditive;
+      else if (!strcmp(cstr, "additive"))
+      arg11 = Gosu::amAdditive;
+      else if (!strcmp(cstr, "multiply"))
+      arg11 = Gosu::amMultiply;
+      else
+      SWIG_exception_fail(SWIG_ValueError, "invalid alpha mode");
+    }
   }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      result = (double)Gosu_Window_mouseY((Gosu::Window const *)arg1);
+      Gosu::drawTriangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_double(static_cast< double >(result));
-  return vresult;
+  return Qnil;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Window_set_mouse_position(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+_wrap_draw_quad(int argc, VALUE *argv, VALUE self) {
+  double arg1 ;
   double arg2 ;
-  double arg3 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  Gosu::Color arg3 ;
+  double arg4 ;
+  double arg5 ;
+  Gosu::Color arg6 ;
+  double arg7 ;
+  double arg8 ;
+  Gosu::Color arg9 ;
+  double arg10 ;
+  double arg11 ;
+  Gosu::Color arg12 ;
+  Gosu::ZPos arg13 = (Gosu::ZPos) 0 ;
+  Gosu::AlphaMode arg14 = (Gosu::AlphaMode) Gosu::amDefault ;
+  double val1 ;
+  int ecode1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
-  double val3 ;
-  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val5 ;
+  int ecode5 = 0 ;
+  double val7 ;
+  int ecode7 = 0 ;
+  double val8 ;
+  int ecode8 = 0 ;
+  double val10 ;
+  int ecode10 = 0 ;
+  double val11 ;
+  int ecode11 = 0 ;
+  double val13 ;
+  int ecode13 = 0 ;
   
-  if ((argc < 2) || (argc > 2)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","setMousePosition", 1, self )); 
+  if ((argc < 12) || (argc > 14)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 12)",argc); SWIG_fail;
   }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::drawQuad", 1, argv[0] ));
+  } 
+  arg1 = static_cast< double >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","setMousePosition", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::drawQuad", 2, argv[1] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  {
+    if (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM)
+    arg3 = Gosu::Color(NUM2ULONG(argv[2]));
+    else
+    {
+      void* ptr;
+      int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+      if (!SWIG_IsOK(res))
+      SWIG_exception_fail(SWIG_ValueError, "invalid value");
+      else if (!ptr)
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
+      else
+      arg3 = *reinterpret_cast<Gosu::Color*>(ptr);
+    }
+  }
+  ecode4 = SWIG_AsVal_double(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","Gosu::drawQuad", 4, argv[3] ));
+  } 
+  arg4 = static_cast< double >(val4);
+  ecode5 = SWIG_AsVal_double(argv[4], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","Gosu::drawQuad", 5, argv[4] ));
+  } 
+  arg5 = static_cast< double >(val5);
+  {
+    if (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM)
+    arg6 = Gosu::Color(NUM2ULONG(argv[5]));
+    else
+    {
+      void* ptr;
+      int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+      if (!SWIG_IsOK(res))
+      SWIG_exception_fail(SWIG_ValueError, "invalid value");
+      else if (!ptr)
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
+      else
+      arg6 = *reinterpret_cast<Gosu::Color*>(ptr);
+    }
+  }
+  ecode7 = SWIG_AsVal_double(argv[6], &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","Gosu::drawQuad", 7, argv[6] ));
+  } 
+  arg7 = static_cast< double >(val7);
+  ecode8 = SWIG_AsVal_double(argv[7], &val8);
+  if (!SWIG_IsOK(ecode8)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","Gosu::drawQuad", 8, argv[7] ));
+  } 
+  arg8 = static_cast< double >(val8);
+  {
+    if (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM)
+    arg9 = Gosu::Color(NUM2ULONG(argv[8]));
+    else
+    {
+      void* ptr;
+      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+      if (!SWIG_IsOK(res))
+      SWIG_exception_fail(SWIG_ValueError, "invalid value");
+      else if (!ptr)
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
+      else
+      arg9 = *reinterpret_cast<Gosu::Color*>(ptr);
+    }
+  }
+  ecode10 = SWIG_AsVal_double(argv[9], &val10);
+  if (!SWIG_IsOK(ecode10)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "double","Gosu::drawQuad", 10, argv[9] ));
   } 
-  arg2 = static_cast< double >(val2);
-  ecode3 = SWIG_AsVal_double(argv[1], &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","setMousePosition", 3, argv[1] ));
+  arg10 = static_cast< double >(val10);
+  ecode11 = SWIG_AsVal_double(argv[10], &val11);
+  if (!SWIG_IsOK(ecode11)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "double","Gosu::drawQuad", 11, argv[10] ));
   } 
-  arg3 = static_cast< double >(val3);
+  arg11 = static_cast< double >(val11);
   {
-    try {
-      Gosu_Window_setMousePosition(arg1,arg2,arg3);
-    } catch (const std::exception& e) {
-      SWIG_exception(SWIG_RuntimeError, e.what());
+    if (TYPE(argv[11]) == T_FIXNUM || TYPE(argv[11]) == T_BIGNUM)
+    arg12 = Gosu::Color(NUM2ULONG(argv[11]));
+    else
+    {
+      void* ptr;
+      int res = SWIG_ConvertPtr(argv[11], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+      if (!SWIG_IsOK(res))
+      SWIG_exception_fail(SWIG_ValueError, "invalid value");
+      else if (!ptr)
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
+      else
+      arg12 = *reinterpret_cast<Gosu::Color*>(ptr);
     }
   }
-  return Qnil;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_Window_mouse_xe___(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  double arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  double val2 ;
-  int ecode2 = 0 ;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  if (argc > 12) {
+    ecode13 = SWIG_AsVal_double(argv[12], &val13);
+    if (!SWIG_IsOK(ecode13)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Gosu::ZPos","Gosu::drawQuad", 13, argv[12] ));
+    } 
+    arg13 = static_cast< Gosu::ZPos >(val13);
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","setMouseX", 1, self )); 
+  if (argc > 13) {
+    {
+      const char* cstr = Gosu::cstrFromSymbol(argv[13]);
+      
+      if (!strcmp(cstr, "default"))
+      arg14 = Gosu::amDefault;
+      else if (!strcmp(cstr, "add"))
+      arg14 = Gosu::amAdditive;
+      else if (!strcmp(cstr, "additive"))
+      arg14 = Gosu::amAdditive;
+      else if (!strcmp(cstr, "multiply"))
+      arg14 = Gosu::amMultiply;
+      else
+      SWIG_exception_fail(SWIG_ValueError, "invalid alpha mode");
+    }
   }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  ecode2 = SWIG_AsVal_double(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","setMouseX", 2, argv[0] ));
-  } 
-  arg2 = static_cast< double >(val2);
   {
     try {
-      Gosu_Window_setMouseX(arg1,arg2);
+      Gosu::drawQuad(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -9701,147 +10081,125 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_mouse_ye___(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+_wrap_draw_rect(int argc, VALUE *argv, VALUE self) {
+  double arg1 ;
   double arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  double arg3 ;
+  double arg4 ;
+  Gosu::Color arg5 ;
+  Gosu::ZPos arg6 = (Gosu::ZPos) 0 ;
+  Gosu::AlphaMode arg7 = (Gosu::AlphaMode) Gosu::amDefault ;
+  double val1 ;
+  int ecode1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val6 ;
+  int ecode6 = 0 ;
   
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","setMouseY", 1, self )); 
+  if ((argc < 5) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
   }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::drawRect", 1, argv[0] ));
+  } 
+  arg1 = static_cast< double >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","setMouseY", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::drawRect", 2, argv[1] ));
   } 
   arg2 = static_cast< double >(val2);
+  ecode3 = SWIG_AsVal_double(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","Gosu::drawRect", 3, argv[2] ));
+  } 
+  arg3 = static_cast< double >(val3);
+  ecode4 = SWIG_AsVal_double(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","Gosu::drawRect", 4, argv[3] ));
+  } 
+  arg4 = static_cast< double >(val4);
   {
-    try {
-      Gosu_Window_setMouseY(arg1,arg2);
-    } catch (const std::exception& e) {
-      SWIG_exception(SWIG_RuntimeError, e.what());
+    if (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM)
+    arg5 = Gosu::Color(NUM2ULONG(argv[4]));
+    else
+    {
+      void* ptr;
+      int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+      if (!SWIG_IsOK(res))
+      SWIG_exception_fail(SWIG_ValueError, "invalid value");
+      else if (!ptr)
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
+      else
+      arg5 = *reinterpret_cast<Gosu::Color*>(ptr);
     }
   }
-  return Qnil;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_Window_width(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","width", 1, self )); 
+  if (argc > 5) {
+    ecode6 = SWIG_AsVal_double(argv[5], &val6);
+    if (!SWIG_IsOK(ecode6)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Gosu::ZPos","Gosu::drawRect", 6, argv[5] ));
+    } 
+    arg6 = static_cast< Gosu::ZPos >(val6);
   }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  {
-    try {
-      result = (int)Gosu_Window_width((Gosu::Window const *)arg1);
-    } catch (const std::exception& e) {
-      SWIG_exception(SWIG_RuntimeError, e.what());
+  if (argc > 6) {
+    {
+      const char* cstr = Gosu::cstrFromSymbol(argv[6]);
+      
+      if (!strcmp(cstr, "default"))
+      arg7 = Gosu::amDefault;
+      else if (!strcmp(cstr, "add"))
+      arg7 = Gosu::amAdditive;
+      else if (!strcmp(cstr, "additive"))
+      arg7 = Gosu::amAdditive;
+      else if (!strcmp(cstr, "multiply"))
+      arg7 = Gosu::amMultiply;
+      else
+      SWIG_exception_fail(SWIG_ValueError, "invalid alpha mode");
     }
   }
-  vresult = SWIG_From_int(static_cast< int >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_Window_height(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int result;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 0) || (argc > 0)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","height", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      result = (int)Gosu_Window_height((Gosu::Window const *)arg1);
+      Gosu::drawRect(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_int(static_cast< int >(result));
-  return vresult;
+  return Qnil;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Window_fullscreenq___(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  bool result;
-  VALUE vresult = Qnil;
-  
+_wrap_flush(int argc, VALUE *argv, VALUE self) {
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","fullscreen", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      result = (bool)Gosu_Window_fullscreen((Gosu::Window const *)arg1);
+      Gosu::flush();
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_bool(static_cast< bool >(result));
-  return vresult;
+  return Qnil;
 fail:
   return Qnil;
 }
 
 
 SWIGINTERN VALUE
-_wrap_Window_unsafe_gl__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  
+_wrap_unsafe_gl__SWIG_0(int argc, VALUE *argv, VALUE self) {
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","unsafe_gl", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      Gosu_Window_unsafe_gl__SWIG_0(arg1);
+      Gosu::unsafe_gl();
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -9853,30 +10211,22 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_unsafe_gl__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  Gosu::ZPos arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  double val2 ;
-  int ecode2 = 0 ;
+_wrap_unsafe_gl__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  Gosu::ZPos arg1 ;
+  double val1 ;
+  int ecode1 = 0 ;
   
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","unsafe_gl", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  ecode2 = SWIG_AsVal_double(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Gosu::ZPos","unsafe_gl", 2, argv[0] ));
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Gosu::ZPos","Gosu::unsafe_gl", 1, argv[0] ));
   } 
-  arg2 = static_cast< Gosu::ZPos >(val2);
+  arg1 = static_cast< Gosu::ZPos >(val1);
   {
     try {
-      Gosu_Window_unsafe_gl__SWIG_1(arg1,arg2);
+      Gosu::unsafe_gl(arg1);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -9887,44 +10237,32 @@ fail:
 }
 
 
-SWIGINTERN VALUE _wrap_Window_unsafe_gl(int nargs, VALUE *args, VALUE self) {
+SWIGINTERN VALUE _wrap_unsafe_gl(int nargs, VALUE *args, VALUE self) {
   int argc;
-  VALUE argv[3];
+  VALUE argv[1];
   int ii;
   
-  argc = nargs + 1;
-  argv[0] = self;
-  if (argc > 3) SWIG_fail;
-  for (ii = 1; (ii < argc); ++ii) {
-    argv[ii] = args[ii-1];
+  argc = nargs;
+  if (argc > 1) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_unsafe_gl__SWIG_0(nargs, args, self);
   }
   if (argc == 1) {
     int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Window, 0);
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_Window_unsafe_gl__SWIG_0(nargs, args, self);
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
     }
-  }
-  if (argc == 2) {
-    int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Window, 0);
-    _v = SWIG_CheckState(res);
     if (_v) {
-      {
-        int res = SWIG_AsVal_double(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_Window_unsafe_gl__SWIG_1(nargs, args, self);
-      }
+      return _wrap_unsafe_gl__SWIG_1(nargs, args, self);
     }
   }
   
 fail:
-  Ruby_Format_OverloadedError( argc, 3, "unsafe_gl", 
+  Ruby_Format_OverloadedError( argc, 1, "unsafe_gl", 
     "    void unsafe_gl()\n"
     "    void unsafe_gl(Gosu::ZPos z)\n");
   
@@ -9933,54 +10271,46 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_clip_to(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+_wrap_clip_to(int argc, VALUE *argv, VALUE self) {
+  double arg1 ;
   double arg2 ;
   double arg3 ;
   double arg4 ;
-  double arg5 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
   double val3 ;
   int ecode3 = 0 ;
   double val4 ;
   int ecode4 = 0 ;
-  double val5 ;
-  int ecode5 = 0 ;
   
   if ((argc < 4) || (argc > 4)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","clipTo", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::clipTo", 1, argv[0] ));
+  } 
+  arg1 = static_cast< double >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","clipTo", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::clipTo", 2, argv[1] ));
   } 
   arg2 = static_cast< double >(val2);
-  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  ecode3 = SWIG_AsVal_double(argv[2], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","clipTo", 3, argv[1] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","Gosu::clipTo", 3, argv[2] ));
   } 
   arg3 = static_cast< double >(val3);
-  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  ecode4 = SWIG_AsVal_double(argv[3], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","clipTo", 4, argv[2] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","Gosu::clipTo", 4, argv[3] ));
   } 
   arg4 = static_cast< double >(val4);
-  ecode5 = SWIG_AsVal_double(argv[3], &val5);
-  if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","clipTo", 5, argv[3] ));
-  } 
-  arg5 = static_cast< double >(val5);
   {
     try {
-      Gosu_Window_clipTo(arg1,arg2,arg3,arg4,arg5);
+      Gosu::clipTo(arg1,arg2,arg3,arg4);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -9992,40 +10322,32 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_record(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+_wrap_record(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
   int arg2 ;
-  int arg3 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  int val1 ;
+  int ecode1 = 0 ;
   int val2 ;
   int ecode2 = 0 ;
-  int val3 ;
-  int ecode3 = 0 ;
   Gosu::Image *result = 0 ;
   VALUE vresult = Qnil;
   
   if ((argc < 2) || (argc > 2)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","record", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Gosu::record", 1, argv[0] ));
+  } 
+  arg1 = static_cast< int >(val1);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","record", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Gosu::record", 2, argv[1] ));
   } 
   arg2 = static_cast< int >(val2);
-  ecode3 = SWIG_AsVal_int(argv[1], &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","record", 3, argv[1] ));
-  } 
-  arg3 = static_cast< int >(val3);
   {
     try {
-      result = (Gosu::Image *)Gosu_Window_record(arg1,arg2,arg3);
+      result = (Gosu::Image *)Gosu::record(arg1,arg2);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -10038,8 +10360,8 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_transform(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+_wrap_transform(int argc, VALUE *argv, VALUE self) {
+  double arg1 ;
   double arg2 ;
   double arg3 ;
   double arg4 ;
@@ -10055,9 +10377,8 @@ _wrap_Window_transform(int argc, VALUE *argv, VALUE self) {
   double arg14 ;
   double arg15 ;
   double arg16 ;
-  double arg17 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
   double val3 ;
@@ -10088,100 +10409,93 @@ _wrap_Window_transform(int argc, VALUE *argv, VALUE self) {
   int ecode15 = 0 ;
   double val16 ;
   int ecode16 = 0 ;
-  double val17 ;
-  int ecode17 = 0 ;
   
   if ((argc < 16) || (argc > 16)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 16)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","transform", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 1, argv[0] ));
+  } 
+  arg1 = static_cast< double >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","transform", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 2, argv[1] ));
   } 
   arg2 = static_cast< double >(val2);
-  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  ecode3 = SWIG_AsVal_double(argv[2], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","transform", 3, argv[1] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 3, argv[2] ));
   } 
   arg3 = static_cast< double >(val3);
-  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  ecode4 = SWIG_AsVal_double(argv[3], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","transform", 4, argv[2] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 4, argv[3] ));
   } 
   arg4 = static_cast< double >(val4);
-  ecode5 = SWIG_AsVal_double(argv[3], &val5);
+  ecode5 = SWIG_AsVal_double(argv[4], &val5);
   if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","transform", 5, argv[3] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 5, argv[4] ));
   } 
   arg5 = static_cast< double >(val5);
-  ecode6 = SWIG_AsVal_double(argv[4], &val6);
+  ecode6 = SWIG_AsVal_double(argv[5], &val6);
   if (!SWIG_IsOK(ecode6)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","transform", 6, argv[4] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 6, argv[5] ));
   } 
   arg6 = static_cast< double >(val6);
-  ecode7 = SWIG_AsVal_double(argv[5], &val7);
+  ecode7 = SWIG_AsVal_double(argv[6], &val7);
   if (!SWIG_IsOK(ecode7)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","transform", 7, argv[5] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 7, argv[6] ));
   } 
   arg7 = static_cast< double >(val7);
-  ecode8 = SWIG_AsVal_double(argv[6], &val8);
+  ecode8 = SWIG_AsVal_double(argv[7], &val8);
   if (!SWIG_IsOK(ecode8)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","transform", 8, argv[6] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 8, argv[7] ));
   } 
   arg8 = static_cast< double >(val8);
-  ecode9 = SWIG_AsVal_double(argv[7], &val9);
+  ecode9 = SWIG_AsVal_double(argv[8], &val9);
   if (!SWIG_IsOK(ecode9)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "double","transform", 9, argv[7] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 9, argv[8] ));
   } 
   arg9 = static_cast< double >(val9);
-  ecode10 = SWIG_AsVal_double(argv[8], &val10);
+  ecode10 = SWIG_AsVal_double(argv[9], &val10);
   if (!SWIG_IsOK(ecode10)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "double","transform", 10, argv[8] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 10, argv[9] ));
   } 
   arg10 = static_cast< double >(val10);
-  ecode11 = SWIG_AsVal_double(argv[9], &val11);
+  ecode11 = SWIG_AsVal_double(argv[10], &val11);
   if (!SWIG_IsOK(ecode11)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "double","transform", 11, argv[9] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 11, argv[10] ));
   } 
   arg11 = static_cast< double >(val11);
-  ecode12 = SWIG_AsVal_double(argv[10], &val12);
+  ecode12 = SWIG_AsVal_double(argv[11], &val12);
   if (!SWIG_IsOK(ecode12)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "double","transform", 12, argv[10] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 12, argv[11] ));
   } 
   arg12 = static_cast< double >(val12);
-  ecode13 = SWIG_AsVal_double(argv[11], &val13);
+  ecode13 = SWIG_AsVal_double(argv[12], &val13);
   if (!SWIG_IsOK(ecode13)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "double","transform", 13, argv[11] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 13, argv[12] ));
   } 
   arg13 = static_cast< double >(val13);
-  ecode14 = SWIG_AsVal_double(argv[12], &val14);
+  ecode14 = SWIG_AsVal_double(argv[13], &val14);
   if (!SWIG_IsOK(ecode14)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "double","transform", 14, argv[12] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 14, argv[13] ));
   } 
   arg14 = static_cast< double >(val14);
-  ecode15 = SWIG_AsVal_double(argv[13], &val15);
+  ecode15 = SWIG_AsVal_double(argv[14], &val15);
   if (!SWIG_IsOK(ecode15)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "double","transform", 15, argv[13] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 15, argv[14] ));
   } 
   arg15 = static_cast< double >(val15);
-  ecode16 = SWIG_AsVal_double(argv[14], &val16);
+  ecode16 = SWIG_AsVal_double(argv[15], &val16);
   if (!SWIG_IsOK(ecode16)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "double","transform", 16, argv[14] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "double","Gosu::transformForRuby", 16, argv[15] ));
   } 
   arg16 = static_cast< double >(val16);
-  ecode17 = SWIG_AsVal_double(argv[15], &val17);
-  if (!SWIG_IsOK(ecode17)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode17), Ruby_Format_TypeError( "", "double","transform", 17, argv[15] ));
-  } 
-  arg17 = static_cast< double >(val17);
   {
     try {
-      Gosu_Window_transform(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
+      Gosu::transformForRuby(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -10193,50 +10507,42 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_rotate(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  double arg2 ;
+_wrap_rotate(int argc, VALUE *argv, VALUE self) {
+  double arg1 ;
+  double arg2 = (double) 0 ;
   double arg3 = (double) 0 ;
-  double arg4 = (double) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
   double val3 ;
   int ecode3 = 0 ;
-  double val4 ;
-  int ecode4 = 0 ;
   
   if ((argc < 1) || (argc > 3)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","rotate", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  ecode2 = SWIG_AsVal_double(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","rotate", 2, argv[0] ));
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::rotateForRuby", 1, argv[0] ));
   } 
-  arg2 = static_cast< double >(val2);
+  arg1 = static_cast< double >(val1);
   if (argc > 1) {
-    ecode3 = SWIG_AsVal_double(argv[1], &val3);
-    if (!SWIG_IsOK(ecode3)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","rotate", 3, argv[1] ));
+    ecode2 = SWIG_AsVal_double(argv[1], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::rotateForRuby", 2, argv[1] ));
     } 
-    arg3 = static_cast< double >(val3);
+    arg2 = static_cast< double >(val2);
   }
   if (argc > 2) {
-    ecode4 = SWIG_AsVal_double(argv[2], &val4);
-    if (!SWIG_IsOK(ecode4)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","rotate", 4, argv[2] ));
+    ecode3 = SWIG_AsVal_double(argv[2], &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","Gosu::rotateForRuby", 3, argv[2] ));
     } 
-    arg4 = static_cast< double >(val4);
+    arg3 = static_cast< double >(val3);
   }
   {
     try {
-      Gosu_Window_rotate(arg1,arg2,arg3,arg4);
+      Gosu::rotateForRuby(arg1,arg2,arg3);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -10248,30 +10554,22 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  double arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  double val2 ;
-  int ecode2 = 0 ;
+_wrap_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  double arg1 ;
+  double val1 ;
+  int ecode1 = 0 ;
   
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","scale", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  ecode2 = SWIG_AsVal_double(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","scale", 2, argv[0] ));
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::scaleForRuby", 1, argv[0] ));
   } 
-  arg2 = static_cast< double >(val2);
+  arg1 = static_cast< double >(val1);
   {
     try {
-      Gosu_Window_scale__SWIG_0(arg1,arg2);
+      Gosu::scaleForRuby(arg1);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -10283,38 +10581,30 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+_wrap_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  double arg1 ;
   double arg2 ;
-  double arg3 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
-  double val3 ;
-  int ecode3 = 0 ;
   
   if ((argc < 2) || (argc > 2)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","scale", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::scaleForRuby", 1, argv[0] ));
+  } 
+  arg1 = static_cast< double >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","scale", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::scaleForRuby", 2, argv[1] ));
   } 
   arg2 = static_cast< double >(val2);
-  ecode3 = SWIG_AsVal_double(argv[1], &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","scale", 3, argv[1] ));
-  } 
-  arg3 = static_cast< double >(val3);
   {
     try {
-      Gosu_Window_scale__SWIG_1(arg1,arg2,arg3);
+      Gosu::scaleForRuby(arg1,arg2);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -10326,54 +10616,46 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+_wrap_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  double arg1 ;
   double arg2 ;
   double arg3 ;
   double arg4 ;
-  double arg5 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
   double val3 ;
   int ecode3 = 0 ;
   double val4 ;
   int ecode4 = 0 ;
-  double val5 ;
-  int ecode5 = 0 ;
   
   if ((argc < 4) || (argc > 4)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","scale", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::scaleForRuby", 1, argv[0] ));
+  } 
+  arg1 = static_cast< double >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","scale", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::scaleForRuby", 2, argv[1] ));
   } 
   arg2 = static_cast< double >(val2);
-  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  ecode3 = SWIG_AsVal_double(argv[2], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","scale", 3, argv[1] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","Gosu::scaleForRuby", 3, argv[2] ));
   } 
   arg3 = static_cast< double >(val3);
-  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  ecode4 = SWIG_AsVal_double(argv[3], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","scale", 4, argv[2] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","Gosu::scaleForRuby", 4, argv[3] ));
   } 
   arg4 = static_cast< double >(val4);
-  ecode5 = SWIG_AsVal_double(argv[3], &val5);
-  if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","scale", 5, argv[3] ));
-  } 
-  arg5 = static_cast< double >(val5);
   {
     try {
-      Gosu_Window_scale__SWIG_2(arg1,arg2,arg3,arg4,arg5);
+      Gosu::scaleForRuby(arg1,arg2,arg3,arg4);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -10384,58 +10666,48 @@ fail:
 }
 
 
-SWIGINTERN VALUE _wrap_Window_scale(int nargs, VALUE *args, VALUE self) {
+SWIGINTERN VALUE _wrap_scale(int nargs, VALUE *args, VALUE self) {
   int argc;
-  VALUE argv[6];
+  VALUE argv[4];
   int ii;
   
-  argc = nargs + 1;
-  argv[0] = self;
-  if (argc > 6) SWIG_fail;
-  for (ii = 1; (ii < argc); ++ii) {
-    argv[ii] = args[ii-1];
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
   }
-  if (argc == 2) {
+  if (argc == 1) {
     int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Window, 0);
-    _v = SWIG_CheckState(res);
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
     if (_v) {
-      {
-        int res = SWIG_AsVal_double(argv[1], NULL);
-        _v = SWIG_CheckState(res);
-      }
-      if (_v) {
-        return _wrap_Window_scale__SWIG_0(nargs, args, self);
-      }
+      return _wrap_scale__SWIG_0(nargs, args, self);
     }
   }
-  if (argc == 3) {
+  if (argc == 2) {
     int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Window, 0);
-    _v = SWIG_CheckState(res);
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
     if (_v) {
       {
         int res = SWIG_AsVal_double(argv[1], NULL);
         _v = SWIG_CheckState(res);
       }
       if (_v) {
-        {
-          int res = SWIG_AsVal_double(argv[2], NULL);
-          _v = SWIG_CheckState(res);
-        }
-        if (_v) {
-          return _wrap_Window_scale__SWIG_1(nargs, args, self);
-        }
+        return _wrap_scale__SWIG_1(nargs, args, self);
       }
     }
   }
-  if (argc == 5) {
+  if (argc == 4) {
     int _v;
-    void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Window, 0);
-    _v = SWIG_CheckState(res);
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
     if (_v) {
       {
         int res = SWIG_AsVal_double(argv[1], NULL);
@@ -10452,13 +10724,7 @@ SWIGINTERN VALUE _wrap_Window_scale(int nargs, VALUE *args, VALUE self) {
             _v = SWIG_CheckState(res);
           }
           if (_v) {
-            {
-              int res = SWIG_AsVal_double(argv[4], NULL);
-              _v = SWIG_CheckState(res);
-            }
-            if (_v) {
-              return _wrap_Window_scale__SWIG_2(nargs, args, self);
-            }
+            return _wrap_scale__SWIG_2(nargs, args, self);
           }
         }
       }
@@ -10466,7 +10732,7 @@ SWIGINTERN VALUE _wrap_Window_scale(int nargs, VALUE *args, VALUE self) {
   }
   
 fail:
-  Ruby_Format_OverloadedError( argc, 6, "scale", 
+  Ruby_Format_OverloadedError( argc, 4, "scale", 
     "    void scale(double factor)\n"
     "    void scale(double factorX, double factorY)\n"
     "    void scale(double factorX, double factorY, double aroundX, double aroundY)\n");
@@ -10476,38 +10742,30 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_translate(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+_wrap_translate(int argc, VALUE *argv, VALUE self) {
+  double arg1 ;
   double arg2 ;
-  double arg3 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
+  double val1 ;
+  int ecode1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
-  double val3 ;
-  int ecode3 = 0 ;
   
   if ((argc < 2) || (argc > 2)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
-  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","translate", 1, self )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::translateForRuby", 1, argv[0] ));
+  } 
+  arg1 = static_cast< double >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","translate", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::translateForRuby", 2, argv[1] ));
   } 
   arg2 = static_cast< double >(val2);
-  ecode3 = SWIG_AsVal_double(argv[1], &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","translate", 3, argv[1] ));
-  } 
-  arg3 = static_cast< double >(val3);
   {
     try {
-      Gosu_Window_translate(arg1,arg2,arg3);
+      Gosu::translateForRuby(arg1,arg2);
     } catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -10518,41 +10776,14 @@ fail:
 }
 
 
-SWIGINTERN VALUE
-_wrap_disown_Window(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","disown_Window", 1, argv[0] )); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
-  {
-    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
-    if (director) director->swig_disown();
-  }
-  
-  return Qnil;
-fail:
-  return Qnil;
-}
-
-
 
 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
-static swig_type_info _swigt__p_Channel = {"_p_Channel", "Channel *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Gosu__Button = {"_p_Gosu__Button", "Gosu::Button *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Gosu__Color = {"_p_Gosu__Color", "Gosu::Color *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Gosu__Font = {"_p_Gosu__Font", "Gosu::Font *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Gosu__GLTexInfo = {"_p_Gosu__GLTexInfo", "Gosu::GLTexInfo *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Gosu__Image = {"_p_Gosu__Image", "Gosu::Image *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_Gosu__ImageData = {"_p_Gosu__ImageData", "Gosu::ImageData *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Gosu__Sample = {"_p_Gosu__Sample", "Gosu::Sample *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Gosu__SampleInstance = {"_p_Gosu__SampleInstance", "Gosu::SampleInstance *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Gosu__Song = {"_p_Gosu__Song", "Gosu::Song *", 0, 0, (void*)0, 0};
@@ -10564,13 +10795,11 @@ static swig_type_info _swigt__p_std__tr1__arrayT_double_16_t = {"_p_std__tr1__ar
 static swig_type_info _swigt__p_std__wstring = {"_p_std__wstring", "std::wstring *", 0, 0, (void*)0, 0};
 
 static swig_type_info *swig_type_initial[] = {
-  &_swigt__p_Channel,
   &_swigt__p_Gosu__Button,
   &_swigt__p_Gosu__Color,
   &_swigt__p_Gosu__Font,
   &_swigt__p_Gosu__GLTexInfo,
   &_swigt__p_Gosu__Image,
-  &_swigt__p_Gosu__ImageData,
   &_swigt__p_Gosu__Sample,
   &_swigt__p_Gosu__SampleInstance,
   &_swigt__p_Gosu__Song,
@@ -10582,13 +10811,11 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_std__wstring,
 };
 
-static swig_cast_info _swigc__p_Channel[] = {  {&_swigt__p_Channel, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Gosu__Button[] = {  {&_swigt__p_Gosu__Button, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Gosu__Color[] = {  {&_swigt__p_Gosu__Color, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Gosu__Font[] = {  {&_swigt__p_Gosu__Font, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Gosu__GLTexInfo[] = {  {&_swigt__p_Gosu__GLTexInfo, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Gosu__Image[] = {  {&_swigt__p_Gosu__Image, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_Gosu__ImageData[] = {  {&_swigt__p_Gosu__ImageData, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Gosu__Sample[] = {  {&_swigt__p_Gosu__Sample, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Gosu__SampleInstance[] = {  {&_swigt__p_Gosu__SampleInstance, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Gosu__Song[] = {  {&_swigt__p_Gosu__Song, 0, 0, 0},{0, 0, 0, 0}};
@@ -10600,13 +10827,11 @@ static swig_cast_info _swigc__p_std__tr1__arrayT_double_16_t[] = {  {&_swigt__p_
 static swig_cast_info _swigc__p_std__wstring[] = {  {&_swigt__p_std__wstring, 0, 0, 0},{0, 0, 0, 0}};
 
 static swig_cast_info *swig_cast_initial[] = {
-  _swigc__p_Channel,
   _swigc__p_Gosu__Button,
   _swigc__p_Gosu__Color,
   _swigc__p_Gosu__Font,
   _swigc__p_Gosu__GLTexInfo,
   _swigc__p_Gosu__Image,
-  _swigc__p_Gosu__ImageData,
   _swigc__p_Gosu__Sample,
   _swigc__p_Gosu__SampleInstance,
   _swigc__p_Gosu__Song,
@@ -10678,7 +10903,7 @@ SWIGRUNTIME void
 SWIG_InitializeModule(void *clientdata) {
   size_t i;
   swig_module_info *module_head, *iter;
-  int found, init;
+  int init;
 
   /* check to see if the circular list has been setup, if not, set it up */
   if (swig_module.next==0) {
@@ -10697,22 +10922,18 @@ SWIG_InitializeModule(void *clientdata) {
     /* This is the first module loaded for this interpreter */
     /* so set the swig module into the interpreter */
     SWIG_SetModule(clientdata, &swig_module);
-    module_head = &swig_module;
   } else {
     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
-    found=0;
     iter=module_head;
     do {
       if (iter==&swig_module) {
-        found=1;
-        break;
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
       }
       iter=iter->next;
     } while (iter!= module_head);
 
-    /* if the is found in the list, then all is done and we may leave */
-    if (found) return;
-    /* otherwise we must add out module into the list */
+    /* otherwise we must add our module into the list */
     swig_module.next = module_head->next;
     module_head->next = &swig_module;
   }
@@ -10875,9 +11096,9 @@ SWIGEXPORT void Init_gosu(void) {
   
   SWIG_RubyInitializeTrackings();
   rb_define_const(mGosu, "MAJOR_VERSION", SWIG_From_int(static_cast< int >(0)));
-  rb_define_const(mGosu, "MINOR_VERSION", SWIG_From_int(static_cast< int >(8)));
-  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(7)));
-  rb_define_const(mGosu, "VERSION", SWIG_FromCharPtr("0.8.7"));
+  rb_define_const(mGosu, "MINOR_VERSION", SWIG_From_int(static_cast< int >(9)));
+  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(0)));
+  rb_define_const(mGosu, "VERSION", SWIG_FromCharPtr("0.9.0.pre1"));
   rb_define_const(mGosu, "GOSU_COPYRIGHT_NOTICE", SWIG_FromCharPtr("This software uses the following third-party libraries:\n\nGosu, http://www.libgosu.org, MIT License, http://opensource.org/licenses/MIT\nSDL 2, http://www.libsdl.org, MIT License, http://opensource.org/licenses/MIT\nFreeImage, http://freeimage.sourceforge.net, FreeImage Public License\nlibogg & libvorbis, http://www.xiph.org, BSD License, 3-Clause Version, http://www.xiph.org/licenses/bsd\nlibsndfile, http://www.mega-nerd.com/libsndfile, GNU LGPL 3, http://www.gnu.org/copyleft/lesser.html\nOpenAL Soft, http://kcat.strangesoft.net/openal.html, GNU LGPL 2, http://www.gnu.org/licenses/old-licenses/lgpl-2.0.html\n"));
   rb_define_module_function(mGosu, "milliseconds", VALUEFUNC(_wrap_milliseconds), -1);
   rb_define_module_function(mGosu, "random", VALUEFUNC(_wrap_random), -1);
@@ -10924,7 +11145,7 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_singleton_method(SwigClassColor.klass, "rgba", VALUEFUNC(_wrap_Color_rgba), -1);
   rb_define_singleton_method(SwigClassColor.klass, "argb", VALUEFUNC(_wrap_Color_argb), -1);
   rb_define_method(SwigClassColor.klass, "dup", VALUEFUNC(_wrap_Color_dup), -1);
-  rb_define_method(SwigClassColor.klass, "to_s", VALUEFUNC(_wrap_Color_to_s), -1);
+  rb_define_method(SwigClassColor.klass, "inspect", VALUEFUNC(_wrap_Color_inspect), -1);
   rb_define_method(SwigClassColor.klass, "==", VALUEFUNC(_wrap_Color___eq__), -1);
   SwigClassColor.mark = 0;
   SwigClassColor.destroy = (void (*)(void *)) free_Gosu_Color;
@@ -10973,12 +11194,10 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassImage.klass, "draw", VALUEFUNC(_wrap_Image_draw), -1);
   rb_define_method(SwigClassImage.klass, "draw_mod", VALUEFUNC(_wrap_Image_draw_mod), -1);
   rb_define_method(SwigClassImage.klass, "draw_rot", VALUEFUNC(_wrap_Image_draw_rot), -1);
-  rb_define_method(SwigClassImage.klass, "get_data", VALUEFUNC(_wrap_Image_get_data), -1);
   rb_define_method(SwigClassImage.klass, "draw_as_quad", VALUEFUNC(_wrap_Image_draw_as_quad), -1);
   rb_define_method(SwigClassImage.klass, "gl_tex_info", VALUEFUNC(_wrap_Image_gl_tex_info), -1);
   rb_define_method(SwigClassImage.klass, "subimage", VALUEFUNC(_wrap_Image_subimage), -1);
-  rb_define_singleton_method(SwigClassImage.klass, "from_text4", VALUEFUNC(_wrap_Image_from_text4), -1);
-  rb_define_singleton_method(SwigClassImage.klass, "from_text7", VALUEFUNC(_wrap_Image_from_text7), -1);
+  rb_define_singleton_method(SwigClassImage.klass, "from_text", VALUEFUNC(_wrap_Image_from_text), -1);
   rb_define_singleton_method(SwigClassImage.klass, "load_tiles", VALUEFUNC(_wrap_Image_load_tiles), -1);
   rb_define_method(SwigClassImage.klass, "to_blob", VALUEFUNC(_wrap_Image_to_blob), -1);
   rb_define_method(SwigClassImage.klass, "columns", VALUEFUNC(_wrap_Image_columns), -1);
@@ -11245,7 +11464,7 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_const(mGosu, "Gp3Button15", SWIG_From_int(static_cast< int >(Gosu::gp3Button15)));
   
   GosusDarkSide::oncePerTick = GosusDarkSide::yieldToOtherRubyThreads;
-  // While we are at it, to some healthy srand() - otherwise unavailable to Ruby people
+  // While we are at it, call srand() - otherwise unavailable to Ruby people
   std::srand(static_cast<unsigned int>(std::time(0)));
   std::rand(); // and flush the first value
   
@@ -11288,13 +11507,6 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassWindow.klass, "release_memory", VALUEFUNC(_wrap_Window_release_memory), -1);
   rb_define_method(SwigClassWindow.klass, "button_down", VALUEFUNC(_wrap_Window_button_down), -1);
   rb_define_method(SwigClassWindow.klass, "button_up", VALUEFUNC(_wrap_Window_button_up), -1);
-  rb_define_method(SwigClassWindow.klass, "draw_line", VALUEFUNC(_wrap_Window_draw_line), -1);
-  rb_define_method(SwigClassWindow.klass, "draw_triangle", VALUEFUNC(_wrap_Window_draw_triangle), -1);
-  rb_define_method(SwigClassWindow.klass, "draw_quad", VALUEFUNC(_wrap_Window_draw_quad), -1);
-  rb_define_method(SwigClassWindow.klass, "flush", VALUEFUNC(_wrap_Window_flush), -1);
-  rb_define_method(SwigClassWindow.klass, "button_down?", VALUEFUNC(_wrap_Window_button_downq___), -1);
-  rb_define_singleton_method(SwigClassWindow.klass, "char_to_button_id", VALUEFUNC(_wrap_Window_char_to_button_id), -1);
-  rb_define_singleton_method(SwigClassWindow.klass, "button_id_to_char", VALUEFUNC(_wrap_Window_button_id_to_char), -1);
   rb_define_method(SwigClassWindow.klass, "text_input", VALUEFUNC(_wrap_Window_text_input), -1);
   rb_define_method(SwigClassWindow.klass, "text_input=", VALUEFUNC(_wrap_Window_text_inpute___), -1);
   rb_define_method(SwigClassWindow.klass, "mouse_x", VALUEFUNC(_wrap_Window_mouse_x), -1);
@@ -11305,15 +11517,23 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassWindow.klass, "width", VALUEFUNC(_wrap_Window_width), -1);
   rb_define_method(SwigClassWindow.klass, "height", VALUEFUNC(_wrap_Window_height), -1);
   rb_define_method(SwigClassWindow.klass, "fullscreen?", VALUEFUNC(_wrap_Window_fullscreenq___), -1);
-  rb_define_method(SwigClassWindow.klass, "unsafe_gl", VALUEFUNC(_wrap_Window_unsafe_gl), -1);
-  rb_define_method(SwigClassWindow.klass, "clip_to", VALUEFUNC(_wrap_Window_clip_to), -1);
-  rb_define_method(SwigClassWindow.klass, "record", VALUEFUNC(_wrap_Window_record), -1);
-  rb_define_method(SwigClassWindow.klass, "transform", VALUEFUNC(_wrap_Window_transform), -1);
-  rb_define_method(SwigClassWindow.klass, "rotate", VALUEFUNC(_wrap_Window_rotate), -1);
-  rb_define_method(SwigClassWindow.klass, "scale", VALUEFUNC(_wrap_Window_scale), -1);
-  rb_define_method(SwigClassWindow.klass, "translate", VALUEFUNC(_wrap_Window_translate), -1);
   SwigClassWindow.mark = (void (*)(void *)) markWindow;
   SwigClassWindow.destroy = (void (*)(void *)) free_Gosu_Window;
   SwigClassWindow.trackObjects = 1;
+  rb_define_module_function(mGosu, "char_to_button_id", VALUEFUNC(_wrap_char_to_button_id), -1);
+  rb_define_module_function(mGosu, "button_id_to_char", VALUEFUNC(_wrap_button_id_to_char), -1);
+  rb_define_module_function(mGosu, "button_down?", VALUEFUNC(_wrap_button_downq___), -1);
+  rb_define_module_function(mGosu, "draw_line", VALUEFUNC(_wrap_draw_line), -1);
+  rb_define_module_function(mGosu, "draw_triangle", VALUEFUNC(_wrap_draw_triangle), -1);
+  rb_define_module_function(mGosu, "draw_quad", VALUEFUNC(_wrap_draw_quad), -1);
+  rb_define_module_function(mGosu, "draw_rect", VALUEFUNC(_wrap_draw_rect), -1);
+  rb_define_module_function(mGosu, "flush", VALUEFUNC(_wrap_flush), -1);
+  rb_define_module_function(mGosu, "unsafe_gl", VALUEFUNC(_wrap_unsafe_gl), -1);
+  rb_define_module_function(mGosu, "clip_to", VALUEFUNC(_wrap_clip_to), -1);
+  rb_define_module_function(mGosu, "record", VALUEFUNC(_wrap_record), -1);
+  rb_define_module_function(mGosu, "transform", VALUEFUNC(_wrap_transform), -1);
+  rb_define_module_function(mGosu, "rotate", VALUEFUNC(_wrap_rotate), -1);
+  rb_define_module_function(mGosu, "scale", VALUEFUNC(_wrap_scale), -1);
+  rb_define_module_function(mGosu, "translate", VALUEFUNC(_wrap_translate), -1);
 }