gosu 0.7.10.3 → 0.7.11

data/GosuImpl/Graphics/TextMac.cpp

@@ -201,24 +201,30 @@ namespace
 unsigned Gosu::textWidth(const std::wstring& text,
     const std::wstring& fontName, unsigned fontHeight, unsigned fontFlags)
 {
+    if (text.empty())
+        return 1;
+
     // TODO: special case :///7
     if (text == L" ")
         return fontHeight / 3;
     
     ATSULayoutAndStyle atlas(text, fontName, fontHeight, fontFlags);
     Rect rect = atlas.textExtents();
-    return rect.right + 1 - rect.left;
+    return rect.right + 1 - rect.left + 1; // add one pixel on OS X
 }
 
 void Gosu::drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
     Color c, const std::wstring& fontName, unsigned fontHeight,
     unsigned fontFlags)
 {
+    if (text.empty())
+        return;
+
     CachedFontInfo& font = getFont(fontName);
     
     ATSULayoutAndStyle atlas(text, fontName, fontHeight, fontFlags);
     Rect rect = atlas.textExtents();
-    unsigned width = rect.right + 1 - rect.left;
+    unsigned width = rect.right + 1 - rect.left + 1; // add one pixel on OS X
     std::vector<boost::uint32_t> buf(width * fontHeight);
     {
         MacBitmap helper(&buf[0], width, fontHeight);

data/GosuImpl/Iconv.hpp

@@ -0,0 +1,62 @@
+#ifndef GOSIMPL_ICONV_HPP
+#define GOSIMPL_ICONV_HPP
+
+#ifdef __APPLE__
+// We want Apple's iconv
+#include </usr/include/iconv.h>
+#else
+#include <iconv.h>
+#endif
+#include <errno.h>
+
+namespace Gosu
+{
+    template<typename Out, const char* to, const char* from, typename In>
+    Out iconvert(const In& in)
+    {
+        if (in.empty())
+            return Out();
+    
+        const size_t bufferLen = 128;
+        typedef typename In::value_type InElem;
+        typedef typename Out::value_type OutElem;
+
+        static iconv_t cd = iconv_open(to, from);
+        
+        Out result;
+        OutElem buffer[bufferLen];
+        
+        char* inbuf = const_cast<char*>(reinterpret_cast<const char*>(&in[0]));
+        size_t inbytesleft = in.size() * sizeof(InElem);
+        char* outbuf = reinterpret_cast<char*>(buffer);
+        size_t outbytesleft = sizeof buffer;
+        
+        for (;;)
+        {
+            size_t ret = ::iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
+            if (ret == static_cast<size_t>(-1) && errno == EILSEQ)
+            {
+                // Skip illegal sequence part, repeat loop.
+                // TODO: Or retry w/ different encoding?
+                ++inbuf;
+                --inbytesleft;
+            }
+            else if (ret == static_cast<size_t>(-1) && errno == E2BIG)
+            {
+                // Append new characters, reset out buffer, then repeat loop.
+                result.insert(result.end(), buffer, buffer + bufferLen);
+                outbuf = reinterpret_cast<char*>(buffer);
+                outbytesleft = sizeof buffer;
+            }
+            else
+            {
+                // Append what's new in the buffer, then LEAVE loop.
+                result.insert(result.end(), buffer, buffer + bufferLen - outbytesleft / sizeof(OutElem));
+                return result;
+            }
+        }        
+    }
+}
+
+#endif
+

data/GosuImpl/InputMac.mm

@@ -607,6 +607,9 @@ Gosu::Button Gosu::Input::charToId(wchar_t ch)
 
 bool Gosu::Input::down(Gosu::Button btn) const
 {
+    if (btn == noButton)
+        return false;
+
     return buttonStates.at(btn.getId());
 }
 

data/GosuImpl/InputWin.cpp

@@ -374,7 +374,7 @@ Gosu::Button Gosu::Input::charToId(wchar_t ch)
 
 wchar_t Gosu::Input::idToChar(Gosu::Button btn)
 {
-    // Only translate keyboard ids.
+	// Only translate keyboard ids.
     if (btn.getId() > 255)
         return 0;
 
@@ -393,6 +393,10 @@ wchar_t Gosu::Input::idToChar(Gosu::Button btn)
 
 bool Gosu::Input::down(Button btn) const
 {
+	// The invalid button is never pressed (but can be passed to this function).
+	if (btn == noButton)
+		return false;
+
     return buttons.at(btn.getId());
 }
 

data/GosuImpl/InputX.cpp

@@ -3,6 +3,8 @@
 #include <Gosu/Utility.hpp>
 #include <vector>
 #include <map>
+
+#include <GosuImpl/Iconv.hpp>
 
 struct Gosu::Input::Impl
 {
@@ -43,19 +45,47 @@ bool Gosu::Input::feedXEvent(::XEvent& event, Gosu::Window* window)
 
 bool Gosu::Input::down(Gosu::Button btn) const
 {
+    if (btn == noButton)
+        return false;
+
     // Will default to false for unknown indices (good).
     return pimpl->keyMap[btn.getId()];
 }
 
 Gosu::Button Gosu::Input::charToId(wchar_t ch)
-{
-    return Gosu::Button(ch);
+{
+    // ASCII chars
+    if (ch >= 32 && ch <= 255)
+        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";
 }
 
 wchar_t Gosu::Input::idToChar(Button btn)
-{
-    return btn.getId();
-}
+{
+    // 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;
+}
 
 double Gosu::Input::mouseX() const
 {
@@ -90,8 +120,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)
@@ -100,10 +131,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;
+                }
+            }
 
-            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)

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 std::atan2(distY, distX) / pi * 180 + 90;
+        return radiansToGosu(std::atan2(distY, distX));
 }
 
 double Gosu::angleDiff(double from, double to)

data/GosuImpl/RubyGosu.swg

@@ -26,7 +26,10 @@
 	$1 = localTemporary2.empty() ? 0 : localTemporary2.at(0);
 }
 %typemap(out) wchar_t {
-    $result = rb_str_new2(Gosu::wstringToUTF8(std::wstring(1, $1)).c_str());
+    if ($1 == 0)
+        $result = Qnil;
+    else
+        $result = rb_str_new2(Gosu::wstringToUTF8(std::wstring(1, $1)).c_str());
 }
 %typemap(in) const std::wstring& (std::wstring temp) {
     VALUE localTemporary = rb_obj_as_string($input);
@@ -39,13 +42,20 @@
 }
 
 %typemap(in) Gosu::Button {
-	$1 = Gosu::Button(NUM2LONG($input));
+    if (NIL_P($input))
+        $1 = Gosu::noButton;
+    else
+        $1 = Gosu::Button(NUM2LONG($input));
 }
 %typemap(out) Gosu::Button {
 	$result = LONG2NUM($1.getId());
+    if ($result == -1)
+        $result = Qnil;
 }
 %typemap(directorin) Gosu::Button {
 	$input = LONG2NUM($1.getId());
+    if ($input == -1)
+        $input = Qnil;
 }
 
 // Typemaps for enums that should be given in as symbols.
@@ -316,8 +326,14 @@ namespace Gosu
         else
             return 0;
     }
-    %newobject fromText;
-    static Gosu::Image* fromText(Gosu::Window& window, const std::wstring& text,
+    %newobject fromText4;
+    static Gosu::Image* fromText4(Gosu::Window& window, const std::wstring& text,
+                                 const std::wstring& fontName, unsigned fontHeight) {
+        Gosu::Bitmap bmp = Gosu::createText(text, fontName, fontHeight);
+        return new Gosu::Image(window.graphics(), bmp);
+    }
+    %newobject fromText7;
+    static Gosu::Image* fromText7(Gosu::Window& window, const std::wstring& text,
                                  const std::wstring& fontName, unsigned fontHeight,
                                  unsigned lineSpacing, unsigned maxWidth, TextAlign align) {
         Gosu::Bitmap bmp = Gosu::createText(text, fontName, fontHeight, lineSpacing, maxWidth, align);
@@ -360,13 +376,16 @@ namespace Gosu
 // Input and Window:
 
 // Button ID constants
+// 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...
+    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.
-    // IMPR: Maybe faster in C?
     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;"

data/GosuImpl/RubyGosu_wrap.cxx

@@ -2337,7 +2337,11 @@ SWIGINTERN Gosu::GLTexInfo *Gosu_Image_glTexInfo(Gosu::Image const *self){
         else
             return 0;
     }
-SWIGINTERN Gosu::Image *Gosu_Image_fromText(Gosu::Window &window,std::wstring const &text,std::wstring const &fontName,unsigned int fontHeight,unsigned int lineSpacing,unsigned int maxWidth,Gosu::TextAlign align){
+SWIGINTERN Gosu::Image *Gosu_Image_fromText4(Gosu::Window &window,std::wstring const &text,std::wstring const &fontName,unsigned int fontHeight){
+        Gosu::Bitmap bmp = Gosu::createText(text, fontName, fontHeight);
+        return new Gosu::Image(window.graphics(), bmp);
+    }
+SWIGINTERN Gosu::Image *Gosu_Image_fromText7(Gosu::Window &window,std::wstring const &text,std::wstring const &fontName,unsigned int fontHeight,unsigned int lineSpacing,unsigned int maxWidth,Gosu::TextAlign align){
         Gosu::Bitmap bmp = Gosu::createText(text, fontName, fontHeight, lineSpacing, maxWidth, align);
         return new Gosu::Image(window.graphics(), bmp);
     }
@@ -2534,6 +2538,8 @@ void SwigDirector_Window::buttonDown(Gosu::Button arg0) {
   
   {
     obj0 = LONG2NUM((&arg0)->getId());
+    if (obj0 == -1)
+    obj0 = Qnil;
   }
   result = rb_funcall(swig_get_self(), rb_intern("button_down"), 1,obj0);
 }
@@ -2545,6 +2551,8 @@ void SwigDirector_Window::buttonUp(Gosu::Button arg0) {
   
   {
     obj0 = LONG2NUM((&arg0)->getId());
+    if (obj0 == -1)
+    obj0 = Qnil;
   }
   result = rb_funcall(swig_get_self(), rb_intern("button_up"), 1,obj0);
 }
@@ -2670,6 +2678,66 @@ 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 ;
@@ -5769,7 +5837,62 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Image_from_text(int argc, VALUE *argv, VALUE self) {
+_wrap_Image_from_text_4(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 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Gosu__Window,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gosu_Image_fromText4" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gosu_Image_fromText4" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+  }
+  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  {
+    VALUE localTemporary = rb_obj_as_string(argv[1]);
+    temp2 = Gosu::utf8ToWstring(StringValueCStr(localTemporary));
+    arg2 = &temp2;
+  }
+  {
+    VALUE localTemporary = rb_obj_as_string(argv[2]);
+    temp3 = Gosu::utf8ToWstring(StringValueCStr(localTemporary));
+    arg3 = &temp3;
+  }
+  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""'");
+  } 
+  arg4 = static_cast< unsigned int >(val4);
+  {
+    try {
+      result = (Gosu::Image *)Gosu_Image_fromText4(*arg1,(std::wstring const &)*arg2,(std::wstring const &)*arg3,arg4);
+    } catch(const std::runtime_error& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gosu__Image, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Image_from_text_7(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = 0 ;
   std::wstring *arg2 = 0 ;
   std::wstring *arg3 = 0 ;
@@ -5795,10 +5918,10 @@ _wrap_Image_from_text(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_fromText" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Gosu_Image_fromText7" "', argument " "1"" of type '" "Gosu::Window &""'"); 
   }
   if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gosu_Image_fromText" "', argument " "1"" of type '" "Gosu::Window &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Gosu_Image_fromText7" "', argument " "1"" of type '" "Gosu::Window &""'"); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
@@ -5813,17 +5936,17 @@ _wrap_Image_from_text(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_fromText" "', argument " "4"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Gosu_Image_fromText7" "', argument " "4"" of type '" "unsigned int""'");
   } 
   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_fromText" "', argument " "5"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Gosu_Image_fromText7" "', argument " "5"" of type '" "unsigned int""'");
   } 
   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_fromText" "', argument " "6"" of type '" "unsigned int""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Gosu_Image_fromText7" "', argument " "6"" of type '" "unsigned int""'");
   } 
   arg6 = static_cast< unsigned int >(val6);
   {
@@ -5841,7 +5964,7 @@ _wrap_Image_from_text(int argc, VALUE *argv, VALUE self) {
   }
   {
     try {
-      result = (Gosu::Image *)Gosu_Image_fromText(*arg1,(std::wstring const &)*arg2,(std::wstring const &)*arg3,arg4,arg5,arg6,arg7);
+      result = (Gosu::Image *)Gosu_Image_fromText7(*arg1,(std::wstring const &)*arg2,(std::wstring const &)*arg3,arg4,arg5,arg6,arg7);
     } catch(const std::runtime_error& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
@@ -7031,6 +7154,9 @@ _wrap_Window_button_down(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
+    if (NIL_P(argv[0]))
+    arg2 = Gosu::noButton;
+    else
     arg2 = Gosu::Button(NUM2LONG(argv[0]));
   }
   director = dynamic_cast<Swig::Director *>(arg1);
@@ -7075,6 +7201,9 @@ _wrap_Window_button_up(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
+    if (NIL_P(argv[0]))
+    arg2 = Gosu::noButton;
+    else
     arg2 = Gosu::Button(NUM2LONG(argv[0]));
   }
   director = dynamic_cast<Swig::Director *>(arg1);
@@ -7518,6 +7647,9 @@ _wrap_Window_button_downq___(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
+    if (NIL_P(argv[0]))
+    arg2 = Gosu::noButton;
+    else
     arg2 = Gosu::Button(NUM2LONG(argv[0]));
   }
   {
@@ -7565,6 +7697,8 @@ _wrap_Window_char_to_button_id(int argc, VALUE *argv, VALUE self) {
   }
   {
     vresult = LONG2NUM((&result)->getId());
+    if (vresult == -1)
+    vresult = Qnil;
   }
   return vresult;
 fail:
@@ -7590,6 +7724,9 @@ _wrap_Window_button_id_to_char(int argc, VALUE *argv, VALUE self) {
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
+    if (NIL_P(argv[0]))
+    arg2 = Gosu::noButton;
+    else
     arg2 = Gosu::Button(NUM2LONG(argv[0]));
   }
   {
@@ -7600,6 +7737,9 @@ _wrap_Window_button_id_to_char(int argc, VALUE *argv, VALUE self) {
     }
   }
   {
+    if (result == 0)
+    vresult = Qnil;
+    else
     vresult = rb_str_new2(Gosu::wstringToUTF8(std::wstring(1, result)).c_str());
   }
   return vresult;
@@ -8222,6 +8362,8 @@ SWIGEXPORT void Init_gosu(void) {
   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);
@@ -8322,7 +8464,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", VALUEFUNC(_wrap_Image_from_text), -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, "load_tiles", VALUEFUNC(_wrap_Image_load_tiles), -1);
   cImage.mark = 0;
   cImage.destroy = (void (*)(void *)) free_Gosu_Image;
@@ -8389,6 +8532,32 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_const(mGosu, "Kb8", SWIG_From_int(static_cast< int >(Gosu::kb8)));
   rb_define_const(mGosu, "Kb9", SWIG_From_int(static_cast< int >(Gosu::kb9)));
   rb_define_const(mGosu, "Kb0", SWIG_From_int(static_cast< int >(Gosu::kb0)));
+  rb_define_const(mGosu, "KbA", SWIG_From_int(static_cast< int >(Gosu::kbA)));
+  rb_define_const(mGosu, "KbB", SWIG_From_int(static_cast< int >(Gosu::kbB)));
+  rb_define_const(mGosu, "KbC", SWIG_From_int(static_cast< int >(Gosu::kbC)));
+  rb_define_const(mGosu, "KbD", SWIG_From_int(static_cast< int >(Gosu::kbD)));
+  rb_define_const(mGosu, "KbE", SWIG_From_int(static_cast< int >(Gosu::kbE)));
+  rb_define_const(mGosu, "KbF", SWIG_From_int(static_cast< int >(Gosu::kbF)));
+  rb_define_const(mGosu, "KbG", SWIG_From_int(static_cast< int >(Gosu::kbG)));
+  rb_define_const(mGosu, "KbH", SWIG_From_int(static_cast< int >(Gosu::kbH)));
+  rb_define_const(mGosu, "KbI", SWIG_From_int(static_cast< int >(Gosu::kbI)));
+  rb_define_const(mGosu, "KbJ", SWIG_From_int(static_cast< int >(Gosu::kbJ)));
+  rb_define_const(mGosu, "KbK", SWIG_From_int(static_cast< int >(Gosu::kbK)));
+  rb_define_const(mGosu, "KbL", SWIG_From_int(static_cast< int >(Gosu::kbL)));
+  rb_define_const(mGosu, "KbM", SWIG_From_int(static_cast< int >(Gosu::kbM)));
+  rb_define_const(mGosu, "KbN", SWIG_From_int(static_cast< int >(Gosu::kbN)));
+  rb_define_const(mGosu, "KbO", SWIG_From_int(static_cast< int >(Gosu::kbO)));
+  rb_define_const(mGosu, "KbP", SWIG_From_int(static_cast< int >(Gosu::kbP)));
+  rb_define_const(mGosu, "KbQ", SWIG_From_int(static_cast< int >(Gosu::kbQ)));
+  rb_define_const(mGosu, "KbR", SWIG_From_int(static_cast< int >(Gosu::kbR)));
+  rb_define_const(mGosu, "KbS", SWIG_From_int(static_cast< int >(Gosu::kbS)));
+  rb_define_const(mGosu, "KbT", SWIG_From_int(static_cast< int >(Gosu::kbT)));
+  rb_define_const(mGosu, "KbU", SWIG_From_int(static_cast< int >(Gosu::kbU)));
+  rb_define_const(mGosu, "KbV", SWIG_From_int(static_cast< int >(Gosu::kbV)));
+  rb_define_const(mGosu, "KbW", SWIG_From_int(static_cast< int >(Gosu::kbW)));
+  rb_define_const(mGosu, "KbX", SWIG_From_int(static_cast< int >(Gosu::kbX)));
+  rb_define_const(mGosu, "KbY", SWIG_From_int(static_cast< int >(Gosu::kbY)));
+  rb_define_const(mGosu, "KbZ", SWIG_From_int(static_cast< int >(Gosu::kbZ)));
   rb_define_const(mGosu, "KbTab", SWIG_From_int(static_cast< int >(Gosu::kbTab)));
   rb_define_const(mGosu, "KbReturn", SWIG_From_int(static_cast< int >(Gosu::kbReturn)));
   rb_define_const(mGosu, "KbSpace", SWIG_From_int(static_cast< int >(Gosu::kbSpace)));
@@ -8465,8 +8634,10 @@ SWIGEXPORT void Init_gosu(void) {
   // 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.
-  // IMPR: Maybe faster in C?
   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;"