gosu 0.7.15 → 0.7.16

data/GosuImpl/ObjGosu/ObjGosuSample.mm

@@ -0,0 +1,32 @@
+#import <Cocoa/Cocoa.h>
+#import <Gosu/Audio.hpp>
+#import <Gosu/Utility.hpp>
+#import <Gosu/Window.hpp>
+
+@interface ObjGosuSample : NSObject {
+    Gosu::Sample* _sample;
+}
+@end
+
+@implementation ObjGosuSample
+- (id)initWithWindow:(id)window filename:(NSString*)filename
+{
+    if (not (self = [super init]))
+        return NULL;
+    
+    _sample = new Gosu::Sample(((Gosu::Window*)[[window _objcObject] _cppObject])->audio(),
+        Gosu::widen([filename UTF8String]));
+    
+    return self;
+}
+
+- (void)playWithVolume: (float)volume speed:(float)speed looping:(BOOL)looping
+{
+    _sample->play(volume, speed, looping);
+}
+
+- (void)playWithPan: (float)pan volume: (float)volume speed:(float)speed looping:(BOOL)looping
+{
+    _sample->playPan(pan, volume, speed, looping);
+}
+@end

data/GosuImpl/ObjGosu/ObjGosuSong.mm

@@ -0,0 +1,43 @@
+#import <Cocoa/Cocoa.h>
+#import <Gosu/Audio.hpp>
+#import <Gosu/Utility.hpp>
+#import <Gosu/Window.hpp>
+
+@interface ObjGosuSong : NSObject {
+    Gosu::Song* _song;
+}
+@end
+
+@implementation ObjGosuSong
+- (id)initWithWindow:(id)window filename:(NSString*)filename
+{
+    if (not (self = [super init]))
+        return NULL;
+    
+    _song = new Gosu::Song(((Gosu::Window*)[[window _objcObject] _cppObject])->audio(),
+        Gosu::widen([filename UTF8String]));
+    
+    return self;
+}
+
+- (void)playWithLoop: (BOOL)looping
+{
+    _song->play(looping);
+}
+
+- (void)stop
+{
+    _song->stop();
+}
+
+- (float)volume
+{
+    _song->volume();
+}
+
+- (void)setVolume:(float)volume
+{
+    _song->changeVolume(volume);
+}
+
+@end

data/GosuImpl/ObjGosu/ObjGosuWindow.h

@@ -0,0 +1,32 @@
+#import <Cocoa/Cocoa.h>
+#import <Gosu/Fwd.hpp>
+
+class _ObjGosuInternalWindow;
+
+@interface ObjGosuWindow : NSObject {
+    _ObjGosuInternalWindow* _window;
+}
+- (Gosu::Window*)_cppObject;
+
+- (NSString*) caption;
+- (void) setCaption: (NSString*) caption;
+- (unsigned) height;
+- (float) mouseX;
+- (void) setMouseX: (float)mouseX;
+- (float) mouseY;
+- (void) setMouseY: (float)mouseY;
+- (id) textInput;
+- (void) setTextInput: (id)textInput;
+- (float) updateInterval;
+- (unsigned) width;
+
+- (id) initWithDelegate:(id)delegate width:(int)width height:(int)height
+    inFullscreen:(BOOL)fullscreen updateInterval:(float)updateInterval;
+- (void) show;
+
+- (void) drawQuadAtX1: (float)x1 y1: (float)y1 color1:(unsigned)c1
+                   x2: (float)x2 y2: (float)y2 color2:(unsigned)c2
+                   x3: (float)x3 y3: (float)y3 color3:(unsigned)c3
+                   x4: (float)x4 y4: (float)y4 color4:(unsigned)c4
+                   z: (float)z mode: (int)mode;
+@end

data/GosuImpl/ObjGosu/ObjGosuWindow.mm

@@ -0,0 +1,155 @@
+#import "ObjGosuWindow.h"
+#import <Gosu/Graphics.hpp>
+#import <Gosu/Input.hpp>
+#import <Gosu/Utility.hpp>
+#import <Gosu/Window.hpp>
+#import <MacRuby/MacRuby.h>
+
+class _ObjGosuInternalWindow : public Gosu::Window
+{
+    id delegate;
+
+public:
+    _ObjGosuInternalWindow(id delegate, unsigned width, unsigned height, 
+        bool fullscreen, double updateInterval)
+    : Gosu::Window(width, height, fullscreen, updateInterval), delegate(delegate)
+    {
+    }
+    
+    void update()
+    {
+        [delegate update];
+    }
+    
+    void draw()
+    {
+        [delegate draw];
+    }
+    
+    void buttonUp(Gosu::Button btn)
+    {
+        [delegate buttonUp: [NSNumber numberWithUnsignedInt: btn.getId()]];
+    }
+    
+    void buttonDown(Gosu::Button btn)
+    {
+        [delegate buttonDown: [NSNumber numberWithUnsignedInt: btn.getId()]];
+    }
+    
+    BOOL needsRedraw()
+    {
+        return [delegate needsRedraw] != nil;
+    }
+};
+
+@implementation ObjGosuWindow
+- (Gosu::Window*)_cppObject
+{
+    return _window;
+}
+
+- (NSString*)caption
+{
+    return nil; // TODO_window->caption();
+}
+
+- (void)setCaption: (NSString*) caption
+{
+    _window->setCaption(Gosu::utf8ToWstring([caption UTF8String]));
+}
+
+- (unsigned)height
+{
+    return _window->graphics().height();
+}
+
+- (float)mouseX
+{
+    return _window->input().mouseX();
+}
+
+- (void)setMouseX: (float)mouseX
+{
+    _window->input().setMousePosition(mouseX, _window->input().mouseY());
+}
+
+- (float)mouseY
+{
+    return _window->input().mouseY();
+}
+
+- (void)setMouseY: (float)mouseY
+{
+    _window->input().setMousePosition(_window->input().mouseX(), mouseY);
+}
+
+- (id)textInput
+{
+    // TODO
+    return nil;
+}
+
+- (void)setTextInput: (id)textInput
+{
+    // TODO
+}
+
+- (float)updateInterval
+{
+    return _window->updateInterval();
+}
+
+- (unsigned)width
+{
+    return _window->graphics().width();
+}
+
+- (id)initWithDelegate: (id)delegate width:(int)width height:(int)height inFullscreen:(BOOL)fullscreen updateInterval:(float)updateInterval
+{
+    if (not (self = [super init]))
+        return NULL;
+    _window = new _ObjGosuInternalWindow(delegate, width, height, fullscreen, updateInterval);
+    return self;
+}
+
+- (void)show
+{
+    _window->show();
+}
+
+- (void)close
+{
+    _window->close();
+}
+
+- (void)update
+{
+}
+
+- (void)draw
+{
+}
+
+- (NSNumber*)isButtonDown: (unsigned)button
+{
+    return [NSNumber numberWithBool: _window->input().down(Gosu::Button(button))];
+}
+@end
+
+extern "C" void Init_gosu()
+{
+//    [[MacRuby sharedRuntime] evaluateString:
+//        @"module Gosu\n"
+//        @"  class Window < ::ObjGosuWindow\n"
+//        @"    def initialize(width, height, fullscreen, update_interval)\n"
+//        @"      initWithWidth width, height: height, inFullscreen: fullscreen, updateInterval: update_interval\n"
+//        @"    end\n"
+//        @"    def mouse_x; mouseX; end\n"
+//        @"    def mouse_y; mouseY; end\n"
+//        @"    def draw_quad(x1, y1, c1, x2, y2, c2, x3, y3, c3, x4, y4, c4, z, mode)\n"
+//        @"      drawQuadAtX1(x1, y1: y1, color1: c1, x2: x2, y2: y2, color2: c2, x3: x3, y3: y3, color3: c3, x4: x4, y4: y4, color4: c4, z: z, mode: mode)\n"
+//        @"    end\n"
+//        @"  end\n"
+//        @"end\n"
+//    ];
+}

data/GosuImpl/RubyGosu.swg

@@ -11,9 +11,12 @@
 // The docs make it seem like this is a generally good idea.
 %feature("compactdefaultargs");
 
-// Overriding virtuals is only necessary in Gosu::Window.
+// Overriding virtuals is necessary in Gosu::Window.
 %feature("director") Gosu::Window;
 
+// Overriding virtuals is necessary in Gosu::TextInput.
+%feature("director") Gosu::TextInput;
+
 // Resolve typedefs that SWIG doesn't recognize.
 %apply unsigned char { boost::uint8_t };
 %apply unsigned long { boost::uint32_t };
@@ -40,6 +43,16 @@
 %typemap(out) std::wstring {
     $result = rb_str_new2(Gosu::wstringToUTF8($1).c_str());
 }
+%typemap(out) const std::wstring& {
+    $result = rb_str_new2(Gosu::wstringToUTF8($1).c_str());
+}
+%typemap(directorin) const std::wstring& {
+    $input = rb_str_new2(Gosu::wstringToUTF8($1).c_str());
+}
+%typemap(directorout) std::wstring {
+    VALUE localTemporary = rb_obj_as_string($1);
+    $result = Gosu::utf8ToWstring(StringValueCStr(localTemporary));;
+}
 
 %typemap(in) Gosu::Button {
     if (NIL_P($input))
@@ -143,6 +156,12 @@
 #include <Gosu/Version.hpp>
 #include <Gosu/Window.hpp>
 
+// For Ruby-only MAX_TEXTURE_SIZE
+#include <Gosu/../GosuImpl/Graphics/Texture.hpp>
+namespace Gosu {
+    unsigned __maxTextureSize() { return Gosu::Texture::maxTextureSize(); }
+}
+
 #include <sstream>
 
 // New Ruby 1.9 syntax (for compilation with Ruby 1.8)
@@ -256,8 +275,17 @@ namespace Gosu
 // For screenWidth/screenHeight
 %ignore Gosu::Graphics;
 %ignore Gosu::BorderFlags;
+//%ignore Gosu::MAX_TEXTURE_SIZE;
 %include "../Gosu/Graphics.hpp"
 
+// More Ubuntu libgl initialization fail workarounds
+
+//%constant unsigned MAX_TEXTURE_SIZE = Gosu::Texture::maxTextureSize();
+
+namespace Gosu {
+    unsigned __maxTextureSize() { return Gosu::Texture::maxTextureSize(); }
+}
+
 // Color
 %rename("alpha=") setAlpha;
 %rename("red=") setRed;
@@ -267,7 +295,21 @@ namespace Gosu
 %rename("saturation=") setSaturation;
 %rename("value=") setValue;
 %include "std_string.i"
+
+%ignore Gosu::Color::NONE;
+%ignore Gosu::Color::BLACK;
+%ignore Gosu::Color::GRAY;
+%ignore Gosu::Color::WHITE;
+%ignore Gosu::Color::AQUA;
+%ignore Gosu::Color::RED;
+%ignore Gosu::Color::GREEN;
+%ignore Gosu::Color::BLUE;
+%ignore Gosu::Color::YELLOW;
+%ignore Gosu::Color::FUCHSIA;
+%ignore Gosu::Color::CYAN;
+
 %include "../Gosu/Color.hpp"
+
 %extend Gosu::Color {
     Gosu::Color dup() const {
         return *$self;
@@ -392,25 +434,16 @@ namespace Gosu
 %Ignore Gosu::SongType;
 %ignore Gosu::Sample::Sample(Audio& audio, const std::wstring& filename);
 %ignore Gosu::Sample::Sample(Audio& audio, Reader reader);
+%ignore Gosu::Sample::Sample(Reader reader);
 %ignore Gosu::Song::Song(Audio& audio, const std::wstring& filename);
 %ignore Gosu::Song::Song(Audio& audio, Type type, Reader reader);
+%ignore Gosu::Song::Song(Type type, Reader reader);
 %rename("playing?") playing;
 %rename("paused?") paused;
 %rename("volume=") changeVolume;
 %rename("pan=") changePan;
 %rename("speed=") changeSpeed;
 %include "../Gosu/Audio.hpp"
-%extend Gosu::Sample {
-    Sample(Gosu::Window& window, const std::string& filename) {
-        return new Gosu::Sample(window.audio(), Gosu::utf8ToWstring(filename));
-    }
-}
-%extend Gosu::Song {
-    Song(Gosu::Window& window, const std::string& filename) {
-        return new Gosu::Song(window.audio(), Gosu::utf8ToWstring(filename));
-    }
-}
-
 
 // Input and Window:
 
@@ -418,9 +451,6 @@ 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.
-    rb_eval_string("module Gosu::Button; Gosu.constants.each { |c| const_set(c, Gosu.const_get(c)) }; end");
-
     // ARGH, SWIG workaround...
     // 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");
@@ -428,12 +458,9 @@ namespace Gosu
     // 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_radian_scale; self*Math::PI/180.0; end; end");
-    rb_eval_string("class ::Numeric; def radian_scale_to_gosu; self*180.0/Math::PI; end; end");
-    rb_eval_string("class ::Numeric; def gosu_to_radians; (self-90)*Math::PI/180.0; end; end");
-    rb_eval_string("class ::Numeric; def radians_to_gosu; self*180.0/Math::PI+90;   end; end");
+    
+    // ARGH, Linux workaround: instead of declaring a constant, we declare a hidden function and call it when we need to define the constant.
+    rb_eval_string("module Gosu;def self.const_missing sym;if sym == :MAX_TEXTURE_SIZE then;const_set sym, __max_texture_size;else;super;end;end;end");
     
     GosusDarkSide::oncePerTick = GosusDarkSide::yieldToOtherRubyThreads;
 %}

data/GosuImpl/RubyGosuStub.mm

@@ -5,6 +5,8 @@
 #include "oniguruma.h"
 
 extern "C" void Init_gosu();
+extern "C" void Init_syck();
+extern "C" void Init_socket();
 
 extern "C" int rb_enc_register(const char *, OnigEncodingType*);
 extern "C" void rb_encdb_declare(const char *name);
@@ -42,8 +44,12 @@ int main()
         rb_enc_register(OnigEncodingUTF_32LE.name, &OnigEncodingUTF_32LE);
 
         Init_gosu();
+        Init_syck();
+        Init_socket();
         rb_eval_string("$LOADED_FEATURES << 'gosu.bundle'");
         rb_eval_string("$LOADED_FEATURES << 'rubygems.rb'");
+        rb_eval_string("$LOADED_FEATURES << 'syck.bundle'");
+        rb_eval_string("$LOADED_FEATURES << 'socket.bundle'");
 
         return ruby_run_node(ruby_options(argc, argv)); 
     }

data/GosuImpl/RubyGosu_wrap.cxx

@@ -2152,21 +2152,22 @@ namespace Swig {
 /* -------- TYPES TABLE (BEGIN) -------- */
 
 #define SWIGTYPE_p_Channel swig_types[0]
-#define SWIGTYPE_p_Gosu__Button swig_types[1]
-#define SWIGTYPE_p_Gosu__Color swig_types[2]
-#define SWIGTYPE_p_Gosu__Font swig_types[3]
-#define SWIGTYPE_p_Gosu__GLTexInfo swig_types[4]
-#define SWIGTYPE_p_Gosu__Image swig_types[5]
-#define SWIGTYPE_p_Gosu__Sample swig_types[6]
-#define SWIGTYPE_p_Gosu__SampleInstance swig_types[7]
-#define SWIGTYPE_p_Gosu__Song swig_types[8]
-#define SWIGTYPE_p_Gosu__TextInput swig_types[9]
-#define SWIGTYPE_p_Gosu__Window swig_types[10]
-#define SWIGTYPE_p_char swig_types[11]
-#define SWIGTYPE_p_double swig_types[12]
-#define SWIGTYPE_p_std__wstring swig_types[13]
-static swig_type_info *swig_types[15];
-static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0};
+#define SWIGTYPE_p_Gosu__Audio swig_types[1]
+#define SWIGTYPE_p_Gosu__Button swig_types[2]
+#define SWIGTYPE_p_Gosu__Color swig_types[3]
+#define SWIGTYPE_p_Gosu__Font swig_types[4]
+#define SWIGTYPE_p_Gosu__GLTexInfo swig_types[5]
+#define SWIGTYPE_p_Gosu__Image swig_types[6]
+#define SWIGTYPE_p_Gosu__Sample swig_types[7]
+#define SWIGTYPE_p_Gosu__SampleInstance swig_types[8]
+#define SWIGTYPE_p_Gosu__Song swig_types[9]
+#define SWIGTYPE_p_Gosu__TextInput swig_types[10]
+#define SWIGTYPE_p_Gosu__Window swig_types[11]
+#define SWIGTYPE_p_char swig_types[12]
+#define SWIGTYPE_p_double swig_types[13]
+#define SWIGTYPE_p_std__wstring swig_types[14]
+static swig_type_info *swig_types[16];
+static swig_module_info swig_module = {swig_types, 15, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -2228,6 +2229,12 @@ static VALUE mGosu;
 #include <Gosu/Version.hpp>
 #include <Gosu/Window.hpp>
 
+// For Ruby-only MAX_TEXTURE_SIZE
+#include <Gosu/../GosuImpl/Graphics/Texture.hpp>
+namespace Gosu {
+    unsigned __maxTextureSize() { return Gosu::Texture::maxTextureSize(); }
+}
+
 #include <sstream>
 
 // New Ruby 1.9 syntax (for compilation with Ruby 1.8)
@@ -2604,81 +2611,6 @@ SWIG_From_bool  (bool value)
   return value ? Qtrue : Qfalse;
 }
 
-
-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) {
-	if (*alloc == SWIG_NEWOBJ) {
-	  *cptr = reinterpret_cast< char* >(memcpy((new char[size]), cstr, sizeof(char)*(size)));
-	} else {
-	  *cptr = cstr;
-	  *alloc = SWIG_OLDOBJ;
-	}
-      }
-    }
-    if (psize) *psize = size;
-    return SWIG_OK;
-  } else {
-    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
-    if (pchar_descriptor) {
-      void* vptr = 0;
-      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
-	if (cptr) *cptr = (char *)vptr;
-	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
-	if (alloc) *alloc = SWIG_OLDOBJ;
-	return SWIG_OK;
-      }
-    }
-  }  
-  return SWIG_TypeError;
-}
-
-
-SWIGINTERN int
-SWIG_AsPtr_std_string (VALUE obj, std::string **val) 
-{
-  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
-  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
-    if (buf) {
-      if (val) *val = new std::string(buf, size - 1);
-      if (alloc == SWIG_NEWOBJ) delete[] buf;
-      return SWIG_NEWOBJ;
-    } else {
-      if (val) *val = 0;
-      return SWIG_OLDOBJ;
-    }
-  } else {
-    static int init = 0;
-    static swig_type_info* descriptor = 0;
-    if (!init) {
-      descriptor = SWIG_TypeQuery("std::string" " *");
-      init = 1;
-    }
-    if (descriptor) {
-      std::string *vptr;
-      int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
-      if (SWIG_IsOK(res) && val) *val = vptr;
-      return res;
-    }
-  }
-  return SWIG_ERROR;
-}
-
-SWIGINTERN Gosu::Sample *new_Gosu_Sample(Gosu::Window &window,std::string const &filename){
-        return new Gosu::Sample(window.audio(), Gosu::utf8ToWstring(filename));
-    }
-SWIGINTERN Gosu::Song *new_Gosu_Song(Gosu::Window &window,std::string const &filename){
-        return new Gosu::Song(window.audio(), Gosu::utf8ToWstring(filename));
-    }
 SWIGINTERN unsigned int Gosu_TextInput_caret_pos(Gosu::TextInput const *self){
         return Gosu::wstringToUTF8(self->text().substr(0, self->caretPos())).size();
     }
@@ -2768,6 +2700,32 @@ SWIGINTERN Gosu::Image *Gosu_Window_record(Gosu::Window *self){
 
 #include "RubyGosu_wrap.h"
 
+SwigDirector_TextInput::SwigDirector_TextInput(VALUE self): Gosu::TextInput(), Swig::Director(self) {
+  
+}
+
+
+
+SwigDirector_TextInput::~SwigDirector_TextInput() {
+}
+
+std::wstring SwigDirector_TextInput::filter(std::wstring const &textIn) const {
+  std::wstring c_result ;
+  VALUE obj0 = Qnil ;
+  VALUE result;
+  
+  {
+    obj0 = rb_str_new2(Gosu::wstringToUTF8(textIn).c_str());
+  }
+  result = rb_funcall(swig_get_self(), rb_intern("filter"), 1,obj0);
+  {
+    VALUE localTemporary = rb_obj_as_string(result);
+    c_result = Gosu::utf8ToWstring(StringValueCStr(localTemporary));;
+  }
+  return (std::wstring) c_result;
+}
+
+
 SwigDirector_Window::SwigDirector_Window(VALUE self, unsigned int width, unsigned int height, bool fullscreen, double updateInterval): Gosu::Window(width, height, fullscreen, updateInterval), Swig::Director(self) {
   
 }
@@ -3282,6 +3240,28 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap___max_texture_size(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::__maxTextureSize();
+    } 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 SwigClassColor;
 
 SWIGINTERN VALUE
@@ -4400,6 +4380,15 @@ _wrap_white_get(VALUE self) {
 }
 
 
+SWIGINTERN VALUE
+_wrap_aqua_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Gosu::Colors::aqua), SWIGTYPE_p_Gosu__Color,  0 );
+  return _val;
+}
+
+
 SWIGINTERN VALUE
 _wrap_red_get(VALUE self) {
   VALUE _val;
@@ -4610,7 +4599,7 @@ _wrap_Font_draw(int argc, VALUE *argv, VALUE self) {
   Gosu::ZPos arg5 ;
   double arg6 = (double) 1 ;
   double arg7 = (double) 1 ;
-  Gosu::Color arg8 = (Gosu::Color) Gosu::Colors::white ;
+  Gosu::Color arg8 = (Gosu::Color) Gosu::Color::WHITE ;
   Gosu::AlphaMode arg9 = (Gosu::AlphaMode) Gosu::amDefault ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -4716,7 +4705,7 @@ _wrap_Font_draw_rel(int argc, VALUE *argv, VALUE self) {
   double arg7 ;
   double arg8 = (double) 1 ;
   double arg9 = (double) 1 ;
-  Gosu::Color arg10 = (Gosu::Color) Gosu::Colors::white ;
+  Gosu::Color arg10 = (Gosu::Color) Gosu::Color::WHITE ;
   Gosu::AlphaMode arg11 = (Gosu::AlphaMode) Gosu::amDefault ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -4835,7 +4824,7 @@ _wrap_Font_draw_rot(int argc, VALUE *argv, VALUE self) {
   double arg6 ;
   double arg7 = (double) 1 ;
   double arg8 = (double) 1 ;
-  Gosu::Color arg9 = (Gosu::Color) Gosu::Colors::white ;
+  Gosu::Color arg9 = (Gosu::Color) Gosu::Color::WHITE ;
   Gosu::AlphaMode arg10 = (Gosu::AlphaMode) Gosu::amDefault ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -5392,7 +5381,7 @@ _wrap_Image_draw(int argc, VALUE *argv, VALUE self) {
   Gosu::ZPos arg4 ;
   double arg5 = (double) 1 ;
   double arg6 = (double) 1 ;
-  Gosu::Color arg7 = (Gosu::Color) Gosu::Colors::white ;
+  Gosu::Color arg7 = (Gosu::Color) Gosu::Color::WHITE ;
   Gosu::AlphaMode arg8 = (Gosu::AlphaMode) Gosu::amDefault ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -5619,7 +5608,7 @@ _wrap_Image_draw_rot(int argc, VALUE *argv, VALUE self) {
   double arg7 = (double) 0.5 ;
   double arg8 = (double) 1 ;
   double arg9 = (double) 1 ;
-  Gosu::Color arg10 = (Gosu::Color) Gosu::Colors::white ;
+  Gosu::Color arg10 = (Gosu::Color) Gosu::Color::WHITE ;
   Gosu::AlphaMode arg11 = (Gosu::AlphaMode) Gosu::amDefault ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -6661,6 +6650,53 @@ free_Gosu_SampleInstance(Gosu::SampleInstance *arg1) {
 
 swig_class SwigClassSample;
 
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+SWIGINTERN VALUE
+_wrap_Sample_allocate(VALUE self) {
+#else
+  SWIGINTERN VALUE
+  _wrap_Sample_allocate(int argc, VALUE *argv, VALUE self) {
+#endif
+    
+    
+    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Gosu__Sample);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+    rb_obj_call_init(vresult, argc, argv);
+#endif
+    return vresult;
+  }
+  
+
+SWIGINTERN VALUE
+_wrap_new_Sample(int argc, VALUE *argv, VALUE self) {
+  std::wstring *arg1 = 0 ;
+  std::wstring temp1 ;
+  const char *classname SWIGUNUSED = "Gosu::Sample";
+  Gosu::Sample *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    VALUE localTemporary = rb_obj_as_string(argv[0]);
+    temp1 = Gosu::utf8ToWstring(StringValueCStr(localTemporary));
+    arg1 = &temp1;
+  }
+  {
+    try {
+      result = (Gosu::Sample *)new Gosu::Sample((std::wstring const &)*arg1);
+      DATA_PTR(self) = result;
+      SWIG_RubyAddTracking(result, self);
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN void
 free_Gosu_Sample(Gosu::Sample *arg1) {
     SWIG_RubyRemoveTracking(arg1);
@@ -6795,16 +6831,18 @@ fail:
 }
 
 
+swig_class SwigClassSong;
+
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 SWIGINTERN VALUE
-_wrap_Sample_allocate(VALUE self) {
+_wrap_Song_allocate(VALUE self) {
 #else
   SWIGINTERN VALUE
-  _wrap_Sample_allocate(int argc, VALUE *argv, VALUE self) {
+  _wrap_Song_allocate(int argc, VALUE *argv, VALUE self) {
 #endif
     
     
-    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Gosu__Sample);
+    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Gosu__Song);
 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
     rb_obj_call_init(vresult, argc, argv);
 #endif
@@ -6813,56 +6851,35 @@ _wrap_Sample_allocate(VALUE self) {
   
 
 SWIGINTERN VALUE
-_wrap_new_Sample(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = 0 ;
-  std::string *arg2 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  int res2 = SWIG_OLDOBJ ;
-  const char *classname SWIGUNUSED = "Gosu::Sample";
-  Gosu::Sample *result = 0 ;
+_wrap_new_Song(int argc, VALUE *argv, VALUE self) {
+  std::wstring *arg1 = 0 ;
+  std::wstring temp1 ;
+  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), Ruby_Format_TypeError( "", "Gosu::Window &","Gosu::Sample", 1, argv[0] )); 
-  }
-  if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Gosu::Window &","Gosu::Sample", 1, argv[0])); 
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
-  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), Ruby_Format_TypeError( "", "std::string const &","Gosu::Sample", 2, argv[1] )); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","Gosu::Sample", 2, argv[1])); 
-    }
-    arg2 = ptr;
+    VALUE localTemporary = rb_obj_as_string(argv[0]);
+    temp1 = Gosu::utf8ToWstring(StringValueCStr(localTemporary));
+    arg1 = &temp1;
   }
   {
     try {
-      result = (Gosu::Sample *)new_Gosu_Sample(*arg1,(std::string const &)*arg2);
+      result = (Gosu::Song *)new Gosu::Song((std::wstring const &)*arg1);
       DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  if (SWIG_IsNewObj(res2)) delete arg2;
   return self;
 fail:
-  if (SWIG_IsNewObj(res2)) delete arg2;
   return Qnil;
 }
 
 
-swig_class SwigClassSong;
-
 SWIGINTERN void
 free_Gosu_Song(Gosu::Song *arg1) {
     SWIG_RubyRemoveTracking(arg1);
@@ -7107,68 +7124,20 @@ fail:
 }
 
 
-#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
 SWIGINTERN VALUE
-_wrap_Song_allocate(VALUE self) {
-#else
-  SWIGINTERN VALUE
-  _wrap_Song_allocate(int argc, VALUE *argv, VALUE self) {
-#endif
-    
-    
-    VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Gosu__Song);
-#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
-    rb_obj_call_init(vresult, argc, argv);
-#endif
-    return vresult;
-  }
-  
-
-SWIGINTERN VALUE
-_wrap_new_Song(int argc, VALUE *argv, VALUE self) {
-  Gosu::Window *arg1 = 0 ;
-  std::string *arg2 = 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), Ruby_Format_TypeError( "", "Gosu::Window &","Gosu::Song", 1, argv[0] )); 
-  }
-  if (!argp1) {
-    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), Ruby_Format_TypeError( "", "std::string const &","Gosu::Song", 2, argv[1] )); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","Gosu::Song", 2, argv[1])); 
-    }
-    arg2 = ptr;
+_wrap_Song_update(int argc, VALUE *argv, VALUE self) {
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
   {
     try {
-      result = (Gosu::Song *)new_Gosu_Song(*arg1,(std::string const &)*arg2);
-      DATA_PTR(self) = result;
-      SWIG_RubyAddTracking(result, self);
+      Gosu::Song::update();
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  if (SWIG_IsNewObj(res2)) delete arg2;
-  return self;
+  return Qnil;
 fail:
-  if (SWIG_IsNewObj(res2)) delete arg2;
   return Qnil;
 }
 
@@ -7194,15 +7163,23 @@ _wrap_TextInput_allocate(VALUE self) {
 
 SWIGINTERN VALUE
 _wrap_new_TextInput(int argc, VALUE *argv, VALUE self) {
+  VALUE arg1 = (VALUE) 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;
   }
+  arg1 = self;
   {
     try {
-      result = (Gosu::TextInput *)new Gosu::TextInput();
+      if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
+        /* subclassed */
+        result = (Gosu::TextInput *)new SwigDirector_TextInput(arg1); 
+      } else {
+        result = (Gosu::TextInput *)new Gosu::TextInput(); 
+      }
+      
       DATA_PTR(self) = result;
       SWIG_RubyAddTracking(result, self);
     } catch(const std::runtime_error& e) {
@@ -7287,6 +7264,58 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_TextInput_filter(int argc, VALUE *argv, VALUE self) {
+  Gosu::TextInput *arg1 = (Gosu::TextInput *) 0 ;
+  std::wstring *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  std::wstring temp2 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  std::wstring result;
+  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__TextInput, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::TextInput const *","filter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::TextInput * >(argp1);
+  {
+    VALUE localTemporary = rb_obj_as_string(argv[0]);
+    temp2 = Gosu::utf8ToWstring(StringValueCStr(localTemporary));
+    arg2 = &temp2;
+  }
+  director = dynamic_cast<Swig::Director *>(arg1);
+  upcall = (director && (director->swig_get_self() == self));
+  try {
+    {
+      try {
+        if (upcall) {
+          result = ((Gosu::TextInput const *)arg1)->Gosu::TextInput::filter((std::wstring const &)*arg2);
+        } else {
+          result = ((Gosu::TextInput const *)arg1)->filter((std::wstring const &)*arg2);
+        }
+      } catch(const std::runtime_error& e) {
+        SWIG_exception(SWIG_RuntimeError, e.what());
+      }
+    }
+  } catch (Swig::DirectorException& e) {
+    rb_exc_raise(e.getError());
+    SWIG_fail;
+  }
+  {
+    vresult = rb_str_new2(Gosu::wstringToUTF8(result).c_str());
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_TextInput_caret_pos(int argc, VALUE *argv, VALUE self) {
   Gosu::TextInput *arg1 = (Gosu::TextInput *) 0 ;
@@ -7347,6 +7376,31 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_disown_TextInput(int argc, VALUE *argv, VALUE self) {
+  Gosu::TextInput *arg1 = (Gosu::TextInput *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Gosu__TextInput, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::TextInput *","disown_TextInput", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< Gosu::TextInput * >(argp1);
+  {
+    Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
 swig_class SwigClassWindow;
 
 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
@@ -7804,6 +7858,105 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Window_audio__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  Gosu::Audio *result = 0 ;
+  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 *","audio", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  {
+    try {
+      result = (Gosu::Audio *) &((Gosu::Window const *)arg1)->audio();
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gosu__Audio, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Window_audio__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  Gosu::Audio *result = 0 ;
+  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 *","audio", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  {
+    try {
+      result = (Gosu::Audio *) &(arg1)->audio();
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gosu__Audio, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_Window_audio(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[2];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 2) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Window, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Window_audio__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Gosu__Window, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_Window_audio__SWIG_0(nargs, args, self);
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 2, "Window.audio", 
+    "    Gosu::Audio & Window.audio()\n"
+    "    Gosu::Audio & Window.audio()\n");
+  
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Window_draw_line(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
@@ -8311,6 +8464,7 @@ _wrap_Window_text_input(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  Swig::Director *director = 0;
   Gosu::TextInput *result = 0 ;
   VALUE vresult = Qnil;
   
@@ -8329,7 +8483,12 @@ _wrap_Window_text_input(int argc, VALUE *argv, VALUE self) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gosu__TextInput, 0 |  0 );
+  director = dynamic_cast<Swig::Director *>(result);
+  if (director) {
+    vresult = director->swig_get_self();
+  } else {
+    vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gosu__TextInput, 0 |  0 );
+  }
   return vresult;
 fail:
   return Qnil;
@@ -8749,6 +8908,7 @@ fail:
 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
 static swig_type_info _swigt__p_Channel = {"_p_Channel", "Channel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_Gosu__Audio = {"_p_Gosu__Audio", "Gosu::Audio *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Gosu__Button = {"_p_Gosu__Button", "Gosu::Button *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Gosu__Color = {"_p_Gosu__Color", "Gosu::Color *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_Gosu__Font = {"_p_Gosu__Font", "Gosu::Font *", 0, 0, (void*)0, 0};
@@ -8765,6 +8925,7 @@ static swig_type_info _swigt__p_std__wstring = {"_p_std__wstring", "std::wstring
 
 static swig_type_info *swig_type_initial[] = {
   &_swigt__p_Channel,
+  &_swigt__p_Gosu__Audio,
   &_swigt__p_Gosu__Button,
   &_swigt__p_Gosu__Color,
   &_swigt__p_Gosu__Font,
@@ -8781,6 +8942,7 @@ static swig_type_info *swig_type_initial[] = {
 };
 
 static swig_cast_info _swigc__p_Channel[] = {  {&_swigt__p_Channel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_Gosu__Audio[] = {  {&_swigt__p_Gosu__Audio, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Gosu__Button[] = {  {&_swigt__p_Gosu__Button, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Gosu__Color[] = {  {&_swigt__p_Gosu__Color, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_Gosu__Font[] = {  {&_swigt__p_Gosu__Font, 0, 0, 0},{0, 0, 0, 0}};
@@ -8797,6 +8959,7 @@ static swig_cast_info _swigc__p_std__wstring[] = {  {&_swigt__p_std__wstring, 0,
 
 static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_Channel,
+  _swigc__p_Gosu__Audio,
   _swigc__p_Gosu__Button,
   _swigc__p_Gosu__Color,
   _swigc__p_Gosu__Font,
@@ -9072,8 +9235,8 @@ SWIGEXPORT void Init_gosu(void) {
   SWIG_RubyInitializeTrackings();
   rb_define_const(mGosu, "MAJOR_VERSION", SWIG_From_int(static_cast< int >(0)));
   rb_define_const(mGosu, "MINOR_VERSION", SWIG_From_int(static_cast< int >(7)));
-  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(15)));
-  rb_define_const(mGosu, "VERSION", SWIG_FromCharPtr("0.7.15"));
+  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(16)));
+  rb_define_const(mGosu, "VERSION", SWIG_FromCharPtr("0.7.16"));
   rb_define_module_function(mGosu, "milliseconds", VALUEFUNC(_wrap_milliseconds), -1);
   rb_define_module_function(mGosu, "random", VALUEFUNC(_wrap_random), -1);
   rb_define_module_function(mGosu, "gosu_to_radian_scale", VALUEFUNC(_wrap_gosu_to_radian_scale), -1);
@@ -9087,6 +9250,7 @@ SWIGEXPORT void Init_gosu(void) {
   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);
+  rb_define_module_function(mGosu, "__max_texture_size", VALUEFUNC(_wrap___max_texture_size), -1);
   
   SwigClassColor.klass = rb_define_class_under(mGosu, "Color", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_Gosu__Color, (void *) &SwigClassColor);
@@ -9122,6 +9286,7 @@ SWIGEXPORT void Init_gosu(void) {
   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, "aqua", VALUEFUNC(_wrap_aqua_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);
@@ -9220,6 +9385,7 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassSong.klass, "playing?", VALUEFUNC(_wrap_Song_playingq___), -1);
   rb_define_method(SwigClassSong.klass, "volume", VALUEFUNC(_wrap_Song_volume), -1);
   rb_define_method(SwigClassSong.klass, "volume=", VALUEFUNC(_wrap_Song_volumee___), -1);
+  rb_define_singleton_method(SwigClassSong.klass, "update", VALUEFUNC(_wrap_Song_update), -1);
   SwigClassSong.mark = 0;
   SwigClassSong.destroy = (void (*)(void *)) free_Gosu_Song;
   SwigClassSong.trackObjects = 1;
@@ -9346,9 +9512,6 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_const(mGosu, "NumButtons", SWIG_From_int(static_cast< int >(Gosu::numButtons)));
   rb_define_const(mGosu, "NoButton", SWIG_From_int(static_cast< int >(Gosu::noButton)));
   
-  // 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...
   // 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");
@@ -9357,14 +9520,12 @@ SWIGEXPORT void Init_gosu(void) {
   // 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_radian_scale; self*Math::PI/180.0; end; end");
-  rb_eval_string("class ::Numeric; def radian_scale_to_gosu; self*180.0/Math::PI; end; end");
-  rb_eval_string("class ::Numeric; def gosu_to_radians; (self-90)*Math::PI/180.0; end; end");
-  rb_eval_string("class ::Numeric; def radians_to_gosu; self*180.0/Math::PI+90;   end; end");
+  // ARGH, Linux workaround: instead of declaring a constant, we declare a hidden function and call it when we need to define the constant.
+  rb_eval_string("module Gosu;def self.const_missing sym;if sym == :MAX_TEXTURE_SIZE then;const_set sym, __max_texture_size;else;super;end;end;end");
   
   GosusDarkSide::oncePerTick = GosusDarkSide::yieldToOtherRubyThreads;
   
+  rb_define_module_function(mGosu, "disown_TextInput", VALUEFUNC(_wrap_disown_TextInput), -1);
   
   SwigClassTextInput.klass = rb_define_class_under(mGosu, "TextInput", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_Gosu__TextInput, (void *) &SwigClassTextInput);
@@ -9372,6 +9533,7 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassTextInput.klass, "initialize", VALUEFUNC(_wrap_new_TextInput), -1);
   rb_define_method(SwigClassTextInput.klass, "text", VALUEFUNC(_wrap_TextInput_text), -1);
   rb_define_method(SwigClassTextInput.klass, "text=", VALUEFUNC(_wrap_TextInput_texte___), -1);
+  rb_define_method(SwigClassTextInput.klass, "filter", VALUEFUNC(_wrap_TextInput_filter), -1);
   rb_define_method(SwigClassTextInput.klass, "caret_pos", VALUEFUNC(_wrap_TextInput_caret_pos), -1);
   rb_define_method(SwigClassTextInput.klass, "selection_start", VALUEFUNC(_wrap_TextInput_selection_start), -1);
   SwigClassTextInput.mark = 0;
@@ -9393,6 +9555,7 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassWindow.klass, "needs_redraw?", VALUEFUNC(_wrap_Window_needs_redrawq___), -1);
   rb_define_method(SwigClassWindow.klass, "button_down", VALUEFUNC(_wrap_Window_button_down), -1);
   rb_define_method(SwigClassWindow.klass, "button_up", VALUEFUNC(_wrap_Window_button_up), -1);
+  rb_define_method(SwigClassWindow.klass, "audio", VALUEFUNC(_wrap_Window_audio), -1);
   rb_define_method(SwigClassWindow.klass, "draw_line", VALUEFUNC(_wrap_Window_draw_line), -1);
   rb_define_method(SwigClassWindow.klass, "draw_triangle", VALUEFUNC(_wrap_Window_draw_triangle), -1);
   rb_define_method(SwigClassWindow.klass, "draw_quad", VALUEFUNC(_wrap_Window_draw_quad), -1);