gosu 0.7.12 → 0.7.13

data/GosuImpl/Graphics/Texture.cpp

@@ -25,11 +25,7 @@ unsigned Gosu::Texture::maxTextureSize()
         do
         {
             size *= 2;
-            #ifdef GOSU_IS_IPHONE
-            glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_RGBA, size * 2, size * 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
-            #else
             glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_BGRA, size * 2, size * 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
-            #endif
             glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width); 
         } while (width != 0 && size < MAX_SIZE);
     }
@@ -108,7 +104,7 @@ std::auto_ptr<Gosu::TexChunk>
     const unsigned* texData = &pixelData[0];
     unsigned format = GL_RGBA;
 #else
-    const unsigned* texData = bmp.glCompatibleData();
+    const unsigned* texData = bmp.data();
     unsigned format = GL_BGRA;
 #endif
     

data/GosuImpl/Iconv.hpp

@@ -3,12 +3,14 @@
 
 #include <Gosu/Platform.hpp>
 
-#ifdef __APPLE__
-// We want Apple's iconv
-#include </usr/include/iconv.h>
+#ifdef GOSU_RUBY_19_MACPORTS
+#include <iconv.h> // from MacPorts
+#elsif defined(__APPLE__)
+#include </usr/include/iconv.h> // We want Apple's iconv
 #else
 #include <iconv.h>
 #endif
+//#endif
 #include <errno.h>
 
 namespace Gosu

data/GosuImpl/InputMac.mm

@@ -502,14 +502,14 @@ struct Gosu::Input::Impl
 
     void updateMods(unsigned newMods)
     {
-        const unsigned ids[8] = { kbLeftShift, kbLeftControl,
-                                  kbLeftAlt, kbLeftMeta,
-                                  kbRightShift, kbRightControl,
-                                  kbRightAlt, kbRightMeta };
-        const unsigned bits[8] = { NX_DEVICELSHIFTKEYMASK, NX_DEVICELCTLKEYMASK,
-                                   NX_DEVICELALTKEYMASK, NX_DEVICELCMDKEYMASK,
-                                   NX_DEVICERSHIFTKEYMASK, NX_DEVICERCTLKEYMASK,
-                                   NX_DEVICERALTKEYMASK, NX_DEVICERCMDKEYMASK };
+        static const unsigned ids[8] = { kbLeftShift, kbLeftControl,
+                                         kbLeftAlt, kbLeftMeta,
+                                         kbRightShift, kbRightControl,
+                                         kbRightAlt, kbRightMeta };
+        static const unsigned bits[8] = { NX_DEVICELSHIFTKEYMASK, NX_DEVICELCTLKEYMASK,
+                                          NX_DEVICELALTKEYMASK, NX_DEVICELCMDKEYMASK,
+                                          NX_DEVICERSHIFTKEYMASK, NX_DEVICERCTLKEYMASK,
+                                          NX_DEVICERALTKEYMASK, NX_DEVICERCMDKEYMASK };
     
         for (unsigned i = 0; i < 8; ++i)
             if ((currentMods & bits[i]) != (newMods & bits[i]))
@@ -561,7 +561,6 @@ bool Gosu::Input::feedNSEvent(void* event)
     if (mods != pimpl->currentMods)
         pimpl->updateMods(mods);
     
-    
     // Handle mouse input.
     switch (type)
     {

data/GosuImpl/InputTouch.mm

@@ -0,0 +1,47 @@
+#include <Gosu/input.hpp>
+
+struct Gosu::Input::Impl {
+};
+
+Gosu::Input::Input() {
+}
+
+Gosu::Input::~Input() {
+}
+
+wchar_t Gosu::Input::idToChar(Button btn) {
+    return 0;
+}
+
+Gosu::Button Gosu::Input::charToId(wchar_t ch) {
+    return noButton;
+}
+        
+bool Gosu::Input::down(Button btn) const {
+    return false;
+}
+
+double Gosu::Input::mouseX() const {
+    return -1000;
+}
+
+double Gosu::Input::mouseY() const {
+    return -1000;
+}
+
+void Gosu::Input::setMousePosition(double x, double y) {
+}
+
+void Gosu::Input::setMouseFactors(double factorX, double factorY) {
+}
+
+void Gosu::Input::update() {
+}
+
+Gosu::TextInput* Gosu::Input::textInput() const {
+    return 0;
+}
+
+void Gosu::Input::setTextInput(TextInput* input) {
+    throw "NYI";
+}

data/GosuImpl/InputWin.cpp

@@ -147,6 +147,10 @@ struct Gosu::Input::Impl
 		DIDEVICEOBJECTDATA data[inputBufferSize];
 		DWORD inOut;
 		HRESULT hr;
+        
+        RECT rect;
+        ::GetClientRect(window, &rect);
+        bool ignoreClicks = mouseX < 0 || mouseX > rect.right || mouseY < 0 || mouseY > rect.bottom;
 
 		inOut = inputBufferSize;
 		hr = mouse->GetDeviceData(sizeof data[0], data, &inOut, 0);
@@ -158,25 +162,25 @@ struct Gosu::Input::Impl
 				// Everything's ok: Update buttons and fire events.
 				for (unsigned i = 0; i < inOut; ++i)
 				{
-					bool down = (data[i].dwData & 0x80) != 0;
+					bool down = (data[i].dwData & 0x80) != 0 && !ignoreClicks;
 	                    
 					switch (data[i].dwOfs)
 					{
 						case DIMOFS_BUTTON0:
 						{
 							unsigned id = swapMouse ? msRight : msLeft;
-							forceButton(id, down, collectEvents);
+							setButton(id, down, collectEvents);
 							break;
 						}
 						case DIMOFS_BUTTON1:
 						{
 							unsigned id = swapMouse ? msLeft : msRight;
-							forceButton(id, down, collectEvents);
+							setButton(id, down, collectEvents);
 							break;
 						}
 						case DIMOFS_BUTTON2:
 						{
-							forceButton(msMiddle, down, collectEvents);
+							setButton(msMiddle, down, collectEvents);
 							break;
 						}
 						case DIMOFS_Z:
@@ -191,6 +195,8 @@ struct Gosu::Input::Impl
 							else
 								event.id = msWheelUp;
 							events.push_back(event);
+                            event.action = EventInfo::buttonUp;
+                            events.push_back(event);
 							break;
 						}
 					}
@@ -208,6 +214,8 @@ struct Gosu::Input::Impl
 				break;
 			}
 		}
+        
+        keyboard:
 
 		inOut = inputBufferSize;
 		hr = keyboard->GetDeviceData(sizeof data[0], data, &inOut, 0);

data/GosuImpl/InputX.cpp

@@ -167,7 +167,9 @@ void Gosu::Input::update()
             pimpl->keyMap[id] = true;
             // TODO: Here, above, below, who came up with that cast? Uh :)
             if (onButtonDown)
-                onButtonDown(*reinterpret_cast<Button*>(&id));
+                onButtonDown(Button(id));
+            if (onButtonUp and id == msWheelUp or id == msWheelDown)
+                onButtonUp(Button(id));
         }
         else if (event.type == ButtonRelease)
         {

data/GosuImpl/MacUtility.hpp

@@ -1,6 +1,47 @@
 #ifndef GOSU_MACUTILITY_HPP
 #define GOSU_MACUTILITY_HPP
 
+#include <Gosu/Platform.hpp>
+
+#import <CoreFoundation/CoreFoundation.h>
+
+#ifndef GOSU_IS_IPHONE
+#import <ApplicationServices/ApplicationServices.h>
+
+// Not defined on 10.4 Tiger SDK which Gosu uses.
+#if __LP64__ || NS_BUILD_32_LIKE_64
+typedef long NSInteger;
+typedef unsigned long NSUInteger;
+#else
+typedef int NSInteger;
+typedef unsigned int NSUInteger;
+#endif
+#endif
+
+#include <iostream>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <stdexcept>
+
+namespace Gosu
+{
+    inline void throwOSError(OSStatus status, unsigned line)
+    {
+        std::ostringstream str;
+        #ifdef GOSU_IS_IPHONE
+        str << "Error on line " << line << " (Code " << status << ")";
+        #else
+        str << "Error on line " << line << " (Code " << status << "): "
+            << GetMacOSStatusErrorString(status)
+            << " (" << GetMacOSStatusCommentString(status) << ")";
+        #endif
+        throw std::runtime_error(str.str());
+    }
+    
+    #define CHECK_OS(status) if (!(status)) {} else Gosu::throwOSError(status, __LINE__)
+}
+
 #ifdef __OBJC__
 #import <objc/objc.h>
 #import <stdexcept>

data/GosuImpl/Math.cpp

@@ -27,7 +27,7 @@ double Gosu::angle(double fromX, double fromY, double toX, double toY,
     if (distX == 0 && distY == 0)
         return def;
     else
-        return radiansToGosu(std::atan2(distY, distX));
+        return normalizeAngle(radiansToGosu(std::atan2(distY, distX)));
 }
 
 double Gosu::angleDiff(double from, double to)

data/GosuImpl/RubyGosu.swg

@@ -236,6 +236,11 @@ namespace Gosu
 %ignore Gosu::TextAlign;
 %include "../Gosu/GraphicsBase.hpp"
 
+// For screenWidth/screenHeight
+%ignore Gosu::Graphics;
+%ignore Gosu::BorderFlags;
+%include "../Gosu/Graphics.hpp"
+
 // Color
 %rename("alpha=") setAlpha;
 %rename("red=") setRed;
@@ -390,11 +395,16 @@ namespace Gosu
 // Does not matter that it's the Mac file, %include only analyses symbols to export, not their values.
 %include "../Gosu/ButtonsMac.hpp"
 %init %{
-        // Backwards compatibility: import the constants into Gosu::Button.
+    // Backwards compatibility: import the constants into Gosu::Button.
     rb_eval_string("module Gosu::Button; Gosu.constants.each { |c| const_set(c, Gosu.const_get(c)) }; end");
 
     // ARGH, SWIG workaround...
-    rb_eval_string("class Gosu::Image; def self.from_text(*args); args.size == 4 ? from_text_4(*args) : from_text_7(*args); end; end");
+    // It doesn't understand the C++ overloading otherwise.
+    rb_eval_string("class Gosu::Image; def self.from_text(*args); args.size == 4 ? from_text4(*args) : from_text7(*args); end; end");
+
+    // ARGH, SWIG workaround 2..
+    // It won't let me have a class method and method with the same name.
+    rb_eval_string("class Gosu::Window; def button_id_to_char(id); self.class.button_id_to_char(id); end; def char_to_button_id(ch); self.class.char_to_button_id(ch); end; end");
 
     // Extend Numeric with simple angle conversion methods.
     rb_eval_string("class ::Numeric;def gosu_to_radians;(self-90)*Math::PI/180.0;end;def radians_to_gosu;self*180.0/Math::PI+90;end;end");
@@ -426,6 +436,7 @@ namespace Gosu
 %rename("text_input=") setTextInput;
 %rename("mouse_x=") setMouseX;
 %rename("mouse_y=") setMouseY;
+%rename("needs_redraw?") needsRedraw;
 %markfunc Gosu::Window "markWindow";
 %include "../Gosu/Window.hpp"
 
@@ -463,11 +474,11 @@ namespace Gosu
     bool isButtonDown(Gosu::Button btn) const {
         return $self->input().down(btn);
     }
-    Gosu::Button charToButtonId(wchar_t ch) {
-        return $self->input().charToId(ch);
+    static Gosu::Button charToButtonId(wchar_t ch) {
+        return Gosu::Input::charToId(ch);
     }
-    wchar_t buttonIdToChar(Gosu::Button btn) {
-        return $self->input().idToChar(btn);
+    static wchar_t buttonIdToChar(Gosu::Button btn) {
+        return Gosu::Input::idToChar(btn);
     }
     
     TextInput* textInput() const {

data/GosuImpl/RubyGosu_wrap.cxx

@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.31
+ * Version 1.3.38
  * 
  * 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
@@ -11,20 +11,28 @@
 #define SWIGRUBY
 #define SWIG_DIRECTORS
 
+
 #ifdef __cplusplus
-template<class T> class SwigValueWrapper {
-    T *tt;
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
 public:
-    SwigValueWrapper() : tt(0) { }
-    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
-    SwigValueWrapper(const T& t) : tt(new T(t)) { }
-    ~SwigValueWrapper() { delete tt; } 
-    SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
-    operator T&() const { return *tt; }
-    T *operator&() { return tt; }
-private:
-    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
 };
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
 #endif
 
 /* -----------------------------------------------------------------------------
@@ -34,14 +42,14 @@ private:
 
 /* template workaround for compilers that cannot correctly implement the C++ standard */
 #ifndef SWIGTEMPLATEDISAMBIGUATOR
-# if defined(__SUNPRO_CC)
-#   if (__SUNPRO_CC <= 0x560)
-#     define SWIGTEMPLATEDISAMBIGUATOR template
-#   else
-#     define SWIGTEMPLATEDISAMBIGUATOR 
-#   endif
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
 # else
-#   define SWIGTEMPLATEDISAMBIGUATOR 
+#  define SWIGTEMPLATEDISAMBIGUATOR
 # endif
 #endif
 
@@ -69,6 +77,12 @@ private:
 # endif
 #endif
 
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif 
+#endif
+
 #ifndef SWIGUNUSEDPARM
 # ifdef __cplusplus
 #   define SWIGUNUSEDPARM(p)
@@ -124,6 +138,12 @@ private:
 # define _CRT_SECURE_NO_DEPRECATE
 #endif
 
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+
 /* -----------------------------------------------------------------------------
  *  This section contains generic SWIG labels for method/variable
  *  declarations/attributes, and other compiler dependent labels.
@@ -131,14 +151,14 @@ private:
 
 /* template workaround for compilers that cannot correctly implement the C++ standard */
 #ifndef SWIGTEMPLATEDISAMBIGUATOR
-# if defined(__SUNPRO_CC)
-#   if (__SUNPRO_CC <= 0x560)
-#     define SWIGTEMPLATEDISAMBIGUATOR template
-#   else
-#     define SWIGTEMPLATEDISAMBIGUATOR 
-#   endif
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
 # else
-#   define SWIGTEMPLATEDISAMBIGUATOR 
+#  define SWIGTEMPLATEDISAMBIGUATOR
 # endif
 #endif
 
@@ -166,6 +186,12 @@ private:
 # endif
 #endif
 
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif 
+#endif
+
 #ifndef SWIGUNUSEDPARM
 # ifdef __cplusplus
 #   define SWIGUNUSEDPARM(p)
@@ -221,16 +247,22 @@ private:
 # define _CRT_SECURE_NO_DEPRECATE
 #endif
 
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+
 /* -----------------------------------------------------------------------------
  * swigrun.swg
  *
- * This file contains generic CAPI SWIG runtime support for pointer
+ * This file contains generic C API SWIG runtime support for pointer
  * type checking.
  * ----------------------------------------------------------------------------- */
 
 /* This should only be incremented when either the layout of swig_type_info changes,
    or for whatever reason, the runtime changes incompatibly */
-#define SWIG_RUNTIME_VERSION "3"
+#define SWIG_RUNTIME_VERSION "4"
 
 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 #ifdef SWIG_TYPE_TABLE
@@ -243,11 +275,11 @@ private:
 
 /*
   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
-  creating a static or dynamic library from the swig runtime code.
-  In 99.9% of the cases, swig just needs to declare them as 'static'.
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
   
-  But only do this if is strictly necessary, ie, if you have problems
-  with your compiler or so.
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
 */
 
 #ifndef SWIGRUNTIME
@@ -265,6 +297,7 @@ private:
 
 /* Flags for pointer conversions */
 #define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
 
 /* Flags for new pointer objects */
 #define SWIG_POINTER_OWN           0x1
@@ -273,14 +306,14 @@ private:
 /* 
    Flags/methods for returning states.
    
-   The swig conversion methods, as ConvertPtr, return and integer 
+   The SWIG conversion methods, as ConvertPtr, return and integer 
    that tells if the conversion was successful or not. And if not,
    an error code can be returned (see swigerrors.swg for the codes).
    
    Use the following macros/flags to set or process the returning
    states.
    
-   In old swig versions, you usually write code as:
+   In old versions of SWIG, code such as the following was usually written:
 
      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
        // success code
@@ -288,7 +321,7 @@ private:
        //fail code
      }
 
-   Now you can be more explicit as:
+   Now you can be more explicit:
 
     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
     if (SWIG_IsOK(res)) {
@@ -297,7 +330,7 @@ private:
       // fail code
     }
 
-   that seems to be the same, but now you can also do
+   which is the same really, but now you can also do
 
     Type *ptr;
     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
@@ -315,7 +348,7 @@ private:
     
    I.e., now SWIG_ConvertPtr can return new objects and you can
    identify the case and take care of the deallocation. Of course that
-   requires also to SWIG_ConvertPtr to return new result values, as
+   also requires SWIG_ConvertPtr to return new result values, such as
 
       int SWIG_ConvertPtr(obj, ptr,...) {         
         if (<obj is ok>) {			       
@@ -333,7 +366,7 @@ private:
 
    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
-   swig errors code.
+   SWIG errors code.
 
    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
    allows to return the 'cast rank', for example, if you have this
@@ -347,9 +380,8 @@ private:
       fooi(1)   // cast rank '0'
 
    just use the SWIG_AddCast()/SWIG_CheckState()
+*/
 
-
- */
 #define SWIG_OK                    (0) 
 #define SWIG_ERROR                 (-1)
 #define SWIG_IsOK(r)               (r >= 0)
@@ -374,7 +406,6 @@ private:
 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 
-
 /* Cast-Rank Mode */
 #if defined(SWIG_CASTRANK_MODE)
 #  ifndef SWIG_TypeRank
@@ -397,18 +428,16 @@ SWIGINTERNINLINE int SWIG_CheckState(int r) {
 #endif
 
 
-
-
 #include <string.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef void *(*swig_converter_func)(void *);
+typedef void *(*swig_converter_func)(void *, int *);
 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 
-/* Structure to store inforomation on one type */
+/* Structure to store information on one type */
 typedef struct swig_type_info {
   const char             *name;			/* mangled name of this type */
   const char             *str;			/* human readable name of this type */
@@ -453,7 +482,7 @@ SWIG_TypeNameComp(const char *f1, const char *l1,
     while ((*f2 == ' ') && (f2 != l2)) ++f2;
     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
   }
-  return (l1 - f1) - (l2 - f2);
+  return (int)((l1 - f1) - (l2 - f2));
 }
 
 /*
@@ -495,48 +524,66 @@ SWIG_TypeCompare(const char *nb, const char *tb) {
 }
 
 
-/* think of this as a c++ template<> or a scheme macro */
-#define SWIG_TypeCheck_Template(comparison, ty)         \
-  if (ty) {                                             \
-    swig_cast_info *iter = ty->cast;                    \
-    while (iter) {                                      \
-      if (comparison) {                                 \
-        if (iter == ty->cast) return iter;              \
-        /* Move iter to the top of the linked list */   \
-        iter->prev->next = iter->next;                  \
-        if (iter->next)                                 \
-          iter->next->prev = iter->prev;                \
-        iter->next = ty->cast;                          \
-        iter->prev = 0;                                 \
-        if (ty->cast) ty->cast->prev = iter;            \
-        ty->cast = iter;                                \
-        return iter;                                    \
-      }                                                 \
-      iter = iter->next;                                \
-    }                                                   \
-  }                                                     \
-  return 0
-
 /*
   Check the typename
 */
 SWIGRUNTIME swig_cast_info *
 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
-  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
 }
 
-/* Same as previous function, except strcmp is replaced with a pointer comparison */
+/* 
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
 SWIGRUNTIME swig_cast_info *
-SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
-  SWIG_TypeCheck_Template(iter->type == from, into);
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
 }
 
 /*
   Cast a pointer up an inheritance hierarchy
 */
 SWIGRUNTIMEINLINE void *
-SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
-  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
 }
 
 /* 
@@ -809,6 +856,15 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 
 #include <ruby.h>
 
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+
+
 /* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
 #ifndef NUM2LL
 #define NUM2LL(x) NUM2LONG((x))
@@ -837,12 +893,44 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 #ifndef RSTRING_PTR
 # define RSTRING_PTR(x) RSTRING(x)->ptr
 #endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
 #ifndef RARRAY_LEN
 # define RARRAY_LEN(x) RARRAY(x)->len
 #endif
 #ifndef RARRAY_PTR
 # define RARRAY_PTR(x) RARRAY(x)->ptr
 #endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
 
 /*
  * Need to be very careful about how these macros are defined, especially
@@ -904,6 +992,7 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 #define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
 #endif
 
+static VALUE _mSWIG = Qnil;
 
 /* -----------------------------------------------------------------------------
  * error manipulation
@@ -994,7 +1083,71 @@ SWIG_Ruby_ErrorType(int SWIG_code) {
 }
 
 
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
 
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
 
 /* -----------------------------------------------------------------------------
  * See the LICENSE file for information on copyright, usage and redistribution
@@ -1012,26 +1165,54 @@ SWIG_Ruby_ErrorType(int SWIG_code) {
 extern "C" {
 #endif
 
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
 
 /* Global Ruby hash table to store Trackings from C/C++
-   structs to Ruby Objects. */
-static VALUE swig_ruby_trackings;
-
-/* Global variable that stores a reference to the ruby
-   hash table delete function. */
-static ID swig_ruby_hash_delete = 0;
+   structs to Ruby Objects. 
+*/
+static VALUE swig_ruby_trackings = Qnil;
+
+/* Global variable that stores a reference to the ruby
+   hash table delete function. */
+static ID swig_ruby_hash_delete;
 
 /* Setup a Ruby hash table to store Trackings */
 SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
   /* Create a ruby hash table to store Trackings from C++ 
-     objects to Ruby objects.  Also make sure to tell
-     the garabage collector about the hash table. */
-  swig_ruby_trackings = rb_hash_new();
-  rb_gc_register_address(&swig_ruby_trackings);
-  
-  /* Now store a reference to the hash table delete function
-     so that we only have to look it up once.*/
-  swig_ruby_hash_delete = rb_intern("delete");
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  ID trackings_id = rb_intern( "@__trackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* No, it hasn't.  Create one ourselves */ 
+  if ( swig_ruby_trackings == Qnil )
+    {
+      swig_ruby_trackings = rb_hash_new();
+      rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings );
+    }
+
+  /* Now store a reference to the hash table delete function
+     so that we only have to look it up once.*/
+  swig_ruby_hash_delete = rb_intern("delete");
 }
 
 /* Get a Ruby number to reference a pointer */
@@ -1041,8 +1222,7 @@ SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
      a Ruby number object. */
 
   /* Convert the pointer to a Ruby number */
-  unsigned long value = (unsigned long) ptr;
-  return LONG2NUM(value);
+  return SWIG2NUM(ptr);
 }
 
 /* Get a Ruby number to reference an object */
@@ -1052,8 +1232,7 @@ SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
      a Ruby number object. */
 
   /* Convert the Object to a Ruby number */
-  unsigned long value = (unsigned long) object;
-  return LONG2NUM(value);
+  return SWIG2NUM(object);
 }
 
 /* Get a Ruby object from a previously stored reference */
@@ -1061,9 +1240,8 @@ SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
   /* The provided Ruby number object is a reference
      to the Ruby object we want.*/
 
-  /* First convert the Ruby number to a C number */
-  unsigned long value = NUM2LONG(reference);
-  return (VALUE) value;
+  /* Convert the Ruby number to a Ruby object */
+  return NUM2SWIG(reference);
 }
 
 /* Add a Tracking from a C/C++ struct to a Ruby object */
@@ -1155,6 +1333,15 @@ SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
   return target;
 }
 
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
 #ifdef __cplusplus
 }
 #endif
@@ -1219,6 +1406,7 @@ SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
 #define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
 #define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
 
+#include "assert.h"
 
 /* -----------------------------------------------------------------------------
  * pointers/data manipulation
@@ -1226,9 +1414,6 @@ SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
 
 #ifdef __cplusplus
 extern "C" {
-#if 0
-} /* cc-mode */
-#endif
 #endif
 
 typedef struct {
@@ -1240,10 +1425,44 @@ typedef struct {
 } swig_class;
 
 
-static VALUE _mSWIG = Qnil;
+/* Global pointer used to keep some internal SWIG stuff */
 static VALUE _cSWIG_Pointer = Qnil;
 static VALUE swig_runtime_data_type_pointer = Qnil;
 
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
 SWIGRUNTIME VALUE 
 getExceptionClass(void) {
   static int init = 0;
@@ -1275,6 +1494,8 @@ SWIG_Ruby_InitRuntime(void)
 {
   if (_mSWIG == Qnil) {
     _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
   }
 }
 
@@ -1298,7 +1519,7 @@ SWIGRUNTIME VALUE
 SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
 {
   int own =  flags & SWIG_POINTER_OWN; 
-  
+  int track;
   char *klass_name;
   swig_class *sklass;
   VALUE klass;
@@ -1311,14 +1532,15 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
     sklass = (swig_class *) type->clientdata;
 		
     /* Are we tracking this class and have we already returned this Ruby object? */
-    if (sklass->trackObjects) {
+    track = sklass->trackObjects;
+    if (track) {
       obj = SWIG_RubyInstanceFor(ptr);
       
       /* Check the object's type and make sure it has the correct type.
         It might not in cases where methods do things like 
         downcast methods. */
       if (obj != Qnil) {
-        VALUE value = rb_iv_get(obj, "__swigtype__");
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
         char* type_name = RSTRING_PTR(value);
 				
         if (strcmp(type->name, type_name) == 0) {
@@ -1328,10 +1550,13 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
     }
 
     /* Create a new Ruby object */
-    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), (own ? VOIDFUNC(sklass->destroy) : 0), ptr);
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
 
     /* If tracking is on for this class then track this object. */
-    if (sklass->trackObjects) {
+    if (track) {
       SWIG_RubyAddTracking(ptr, obj);
     }
   } else {
@@ -1341,7 +1566,7 @@ SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
     free((void *) klass_name);
     obj = Data_Wrap_Struct(klass, 0, 0, ptr);
   }
-  rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
   
   return obj;
 }
@@ -1353,7 +1578,7 @@ SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
   VALUE obj;
   swig_class *sklass = (swig_class *) type->clientdata;
   obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
-  rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
   return obj;
 }
 
@@ -1361,7 +1586,7 @@ SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
 SWIGRUNTIMEINLINE char *
 SWIG_Ruby_MangleStr(VALUE obj)
 {
-  VALUE stype = rb_iv_get(obj, "__swigtype__");
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
   return StringValuePtr(stype);
 }
 
@@ -1443,8 +1668,11 @@ SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags,
     tc = SWIG_TypeCheck(c, ty);
     if (!tc) {
       return SWIG_ERROR;
+    } else {
+      int newmemory = 0;
+      *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+      assert(!newmemory); /* newmemory handling not yet implemented */
     }
-    *ptr = SWIG_TypeCast(tc, vptr);
   } else {
     *ptr = vptr;
   }
@@ -1525,10 +1753,42 @@ SWIG_Ruby_SetModule(swig_module_info *pointer)
   rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
 }
 
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) == Qtrue )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) == Qtrue )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
 #ifdef __cplusplus
-#if 0
-{ /* cc-mode */
-#endif
 }
 #endif
 
@@ -1782,7 +2042,7 @@ namespace Swig {
     }
 
     DirectorMethodException(const char* msg = "") 
-      : Swig::DirectorException(rb_eRuntimeError, "Swig director method error", msg) {
+      : Swig::DirectorException(rb_eRuntimeError, "Swig director method error.", msg) {
     }
     
     static void raise(VALUE error)
@@ -1953,7 +2213,11 @@ static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
 
 static VALUE mGosu;
 
-#define SWIGVERSION 0x010331 
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x010338 
 #define SWIG_VERSION SWIGVERSION
 
 
@@ -2059,14 +2323,12 @@ namespace Gosu
 
 
 #include <limits.h>
-#ifndef LLONG_MIN
-# define LLONG_MIN	LONG_LONG_MIN
-#endif
-#ifndef LLONG_MAX
-# define LLONG_MAX	LONG_LONG_MAX
-#endif
-#ifndef ULLONG_MAX
-# define ULLONG_MAX	ULONG_LONG_MAX
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
 #endif
 
 
@@ -2087,7 +2349,7 @@ SWIG_ruby_failed(void)
 } 
 
 
-/*@SWIG:%ruby_aux_method@*/
+/*@SWIG:/usr/local/share/swig/1.3.38/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
 {
   VALUE obj = args[0];
@@ -2119,10 +2381,17 @@ SWIG_AsVal_double (VALUE obj, double *val)
   #define SWIG_From_double   rb_float_new 
 
 
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
 #include <string>
 
 
-/*@SWIG:%ruby_aux_method@*/
+/*@SWIG:/usr/local/share/swig/1.3.38/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
 {
   VALUE obj = args[0];
@@ -2223,14 +2492,7 @@ SWIG_From_std_string  (const std::string& s)
 }
 
 
-SWIGINTERNINLINE VALUE
-SWIG_From_unsigned_SS_int  (unsigned int value)
-{    
-  return SWIG_From_unsigned_SS_long  (value);
-}
-
-
-/*@SWIG:%ruby_aux_method@*/
+/*@SWIG:/usr/local/share/swig/1.3.38/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
 SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
 {
   VALUE obj = args[0];
@@ -2345,7 +2607,7 @@ SWIGINTERN Gosu::Image *Gosu_Image_fromText7(Gosu::Window &window,std::wstring c
         Gosu::Bitmap bmp = Gosu::createText(text, fontName, fontHeight, lineSpacing, maxWidth, align);
         return new Gosu::Image(window.graphics(), bmp);
     }
-SWIGINTERN std::vector<Gosu::Image * > Gosu_Image_loadTiles(Gosu::Window &window,VALUE source,int tileWidth,int tileHeight,bool hardBorders){
+SWIGINTERN std::vector< Gosu::Image * > Gosu_Image_loadTiles(Gosu::Window &window,VALUE source,int tileWidth,int tileHeight,bool hardBorders){
         std::vector<Gosu::Image*> vec;
         // TODO: const correctness (<- did I mean exception safety?)
         Gosu::imagesFromTiledBitmap(window.graphics(), Gosu::loadBitmap(source),
@@ -2364,11 +2626,11 @@ SWIGINTERN int
 SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
 {
   if (TYPE(obj) == T_STRING) {
-    
-
-
+    #if defined(StringValuePtr)
+    char *cstr = StringValuePtr(obj); 
+    #else
     char *cstr = STR2CSTR(obj);
-    
+    #endif
     size_t size = RSTRING_LEN(obj) + 1;
     if (cptr)  {
       if (alloc) {
@@ -2456,11 +2718,11 @@ SWIGINTERN void Gosu_Window_drawQuad(Gosu::Window *self,double x1,double y1,Gosu
 SWIGINTERN bool Gosu_Window_isButtonDown(Gosu::Window const *self,Gosu::Button btn){
         return self->input().down(btn);
     }
-SWIGINTERN Gosu::Button Gosu_Window_charToButtonId(Gosu::Window *self,wchar_t ch){
-        return self->input().charToId(ch);
+SWIGINTERN Gosu::Button Gosu_Window_charToButtonId(wchar_t ch){
+        return Gosu::Input::charToId(ch);
     }
-SWIGINTERN wchar_t Gosu_Window_buttonIdToChar(Gosu::Window *self,Gosu::Button btn){
-        return self->input().idToChar(btn);
+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();
@@ -2541,6 +2803,21 @@ void SwigDirector_Window::draw() {
 }
 
 
+bool SwigDirector_Window::needsRedraw() const {
+  bool c_result ;
+  VALUE result;
+  
+  result = rb_funcall(swig_get_self(), rb_intern("needs_redraw?"), 0, NULL);
+  bool swig_val;
+  int swig_res = SWIG_AsVal_bool(result, &swig_val);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
+  }
+  c_result = static_cast< bool >(swig_val);
+  return (bool) c_result;
+}
+
+
 void SwigDirector_Window::buttonDown(Gosu::Button arg0) {
   VALUE obj0 = Qnil ;
   VALUE result;
@@ -2593,11 +2870,11 @@ SWIGINTERN VALUE
 _wrap_random(int argc, VALUE *argv, VALUE self) {
   double arg1 ;
   double arg2 ;
-  double result;
   double val1 ;
   int ecode1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 2) || (argc > 2)) {
@@ -2605,12 +2882,12 @@ _wrap_random(int argc, VALUE *argv, VALUE self) {
   }
   ecode1 = SWIG_AsVal_double(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::random" "', argument " "1"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::random", 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), "in method '" "Gosu::random" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::random", 2, argv[1] ));
   } 
   arg2 = static_cast< double >(val2);
   {
@@ -2631,11 +2908,11 @@ SWIGINTERN VALUE
 _wrap_offset_x(int argc, VALUE *argv, VALUE self) {
   double arg1 ;
   double arg2 ;
-  double result;
   double val1 ;
   int ecode1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 2) || (argc > 2)) {
@@ -2643,12 +2920,12 @@ _wrap_offset_x(int argc, VALUE *argv, VALUE self) {
   }
   ecode1 = SWIG_AsVal_double(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::offsetX" "', argument " "1"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::offsetX", 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), "in method '" "Gosu::offsetX" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::offsetX", 2, argv[1] ));
   } 
   arg2 = static_cast< double >(val2);
   {
@@ -2669,11 +2946,11 @@ SWIGINTERN VALUE
 _wrap_offset_y(int argc, VALUE *argv, VALUE self) {
   double arg1 ;
   double arg2 ;
-  double result;
   double val1 ;
   int ecode1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 2) || (argc > 2)) {
@@ -2681,12 +2958,12 @@ _wrap_offset_y(int argc, VALUE *argv, VALUE self) {
   }
   ecode1 = SWIG_AsVal_double(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::offsetY" "', argument " "1"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::offsetY", 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), "in method '" "Gosu::offsetY" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::offsetY", 2, argv[1] ));
   } 
   arg2 = static_cast< double >(val2);
   {
@@ -2710,7 +2987,6 @@ _wrap_angle(int argc, VALUE *argv, VALUE self) {
   double arg3 ;
   double arg4 ;
   double arg5 = (double) 0 ;
-  double result;
   double val1 ;
   int ecode1 = 0 ;
   double val2 ;
@@ -2721,6 +2997,7 @@ _wrap_angle(int argc, VALUE *argv, VALUE self) {
   int ecode4 = 0 ;
   double val5 ;
   int ecode5 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 4) || (argc > 5)) {
@@ -2728,28 +3005,28 @@ _wrap_angle(int argc, VALUE *argv, VALUE self) {
   }
   ecode1 = SWIG_AsVal_double(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::angle" "', argument " "1"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::angle", 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), "in method '" "Gosu::angle" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::angle", 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), "in method '" "Gosu::angle" "', argument " "3"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","Gosu::angle", 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), "in method '" "Gosu::angle" "', argument " "4"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","Gosu::angle", 4, argv[3] ));
   } 
   arg4 = static_cast< double >(val4);
   if (argc > 4) {
     ecode5 = SWIG_AsVal_double(argv[4], &val5);
     if (!SWIG_IsOK(ecode5)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Gosu::angle" "', argument " "5"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","Gosu::angle", 5, argv[4] ));
     } 
     arg5 = static_cast< double >(val5);
   }
@@ -2771,11 +3048,11 @@ SWIGINTERN VALUE
 _wrap_angle_diff(int argc, VALUE *argv, VALUE self) {
   double arg1 ;
   double arg2 ;
-  double result;
   double val1 ;
   int ecode1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 2) || (argc > 2)) {
@@ -2783,12 +3060,12 @@ _wrap_angle_diff(int argc, VALUE *argv, VALUE self) {
   }
   ecode1 = SWIG_AsVal_double(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::angleDiff" "', argument " "1"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::angleDiff", 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), "in method '" "Gosu::angleDiff" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::angleDiff", 2, argv[1] ));
   } 
   arg2 = static_cast< double >(val2);
   {
@@ -2808,9 +3085,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_normalize_angle(int argc, VALUE *argv, VALUE self) {
   double arg1 ;
-  double result;
   double val1 ;
   int ecode1 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 1) || (argc > 1)) {
@@ -2818,7 +3095,7 @@ _wrap_normalize_angle(int argc, VALUE *argv, VALUE self) {
   }
   ecode1 = SWIG_AsVal_double(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::normalizeAngle" "', argument " "1"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::normalizeAngle", 1, argv[0] ));
   } 
   arg1 = static_cast< double >(val1);
   {
@@ -2841,7 +3118,6 @@ _wrap_distance(int argc, VALUE *argv, VALUE self) {
   double arg2 ;
   double arg3 ;
   double arg4 ;
-  double result;
   double val1 ;
   int ecode1 = 0 ;
   double val2 ;
@@ -2850,6 +3126,7 @@ _wrap_distance(int argc, VALUE *argv, VALUE self) {
   int ecode3 = 0 ;
   double val4 ;
   int ecode4 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 4) || (argc > 4)) {
@@ -2857,22 +3134,22 @@ _wrap_distance(int argc, VALUE *argv, VALUE self) {
   }
   ecode1 = SWIG_AsVal_double(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::distance" "', argument " "1"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::distance", 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), "in method '" "Gosu::distance" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::distance", 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), "in method '" "Gosu::distance" "', argument " "3"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","Gosu::distance", 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), "in method '" "Gosu::distance" "', argument " "4"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","Gosu::distance", 4, argv[3] ));
   } 
   arg4 = static_cast< double >(val4);
   {
@@ -2913,21 +3190,65 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_screen_width(int argc, VALUE *argv, VALUE self) {
+  unsigned int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    try {
+      result = (unsigned int)Gosu::screenWidth();
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_screen_height(int argc, VALUE *argv, VALUE self) {
+  unsigned int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    try {
+      result = (unsigned int)Gosu::screenHeight();
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 swig_class cColor;
 
 SWIGINTERN VALUE
 _wrap_new_Color__SWIG_0(int argc, VALUE *argv, VALUE self) {
-  Gosu::Color *result = 0 ;
   const char *classname SWIGUNUSED = "Gosu::Color";
+  Gosu::Color *result = 0 ;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
   {
     try {
-      result = (Gosu::Color *)new Gosu::Color();DATA_PTR(self) = result;
+      result = (Gosu::Color *)new Gosu::Color();
+      DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
-      
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -2941,24 +3262,24 @@ fail:
 SWIGINTERN VALUE
 _wrap_new_Color__SWIG_1(int argc, VALUE *argv, VALUE self) {
   boost::uint32_t arg1 ;
-  Gosu::Color *result = 0 ;
   unsigned long val1 ;
   int ecode1 = 0 ;
   const char *classname SWIGUNUSED = "Gosu::Color";
+  Gosu::Color *result = 0 ;
   
   if ((argc < 1) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
   ecode1 = SWIG_AsVal_unsigned_SS_long(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::Color" "', argument " "1"" of type '" "boost::uint32_t""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "boost::uint32_t","Gosu::Color", 1, argv[0] ));
   } 
   arg1 = static_cast< boost::uint32_t >(val1);
   {
     try {
-      result = (Gosu::Color *)new Gosu::Color(arg1);DATA_PTR(self) = result;
+      result = (Gosu::Color *)new Gosu::Color(arg1);
+      DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
-      
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -2974,7 +3295,6 @@ _wrap_new_Color__SWIG_2(int argc, VALUE *argv, VALUE self) {
   Gosu::Color::Channel arg1 ;
   Gosu::Color::Channel arg2 ;
   Gosu::Color::Channel arg3 ;
-  Gosu::Color *result = 0 ;
   unsigned char val1 ;
   int ecode1 = 0 ;
   unsigned char val2 ;
@@ -2982,30 +3302,31 @@ _wrap_new_Color__SWIG_2(int argc, VALUE *argv, VALUE self) {
   unsigned char val3 ;
   int ecode3 = 0 ;
   const char *classname SWIGUNUSED = "Gosu::Color";
+  Gosu::Color *result = 0 ;
   
   if ((argc < 3) || (argc > 3)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
   }
   ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::Color" "', argument " "1"" of type '" "Gosu::Color::Channel""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Gosu::Color::Channel","Gosu::Color", 1, argv[0] ));
   } 
   arg1 = static_cast< Gosu::Color::Channel >(val1);
   ecode2 = SWIG_AsVal_unsigned_SS_char(argv[1], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gosu::Color" "', argument " "2"" of type '" "Gosu::Color::Channel""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Gosu::Color::Channel","Gosu::Color", 2, argv[1] ));
   } 
   arg2 = static_cast< Gosu::Color::Channel >(val2);
   ecode3 = SWIG_AsVal_unsigned_SS_char(argv[2], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Gosu::Color" "', argument " "3"" of type '" "Gosu::Color::Channel""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Gosu::Color::Channel","Gosu::Color", 3, argv[2] ));
   } 
   arg3 = static_cast< Gosu::Color::Channel >(val3);
   {
     try {
-      result = (Gosu::Color *)new Gosu::Color(arg1,arg2,arg3);DATA_PTR(self) = result;
+      result = (Gosu::Color *)new Gosu::Color(arg1,arg2,arg3);
+      DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
-      
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -3039,7 +3360,6 @@ _wrap_new_Color__SWIG_3(int argc, VALUE *argv, VALUE self) {
   Gosu::Color::Channel arg2 ;
   Gosu::Color::Channel arg3 ;
   Gosu::Color::Channel arg4 ;
-  Gosu::Color *result = 0 ;
   unsigned char val1 ;
   int ecode1 = 0 ;
   unsigned char val2 ;
@@ -3049,35 +3369,36 @@ _wrap_new_Color__SWIG_3(int argc, VALUE *argv, VALUE self) {
   unsigned char val4 ;
   int ecode4 = 0 ;
   const char *classname SWIGUNUSED = "Gosu::Color";
+  Gosu::Color *result = 0 ;
   
   if ((argc < 4) || (argc > 4)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
   }
   ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::Color" "', argument " "1"" of type '" "Gosu::Color::Channel""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Gosu::Color::Channel","Gosu::Color", 1, argv[0] ));
   } 
   arg1 = static_cast< Gosu::Color::Channel >(val1);
   ecode2 = SWIG_AsVal_unsigned_SS_char(argv[1], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gosu::Color" "', argument " "2"" of type '" "Gosu::Color::Channel""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Gosu::Color::Channel","Gosu::Color", 2, argv[1] ));
   } 
   arg2 = static_cast< Gosu::Color::Channel >(val2);
   ecode3 = SWIG_AsVal_unsigned_SS_char(argv[2], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Gosu::Color" "', argument " "3"" of type '" "Gosu::Color::Channel""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Gosu::Color::Channel","Gosu::Color", 3, argv[2] ));
   } 
   arg3 = static_cast< Gosu::Color::Channel >(val3);
   ecode4 = SWIG_AsVal_unsigned_SS_char(argv[3], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Gosu::Color" "', argument " "4"" of type '" "Gosu::Color::Channel""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Gosu::Color::Channel","Gosu::Color", 4, argv[3] ));
   } 
   arg4 = static_cast< Gosu::Color::Channel >(val4);
   {
     try {
-      result = (Gosu::Color *)new Gosu::Color(arg1,arg2,arg3,arg4);DATA_PTR(self) = result;
+      result = (Gosu::Color *)new Gosu::Color(arg1,arg2,arg3,arg4);
+      DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
-      
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -3095,7 +3416,7 @@ SWIGINTERN VALUE _wrap_new_Color(int nargs, VALUE *args, VALUE self) {
   
   argc = nargs;
   if (argc > 4) SWIG_fail;
-  for (ii = 0; (ii < argc); ii++) {
+  for (ii = 0; (ii < argc); ++ii) {
     argv[ii] = args[ii];
   }
   if (argc == 0) {
@@ -3163,7 +3484,12 @@ SWIGINTERN VALUE _wrap_new_Color(int nargs, VALUE *args, VALUE self) {
   }
   
 fail:
-  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Color'");
+  Ruby_Format_OverloadedError( argc, 4, "Color.new", 
+    "    Color.new()\n"
+    "    Color.new(boost::uint32_t argb)\n"
+    "    Color.new(Gosu::Color::Channel red, Gosu::Color::Channel green, Gosu::Color::Channel blue)\n"
+    "    Color.new(Gosu::Color::Channel alpha, Gosu::Color::Channel red, Gosu::Color::Channel green, Gosu::Color::Channel blue)\n");
+  
   return Qnil;
 }
 
@@ -3173,13 +3499,13 @@ _wrap_Color_from_hsv(int argc, VALUE *argv, VALUE self) {
   double arg1 ;
   double arg2 ;
   double arg3 ;
-  Gosu::Color result;
   double val1 ;
   int ecode1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
   double val3 ;
   int ecode3 = 0 ;
+  Gosu::Color result;
   VALUE vresult = Qnil;
   
   if ((argc < 3) || (argc > 3)) {
@@ -3187,17 +3513,17 @@ _wrap_Color_from_hsv(int argc, VALUE *argv, VALUE self) {
   }
   ecode1 = SWIG_AsVal_double(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::Color::fromHSV" "', argument " "1"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","Gosu::Color::fromHSV", 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), "in method '" "Gosu::Color::fromHSV" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::Color::fromHSV", 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), "in method '" "Gosu::Color::fromHSV" "', argument " "3"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","Gosu::Color::fromHSV", 3, argv[2] ));
   } 
   arg3 = static_cast< double >(val3);
   {
@@ -3220,7 +3546,6 @@ _wrap_Color_from_ahsv(int argc, VALUE *argv, VALUE self) {
   double arg2 ;
   double arg3 ;
   double arg4 ;
-  Gosu::Color result;
   unsigned char val1 ;
   int ecode1 = 0 ;
   double val2 ;
@@ -3229,6 +3554,7 @@ _wrap_Color_from_ahsv(int argc, VALUE *argv, VALUE self) {
   int ecode3 = 0 ;
   double val4 ;
   int ecode4 = 0 ;
+  Gosu::Color result;
   VALUE vresult = Qnil;
   
   if ((argc < 4) || (argc > 4)) {
@@ -3236,22 +3562,22 @@ _wrap_Color_from_ahsv(int argc, VALUE *argv, VALUE self) {
   }
   ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::Color::fromAHSV" "', argument " "1"" of type '" "Gosu::Color::Channel""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Gosu::Color::Channel","Gosu::Color::fromAHSV", 1, argv[0] ));
   } 
   arg1 = static_cast< Gosu::Color::Channel >(val1);
   ecode2 = SWIG_AsVal_double(argv[1], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gosu::Color::fromAHSV" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu::Color::fromAHSV", 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), "in method '" "Gosu::Color::fromAHSV" "', argument " "3"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","Gosu::Color::fromAHSV", 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), "in method '" "Gosu::Color::fromAHSV" "', argument " "4"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","Gosu::Color::fromAHSV", 4, argv[3] ));
   } 
   arg4 = static_cast< double >(val4);
   {
@@ -3271,9 +3597,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Color_alpha(int argc, VALUE *argv, VALUE self) {
   Gosu::Color *arg1 = (Gosu::Color *) 0 ;
-  Gosu::Color::Channel result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  Gosu::Color::Channel result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -3281,7 +3607,7 @@ _wrap_Color_alpha(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), "in method '" "alpha" "', argument " "1"" of type '" "Gosu::Color const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color const *","alpha", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   {
@@ -3301,9 +3627,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Color_red(int argc, VALUE *argv, VALUE self) {
   Gosu::Color *arg1 = (Gosu::Color *) 0 ;
-  Gosu::Color::Channel result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  Gosu::Color::Channel result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -3311,7 +3637,7 @@ _wrap_Color_red(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), "in method '" "red" "', argument " "1"" of type '" "Gosu::Color const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color const *","red", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   {
@@ -3331,9 +3657,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Color_green(int argc, VALUE *argv, VALUE self) {
   Gosu::Color *arg1 = (Gosu::Color *) 0 ;
-  Gosu::Color::Channel result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  Gosu::Color::Channel result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -3341,7 +3667,7 @@ _wrap_Color_green(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), "in method '" "green" "', argument " "1"" of type '" "Gosu::Color const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color const *","green", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   {
@@ -3361,9 +3687,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Color_blue(int argc, VALUE *argv, VALUE self) {
   Gosu::Color *arg1 = (Gosu::Color *) 0 ;
-  Gosu::Color::Channel result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  Gosu::Color::Channel result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -3371,7 +3697,7 @@ _wrap_Color_blue(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), "in method '" "blue" "', argument " "1"" of type '" "Gosu::Color const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color const *","blue", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   {
@@ -3402,12 +3728,12 @@ _wrap_Color_alphae___(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), "in method '" "setAlpha" "', argument " "1"" of type '" "Gosu::Color *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color *","setAlpha", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setAlpha" "', argument " "2"" of type '" "Gosu::Color::Channel""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Gosu::Color::Channel","setAlpha", 2, argv[0] ));
   } 
   arg2 = static_cast< Gosu::Color::Channel >(val2);
   {
@@ -3437,12 +3763,12 @@ _wrap_Color_rede___(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), "in method '" "setRed" "', argument " "1"" of type '" "Gosu::Color *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color *","setRed", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setRed" "', argument " "2"" of type '" "Gosu::Color::Channel""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Gosu::Color::Channel","setRed", 2, argv[0] ));
   } 
   arg2 = static_cast< Gosu::Color::Channel >(val2);
   {
@@ -3472,12 +3798,12 @@ _wrap_Color_greene___(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), "in method '" "setGreen" "', argument " "1"" of type '" "Gosu::Color *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color *","setGreen", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setGreen" "', argument " "2"" of type '" "Gosu::Color::Channel""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Gosu::Color::Channel","setGreen", 2, argv[0] ));
   } 
   arg2 = static_cast< Gosu::Color::Channel >(val2);
   {
@@ -3507,12 +3833,12 @@ _wrap_Color_bluee___(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), "in method '" "setBlue" "', argument " "1"" of type '" "Gosu::Color *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color *","setBlue", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setBlue" "', argument " "2"" of type '" "Gosu::Color::Channel""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Gosu::Color::Channel","setBlue", 2, argv[0] ));
   } 
   arg2 = static_cast< Gosu::Color::Channel >(val2);
   {
@@ -3531,9 +3857,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Color_hue(int argc, VALUE *argv, VALUE self) {
   Gosu::Color *arg1 = (Gosu::Color *) 0 ;
-  double result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -3541,7 +3867,7 @@ _wrap_Color_hue(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), "in method '" "hue" "', argument " "1"" of type '" "Gosu::Color const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color const *","hue", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   {
@@ -3572,12 +3898,12 @@ _wrap_Color_huee___(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), "in method '" "setHue" "', argument " "1"" of type '" "Gosu::Color *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color *","setHue", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setHue" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","setHue", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
   {
@@ -3596,9 +3922,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Color_saturation(int argc, VALUE *argv, VALUE self) {
   Gosu::Color *arg1 = (Gosu::Color *) 0 ;
-  double result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -3606,7 +3932,7 @@ _wrap_Color_saturation(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), "in method '" "saturation" "', argument " "1"" of type '" "Gosu::Color const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color const *","saturation", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   {
@@ -3637,12 +3963,12 @@ _wrap_Color_saturatione___(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), "in method '" "setSaturation" "', argument " "1"" of type '" "Gosu::Color *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color *","setSaturation", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setSaturation" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","setSaturation", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
   {
@@ -3661,9 +3987,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Color_value(int argc, VALUE *argv, VALUE self) {
   Gosu::Color *arg1 = (Gosu::Color *) 0 ;
-  double result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -3671,7 +3997,7 @@ _wrap_Color_value(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), "in method '" "value" "', argument " "1"" of type '" "Gosu::Color const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color const *","value", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   {
@@ -3702,12 +4028,12 @@ _wrap_Color_valuee___(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), "in method '" "setValue" "', argument " "1"" of type '" "Gosu::Color *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color *","setValue", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "setValue" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","setValue", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
   {
@@ -3726,9 +4052,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Color_argb(int argc, VALUE *argv, VALUE self) {
   Gosu::Color *arg1 = (Gosu::Color *) 0 ;
-  boost::uint32_t result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  boost::uint32_t result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -3736,7 +4062,7 @@ _wrap_Color_argb(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), "in method '" "argb" "', argument " "1"" of type '" "Gosu::Color const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color const *","argb", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   {
@@ -3756,9 +4082,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Color_bgr(int argc, VALUE *argv, VALUE self) {
   Gosu::Color *arg1 = (Gosu::Color *) 0 ;
-  boost::uint32_t result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  boost::uint32_t result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -3766,7 +4092,7 @@ _wrap_Color_bgr(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), "in method '" "bgr" "', argument " "1"" of type '" "Gosu::Color const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color const *","bgr", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   {
@@ -3786,9 +4112,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Color_abgr(int argc, VALUE *argv, VALUE self) {
   Gosu::Color *arg1 = (Gosu::Color *) 0 ;
-  boost::uint32_t result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  boost::uint32_t result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -3796,7 +4122,7 @@ _wrap_Color_abgr(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), "in method '" "abgr" "', argument " "1"" of type '" "Gosu::Color const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color const *","abgr", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   {
@@ -3816,9 +4142,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Color_to_s(int argc, VALUE *argv, VALUE self) {
   Gosu::Color *arg1 = (Gosu::Color *) 0 ;
-  std::string result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  std::string result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -3826,7 +4152,7 @@ _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), "in method '" "toS" "', argument " "1"" of type '" "Gosu::Color const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Color const *","toS", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Color * >(argp1);
   {
@@ -3854,9 +4180,9 @@ _wrap_interpolate(int argc, VALUE *argv, VALUE self) {
   Gosu::Color arg1 ;
   Gosu::Color arg2 ;
   double arg3 = (double) 0.5 ;
-  Gosu::Color result;
   double val3 ;
   int ecode3 = 0 ;
+  Gosu::Color result;
   VALUE vresult = Qnil;
   
   if ((argc < 2) || (argc > 3)) {
@@ -3887,7 +4213,7 @@ _wrap_interpolate(int argc, VALUE *argv, VALUE self) {
   if (argc > 2) {
     ecode3 = SWIG_AsVal_double(argv[2], &val3);
     if (!SWIG_IsOK(ecode3)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Gosu::interpolate" "', argument " "3"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","Gosu::interpolate", 3, argv[2] ));
     } 
     arg3 = static_cast< double >(val3);
   }
@@ -3952,7 +4278,7 @@ fail:
 
 
 SWIGINTERN VALUE
-none_get(VALUE self) {
+_wrap_none_get(VALUE self) {
   VALUE _val;
   
   _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Gosu::Colors::none), SWIGTYPE_p_Gosu__Color,  0 );
@@ -3961,7 +4287,7 @@ none_get(VALUE self) {
 
 
 SWIGINTERN VALUE
-black_get(VALUE self) {
+_wrap_black_get(VALUE self) {
   VALUE _val;
   
   _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Gosu::Colors::black), SWIGTYPE_p_Gosu__Color,  0 );
@@ -3970,7 +4296,7 @@ black_get(VALUE self) {
 
 
 SWIGINTERN VALUE
-gray_get(VALUE self) {
+_wrap_gray_get(VALUE self) {
   VALUE _val;
   
   _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Gosu::Colors::gray), SWIGTYPE_p_Gosu__Color,  0 );
@@ -3979,7 +4305,7 @@ gray_get(VALUE self) {
 
 
 SWIGINTERN VALUE
-white_get(VALUE self) {
+_wrap_white_get(VALUE self) {
   VALUE _val;
   
   _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Gosu::Colors::white), SWIGTYPE_p_Gosu__Color,  0 );
@@ -3988,7 +4314,7 @@ white_get(VALUE self) {
 
 
 SWIGINTERN VALUE
-red_get(VALUE self) {
+_wrap_red_get(VALUE self) {
   VALUE _val;
   
   _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Gosu::Colors::red), SWIGTYPE_p_Gosu__Color,  0 );
@@ -3997,7 +4323,7 @@ red_get(VALUE self) {
 
 
 SWIGINTERN VALUE
-green_get(VALUE self) {
+_wrap_green_get(VALUE self) {
   VALUE _val;
   
   _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Gosu::Colors::green), SWIGTYPE_p_Gosu__Color,  0 );
@@ -4006,7 +4332,7 @@ green_get(VALUE self) {
 
 
 SWIGINTERN VALUE
-blue_get(VALUE self) {
+_wrap_blue_get(VALUE self) {
   VALUE _val;
   
   _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Gosu::Colors::blue), SWIGTYPE_p_Gosu__Color,  0 );
@@ -4015,7 +4341,7 @@ blue_get(VALUE self) {
 
 
 SWIGINTERN VALUE
-yellow_get(VALUE self) {
+_wrap_yellow_get(VALUE self) {
   VALUE _val;
   
   _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Gosu::Colors::yellow), SWIGTYPE_p_Gosu__Color,  0 );
@@ -4024,7 +4350,7 @@ yellow_get(VALUE self) {
 
 
 SWIGINTERN VALUE
-fuchsia_get(VALUE self) {
+_wrap_fuchsia_get(VALUE self) {
   VALUE _val;
   
   _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Gosu::Colors::fuchsia), SWIGTYPE_p_Gosu__Color,  0 );
@@ -4033,7 +4359,7 @@ fuchsia_get(VALUE self) {
 
 
 SWIGINTERN VALUE
-cyan_get(VALUE self) {
+_wrap_cyan_get(VALUE self) {
   VALUE _val;
   
   _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Gosu::Colors::cyan), SWIGTYPE_p_Gosu__Color,  0 );
@@ -4052,9 +4378,9 @@ free_Gosu_Font(Gosu::Font *arg1) {
 SWIGINTERN VALUE
 _wrap_Font_height(int argc, VALUE *argv, VALUE self) {
   Gosu::Font *arg1 = (Gosu::Font *) 0 ;
-  unsigned int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  unsigned int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -4062,7 +4388,7 @@ _wrap_Font_height(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Font, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "height" "', argument " "1"" of type '" "Gosu::Font const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font const *","height", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Font * >(argp1);
   {
@@ -4084,12 +4410,12 @@ _wrap_Font_text_width(int argc, VALUE *argv, VALUE self) {
   Gosu::Font *arg1 = (Gosu::Font *) 0 ;
   std::wstring *arg2 = 0 ;
   double arg3 = (double) 1 ;
-  double result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   std::wstring temp2 ;
   double val3 ;
   int ecode3 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 1) || (argc > 2)) {
@@ -4097,7 +4423,7 @@ _wrap_Font_text_width(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Font, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "textWidth" "', argument " "1"" of type '" "Gosu::Font const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font const *","textWidth", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Font * >(argp1);
   {
@@ -4108,7 +4434,7 @@ _wrap_Font_text_width(int argc, VALUE *argv, VALUE self) {
   if (argc > 1) {
     ecode3 = SWIG_AsVal_double(argv[1], &val3);
     if (!SWIG_IsOK(ecode3)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "textWidth" "', argument " "3"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","textWidth", 3, argv[1] ));
     } 
     arg3 = static_cast< double >(val3);
   }
@@ -4156,7 +4482,7 @@ _wrap_Font_draw(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Font, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "draw" "', argument " "1"" of type '" "Gosu::Font const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font const *","draw", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Font * >(argp1);
   {
@@ -4166,30 +4492,30 @@ _wrap_Font_draw(int argc, VALUE *argv, VALUE self) {
   }
   ecode3 = SWIG_AsVal_double(argv[1], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "draw" "', argument " "3"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","draw", 3, argv[1] ));
   } 
   arg3 = static_cast< double >(val3);
   ecode4 = SWIG_AsVal_double(argv[2], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "draw" "', argument " "4"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","draw", 4, argv[2] ));
   } 
   arg4 = static_cast< double >(val4);
   ecode5 = SWIG_AsVal_double(argv[3], &val5);
   if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "draw" "', argument " "5"" of type '" "Gosu::ZPos""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Gosu::ZPos","draw", 5, argv[3] ));
   } 
   arg5 = static_cast< Gosu::ZPos >(val5);
   if (argc > 4) {
     ecode6 = SWIG_AsVal_double(argv[4], &val6);
     if (!SWIG_IsOK(ecode6)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "draw" "', argument " "6"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","draw", 6, argv[4] ));
     } 
     arg6 = static_cast< double >(val6);
   }
   if (argc > 5) {
     ecode7 = SWIG_AsVal_double(argv[5], &val7);
     if (!SWIG_IsOK(ecode7)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "draw" "', argument " "7"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","draw", 7, argv[5] ));
     } 
     arg7 = static_cast< double >(val7);
   }
@@ -4266,7 +4592,7 @@ _wrap_Font_draw_rel(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Font, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "drawRel" "', argument " "1"" of type '" "Gosu::Font const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font const *","drawRel", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Font * >(argp1);
   {
@@ -4276,40 +4602,40 @@ _wrap_Font_draw_rel(int argc, VALUE *argv, VALUE self) {
   }
   ecode3 = SWIG_AsVal_double(argv[1], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "drawRel" "', argument " "3"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","drawRel", 3, argv[1] ));
   } 
   arg3 = static_cast< double >(val3);
   ecode4 = SWIG_AsVal_double(argv[2], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "drawRel" "', argument " "4"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","drawRel", 4, argv[2] ));
   } 
   arg4 = static_cast< double >(val4);
   ecode5 = SWIG_AsVal_double(argv[3], &val5);
   if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "drawRel" "', argument " "5"" of type '" "Gosu::ZPos""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Gosu::ZPos","drawRel", 5, argv[3] ));
   } 
   arg5 = static_cast< Gosu::ZPos >(val5);
   ecode6 = SWIG_AsVal_double(argv[4], &val6);
   if (!SWIG_IsOK(ecode6)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "drawRel" "', argument " "6"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","drawRel", 6, argv[4] ));
   } 
   arg6 = static_cast< double >(val6);
   ecode7 = SWIG_AsVal_double(argv[5], &val7);
   if (!SWIG_IsOK(ecode7)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "drawRel" "', argument " "7"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","drawRel", 7, argv[5] ));
   } 
   arg7 = static_cast< double >(val7);
   if (argc > 6) {
     ecode8 = SWIG_AsVal_double(argv[6], &val8);
     if (!SWIG_IsOK(ecode8)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "drawRel" "', argument " "8"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","drawRel", 8, argv[6] ));
     } 
     arg8 = static_cast< double >(val8);
   }
   if (argc > 7) {
     ecode9 = SWIG_AsVal_double(argv[7], &val9);
     if (!SWIG_IsOK(ecode9)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "drawRel" "', argument " "9"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "double","drawRel", 9, argv[7] ));
     } 
     arg9 = static_cast< double >(val9);
   }
@@ -4383,7 +4709,7 @@ _wrap_Font_draw_rot(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Font, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "drawRot" "', argument " "1"" of type '" "Gosu::Font const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font const *","drawRot", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Font * >(argp1);
   {
@@ -4393,35 +4719,35 @@ _wrap_Font_draw_rot(int argc, VALUE *argv, VALUE self) {
   }
   ecode3 = SWIG_AsVal_double(argv[1], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "drawRot" "', argument " "3"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","drawRot", 3, argv[1] ));
   } 
   arg3 = static_cast< double >(val3);
   ecode4 = SWIG_AsVal_double(argv[2], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "drawRot" "', argument " "4"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","drawRot", 4, argv[2] ));
   } 
   arg4 = static_cast< double >(val4);
   ecode5 = SWIG_AsVal_double(argv[3], &val5);
   if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "drawRot" "', argument " "5"" of type '" "Gosu::ZPos""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Gosu::ZPos","drawRot", 5, argv[3] ));
   } 
   arg5 = static_cast< Gosu::ZPos >(val5);
   ecode6 = SWIG_AsVal_double(argv[4], &val6);
   if (!SWIG_IsOK(ecode6)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "drawRot" "', argument " "6"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","drawRot", 6, argv[4] ));
   } 
   arg6 = static_cast< double >(val6);
   if (argc > 5) {
     ecode7 = SWIG_AsVal_double(argv[5], &val7);
     if (!SWIG_IsOK(ecode7)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "drawRot" "', argument " "7"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","drawRot", 7, argv[5] ));
     } 
     arg7 = static_cast< double >(val7);
   }
   if (argc > 6) {
     ecode8 = SWIG_AsVal_double(argv[6], &val8);
     if (!SWIG_IsOK(ecode8)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "drawRot" "', argument " "8"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","drawRot", 8, argv[6] ));
     } 
     arg8 = static_cast< double >(val8);
   }
@@ -4484,23 +4810,23 @@ _wrap_new_Font(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = 0 ;
   std::wstring *arg2 = 0 ;
   unsigned int arg3 ;
-  Gosu::Font *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   std::wstring temp2 ;
   unsigned int val3 ;
   int ecode3 = 0 ;
   const char *classname SWIGUNUSED = "Gosu::Font";
+  Gosu::Font *result = 0 ;
   
   if ((argc < 3) || (argc > 3)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Gosu__Window,  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gosu::Font" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window &","Gosu::Font", 1, argv[0] )); 
   }
   if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gosu::Font" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Gosu::Window &","Gosu::Font", 1, argv[0])); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -4510,14 +4836,14 @@ _wrap_new_Font(int argc, VALUE *argv, VALUE self) {
   }
   ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Gosu::Font" "', argument " "3"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","Gosu::Font", 3, argv[2] ));
   } 
   arg3 = static_cast< unsigned int >(val3);
   {
     try {
-      result = (Gosu::Font *)new_Gosu_Font(*arg1,(std::wstring const &)*arg2,arg3);DATA_PTR(self) = result;
+      result = (Gosu::Font *)new_Gosu_Font(*arg1,(std::wstring const &)*arg2,arg3);
+      DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
-      
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -4544,16 +4870,15 @@ _wrap_GLTexInfo_tex_name_set(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__GLTexInfo, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "texName" "', argument " "1"" of type '" "Gosu::GLTexInfo *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","texName", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
   ecode2 = SWIG_AsVal_int(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "texName" "', argument " "2"" of type '" "int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","texName", 2, argv[0] ));
   } 
   arg2 = static_cast< int >(val2);
   if (arg1) (arg1)->texName = arg2;
-  
   return Qnil;
 fail:
   return Qnil;
@@ -4563,9 +4888,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_GLTexInfo_tex_name_get(int argc, VALUE *argv, VALUE self) {
   Gosu::GLTexInfo *arg1 = (Gosu::GLTexInfo *) 0 ;
-  int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -4573,7 +4898,7 @@ _wrap_GLTexInfo_tex_name_get(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__GLTexInfo, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "texName" "', argument " "1"" of type '" "Gosu::GLTexInfo *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","texName", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
   result = (int) ((arg1)->texName);
@@ -4598,16 +4923,15 @@ _wrap_GLTexInfo_left_set(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__GLTexInfo, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "left" "', argument " "1"" of type '" "Gosu::GLTexInfo *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","left", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "left" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","left", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
   if (arg1) (arg1)->left = arg2;
-  
   return Qnil;
 fail:
   return Qnil;
@@ -4617,9 +4941,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_GLTexInfo_left_get(int argc, VALUE *argv, VALUE self) {
   Gosu::GLTexInfo *arg1 = (Gosu::GLTexInfo *) 0 ;
-  double result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -4627,7 +4951,7 @@ _wrap_GLTexInfo_left_get(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__GLTexInfo, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "left" "', argument " "1"" of type '" "Gosu::GLTexInfo *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","left", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
   result = (double) ((arg1)->left);
@@ -4652,16 +4976,15 @@ _wrap_GLTexInfo_right_set(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__GLTexInfo, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "right" "', argument " "1"" of type '" "Gosu::GLTexInfo *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","right", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "right" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","right", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
   if (arg1) (arg1)->right = arg2;
-  
   return Qnil;
 fail:
   return Qnil;
@@ -4671,9 +4994,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_GLTexInfo_right_get(int argc, VALUE *argv, VALUE self) {
   Gosu::GLTexInfo *arg1 = (Gosu::GLTexInfo *) 0 ;
-  double result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -4681,7 +5004,7 @@ _wrap_GLTexInfo_right_get(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__GLTexInfo, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "right" "', argument " "1"" of type '" "Gosu::GLTexInfo *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","right", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
   result = (double) ((arg1)->right);
@@ -4706,16 +5029,15 @@ _wrap_GLTexInfo_top_set(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__GLTexInfo, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "top" "', argument " "1"" of type '" "Gosu::GLTexInfo *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","top", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "top" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","top", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
   if (arg1) (arg1)->top = arg2;
-  
   return Qnil;
 fail:
   return Qnil;
@@ -4725,9 +5047,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_GLTexInfo_top_get(int argc, VALUE *argv, VALUE self) {
   Gosu::GLTexInfo *arg1 = (Gosu::GLTexInfo *) 0 ;
-  double result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -4735,7 +5057,7 @@ _wrap_GLTexInfo_top_get(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__GLTexInfo, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "top" "', argument " "1"" of type '" "Gosu::GLTexInfo *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","top", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
   result = (double) ((arg1)->top);
@@ -4760,16 +5082,15 @@ _wrap_GLTexInfo_bottom_set(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__GLTexInfo, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bottom" "', argument " "1"" of type '" "Gosu::GLTexInfo *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","bottom", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "bottom" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","bottom", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
   if (arg1) (arg1)->bottom = arg2;
-  
   return Qnil;
 fail:
   return Qnil;
@@ -4779,9 +5100,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_GLTexInfo_bottom_get(int argc, VALUE *argv, VALUE self) {
   Gosu::GLTexInfo *arg1 = (Gosu::GLTexInfo *) 0 ;
-  double result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -4789,7 +5110,7 @@ _wrap_GLTexInfo_bottom_get(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__GLTexInfo, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bottom" "', argument " "1"" of type '" "Gosu::GLTexInfo *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::GLTexInfo *","bottom", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::GLTexInfo * >(argp1);
   result = (double) ((arg1)->bottom);
@@ -4819,17 +5140,17 @@ _wrap_GLTexInfo_allocate(VALUE self) {
 
 SWIGINTERN VALUE
 _wrap_new_GLTexInfo(int argc, VALUE *argv, VALUE self) {
-  Gosu::GLTexInfo *result = 0 ;
   const char *classname SWIGUNUSED = "Gosu::GLTexInfo";
+  Gosu::GLTexInfo *result = 0 ;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
   {
     try {
-      result = (Gosu::GLTexInfo *)new Gosu::GLTexInfo();DATA_PTR(self) = result;
+      result = (Gosu::GLTexInfo *)new Gosu::GLTexInfo();
+      DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
-      
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -4857,9 +5178,9 @@ free_Gosu_Image(Gosu::Image *arg1) {
 SWIGINTERN VALUE
 _wrap_Image_width(int argc, VALUE *argv, VALUE self) {
   Gosu::Image *arg1 = (Gosu::Image *) 0 ;
-  unsigned int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  unsigned int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -4867,7 +5188,7 @@ _wrap_Image_width(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Image, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "width" "', argument " "1"" of type '" "Gosu::Image const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Image const *","width", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Image * >(argp1);
   {
@@ -4887,9 +5208,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Image_height(int argc, VALUE *argv, VALUE self) {
   Gosu::Image *arg1 = (Gosu::Image *) 0 ;
-  unsigned int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  unsigned int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -4897,7 +5218,7 @@ _wrap_Image_height(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Image, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "height" "', argument " "1"" of type '" "Gosu::Image const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Image const *","height", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Image * >(argp1);
   {
@@ -4942,35 +5263,35 @@ _wrap_Image_draw(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Image, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "draw" "', argument " "1"" of type '" "Gosu::Image const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Image const *","draw", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Image * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "draw" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","draw", 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), "in method '" "draw" "', argument " "3"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","draw", 3, argv[1] ));
   } 
   arg3 = static_cast< double >(val3);
   ecode4 = SWIG_AsVal_double(argv[2], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "draw" "', argument " "4"" of type '" "Gosu::ZPos""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Gosu::ZPos","draw", 4, argv[2] ));
   } 
   arg4 = static_cast< Gosu::ZPos >(val4);
   if (argc > 3) {
     ecode5 = SWIG_AsVal_double(argv[3], &val5);
     if (!SWIG_IsOK(ecode5)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "draw" "', argument " "5"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","draw", 5, argv[3] ));
     } 
     arg5 = static_cast< double >(val5);
   }
   if (argc > 4) {
     ecode6 = SWIG_AsVal_double(argv[4], &val6);
     if (!SWIG_IsOK(ecode6)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "draw" "', argument " "6"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","draw", 6, argv[4] ));
     } 
     arg6 = static_cast< double >(val6);
   }
@@ -5042,32 +5363,32 @@ _wrap_Image_draw_mod(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Image, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "drawMod" "', argument " "1"" of type '" "Gosu::Image const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Image const *","drawMod", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Image * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "drawMod" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","drawMod", 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), "in method '" "drawMod" "', argument " "3"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","drawMod", 3, argv[1] ));
   } 
   arg3 = static_cast< double >(val3);
   ecode4 = SWIG_AsVal_double(argv[2], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "drawMod" "', argument " "4"" of type '" "Gosu::ZPos""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Gosu::ZPos","drawMod", 4, argv[2] ));
   } 
   arg4 = static_cast< Gosu::ZPos >(val4);
   ecode5 = SWIG_AsVal_double(argv[3], &val5);
   if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "drawMod" "', argument " "5"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","drawMod", 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), "in method '" "drawMod" "', argument " "6"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","drawMod", 6, argv[4] ));
   } 
   arg6 = static_cast< double >(val6);
   {
@@ -5175,54 +5496,54 @@ _wrap_Image_draw_rot(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Image, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "drawRot" "', argument " "1"" of type '" "Gosu::Image const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Image const *","drawRot", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Image * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "drawRot" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","drawRot", 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), "in method '" "drawRot" "', argument " "3"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","drawRot", 3, argv[1] ));
   } 
   arg3 = static_cast< double >(val3);
   ecode4 = SWIG_AsVal_double(argv[2], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "drawRot" "', argument " "4"" of type '" "Gosu::ZPos""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Gosu::ZPos","drawRot", 4, argv[2] ));
   } 
   arg4 = static_cast< Gosu::ZPos >(val4);
   ecode5 = SWIG_AsVal_double(argv[3], &val5);
   if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "drawRot" "', argument " "5"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","drawRot", 5, argv[3] ));
   } 
   arg5 = static_cast< double >(val5);
   if (argc > 4) {
     ecode6 = SWIG_AsVal_double(argv[4], &val6);
     if (!SWIG_IsOK(ecode6)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "drawRot" "', argument " "6"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","drawRot", 6, argv[4] ));
     } 
     arg6 = static_cast< double >(val6);
   }
   if (argc > 5) {
     ecode7 = SWIG_AsVal_double(argv[5], &val7);
     if (!SWIG_IsOK(ecode7)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "drawRot" "', argument " "7"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","drawRot", 7, argv[5] ));
     } 
     arg7 = static_cast< double >(val7);
   }
   if (argc > 6) {
     ecode8 = SWIG_AsVal_double(argv[6], &val8);
     if (!SWIG_IsOK(ecode8)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "drawRot" "', argument " "8"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","drawRot", 8, argv[6] ));
     } 
     arg8 = static_cast< double >(val8);
   }
   if (argc > 7) {
     ecode9 = SWIG_AsVal_double(argv[7], &val9);
     if (!SWIG_IsOK(ecode9)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "drawRot" "', argument " "9"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "double","drawRot", 9, argv[7] ));
     } 
     arg9 = static_cast< double >(val9);
   }
@@ -5268,37 +5589,37 @@ _wrap_new_Image__SWIG_0(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = 0 ;
   VALUE arg2 = (VALUE) 0 ;
   bool arg3 = (bool) false ;
-  Gosu::Image *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   bool val3 ;
   int ecode3 = 0 ;
   const char *classname SWIGUNUSED = "Gosu::Image";
+  Gosu::Image *result = 0 ;
   
   if ((argc < 2) || (argc > 3)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Gosu__Window,  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gosu::Image" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window &","Gosu::Image", 1, argv[0] )); 
   }
   if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gosu::Image" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Gosu::Window &","Gosu::Image", 1, argv[0])); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   arg2 = argv[1];
   if (argc > 2) {
     ecode3 = SWIG_AsVal_bool(argv[2], &val3);
     if (!SWIG_IsOK(ecode3)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Gosu::Image" "', argument " "3"" of type '" "bool""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Gosu::Image", 3, argv[2] ));
     } 
     arg3 = static_cast< bool >(val3);
   }
   {
     try {
-      result = (Gosu::Image *)new_Gosu_Image__SWIG_0(*arg1,arg2,arg3);DATA_PTR(self) = result;
+      result = (Gosu::Image *)new_Gosu_Image__SWIG_0(*arg1,arg2,arg3);
+      DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
-      
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -5335,7 +5656,6 @@ _wrap_new_Image__SWIG_1(int argc, VALUE *argv, VALUE self) {
   unsigned int arg5 ;
   unsigned int arg6 ;
   unsigned int arg7 ;
-  Gosu::Image *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   bool val3 ;
@@ -5349,49 +5669,50 @@ _wrap_new_Image__SWIG_1(int argc, VALUE *argv, VALUE self) {
   unsigned int val7 ;
   int ecode7 = 0 ;
   const char *classname SWIGUNUSED = "Gosu::Image";
+  Gosu::Image *result = 0 ;
   
   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), "in method '" "Gosu::Image" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window &","Gosu::Image", 1, argv[0] )); 
   }
   if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gosu::Image" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Gosu::Window &","Gosu::Image", 1, argv[0])); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   arg2 = argv[1];
   ecode3 = SWIG_AsVal_bool(argv[2], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Gosu::Image" "', argument " "3"" of type '" "bool""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Gosu::Image", 3, argv[2] ));
   } 
   arg3 = static_cast< bool >(val3);
   ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Gosu::Image" "', argument " "4"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","Gosu::Image", 4, argv[3] ));
   } 
   arg4 = static_cast< unsigned int >(val4);
   ecode5 = SWIG_AsVal_unsigned_SS_int(argv[4], &val5);
   if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Gosu::Image" "', argument " "5"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "unsigned int","Gosu::Image", 5, argv[4] ));
   } 
   arg5 = static_cast< unsigned int >(val5);
   ecode6 = SWIG_AsVal_unsigned_SS_int(argv[5], &val6);
   if (!SWIG_IsOK(ecode6)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Gosu::Image" "', argument " "6"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "unsigned int","Gosu::Image", 6, argv[5] ));
   } 
   arg6 = static_cast< unsigned int >(val6);
   ecode7 = SWIG_AsVal_unsigned_SS_int(argv[6], &val7);
   if (!SWIG_IsOK(ecode7)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Gosu::Image" "', argument " "7"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "unsigned int","Gosu::Image", 7, argv[6] ));
   } 
   arg7 = static_cast< unsigned int >(val7);
   {
     try {
-      result = (Gosu::Image *)new_Gosu_Image__SWIG_1(*arg1,arg2,arg3,arg4,arg5,arg6,arg7);DATA_PTR(self) = result;
+      result = (Gosu::Image *)new_Gosu_Image__SWIG_1(*arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+      DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
-      
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -5409,7 +5730,7 @@ SWIGINTERN VALUE _wrap_new_Image(int nargs, VALUE *args, VALUE self) {
   
   argc = nargs;
   if (argc > 7) SWIG_fail;
-  for (ii = 0; (ii < argc); ii++) {
+  for (ii = 0; (ii < argc); ++ii) {
     argv[ii] = args[ii];
   }
   if ((argc >= 2) && (argc <= 3)) {
@@ -5477,7 +5798,10 @@ SWIGINTERN VALUE _wrap_new_Image(int nargs, VALUE *args, VALUE self) {
   }
   
 fail:
-  rb_raise(rb_eArgError, "No matching function for overloaded 'new_Image'");
+  Ruby_Format_OverloadedError( argc, 7, "Image.new", 
+    "    Image.new(Gosu::Window &window, VALUE source, bool hardBorders)\n"
+    "    Image.new(Gosu::Window &window, VALUE source, bool hardBorders, unsigned int srcX, unsigned int srcY, unsigned int srcWidth, unsigned int srcHeight)\n");
+  
   return Qnil;
 }
 
@@ -5525,17 +5849,17 @@ _wrap_Image_draw_as_quad(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Image, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "drawAsQuad" "', argument " "1"" of type '" "Gosu::Image *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Image *","drawAsQuad", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Image * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "drawAsQuad" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","drawAsQuad", 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), "in method '" "drawAsQuad" "', argument " "3"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","drawAsQuad", 3, argv[1] ));
   } 
   arg3 = static_cast< double >(val3);
   {
@@ -5551,12 +5875,12 @@ _wrap_Image_draw_as_quad(int argc, VALUE *argv, VALUE self) {
   }
   ecode5 = SWIG_AsVal_double(argv[3], &val5);
   if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "drawAsQuad" "', argument " "5"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","drawAsQuad", 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), "in method '" "drawAsQuad" "', argument " "6"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","drawAsQuad", 6, argv[4] ));
   } 
   arg6 = static_cast< double >(val6);
   {
@@ -5572,12 +5896,12 @@ _wrap_Image_draw_as_quad(int argc, VALUE *argv, VALUE self) {
   }
   ecode8 = SWIG_AsVal_double(argv[6], &val8);
   if (!SWIG_IsOK(ecode8)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "drawAsQuad" "', argument " "8"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","drawAsQuad", 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), "in method '" "drawAsQuad" "', argument " "9"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "double","drawAsQuad", 9, argv[7] ));
   } 
   arg9 = static_cast< double >(val9);
   {
@@ -5593,12 +5917,12 @@ _wrap_Image_draw_as_quad(int argc, VALUE *argv, VALUE self) {
   }
   ecode11 = SWIG_AsVal_double(argv[9], &val11);
   if (!SWIG_IsOK(ecode11)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "drawAsQuad" "', argument " "11"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "double","drawAsQuad", 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), "in method '" "drawAsQuad" "', argument " "12"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "double","drawAsQuad", 12, argv[10] ));
   } 
   arg12 = static_cast< double >(val12);
   {
@@ -5614,7 +5938,7 @@ _wrap_Image_draw_as_quad(int argc, VALUE *argv, VALUE self) {
   }
   ecode14 = SWIG_AsVal_double(argv[12], &val14);
   if (!SWIG_IsOK(ecode14)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "drawAsQuad" "', argument " "14"" of type '" "Gosu::ZPos""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "Gosu::ZPos","drawAsQuad", 14, argv[12] ));
   } 
   arg14 = static_cast< Gosu::ZPos >(val14);
   if (argc > 13) {
@@ -5644,9 +5968,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Image_gl_tex_info(int argc, VALUE *argv, VALUE self) {
   Gosu::Image *arg1 = (Gosu::Image *) 0 ;
-  Gosu::GLTexInfo *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  Gosu::GLTexInfo *result = 0 ;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -5654,7 +5978,7 @@ _wrap_Image_gl_tex_info(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Image, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "glTexInfo" "', argument " "1"" of type '" "Gosu::Image const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Image const *","glTexInfo", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Image * >(argp1);
   {
@@ -5672,18 +5996,18 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Image_from_text_4(int argc, VALUE *argv, VALUE self) {
+_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 ;
-  Gosu::Image *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   std::wstring temp2 ;
   std::wstring temp3 ;
   unsigned int val4 ;
   int ecode4 = 0 ;
+  Gosu::Image *result = 0 ;
   VALUE vresult = Qnil;
   
   if ((argc < 4) || (argc > 4)) {
@@ -5691,10 +6015,10 @@ _wrap_Image_from_text_4(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), "in method '" "Gosu_Image_fromText4" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window &","Gosu_Image_fromText4", 1, argv[0] )); 
   }
   if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gosu_Image_fromText4" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    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);
   {
@@ -5709,7 +6033,7 @@ _wrap_Image_from_text_4(int argc, VALUE *argv, VALUE self) {
   }
   ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Gosu_Image_fromText4" "', argument " "4"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","Gosu_Image_fromText4", 4, argv[3] ));
   } 
   arg4 = static_cast< unsigned int >(val4);
   {
@@ -5727,7 +6051,7 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Image_from_text_7(int argc, VALUE *argv, VALUE self) {
+_wrap_Image_from_text7(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = 0 ;
   std::wstring *arg2 = 0 ;
   std::wstring *arg3 = 0 ;
@@ -5735,7 +6059,6 @@ _wrap_Image_from_text_7(int argc, VALUE *argv, VALUE self) {
   unsigned int arg5 ;
   unsigned int arg6 ;
   Gosu::TextAlign arg7 ;
-  Gosu::Image *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   std::wstring temp2 ;
@@ -5746,6 +6069,7 @@ _wrap_Image_from_text_7(int argc, VALUE *argv, VALUE self) {
   int ecode5 = 0 ;
   unsigned int val6 ;
   int ecode6 = 0 ;
+  Gosu::Image *result = 0 ;
   VALUE vresult = Qnil;
   
   if ((argc < 7) || (argc > 7)) {
@@ -5753,10 +6077,10 @@ _wrap_Image_from_text_7(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), "in method '" "Gosu_Image_fromText7" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window &","Gosu_Image_fromText7", 1, argv[0] )); 
   }
   if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gosu_Image_fromText7" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    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);
   {
@@ -5771,17 +6095,17 @@ _wrap_Image_from_text_7(int argc, VALUE *argv, VALUE self) {
   }
   ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Gosu_Image_fromText7" "', argument " "4"" of type '" "unsigned int""'");
+    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_unsigned_SS_int(argv[4], &val5);
   if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Gosu_Image_fromText7" "', argument " "5"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "unsigned int","Gosu_Image_fromText7", 5, argv[4] ));
   } 
   arg5 = static_cast< unsigned int >(val5);
   ecode6 = SWIG_AsVal_unsigned_SS_int(argv[5], &val6);
   if (!SWIG_IsOK(ecode6)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Gosu_Image_fromText7" "', argument " "6"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "unsigned int","Gosu_Image_fromText7", 6, argv[5] ));
   } 
   arg6 = static_cast< unsigned int >(val6);
   {
@@ -5818,7 +6142,6 @@ _wrap_Image_load_tiles(int argc, VALUE *argv, VALUE self) {
   int arg3 ;
   int arg4 ;
   bool arg5 ;
-  SwigValueWrapper<std::vector<Gosu::Image * > > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   int val3 ;
@@ -5827,6 +6150,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;
   VALUE vresult = Qnil;
   
   if ((argc < 5) || (argc > 5)) {
@@ -5834,26 +6158,26 @@ _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), "in method '" "Gosu_Image_loadTiles" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window &","Gosu_Image_loadTiles", 1, argv[0] )); 
   }
   if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gosu_Image_loadTiles" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Gosu::Window &","Gosu_Image_loadTiles", 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), "in method '" "Gosu_Image_loadTiles" "', argument " "3"" of type '" "int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Gosu_Image_loadTiles", 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), "in method '" "Gosu_Image_loadTiles" "', argument " "4"" of type '" "int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Gosu_Image_loadTiles", 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), "in method '" "Gosu_Image_loadTiles" "', argument " "5"" of type '" "bool""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Gosu_Image_loadTiles", 5, argv[4] ));
   } 
   arg5 = static_cast< bool >(val5);
   {
@@ -5899,31 +6223,31 @@ SWIGINTERN VALUE
 _wrap_new_SampleInstance(int argc, VALUE *argv, VALUE self) {
   int arg1 ;
   int arg2 ;
-  Gosu::SampleInstance *result = 0 ;
   int val1 ;
   int ecode1 = 0 ;
   int val2 ;
   int ecode2 = 0 ;
   const char *classname SWIGUNUSED = "Gosu::SampleInstance";
+  Gosu::SampleInstance *result = 0 ;
   
   if ((argc < 2) || (argc > 2)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
   ecode1 = SWIG_AsVal_int(argv[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::SampleInstance" "', argument " "1"" of type '" "int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Gosu::SampleInstance", 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), "in method '" "Gosu::SampleInstance" "', argument " "2"" of type '" "int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Gosu::SampleInstance", 2, argv[1] ));
   } 
   arg2 = static_cast< int >(val2);
   {
     try {
-      result = (Gosu::SampleInstance *)new Gosu::SampleInstance(arg1,arg2);DATA_PTR(self) = result;
+      result = (Gosu::SampleInstance *)new Gosu::SampleInstance(arg1,arg2);
+      DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
-      
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -5937,9 +6261,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_SampleInstance_playingq___(int argc, VALUE *argv, VALUE self) {
   Gosu::SampleInstance *arg1 = (Gosu::SampleInstance *) 0 ;
-  bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  bool result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -5947,7 +6271,7 @@ _wrap_SampleInstance_playingq___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__SampleInstance, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "playing" "', argument " "1"" of type '" "Gosu::SampleInstance const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::SampleInstance const *","playing", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::SampleInstance * >(argp1);
   {
@@ -5967,9 +6291,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_SampleInstance_pausedq___(int argc, VALUE *argv, VALUE self) {
   Gosu::SampleInstance *arg1 = (Gosu::SampleInstance *) 0 ;
-  bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  bool result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -5977,7 +6301,7 @@ _wrap_SampleInstance_pausedq___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__SampleInstance, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "paused" "', argument " "1"" of type '" "Gosu::SampleInstance const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::SampleInstance const *","paused", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::SampleInstance * >(argp1);
   {
@@ -6005,7 +6329,7 @@ _wrap_SampleInstance_pause(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__SampleInstance, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pause" "', argument " "1"" of type '" "Gosu::SampleInstance *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::SampleInstance *","pause", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::SampleInstance * >(argp1);
   {
@@ -6032,7 +6356,7 @@ _wrap_SampleInstance_resume(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__SampleInstance, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resume" "', argument " "1"" of type '" "Gosu::SampleInstance *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::SampleInstance *","resume", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::SampleInstance * >(argp1);
   {
@@ -6059,7 +6383,7 @@ _wrap_SampleInstance_stop(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__SampleInstance, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stop" "', argument " "1"" of type '" "Gosu::SampleInstance *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::SampleInstance *","stop", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::SampleInstance * >(argp1);
   {
@@ -6089,12 +6413,12 @@ _wrap_SampleInstance_volumee___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__SampleInstance, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "changeVolume" "', argument " "1"" of type '" "Gosu::SampleInstance *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::SampleInstance *","changeVolume", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::SampleInstance * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "changeVolume" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","changeVolume", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
   {
@@ -6124,12 +6448,12 @@ _wrap_SampleInstance_pane___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__SampleInstance, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "changePan" "', argument " "1"" of type '" "Gosu::SampleInstance *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::SampleInstance *","changePan", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::SampleInstance * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "changePan" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","changePan", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
   {
@@ -6159,12 +6483,12 @@ _wrap_SampleInstance_speede___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__SampleInstance, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "changeSpeed" "', argument " "1"" of type '" "Gosu::SampleInstance *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::SampleInstance *","changeSpeed", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::SampleInstance * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "changeSpeed" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","changeSpeed", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
   {
@@ -6200,7 +6524,6 @@ _wrap_Sample_play(int argc, VALUE *argv, VALUE self) {
   double arg2 = (double) 1 ;
   double arg3 = (double) 1 ;
   bool arg4 = (bool) false ;
-  SwigValueWrapper<Gosu::SampleInstance > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   double val2 ;
@@ -6209,6 +6532,7 @@ _wrap_Sample_play(int argc, VALUE *argv, VALUE self) {
   int ecode3 = 0 ;
   bool val4 ;
   int ecode4 = 0 ;
+  SwigValueWrapper< Gosu::SampleInstance > result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 3)) {
@@ -6216,27 +6540,27 @@ _wrap_Sample_play(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Sample, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "play" "', argument " "1"" of type '" "Gosu::Sample const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Sample const *","play", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Sample * >(argp1);
   if (argc > 0) {
     ecode2 = SWIG_AsVal_double(argv[0], &val2);
     if (!SWIG_IsOK(ecode2)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "play" "', argument " "2"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","play", 2, argv[0] ));
     } 
     arg2 = static_cast< double >(val2);
   }
   if (argc > 1) {
     ecode3 = SWIG_AsVal_double(argv[1], &val3);
     if (!SWIG_IsOK(ecode3)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "play" "', argument " "3"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","play", 3, argv[1] ));
     } 
     arg3 = static_cast< double >(val3);
   }
   if (argc > 2) {
     ecode4 = SWIG_AsVal_bool(argv[2], &val4);
     if (!SWIG_IsOK(ecode4)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "play" "', argument " "4"" of type '" "bool""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","play", 4, argv[2] ));
     } 
     arg4 = static_cast< bool >(val4);
   }
@@ -6261,7 +6585,6 @@ _wrap_Sample_play_pan(int argc, VALUE *argv, VALUE self) {
   double arg3 = (double) 1 ;
   double arg4 = (double) 1 ;
   bool arg5 = (bool) false ;
-  SwigValueWrapper<Gosu::SampleInstance > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   double val2 ;
@@ -6272,6 +6595,7 @@ _wrap_Sample_play_pan(int argc, VALUE *argv, VALUE self) {
   int ecode4 = 0 ;
   bool val5 ;
   int ecode5 = 0 ;
+  SwigValueWrapper< Gosu::SampleInstance > result;
   VALUE vresult = Qnil;
   
   if ((argc < 1) || (argc > 4)) {
@@ -6279,32 +6603,32 @@ _wrap_Sample_play_pan(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Sample, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "playPan" "', argument " "1"" of type '" "Gosu::Sample const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Sample const *","playPan", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Sample * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "playPan" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","playPan", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
   if (argc > 1) {
     ecode3 = SWIG_AsVal_double(argv[1], &val3);
     if (!SWIG_IsOK(ecode3)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "playPan" "', argument " "3"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","playPan", 3, argv[1] ));
     } 
     arg3 = static_cast< double >(val3);
   }
   if (argc > 2) {
     ecode4 = SWIG_AsVal_double(argv[2], &val4);
     if (!SWIG_IsOK(ecode4)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "playPan" "', argument " "4"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","playPan", 4, argv[2] ));
     } 
     arg4 = static_cast< double >(val4);
   }
   if (argc > 3) {
     ecode5 = SWIG_AsVal_bool(argv[3], &val5);
     if (!SWIG_IsOK(ecode5)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "playPan" "', argument " "5"" of type '" "bool""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","playPan", 5, argv[3] ));
     } 
     arg5 = static_cast< bool >(val5);
   }
@@ -6343,39 +6667,39 @@ SWIGINTERN VALUE
 _wrap_new_Sample(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = 0 ;
   std::string *arg2 = 0 ;
-  Gosu::Sample *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   int res2 = SWIG_OLDOBJ ;
   const char *classname SWIGUNUSED = "Gosu::Sample";
+  Gosu::Sample *result = 0 ;
   
   if ((argc < 2) || (argc > 2)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Gosu__Window,  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gosu::Sample" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window &","Gosu::Sample", 1, argv[0] )); 
   }
   if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gosu::Sample" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Gosu::Window &","Gosu::Sample", 1, argv[0])); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     std::string *ptr = (std::string *)0;
     res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
     if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gosu::Sample" "', argument " "2"" of type '" "std::string const &""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","Gosu::Sample", 2, argv[1] )); 
     }
     if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gosu::Sample" "', argument " "2"" of type '" "std::string const &""'"); 
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","Gosu::Sample", 2, argv[1])); 
     }
     arg2 = ptr;
   }
   {
     try {
-      result = (Gosu::Sample *)new_Gosu_Sample(*arg1,(std::string const &)*arg2);DATA_PTR(self) = result;
+      result = (Gosu::Sample *)new_Gosu_Sample(*arg1,(std::string const &)*arg2);
+      DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
-      
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -6432,13 +6756,13 @@ _wrap_Song_play(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Song, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "play" "', argument " "1"" of type '" "Gosu::Song *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Song *","play", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Song * >(argp1);
   if (argc > 0) {
     ecode2 = SWIG_AsVal_bool(argv[0], &val2);
     if (!SWIG_IsOK(ecode2)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "play" "', argument " "2"" of type '" "bool""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","play", 2, argv[0] ));
     } 
     arg2 = static_cast< bool >(val2);
   }
@@ -6466,7 +6790,7 @@ _wrap_Song_pause(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Song, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pause" "', argument " "1"" of type '" "Gosu::Song *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Song *","pause", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Song * >(argp1);
   {
@@ -6485,9 +6809,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Song_pausedq___(int argc, VALUE *argv, VALUE self) {
   Gosu::Song *arg1 = (Gosu::Song *) 0 ;
-  bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  bool result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -6495,7 +6819,7 @@ _wrap_Song_pausedq___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Song, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "paused" "', argument " "1"" of type '" "Gosu::Song const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Song const *","paused", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Song * >(argp1);
   {
@@ -6523,7 +6847,7 @@ _wrap_Song_stop(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Song, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stop" "', argument " "1"" of type '" "Gosu::Song *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Song *","stop", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Song * >(argp1);
   {
@@ -6542,9 +6866,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Song_playingq___(int argc, VALUE *argv, VALUE self) {
   Gosu::Song *arg1 = (Gosu::Song *) 0 ;
-  bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  bool result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -6552,7 +6876,7 @@ _wrap_Song_playingq___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Song, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "playing" "', argument " "1"" of type '" "Gosu::Song const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Song const *","playing", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Song * >(argp1);
   {
@@ -6572,9 +6896,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Song_volume(int argc, VALUE *argv, VALUE self) {
   Gosu::Song *arg1 = (Gosu::Song *) 0 ;
-  double result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -6582,7 +6906,7 @@ _wrap_Song_volume(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Song, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "volume" "', argument " "1"" of type '" "Gosu::Song const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Song const *","volume", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Song * >(argp1);
   {
@@ -6613,12 +6937,12 @@ _wrap_Song_volumee___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Song, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "changeVolume" "', argument " "1"" of type '" "Gosu::Song *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Song *","changeVolume", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Song * >(argp1);
   ecode2 = SWIG_AsVal_double(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "changeVolume" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","changeVolume", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
   {
@@ -6655,39 +6979,39 @@ SWIGINTERN VALUE
 _wrap_new_Song(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = 0 ;
   std::string *arg2 = 0 ;
-  Gosu::Song *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   int res2 = SWIG_OLDOBJ ;
   const char *classname SWIGUNUSED = "Gosu::Song";
+  Gosu::Song *result = 0 ;
   
   if ((argc < 2) || (argc > 2)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Gosu__Window,  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gosu::Song" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window &","Gosu::Song", 1, argv[0] )); 
   }
   if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gosu::Song" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Gosu::Window &","Gosu::Song", 1, argv[0])); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     std::string *ptr = (std::string *)0;
     res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
     if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Gosu::Song" "', argument " "2"" of type '" "std::string const &""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","Gosu::Song", 2, argv[1] )); 
     }
     if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gosu::Song" "', argument " "2"" of type '" "std::string const &""'"); 
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","Gosu::Song", 2, argv[1])); 
     }
     arg2 = ptr;
   }
   {
     try {
-      result = (Gosu::Song *)new_Gosu_Song(*arg1,(std::string const &)*arg2);DATA_PTR(self) = result;
+      result = (Gosu::Song *)new_Gosu_Song(*arg1,(std::string const &)*arg2);
+      DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
-      
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -6721,17 +7045,17 @@ _wrap_TextInput_allocate(VALUE self) {
 
 SWIGINTERN VALUE
 _wrap_new_TextInput(int argc, VALUE *argv, VALUE self) {
-  Gosu::TextInput *result = 0 ;
   const char *classname SWIGUNUSED = "Gosu::TextInput";
+  Gosu::TextInput *result = 0 ;
   
   if ((argc < 0) || (argc > 0)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
   {
     try {
-      result = (Gosu::TextInput *)new Gosu::TextInput();DATA_PTR(self) = result;
+      result = (Gosu::TextInput *)new Gosu::TextInput();
+      DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
-      
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -6751,9 +7075,9 @@ free_Gosu_TextInput(Gosu::TextInput *arg1) {
 SWIGINTERN VALUE
 _wrap_TextInput_text(int argc, VALUE *argv, VALUE self) {
   Gosu::TextInput *arg1 = (Gosu::TextInput *) 0 ;
-  std::wstring result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  std::wstring result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -6761,7 +7085,7 @@ _wrap_TextInput_text(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__TextInput, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "text" "', argument " "1"" of type '" "Gosu::TextInput const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::TextInput const *","text", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::TextInput * >(argp1);
   {
@@ -6793,7 +7117,7 @@ _wrap_TextInput_texte___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__TextInput, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setText" "', argument " "1"" of type '" "Gosu::TextInput *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::TextInput *","setText", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::TextInput * >(argp1);
   {
@@ -6817,9 +7141,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_TextInput_caret_pos(int argc, VALUE *argv, VALUE self) {
   Gosu::TextInput *arg1 = (Gosu::TextInput *) 0 ;
-  unsigned int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  unsigned int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -6827,7 +7151,7 @@ _wrap_TextInput_caret_pos(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__TextInput, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "caret_pos" "', argument " "1"" of type '" "Gosu::TextInput const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::TextInput const *","caret_pos", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::TextInput * >(argp1);
   {
@@ -6847,9 +7171,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_TextInput_selection_start(int argc, VALUE *argv, VALUE self) {
   Gosu::TextInput *arg1 = (Gosu::TextInput *) 0 ;
-  unsigned int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  unsigned int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -6857,7 +7181,7 @@ _wrap_TextInput_selection_start(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__TextInput, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "selection_start" "', argument " "1"" of type '" "Gosu::TextInput const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::TextInput const *","selection_start", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::TextInput * >(argp1);
   {
@@ -6900,7 +7224,6 @@ _wrap_new_Window(int argc, VALUE *argv, VALUE self) {
   unsigned int arg3 ;
   bool arg4 ;
   double arg5 = (double) 16.666666 ;
-  Gosu::Window *result = 0 ;
   unsigned int val2 ;
   int ecode2 = 0 ;
   unsigned int val3 ;
@@ -6910,6 +7233,7 @@ _wrap_new_Window(int argc, VALUE *argv, VALUE self) {
   double val5 ;
   int ecode5 = 0 ;
   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;
@@ -6917,23 +7241,23 @@ _wrap_new_Window(int argc, VALUE *argv, VALUE self) {
   arg1 = self;
   ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Gosu::Window" "', argument " "2"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","Gosu::Window", 2, argv[0] ));
   } 
   arg2 = static_cast< unsigned int >(val2);
   ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Gosu::Window" "', argument " "3"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","Gosu::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), "in method '" "Gosu::Window" "', argument " "4"" of type '" "bool""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Gosu::Window", 4, argv[2] ));
   } 
   arg4 = static_cast< bool >(val4);
   if (argc > 3) {
     ecode5 = SWIG_AsVal_double(argv[3], &val5);
     if (!SWIG_IsOK(ecode5)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Gosu::Window" "', argument " "5"" of type '" "double""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","Gosu::Window", 5, argv[3] ));
     } 
     arg5 = static_cast< double >(val5);
   }
@@ -6945,9 +7269,9 @@ _wrap_new_Window(int argc, VALUE *argv, VALUE self) {
       } else {
         result = (Gosu::Window *)new Gosu::Window(arg2,arg3,arg4,arg5); 
       }
+      
       DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
-      
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -6967,9 +7291,9 @@ free_Gosu_Window(Gosu::Window *arg1) {
 SWIGINTERN VALUE
 _wrap_Window_caption(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  std::wstring result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  std::wstring result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -6977,7 +7301,7 @@ _wrap_Window_caption(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "caption" "', argument " "1"" of type '" "Gosu::Window const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","caption", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -7009,7 +7333,7 @@ _wrap_Window_captione___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setCaption" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","setCaption", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -7030,6 +7354,36 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Window_update_interval(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 *","updateInterval", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  {
+    try {
+      result = (double)((Gosu::Window const *)arg1)->updateInterval();
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Window_show(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
@@ -7041,7 +7395,7 @@ _wrap_Window_show(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "show" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","show", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -7068,7 +7422,7 @@ _wrap_Window_close(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "close" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","close", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -7097,7 +7451,7 @@ _wrap_Window_update(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "update" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","update", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   director = dynamic_cast<Swig::Director *>(arg1);
@@ -7137,7 +7491,7 @@ _wrap_Window_draw(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "draw" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","draw", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   director = dynamic_cast<Swig::Director *>(arg1);
@@ -7164,6 +7518,49 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Window_needs_redrawq___(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  bool 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 *","needsRedraw", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  director = dynamic_cast<Swig::Director *>(arg1);
+  upcall = (director && (director->swig_get_self() == self));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = (bool)((Gosu::Window const *)arg1)->Gosu::Window::needsRedraw();
+        } else {
+          result = (bool)((Gosu::Window const *)arg1)->needsRedraw();
+        }
+      } catch(const std::runtime_error& e) {
+        SWIG_exception(SWIG_RuntimeError, e.what());
+      }
+    }
+  } catch (Swig::DirectorException& e) {
+    rb_exc_raise(e.getError());
+    SWIG_fail;
+  }
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Window_button_down(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
@@ -7178,7 +7575,7 @@ _wrap_Window_button_down(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "buttonDown" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","buttonDown", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -7225,7 +7622,7 @@ _wrap_Window_button_up(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "buttonUp" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","buttonUp", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -7287,17 +7684,17 @@ _wrap_Window_draw_line(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "drawLine" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","drawLine", 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), "in method '" "drawLine" "', argument " "2"" of type '" "double""'");
+    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), "in method '" "drawLine" "', argument " "3"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","drawLine", 3, argv[1] ));
   } 
   arg3 = static_cast< double >(val3);
   {
@@ -7313,12 +7710,12 @@ _wrap_Window_draw_line(int argc, VALUE *argv, VALUE self) {
   }
   ecode5 = SWIG_AsVal_double(argv[3], &val5);
   if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "drawLine" "', argument " "5"" of type '" "double""'");
+    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), "in method '" "drawLine" "', argument " "6"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","drawLine", 6, argv[4] ));
   } 
   arg6 = static_cast< double >(val6);
   {
@@ -7335,7 +7732,7 @@ _wrap_Window_draw_line(int argc, VALUE *argv, VALUE self) {
   if (argc > 6) {
     ecode8 = SWIG_AsVal_double(argv[6], &val8);
     if (!SWIG_IsOK(ecode8)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "drawLine" "', argument " "8"" of type '" "Gosu::ZPos""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Gosu::ZPos","drawLine", 8, argv[6] ));
     } 
     arg8 = static_cast< Gosu::ZPos >(val8);
   }
@@ -7399,17 +7796,17 @@ _wrap_Window_draw_triangle(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "drawTriangle" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","drawTriangle", 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), "in method '" "drawTriangle" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","drawTriangle", 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), "in method '" "drawTriangle" "', argument " "3"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","drawTriangle", 3, argv[1] ));
   } 
   arg3 = static_cast< double >(val3);
   {
@@ -7425,12 +7822,12 @@ _wrap_Window_draw_triangle(int argc, VALUE *argv, VALUE self) {
   }
   ecode5 = SWIG_AsVal_double(argv[3], &val5);
   if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "drawTriangle" "', argument " "5"" of type '" "double""'");
+    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), "in method '" "drawTriangle" "', argument " "6"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","drawTriangle", 6, argv[4] ));
   } 
   arg6 = static_cast< double >(val6);
   {
@@ -7446,12 +7843,12 @@ _wrap_Window_draw_triangle(int argc, VALUE *argv, VALUE self) {
   }
   ecode8 = SWIG_AsVal_double(argv[6], &val8);
   if (!SWIG_IsOK(ecode8)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "drawTriangle" "', argument " "8"" of type '" "double""'");
+    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), "in method '" "drawTriangle" "', argument " "9"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "double","drawTriangle", 9, argv[7] ));
   } 
   arg9 = static_cast< double >(val9);
   {
@@ -7468,7 +7865,7 @@ _wrap_Window_draw_triangle(int argc, VALUE *argv, VALUE self) {
   if (argc > 9) {
     ecode11 = SWIG_AsVal_double(argv[9], &val11);
     if (!SWIG_IsOK(ecode11)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "drawTriangle" "', argument " "11"" of type '" "Gosu::ZPos""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Gosu::ZPos","drawTriangle", 11, argv[9] ));
     } 
     arg11 = static_cast< Gosu::ZPos >(val11);
   }
@@ -7539,17 +7936,17 @@ _wrap_Window_draw_quad(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "drawQuad" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","drawQuad", 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), "in method '" "drawQuad" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","drawQuad", 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), "in method '" "drawQuad" "', argument " "3"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","drawQuad", 3, argv[1] ));
   } 
   arg3 = static_cast< double >(val3);
   {
@@ -7565,12 +7962,12 @@ _wrap_Window_draw_quad(int argc, VALUE *argv, VALUE self) {
   }
   ecode5 = SWIG_AsVal_double(argv[3], &val5);
   if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "drawQuad" "', argument " "5"" of type '" "double""'");
+    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), "in method '" "drawQuad" "', argument " "6"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","drawQuad", 6, argv[4] ));
   } 
   arg6 = static_cast< double >(val6);
   {
@@ -7586,12 +7983,12 @@ _wrap_Window_draw_quad(int argc, VALUE *argv, VALUE self) {
   }
   ecode8 = SWIG_AsVal_double(argv[6], &val8);
   if (!SWIG_IsOK(ecode8)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "drawQuad" "', argument " "8"" of type '" "double""'");
+    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), "in method '" "drawQuad" "', argument " "9"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "double","drawQuad", 9, argv[7] ));
   } 
   arg9 = static_cast< double >(val9);
   {
@@ -7607,12 +8004,12 @@ _wrap_Window_draw_quad(int argc, VALUE *argv, VALUE self) {
   }
   ecode11 = SWIG_AsVal_double(argv[9], &val11);
   if (!SWIG_IsOK(ecode11)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "drawQuad" "', argument " "11"" of type '" "double""'");
+    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), "in method '" "drawQuad" "', argument " "12"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "double","drawQuad", 12, argv[10] ));
   } 
   arg12 = static_cast< double >(val12);
   {
@@ -7629,7 +8026,7 @@ _wrap_Window_draw_quad(int argc, VALUE *argv, VALUE self) {
   if (argc > 12) {
     ecode14 = SWIG_AsVal_double(argv[12], &val14);
     if (!SWIG_IsOK(ecode14)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "drawQuad" "', argument " "14"" of type '" "Gosu::ZPos""'");
+      SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "Gosu::ZPos","drawQuad", 14, argv[12] ));
     } 
     arg14 = static_cast< Gosu::ZPos >(val14);
   }
@@ -7661,9 +8058,9 @@ SWIGINTERN VALUE
 _wrap_Window_button_downq___(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
   Gosu::Button arg2 ;
-  bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  bool result;
   VALUE vresult = Qnil;
   
   if ((argc < 1) || (argc > 1)) {
@@ -7671,7 +8068,7 @@ _wrap_Window_button_downq___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isButtonDown" "', argument " "1"" of type '" "Gosu::Window const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","isButtonDown", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -7696,29 +8093,21 @@ fail:
 
 SWIGINTERN VALUE
 _wrap_Window_char_to_button_id(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  wchar_t arg2 ;
+  wchar_t arg1 ;
   Gosu::Button result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
   VALUE vresult = Qnil;
   
   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), "in method '" "charToButtonId" "', argument " "1"" of type '" "Gosu::Window *""'"); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     VALUE localTemporary = rb_obj_as_string(argv[0]);
     std::wstring localTemporary2 = Gosu::utf8ToWstring(StringValueCStr(localTemporary));
-    arg2 = localTemporary2.empty() ? 0 : localTemporary2.at(0);
+    arg1 = localTemporary2.empty() ? 0 : localTemporary2.at(0);
   }
   {
     try {
-      result = Gosu_Window_charToButtonId(arg1,arg2);
+      result = Gosu_Window_charToButtonId(arg1);
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -7736,30 +8125,22 @@ fail:
 
 SWIGINTERN VALUE
 _wrap_Window_button_id_to_char(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  Gosu::Button arg2 ;
+  Gosu::Button arg1 ;
   wchar_t result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
   VALUE vresult = Qnil;
   
   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), "in method '" "buttonIdToChar" "', argument " "1"" of type '" "Gosu::Window *""'"); 
-  }
-  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     if (NIL_P(argv[0]))
-    arg2 = Gosu::noButton;
+    arg1 = Gosu::noButton;
     else
-    arg2 = Gosu::Button(NUM2LONG(argv[0]));
+    arg1 = Gosu::Button(NUM2LONG(argv[0]));
   }
   {
     try {
-      result = Gosu_Window_buttonIdToChar(arg1,arg2);
+      result = Gosu_Window_buttonIdToChar(arg1);
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -7779,9 +8160,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Window_text_input(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  Gosu::TextInput *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  Gosu::TextInput *result = 0 ;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -7789,7 +8170,7 @@ _wrap_Window_text_input(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "textInput" "', argument " "1"" of type '" "Gosu::Window const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","textInput", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -7820,12 +8201,12 @@ _wrap_Window_text_inpute___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setTextInput" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    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), "in method '" "setTextInput" "', argument " "2"" of type '" "Gosu::TextInput *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Gosu::TextInput *","setTextInput", 2, argv[0] )); 
   }
   arg2 = reinterpret_cast< Gosu::TextInput * >(argp2);
   {
@@ -7844,9 +8225,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Window_mouse_x(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  double result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -7854,7 +8235,7 @@ _wrap_Window_mouse_x(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mouseX" "', argument " "1"" of type '" "Gosu::Window const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","mouseX", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -7874,9 +8255,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Window_mouse_y(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  double result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  double result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -7884,7 +8265,7 @@ _wrap_Window_mouse_y(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mouseY" "', argument " "1"" of type '" "Gosu::Window const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","mouseY", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -7918,17 +8299,17 @@ _wrap_Window_set_mouse_position(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setMousePosition" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    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), "in method '" "setMousePosition" "', argument " "2"" of type '" "double""'");
+    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), "in method '" "setMousePosition" "', argument " "3"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","setMousePosition", 3, argv[1] ));
   } 
   arg3 = static_cast< double >(val3);
   {
@@ -7958,12 +8339,12 @@ _wrap_Window_mouse_xe___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setMouseX" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    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), "in method '" "setMouseX" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","setMouseX", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
   {
@@ -7993,12 +8374,12 @@ _wrap_Window_mouse_ye___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setMouseY" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","setMouseY", 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), "in method '" "setMouseY" "', argument " "2"" of type '" "double""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","setMouseY", 2, argv[0] ));
   } 
   arg2 = static_cast< double >(val2);
   {
@@ -8017,9 +8398,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Window_width(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -8027,7 +8408,7 @@ _wrap_Window_width(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "width" "', argument " "1"" of type '" "Gosu::Window const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","width", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -8047,9 +8428,9 @@ fail:
 SWIGINTERN VALUE
 _wrap_Window_height(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
-  int result;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -8057,7 +8438,7 @@ _wrap_Window_height(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "height" "', argument " "1"" of type '" "Gosu::Window const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","height", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -8085,7 +8466,7 @@ _wrap_Window_gl(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gl" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","gl", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -8124,27 +8505,27 @@ _wrap_Window_clip_to(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clipTo" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","clipTo", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   ecode2 = SWIG_AsVal_int(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "clipTo" "', argument " "2"" of type '" "int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","clipTo", 2, argv[0] ));
   } 
   arg2 = static_cast< int >(val2);
   ecode3 = SWIG_AsVal_int(argv[1], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "clipTo" "', argument " "3"" of type '" "int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","clipTo", 3, argv[1] ));
   } 
   arg3 = static_cast< int >(val3);
   ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "clipTo" "', argument " "4"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","clipTo", 4, argv[2] ));
   } 
   arg4 = static_cast< unsigned int >(val4);
   ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
   if (!SWIG_IsOK(ecode5)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "clipTo" "', argument " "5"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "unsigned int","clipTo", 5, argv[3] ));
   } 
   arg5 = static_cast< unsigned int >(val5);
   {
@@ -8171,7 +8552,7 @@ _wrap_disown_Window(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Window" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window *","disown_Window", 1, argv[0] )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -8200,7 +8581,7 @@ static swig_type_info _swigt__p_Gosu__Song = {"_p_Gosu__Song", "Gosu::Song *", 0
 static swig_type_info _swigt__p_Gosu__TextInput = {"_p_Gosu__TextInput", "Gosu::TextInput *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Gosu__Window = {"_p_Gosu__Window", "Gosu::Window *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_double = {"_p_double", "double *|Gosu::ZPos *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "Gosu::ZPos *|double *", 0, 0, (void*)0, 0};
 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[] = {
@@ -8312,7 +8693,7 @@ SWIGRUNTIME void
 SWIG_InitializeModule(void *clientdata) {
   size_t i;
   swig_module_info *module_head, *iter;
-  int found;
+  int found, init;
 
   clientdata = clientdata;
 
@@ -8322,6 +8703,9 @@ SWIG_InitializeModule(void *clientdata) {
     swig_module.type_initial = swig_type_initial;
     swig_module.cast_initial = swig_cast_initial;
     swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
   }
 
   /* Try and load any already created modules */
@@ -8350,6 +8734,12 @@ SWIG_InitializeModule(void *clientdata) {
     module_head->next = &swig_module;
   }
 
+  /* When multiple interpeters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
   /* Now work on filling in swig_module.types */
 #ifdef SWIGRUNTIME_DEBUG
   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
@@ -8483,7 +8873,9 @@ SWIG_PropagateClientData(void) {
 }
 #endif
 
+/*
 
+*/
 #ifdef __cplusplus
 extern "C"
 #endif
@@ -8508,6 +8900,8 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_module_function(mGosu, "normalize_angle", VALUEFUNC(_wrap_normalize_angle), -1);
   rb_define_module_function(mGosu, "distance", VALUEFUNC(_wrap_distance), -1);
   rb_define_module_function(mGosu, "default_font_name", VALUEFUNC(_wrap_default_font_name), -1);
+  rb_define_module_function(mGosu, "screen_width", VALUEFUNC(_wrap_screen_width), -1);
+  rb_define_module_function(mGosu, "screen_height", VALUEFUNC(_wrap_screen_height), -1);
   
   cColor.klass = rb_define_class_under(mGosu, "Color", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_Gosu__Color, (void *) &cColor);
@@ -8538,16 +8932,16 @@ SWIGEXPORT void Init_gosu(void) {
   cColor.trackObjects = 1;
   rb_define_module_function(mGosu, "interpolate", VALUEFUNC(_wrap_interpolate), -1);
   rb_define_module_function(mGosu, "multiply", VALUEFUNC(_wrap_multiply), -1);
-  rb_define_singleton_method(mGosu, "none", VALUEFUNC(none_get), 0);
-  rb_define_singleton_method(mGosu, "black", VALUEFUNC(black_get), 0);
-  rb_define_singleton_method(mGosu, "gray", VALUEFUNC(gray_get), 0);
-  rb_define_singleton_method(mGosu, "white", VALUEFUNC(white_get), 0);
-  rb_define_singleton_method(mGosu, "red", VALUEFUNC(red_get), 0);
-  rb_define_singleton_method(mGosu, "green", VALUEFUNC(green_get), 0);
-  rb_define_singleton_method(mGosu, "blue", VALUEFUNC(blue_get), 0);
-  rb_define_singleton_method(mGosu, "yellow", VALUEFUNC(yellow_get), 0);
-  rb_define_singleton_method(mGosu, "fuchsia", VALUEFUNC(fuchsia_get), 0);
-  rb_define_singleton_method(mGosu, "cyan", VALUEFUNC(cyan_get), 0);
+  rb_define_singleton_method(mGosu, "none", VALUEFUNC(_wrap_none_get), 0);
+  rb_define_singleton_method(mGosu, "black", VALUEFUNC(_wrap_black_get), 0);
+  rb_define_singleton_method(mGosu, "gray", VALUEFUNC(_wrap_gray_get), 0);
+  rb_define_singleton_method(mGosu, "white", VALUEFUNC(_wrap_white_get), 0);
+  rb_define_singleton_method(mGosu, "red", VALUEFUNC(_wrap_red_get), 0);
+  rb_define_singleton_method(mGosu, "green", VALUEFUNC(_wrap_green_get), 0);
+  rb_define_singleton_method(mGosu, "blue", VALUEFUNC(_wrap_blue_get), 0);
+  rb_define_singleton_method(mGosu, "yellow", VALUEFUNC(_wrap_yellow_get), 0);
+  rb_define_singleton_method(mGosu, "fuchsia", VALUEFUNC(_wrap_fuchsia_get), 0);
+  rb_define_singleton_method(mGosu, "cyan", VALUEFUNC(_wrap_cyan_get), 0);
   
   cFont.klass = rb_define_class_under(mGosu, "Font", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_Gosu__Font, (void *) &cFont);
@@ -8591,8 +8985,8 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(cImage.klass, "draw_rot", VALUEFUNC(_wrap_Image_draw_rot), -1);
   rb_define_method(cImage.klass, "draw_as_quad", VALUEFUNC(_wrap_Image_draw_as_quad), -1);
   rb_define_method(cImage.klass, "gl_tex_info", VALUEFUNC(_wrap_Image_gl_tex_info), -1);
-  rb_define_singleton_method(cImage.klass, "from_text_4", VALUEFUNC(_wrap_Image_from_text_4), -1);
-  rb_define_singleton_method(cImage.klass, "from_text_7", VALUEFUNC(_wrap_Image_from_text_7), -1);
+  rb_define_singleton_method(cImage.klass, "from_text4", VALUEFUNC(_wrap_Image_from_text4), -1);
+  rb_define_singleton_method(cImage.klass, "from_text7", VALUEFUNC(_wrap_Image_from_text7), -1);
   rb_define_singleton_method(cImage.klass, "load_tiles", VALUEFUNC(_wrap_Image_load_tiles), -1);
   cImage.mark = 0;
   cImage.destroy = (void (*)(void *)) free_Gosu_Image;
@@ -8768,7 +9162,12 @@ SWIGEXPORT void Init_gosu(void) {
   rb_eval_string("module Gosu::Button; Gosu.constants.each { |c| const_set(c, Gosu.const_get(c)) }; end");
   
   // ARGH, SWIG workaround...
-  rb_eval_string("class Gosu::Image; def self.from_text(*args); args.size == 4 ? from_text_4(*args) : from_text_7(*args); end; end");
+  // It doesn't understand the C++ overloading otherwise.
+  rb_eval_string("class Gosu::Image; def self.from_text(*args); args.size == 4 ? from_text4(*args) : from_text7(*args); end; end");
+  
+  // ARGH, SWIG workaround 2..
+  // It won't let me have a class method and method with the same name.
+  rb_eval_string("class Gosu::Window; def button_id_to_char(id); self.class.button_id_to_char(id); end; def char_to_button_id(ch); self.class.char_to_button_id(ch); end; end");
   
   // Extend Numeric with simple angle conversion methods.
   rb_eval_string("class ::Numeric;def gosu_to_radians;(self-90)*Math::PI/180.0;end;def radians_to_gosu;self*180.0/Math::PI+90;end;end");
@@ -8795,18 +9194,20 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(cWindow.klass, "initialize", VALUEFUNC(_wrap_new_Window), -1);
   rb_define_method(cWindow.klass, "caption", VALUEFUNC(_wrap_Window_caption), -1);
   rb_define_method(cWindow.klass, "caption=", VALUEFUNC(_wrap_Window_captione___), -1);
+  rb_define_method(cWindow.klass, "update_interval", VALUEFUNC(_wrap_Window_update_interval), -1);
   rb_define_method(cWindow.klass, "show", VALUEFUNC(_wrap_Window_show), -1);
   rb_define_method(cWindow.klass, "close", VALUEFUNC(_wrap_Window_close), -1);
   rb_define_method(cWindow.klass, "update", VALUEFUNC(_wrap_Window_update), -1);
   rb_define_method(cWindow.klass, "draw", VALUEFUNC(_wrap_Window_draw), -1);
+  rb_define_method(cWindow.klass, "needs_redraw?", VALUEFUNC(_wrap_Window_needs_redrawq___), -1);
   rb_define_method(cWindow.klass, "button_down", VALUEFUNC(_wrap_Window_button_down), -1);
   rb_define_method(cWindow.klass, "button_up", VALUEFUNC(_wrap_Window_button_up), -1);
   rb_define_method(cWindow.klass, "draw_line", VALUEFUNC(_wrap_Window_draw_line), -1);
   rb_define_method(cWindow.klass, "draw_triangle", VALUEFUNC(_wrap_Window_draw_triangle), -1);
   rb_define_method(cWindow.klass, "draw_quad", VALUEFUNC(_wrap_Window_draw_quad), -1);
   rb_define_method(cWindow.klass, "button_down?", VALUEFUNC(_wrap_Window_button_downq___), -1);
-  rb_define_method(cWindow.klass, "char_to_button_id", VALUEFUNC(_wrap_Window_char_to_button_id), -1);
-  rb_define_method(cWindow.klass, "button_id_to_char", VALUEFUNC(_wrap_Window_button_id_to_char), -1);
+  rb_define_singleton_method(cWindow.klass, "char_to_button_id", VALUEFUNC(_wrap_Window_char_to_button_id), -1);
+  rb_define_singleton_method(cWindow.klass, "button_id_to_char", VALUEFUNC(_wrap_Window_button_id_to_char), -1);
   rb_define_method(cWindow.klass, "text_input", VALUEFUNC(_wrap_Window_text_input), -1);
   rb_define_method(cWindow.klass, "text_input=", VALUEFUNC(_wrap_Window_text_inpute___), -1);
   rb_define_method(cWindow.klass, "mouse_x", VALUEFUNC(_wrap_Window_mouse_x), -1);