gosu 0.7.11 → 0.7.12

data/GosuImpl/Iconv.hpp

@@ -1,6 +1,8 @@
 #ifndef GOSIMPL_ICONV_HPP
 #define GOSIMPL_ICONV_HPP
 
+#include <Gosu/Platform.hpp>
+
 #ifdef __APPLE__
 // We want Apple's iconv
 #include </usr/include/iconv.h>
@@ -58,5 +60,6 @@ namespace Gosu
     }
 }
 
+
 #endif
 

data/GosuImpl/InputMac.mm

@@ -517,6 +517,20 @@ struct Gosu::Input::Impl
         
         currentMods = newMods;
     }
+
+    void refreshMousePosition()
+    {
+        NSPoint mousePos = [NSEvent mouseLocation];
+        if (window)
+        {
+            mousePos = [window convertScreenToBase: mousePos];
+            mousePos.y = [[window contentView] frame].size.height - mousePos.y;
+        }
+        else
+            mousePos.y = CGDisplayBounds(CGMainDisplayID()).size.height - mousePos.y;
+        mouseX = mousePos.x;
+        mouseY = mousePos.y;
+    }
 };
 
 Gosu::Input::Input(void* window)
@@ -623,6 +637,22 @@ double Gosu::Input::mouseY() const
     return pimpl->mouseY * pimpl->mouseFactorY;
 }
 
+void Gosu::Input::setMousePosition(double x, double y)
+{
+    NSPoint mousePos = NSMakePoint(x, y);
+    if (pimpl->window)
+    {
+        mousePos.y = [[pimpl->window contentView] frame].size.height - mousePos.y;
+        mousePos = [pimpl->window convertBaseToScreen: mousePos];
+        mousePos.y = CGDisplayBounds(CGMainDisplayID()).size.height - mousePos.y;
+    }
+
+    CGSetLocalEventsSuppressionInterval(0.0);
+    CGWarpMouseCursorPosition(CGPointMake(mousePos.x, mousePos.y));
+    
+    pimpl->refreshMousePosition();
+}
+
 void Gosu::Input::setMouseFactors(double factorX, double factorY)
 {
     pimpl->mouseFactorX = factorX;
@@ -631,16 +661,7 @@ void Gosu::Input::setMouseFactors(double factorX, double factorY)
 
 void Gosu::Input::update()
 {
-    NSPoint mousePos = [NSEvent mouseLocation];
-    if (pimpl->window)
-    {
-        mousePos = [pimpl->window convertScreenToBase: mousePos];
-        mousePos.y = [[pimpl->window contentView] frame].size.height - mousePos.y;
-    }
-    else
-        mousePos.y = CGDisplayBounds(CGMainDisplayID()).size.height - mousePos.y;
-    pimpl->mouseX = mousePos.x;
-    pimpl->mouseY = mousePos.y;
+    pimpl->refreshMousePosition();
     
     for (unsigned i = 0; i < pimpl->queue.size(); ++i)
     {

data/GosuImpl/InputWin.cpp

@@ -410,6 +410,14 @@ double Gosu::Input::mouseY() const
     return pimpl->mouseY * pimpl->mouseFactorY;
 }
 
+void Gosu::Input::setMousePosition(double x, double y)
+{
+	POINT pos = { x / pimpl->mouseFactorX, y / pimpl->mouseFactorY };
+	::ClientToScreen(pimpl->window, &pos);
+	::SetCursorPos(pos.x, pos.y);
+	pimpl->updateMousePos();
+}
+
 void Gosu::Input::setMouseFactors(double factorX, double factorY)
 {
 	pimpl->mouseFactorX = factorX;

data/GosuImpl/InputX.cpp

@@ -3,8 +3,8 @@
 #include <Gosu/Utility.hpp>
 #include <vector>
 #include <map>
-
-#include <GosuImpl/Iconv.hpp>
+
+#include <GosuImpl/Iconv.hpp>
 
 struct Gosu::Input::Impl
 {
@@ -13,24 +13,28 @@ struct Gosu::Input::Impl
     std::map<unsigned int, bool> keyMap;
     double mouseX, mouseY, mouseFactorX, mouseFactorY;
     ::Display* display;
+	::Window window;
     Impl() : textInput(0) {}
 };
 
-Gosu::Input::Input(::Display* dpy)
+Gosu::Input::Input(::Display* dpy, ::Window wnd)
     : pimpl(new Impl)
 {
     // IMPR: Get current position?
     pimpl->mouseX = pimpl->mouseY = 0;
     pimpl->mouseFactorX = pimpl->mouseFactorY = 1.0;
     pimpl->display = dpy;
+	pimpl->window = wnd;
 }
 
 Gosu::Input::~Input()
 {
 }
 
-bool Gosu::Input::feedXEvent(::XEvent& event, Gosu::Window* window)
+bool Gosu::Input::feedXEvent(::XEvent& event)
 {
+	// IMPR: Wouldn't it make more sense to filter the other way around?
+	
     if(event.type == VisibilityNotify ||
        event.type == CirculateRequest ||
        event.type == ConfigureRequest ||
@@ -38,7 +42,7 @@ bool Gosu::Input::feedXEvent(::XEvent& event, Gosu::Window* window)
        event.type == ResizeRequest ||
        event.type == ClientMessage)
         return false;
-
+	
     pimpl->eventList.push_back(event);
     return true;
 }
@@ -53,39 +57,39 @@ bool Gosu::Input::down(Gosu::Button btn) const
 }
 
 Gosu::Button Gosu::Input::charToId(wchar_t ch)
-{
-    // ASCII chars
+{
+    // ASCII chars
     if (ch >= 32 && ch <= 255)
-        return Button(ch);
+        return Button(ch);
     // Other chars are conceptually not findable :(
     return noButton;
-}
-
-namespace
-{
-    extern const char LATIN[] = "ISO8859-1";
-    extern const char UCS_4_INTERNAL[] = "UCS-4LE";
+}
+
+namespace
+{
+    extern const char LATIN[] = "ISO8859-1";
+    extern const char UCS_4_INTERNAL[] = "UCS-4LE";
 }
 
 wchar_t Gosu::Input::idToChar(Button btn)
-{
-    // ASCII chars
+{
+    // ASCII chars
     if (btn.getId() >= 32 && btn.getId() <= 255)
-        return btn.getId();
-    
-    // Looking at SDL source suggests that this is to be interpreted depending on the third byte.
-    // Should find solid literature on that if it exists.
-    // Commented out: This is pretty pointless since LATIN-1 maps to Unicode directly...
-    // BUT could serve as a basis for more?!
-    //if ((btn.getId() >> 8) == 0)
-    //{
-    //    unsigned char in[] = { btn.getId() & 0xff, 0 };
-    //    std::wstring converted = iconvert<std::wstring, UCS_4_INTERNAL, LATIN>(std::string(reinterpret_cast<char*>(in)));
-    //    return converted.at(0);
-    //}
-
-    return 0;
-}
+        return btn.getId();
+    
+    // Looking at SDL source suggests that this is to be interpreted depending on the third byte.
+    // Should find solid literature on that if it exists.
+    // Commented out: This is pretty pointless since LATIN-1 maps to Unicode directly...
+    // BUT could serve as a basis for more?!
+    //if ((btn.getId() >> 8) == 0)
+    //{
+    //    unsigned char in[] = { btn.getId() & 0xff, 0 };
+    //    std::wstring converted = iconvert<std::wstring, UCS_4_INTERNAL, LATIN>(std::string(reinterpret_cast<char*>(in)));
+    //    return converted.at(0);
+    //}
+
+    return 0;
+}
 
 double Gosu::Input::mouseX() const
 {
@@ -120,9 +124,9 @@ void Gosu::Input::update()
             // unsigned id = (chars == 0) ? keysym : widen(buf).at(0);
 
             unsigned id = XKeycodeToKeysym(pimpl->display, event.xkey.keycode, 0);
-
+
             pimpl->keyMap[id] = true;
-            if (onButtonDown)
+            if (onButtonDown)
                 onButtonDown(Button(id));
         }
         else if (event.type == KeyRelease)
@@ -131,21 +135,21 @@ void Gosu::Input::update()
             // unsigned chars = XLookupString(&event.xkey, buf, sizeof buf, 0, 0);
             // unsigned keysym = XKeycodeToKeysym(pimpl->display, event.xkey.keycode, 0);
             // unsigned id = (chars == 0) ? keysym : widen(buf).at(0);
-
-            if (i < pimpl->eventList.size() - 1)
-            {
-                ::XEvent nextEvent = pimpl->eventList[i + 1];
-                if (nextEvent.type == KeyPress && nextEvent.xkey.keycode == event.xkey.keycode)
-                {
-                    i += 1;
-                    continue;
+
+            if (i < pimpl->eventList.size() - 1)
+            {
+                ::XEvent nextEvent = pimpl->eventList[i + 1];
+                if (nextEvent.type == KeyPress && nextEvent.xkey.keycode == event.xkey.keycode)
+                {
+                    i += 1;
+                    continue;
                 }
             }
 
-            unsigned id = XKeycodeToKeysym(pimpl->display, event.xkey.keycode, 0);
-
+            unsigned id = XKeycodeToKeysym(pimpl->display, event.xkey.keycode, 0);
+
             pimpl->keyMap[id] = false;
-            if (onButtonUp)
+            if (onButtonUp)
                 onButtonUp(Button(id));
         }
         else if (event.type == ButtonPress)
@@ -183,11 +187,26 @@ void Gosu::Input::update()
         {
             pimpl->mouseX = event.xbutton.x;
             pimpl->mouseY = event.xbutton.y;
-        }
+        }
+        else if (event.type == EnterNotify || event.type == LeaveNotify)
+        {
+            pimpl->mouseX = event.xcrossing.x;
+            pimpl->mouseY = event.xcrossing.y;
+        }
     }
     pimpl->eventList.clear();
 }
 
+void Gosu::Input::setMousePosition(double x, double y)
+{
+    ::XWarpPointer(pimpl->display, None, pimpl->window, 0, 0, 0, 0,
+				   x / pimpl->mouseFactorX, y / pimpl->mouseFactorY);
+    ::XSync(pimpl->display, False);
+    // Couldn't find a way to fetch the current mouse position. These
+    // values may not be correct if the cursor was grabbed, for example.
+    pimpl->mouseX = x, pimpl->mouseY = y;
+}
+
 Gosu::TextInput* Gosu::Input::textInput() const
 {
     return pimpl->textInput;

data/GosuImpl/Math.cpp

@@ -32,7 +32,7 @@ double Gosu::angle(double fromX, double fromY, double toX, double toY,
 
 double Gosu::angleDiff(double from, double to)
 {
-    return normalizeAngle(std::fmod(to - from + 180, 360) - 180);
+    return std::fmod(to - from + 180, 360) - 180;
 }
 
 double Gosu::normalizeAngle(double angle)

data/GosuImpl/RubyGosu.swg

@@ -214,6 +214,11 @@ namespace Gosu
 %ignore Gosu::sleep;
 %include "../Gosu/Timing.hpp"
 %ignore Gosu::pi;
+%ignore Gosu::distanceSqr;
+%ignore Gosu::round;
+%ignore Gosu::trunc;
+%ignore Gosu::radiansToGosu;
+%ignore Gosu::gosuToRadians;
 %include "../Gosu/Math.hpp"
 %ignore Gosu::textWidth;
 %ignore Gosu::createText;
@@ -225,6 +230,10 @@ namespace Gosu
 // Graphics:
 
 // ZPos, AlphaMode, FontFlags, TextAlign
+%ignore Gosu::zImmediate;
+%ignore Gosu::AlphaMode;
+%ignore Gosu::FontFlags;
+%ignore Gosu::TextAlign;
 %include "../Gosu/GraphicsBase.hpp"
 
 // Color
@@ -352,11 +361,13 @@ namespace Gosu
 // Audio:
 
 %ignore Gosu::Audio;
+%Ignore Gosu::SongType;
 %ignore Gosu::Sample::Sample(Audio& audio, const std::wstring& filename);
 %ignore Gosu::Sample::Sample(Audio& audio, Reader reader);
 %ignore Gosu::Song::Song(Audio& audio, const std::wstring& filename);
 %ignore Gosu::Song::Song(Audio& audio, Type type, Reader reader);
 %rename("playing?") playing;
+%rename("paused?") paused;
 %rename("volume=") changeVolume;
 %rename("pan=") changePan;
 %rename("speed=") changeSpeed;
@@ -379,18 +390,15 @@ 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");
-    
-    // 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");
 
+    // 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");
+    
     GosusDarkSide::oncePerTick = GosusDarkSide::yieldToOtherRubyThreads;
 %}
 
@@ -416,6 +424,8 @@ namespace Gosu
 %rename("caption=") setCaption;
 %rename("button_down?") isButtonDown;
 %rename("text_input=") setTextInput;
+%rename("mouse_x=") setMouseX;
+%rename("mouse_y=") setMouseY;
 %markfunc Gosu::Window "markWindow";
 %include "../Gosu/Window.hpp"
 
@@ -474,6 +484,16 @@ namespace Gosu
 	double mouseY() const {
 		return $self->input().mouseY();
 	}
+    void setMousePosition(double x, double y) {
+        $self->input().setMousePosition(x, y);
+    }
+    void setMouseX(double x) {
+        $self->input().setMousePosition(x, $self->input().mouseY());
+    }
+    void setMouseY(double y) {
+        $self->input().setMousePosition($self->input().mouseX(), y);
+    }
+    
 	int width() const {
 		return $self->graphics().width();
 	}

data/GosuImpl/RubyGosu_wrap.cxx

@@ -2119,13 +2119,6 @@ SWIG_AsVal_double (VALUE obj, double *val)
   #define SWIG_From_double   rb_float_new 
 
 
-SWIGINTERNINLINE VALUE
-SWIG_From_int  (int value)
-{    
-  return SWIG_From_long  (value);
-}
-
-
 #include <string>
 
 
@@ -2301,6 +2294,13 @@ SWIGINTERN Gosu::Font *new_Gosu_Font(Gosu::Window &window,std::wstring const &fo
         return new Gosu::Font(window.graphics(), fontName, height);
     }
 
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+
 SWIGINTERN int
 SWIG_AsVal_bool (VALUE obj, bool *val)
 {
@@ -2474,6 +2474,15 @@ SWIGINTERN double Gosu_Window_mouseX(Gosu::Window const *self){
 SWIGINTERN double Gosu_Window_mouseY(Gosu::Window const *self){
 		return self->input().mouseY();
 	}
+SWIGINTERN void Gosu_Window_setMousePosition(Gosu::Window *self,double x,double y){
+        self->input().setMousePosition(x, y);
+    }
+SWIGINTERN void Gosu_Window_setMouseX(Gosu::Window *self,double x){
+        self->input().setMousePosition(x, self->input().mouseY());
+    }
+SWIGINTERN void Gosu_Window_setMouseY(Gosu::Window *self,double y){
+        self->input().setMousePosition(self->input().mouseX(), y);
+    }
 SWIGINTERN int Gosu_Window_width(Gosu::Window const *self){
 		return self->graphics().width();
 	}
@@ -2580,66 +2589,6 @@ fail:
 }
 
 
-SWIGINTERN VALUE
-_wrap_trunc(int argc, VALUE *argv, VALUE self) {
-  double arg1 ;
-  long result;
-  double val1 ;
-  int ecode1 = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  ecode1 = SWIG_AsVal_double(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::trunc" "', argument " "1"" of type '" "double""'");
-  } 
-  arg1 = static_cast< double >(val1);
-  {
-    try {
-      result = (long)Gosu::trunc(arg1);
-    } catch(const std::runtime_error& e) {
-      SWIG_exception(SWIG_RuntimeError, e.what());
-    }
-  }
-  vresult = SWIG_From_long(static_cast< long >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
-SWIGINTERN VALUE
-_wrap_round(int argc, VALUE *argv, VALUE self) {
-  double arg1 ;
-  long result;
-  double val1 ;
-  int ecode1 = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  ecode1 = SWIG_AsVal_double(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::round" "', argument " "1"" of type '" "double""'");
-  } 
-  arg1 = static_cast< double >(val1);
-  {
-    try {
-      result = (long)Gosu::round(arg1);
-    } catch(const std::runtime_error& e) {
-      SWIG_exception(SWIG_RuntimeError, e.what());
-    }
-  }
-  vresult = SWIG_From_long(static_cast< long >(result));
-  return vresult;
-fail:
-  return Qnil;
-}
-
-
 SWIGINTERN VALUE
 _wrap_random(int argc, VALUE *argv, VALUE self) {
   double arg1 ;
@@ -2678,66 +2627,6 @@ fail:
 }
 
 
-SWIGINTERN VALUE
-_wrap_gosu_to_radians(int argc, VALUE *argv, VALUE self) {
-  double arg1 ;
-  double result;
-  double val1 ;
-  int ecode1 = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  ecode1 = SWIG_AsVal_double(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::gosuToRadians" "', argument " "1"" of type '" "double""'");
-  } 
-  arg1 = static_cast< double >(val1);
-  {
-    try {
-      result = (double)Gosu::gosuToRadians(arg1);
-    } 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_radians_to_gosu(int argc, VALUE *argv, VALUE self) {
-  double arg1 ;
-  double result;
-  double val1 ;
-  int ecode1 = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 1) || (argc > 1)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
-  }
-  ecode1 = SWIG_AsVal_double(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::radiansToGosu" "', argument " "1"" of type '" "double""'");
-  } 
-  arg1 = static_cast< double >(val1);
-  {
-    try {
-      result = (double)Gosu::radiansToGosu(arg1);
-    } 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_offset_x(int argc, VALUE *argv, VALUE self) {
   double arg1 ;
@@ -2946,60 +2835,6 @@ fail:
 }
 
 
-SWIGINTERN VALUE
-_wrap_distance_sqr(int argc, VALUE *argv, VALUE self) {
-  double arg1 ;
-  double arg2 ;
-  double arg3 ;
-  double arg4 ;
-  double result;
-  double val1 ;
-  int ecode1 = 0 ;
-  double val2 ;
-  int ecode2 = 0 ;
-  double val3 ;
-  int ecode3 = 0 ;
-  double val4 ;
-  int ecode4 = 0 ;
-  VALUE vresult = Qnil;
-  
-  if ((argc < 4) || (argc > 4)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
-  }
-  ecode1 = SWIG_AsVal_double(argv[0], &val1);
-  if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Gosu::distanceSqr" "', argument " "1"" of type '" "double""'");
-  } 
-  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::distanceSqr" "', argument " "2"" of type '" "double""'");
-  } 
-  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::distanceSqr" "', argument " "3"" of type '" "double""'");
-  } 
-  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::distanceSqr" "', argument " "4"" of type '" "double""'");
-  } 
-  arg4 = static_cast< double >(val4);
-  {
-    try {
-      result = (double)Gosu::distanceSqr(arg1,arg2,arg3,arg4);
-    } 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_distance(int argc, VALUE *argv, VALUE self) {
   double arg1 ;
@@ -6129,6 +5964,90 @@ 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 ;
+  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__SampleInstance, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "paused" "', argument " "1"" of type '" "Gosu::SampleInstance const *""'"); 
+  }
+  arg1 = reinterpret_cast< Gosu::SampleInstance * >(argp1);
+  {
+    try {
+      result = (bool)((Gosu::SampleInstance const *)arg1)->paused();
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SampleInstance_pause(int argc, VALUE *argv, VALUE self) {
+  Gosu::SampleInstance *arg1 = (Gosu::SampleInstance *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  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__SampleInstance, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pause" "', argument " "1"" of type '" "Gosu::SampleInstance *""'"); 
+  }
+  arg1 = reinterpret_cast< Gosu::SampleInstance * >(argp1);
+  {
+    try {
+      (arg1)->pause();
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SampleInstance_resume(int argc, VALUE *argv, VALUE self) {
+  Gosu::SampleInstance *arg1 = (Gosu::SampleInstance *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  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__SampleInstance, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resume" "', argument " "1"" of type '" "Gosu::SampleInstance *""'"); 
+  }
+  arg1 = reinterpret_cast< Gosu::SampleInstance * >(argp1);
+  {
+    try {
+      (arg1)->resume();
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_SampleInstance_stop(int argc, VALUE *argv, VALUE self) {
   Gosu::SampleInstance *arg1 = (Gosu::SampleInstance *) 0 ;
@@ -6280,6 +6199,7 @@ _wrap_Sample_play(int argc, VALUE *argv, VALUE self) {
   Gosu::Sample *arg1 = (Gosu::Sample *) 0 ;
   double arg2 = (double) 1 ;
   double arg3 = (double) 1 ;
+  bool arg4 = (bool) false ;
   SwigValueWrapper<Gosu::SampleInstance > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -6287,9 +6207,11 @@ _wrap_Sample_play(int argc, VALUE *argv, VALUE self) {
   int ecode2 = 0 ;
   double val3 ;
   int ecode3 = 0 ;
+  bool val4 ;
+  int ecode4 = 0 ;
   VALUE vresult = Qnil;
   
-  if ((argc < 0) || (argc > 2)) {
+  if ((argc < 0) || (argc > 3)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Sample, 0 |  0 );
@@ -6311,9 +6233,16 @@ _wrap_Sample_play(int argc, VALUE *argv, VALUE self) {
     } 
     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""'");
+    } 
+    arg4 = static_cast< bool >(val4);
+  }
   {
     try {
-      result = ((Gosu::Sample const *)arg1)->play(arg2,arg3);
+      result = ((Gosu::Sample const *)arg1)->play(arg2,arg3,arg4);
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -6331,6 +6260,7 @@ _wrap_Sample_play_pan(int argc, VALUE *argv, VALUE self) {
   double arg2 ;
   double arg3 = (double) 1 ;
   double arg4 = (double) 1 ;
+  bool arg5 = (bool) false ;
   SwigValueWrapper<Gosu::SampleInstance > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -6340,9 +6270,11 @@ _wrap_Sample_play_pan(int argc, VALUE *argv, VALUE self) {
   int ecode3 = 0 ;
   double val4 ;
   int ecode4 = 0 ;
+  bool val5 ;
+  int ecode5 = 0 ;
   VALUE vresult = Qnil;
   
-  if ((argc < 1) || (argc > 3)) {
+  if ((argc < 1) || (argc > 4)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Sample, 0 |  0 );
@@ -6369,9 +6301,16 @@ _wrap_Sample_play_pan(int argc, VALUE *argv, VALUE self) {
     } 
     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""'");
+    } 
+    arg5 = static_cast< bool >(val5);
+  }
   {
     try {
-      result = ((Gosu::Sample const *)arg1)->playPan(arg2,arg3,arg4);
+      result = ((Gosu::Sample const *)arg1)->playPan(arg2,arg3,arg4,arg5);
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -6457,13 +6396,38 @@ free_Gosu_Song(Gosu::Song *arg1) {
     delete arg1;
 }
 
+SWIGINTERN VALUE
+_wrap_Song_current_song(int argc, VALUE *argv, VALUE self) {
+  Gosu::Song *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    try {
+      result = (Gosu::Song *)Gosu::Song::currentSong();
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gosu__Song, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Song_play(int argc, VALUE *argv, VALUE self) {
   Gosu::Song *arg1 = (Gosu::Song *) 0 ;
+  bool arg2 = (bool) false ;
   void *argp1 = 0 ;
   int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
   
-  if ((argc < 0) || (argc > 0)) {
+  if ((argc < 0) || (argc > 1)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Song, 0 |  0 );
@@ -6471,9 +6435,43 @@ _wrap_Song_play(int argc, VALUE *argv, VALUE self) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "play" "', argument " "1"" of type '" "Gosu::Song *""'"); 
   }
   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""'");
+    } 
+    arg2 = static_cast< bool >(val2);
+  }
+  {
+    try {
+      (arg1)->play(arg2);
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Song_pause(int argc, VALUE *argv, VALUE self) {
+  Gosu::Song *arg1 = (Gosu::Song *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  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__Song, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pause" "', argument " "1"" of type '" "Gosu::Song *""'"); 
+  }
+  arg1 = reinterpret_cast< Gosu::Song * >(argp1);
   {
     try {
-      (arg1)->play();
+      (arg1)->pause();
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -6484,6 +6482,36 @@ 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 ;
+  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__Song, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "paused" "', argument " "1"" of type '" "Gosu::Song const *""'"); 
+  }
+  arg1 = reinterpret_cast< Gosu::Song * >(argp1);
+  {
+    try {
+      result = (bool)((Gosu::Song const *)arg1)->paused();
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Song_stop(int argc, VALUE *argv, VALUE self) {
   Gosu::Song *arg1 = (Gosu::Song *) 0 ;
@@ -7873,6 +7901,119 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Window_set_mouse_position(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  double arg2 ;
+  double arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "setMousePosition" "', argument " "1"" of type '" "Gosu::Window *""'"); 
+  }
+  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""'");
+  } 
+  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""'");
+  } 
+  arg3 = static_cast< double >(val3);
+  {
+    try {
+      Gosu_Window_setMousePosition(arg1,arg2,arg3);
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Window_mouse_xe___(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  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 *""'"); 
+  }
+  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""'");
+  } 
+  arg2 = static_cast< double >(val2);
+  {
+    try {
+      Gosu_Window_setMouseX(arg1,arg2);
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Window_mouse_ye___(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  double arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  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 *""'"); 
+  }
+  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""'");
+  } 
+  arg2 = static_cast< double >(val2);
+  {
+    try {
+      Gosu_Window_setMouseY(arg1,arg2);
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Window_width(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
@@ -8359,28 +8500,14 @@ SWIGEXPORT void Init_gosu(void) {
   
   SWIG_RubyInitializeTrackings();
   rb_define_module_function(mGosu, "milliseconds", VALUEFUNC(_wrap_milliseconds), -1);
-  rb_define_module_function(mGosu, "trunc", VALUEFUNC(_wrap_trunc), -1);
-  rb_define_module_function(mGosu, "round", VALUEFUNC(_wrap_round), -1);
   rb_define_module_function(mGosu, "random", VALUEFUNC(_wrap_random), -1);
-  rb_define_module_function(mGosu, "gosu_to_radians", VALUEFUNC(_wrap_gosu_to_radians), -1);
-  rb_define_module_function(mGosu, "radians_to_gosu", VALUEFUNC(_wrap_radians_to_gosu), -1);
   rb_define_module_function(mGosu, "offset_x", VALUEFUNC(_wrap_offset_x), -1);
   rb_define_module_function(mGosu, "offset_y", VALUEFUNC(_wrap_offset_y), -1);
   rb_define_module_function(mGosu, "angle", VALUEFUNC(_wrap_angle), -1);
   rb_define_module_function(mGosu, "angle_diff", VALUEFUNC(_wrap_angle_diff), -1);
   rb_define_module_function(mGosu, "normalize_angle", VALUEFUNC(_wrap_normalize_angle), -1);
-  rb_define_module_function(mGosu, "distance_sqr", VALUEFUNC(_wrap_distance_sqr), -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_const(mGosu, "AmDefault", SWIG_From_int(static_cast< int >(Gosu::amDefault)));
-  rb_define_const(mGosu, "AmAdditive", SWIG_From_int(static_cast< int >(Gosu::amAdditive)));
-  rb_define_const(mGosu, "FfBold", SWIG_From_int(static_cast< int >(Gosu::ffBold)));
-  rb_define_const(mGosu, "FfItalic", SWIG_From_int(static_cast< int >(Gosu::ffItalic)));
-  rb_define_const(mGosu, "FfUnderline", SWIG_From_int(static_cast< int >(Gosu::ffUnderline)));
-  rb_define_const(mGosu, "TaLeft", SWIG_From_int(static_cast< int >(Gosu::taLeft)));
-  rb_define_const(mGosu, "TaRight", SWIG_From_int(static_cast< int >(Gosu::taRight)));
-  rb_define_const(mGosu, "TaCenter", SWIG_From_int(static_cast< int >(Gosu::taCenter)));
-  rb_define_const(mGosu, "TaJustify", SWIG_From_int(static_cast< int >(Gosu::taJustify)));
   
   cColor.klass = rb_define_class_under(mGosu, "Color", rb_cObject);
   SWIG_TypeClientData(SWIGTYPE_p_Gosu__Color, (void *) &cColor);
@@ -8476,6 +8603,9 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_alloc_func(cSampleInstance.klass, _wrap_SampleInstance_allocate);
   rb_define_method(cSampleInstance.klass, "initialize", VALUEFUNC(_wrap_new_SampleInstance), -1);
   rb_define_method(cSampleInstance.klass, "playing?", VALUEFUNC(_wrap_SampleInstance_playingq___), -1);
+  rb_define_method(cSampleInstance.klass, "paused?", VALUEFUNC(_wrap_SampleInstance_pausedq___), -1);
+  rb_define_method(cSampleInstance.klass, "pause", VALUEFUNC(_wrap_SampleInstance_pause), -1);
+  rb_define_method(cSampleInstance.klass, "resume", VALUEFUNC(_wrap_SampleInstance_resume), -1);
   rb_define_method(cSampleInstance.klass, "stop", VALUEFUNC(_wrap_SampleInstance_stop), -1);
   rb_define_method(cSampleInstance.klass, "volume=", VALUEFUNC(_wrap_SampleInstance_volumee___), -1);
   rb_define_method(cSampleInstance.klass, "pan=", VALUEFUNC(_wrap_SampleInstance_pane___), -1);
@@ -8500,7 +8630,10 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(cSong.klass, "initialize", VALUEFUNC(_wrap_new_Song), -1);
   rb_define_const(cSong.klass, "StStream", SWIG_From_int(static_cast< int >(Gosu::Song::stStream)));
   rb_define_const(cSong.klass, "StModule", SWIG_From_int(static_cast< int >(Gosu::Song::stModule)));
+  rb_define_singleton_method(cSong.klass, "current_song", VALUEFUNC(_wrap_Song_current_song), -1);
   rb_define_method(cSong.klass, "play", VALUEFUNC(_wrap_Song_play), -1);
+  rb_define_method(cSong.klass, "pause", VALUEFUNC(_wrap_Song_pause), -1);
+  rb_define_method(cSong.klass, "paused?", VALUEFUNC(_wrap_Song_pausedq___), -1);
   rb_define_method(cSong.klass, "stop", VALUEFUNC(_wrap_Song_stop), -1);
   rb_define_method(cSong.klass, "playing?", VALUEFUNC(_wrap_Song_playingq___), -1);
   rb_define_method(cSong.klass, "volume", VALUEFUNC(_wrap_Song_volume), -1);
@@ -8638,10 +8771,7 @@ SWIGEXPORT void Init_gosu(void) {
   rb_eval_string("class Gosu::Image; def self.from_text(*args); args.size == 4 ? from_text_4(*args) : from_text_7(*args); 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");
+  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");
   
   GosusDarkSide::oncePerTick = GosusDarkSide::yieldToOtherRubyThreads;
   
@@ -8681,6 +8811,9 @@ SWIGEXPORT void Init_gosu(void) {
   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);
   rb_define_method(cWindow.klass, "mouse_y", VALUEFUNC(_wrap_Window_mouse_y), -1);
+  rb_define_method(cWindow.klass, "set_mouse_position", VALUEFUNC(_wrap_Window_set_mouse_position), -1);
+  rb_define_method(cWindow.klass, "mouse_x=", VALUEFUNC(_wrap_Window_mouse_xe___), -1);
+  rb_define_method(cWindow.klass, "mouse_y=", VALUEFUNC(_wrap_Window_mouse_ye___), -1);
   rb_define_method(cWindow.klass, "width", VALUEFUNC(_wrap_Window_width), -1);
   rb_define_method(cWindow.klass, "height", VALUEFUNC(_wrap_Window_height), -1);
   rb_define_method(cWindow.klass, "gl", VALUEFUNC(_wrap_Window_gl), -1);