gosu 1.0.0.pre1 → 1.1.0

data/rdoc/gosu.rb

@@ -32,8 +32,8 @@ module Gosu
   KB_DOWN = :an_integer
   KB_END = :an_integer
 
-  KB_PRINTSCREEN = :an_integer
-  KB_SCROLLLOCK = :an_integer
+  KB_PRINT_SCREEN = :an_integer
+  KB_SCROLL_LOCK = :an_integer
   KB_PAUSE = :an_integer
 
   ##
@@ -75,7 +75,7 @@ module Gosu
   KB_RIGHT_SHIFT = :an_integer
   KB_SEMICOLON = :an_integer
   KB_SLASH = :an_integer
-  KB_CAPSLOCK = :an_integer
+  KB_CAPS_LOCK = :an_integer
   KB_SPACE = :an_integer
   KB_TAB = :an_integer
   KB_UP = :an_integer
@@ -811,6 +811,18 @@ module Gosu
     # @return [true, false] whether this window is resizable.
     def resizable?; end
 
+    ##
+    # Toggles between resizable and fixed modes.
+    attr_writer :resizable
+
+    ##
+    # @return [true, false] whether this window is borderless.
+    def borderless?; end
+
+    ##
+    # Toggles between borderless mode and having window chrome.
+    attr_writer :borderless
+
     ##
     # @return [Float] the interval between calls to {#update}, in milliseconds.
     attr_accessor :update_interval
@@ -828,7 +840,8 @@ module Gosu
     # @param height [Integer] the desired window height.
     # @param [Hash] options
     # @option options [true, false] :fullscreen (false) whether to present the window in fullscreen mode.
-    # @option options [true, false] :resizable (false) whether the window can be resized by the user.
+    # @option options [true, false] :resizable (false) whether the window can be resized by the user. Not useful if the window is either fullscreen or borderless.
+    # @option options [true, false] :borderless (false) whether the window should hide all its window chrome. Does not affect fullscreen windows.
     # @option options [Float] :update_interval (16.666666) the interval between frames, in milliseconds.
     def initialize(width, height, options); end
 
@@ -875,7 +888,7 @@ module Gosu
     def draw; end
 
     ##
-    # This method can be overriden to give the game a chance to opt out of a call to {#draw}; however, the operating system can still force a redraw for any reason.
+    # This method can be overridden to give the game a chance to opt out of a call to {#draw}; however, the operating system can still force a redraw for any reason.
     #
     # @return [true, false] whether the window needs to be redrawn.
     #
@@ -883,7 +896,8 @@ module Gosu
     def needs_redraw?; end
 
     ##
-    # This method can be overriden to control the visibility of the system cursor over your window, e.g., for level editors or other situations where introducing a custom cursor or hiding the default one is not desired.
+    # This method can be overridden to control the visibility of the system cursor over your window.
+    # The base class implementation returns true.
     #
     # @return [true, false] whether the system cursor should be shown.
     def needs_cursor?; end

data/src/AudioFile.hpp

@@ -3,6 +3,9 @@
 #include <Gosu/IO.hpp>
 
 #ifdef GOSU_IS_MAC
+// Ignore OpenAL deprecation warnings. If macOS stops shipping OpenAL, it's more likely that we bundle our own version
+// of it than that we switch to another audio API.
+#define OPENAL_DEPRECATED
 #include <OpenAL/al.h>
 #else
 #include <AL/al.h>

data/src/Input.cpp

@@ -26,8 +26,7 @@ static void require_sdl_video()
 
 static const unsigned NUM_BUTTONS_PER_GAMEPAD =
     (Gosu::GP_RANGE_END - Gosu::GP_RANGE_BEGIN + 1 - 4) / (Gosu::NUM_GAMEPADS + 1) - 3;
-static const unsigned NUM_AXES_PER_GAMEPAD =
-    (Gosu::GP_AXES_RANGE_END - Gosu::GP_AXES_RANGE_BEGIN + 1) / (Gosu::NUM_GAMEPADS + 1);
+static const unsigned NUM_AXES_PER_GAMEPAD = Gosu::NUM_AXES / (Gosu::NUM_GAMEPADS + 1);
 static const unsigned NUM_BUTTONS = Gosu::GP_RANGE_END + 1;
 
 static array<bool, NUM_BUTTONS> button_states = {false};
@@ -79,20 +78,11 @@ struct Gosu::Input::Impl
 
     void update_mouse_position()
     {
-    #if SDL_VERSION_ATLEAST(2, 0, 5)
-        // SDL_GetGlobalMouseState was added in SDL 2.0.4, but it only started using the same
-        // coordinate system as SDL_GetWindowPosition on X11 in 2.0.5.
         int x, y, window_x, window_y;
         SDL_GetWindowPosition(window, &window_x, &window_y);
         SDL_GetGlobalMouseState(&x, &y);
         mouse_x = x - window_x;
         mouse_y = y - window_y;
-    #else
-        int x, y;
-        SDL_GetMouseState(&x, &y);
-        mouse_x = x;
-        mouse_y = y;
-    #endif
     }
 
     void set_mouse_position(double x, double y)
@@ -101,7 +91,7 @@ struct Gosu::Input::Impl
                               static_cast<int>((x - mouse_offset_x) / mouse_scale_x),
                               static_cast<int>((y - mouse_offset_y) / mouse_scale_y));
 
-    #if SDL_VERSION_ATLEAST(2, 0, 4) && !defined(GOSU_IS_X)
+    #if !defined(GOSU_IS_X)
         // On systems where we have a working GetGlobalMouseState, we can warp the mouse and
         // retrieve its position directly afterwards.
         update_mouse_position();
@@ -416,17 +406,17 @@ private:
         GamepadBuffer gamepad;
 
         // Poll axes first.
-        gamepad.axes[GP_LEFT_STICK_X_AXIS - GP_AXES_RANGE_BEGIN] =
+        gamepad.axes[GP_LEFT_STICK_X_AXIS] =
             scale_axis(SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_LEFTX));
-        gamepad.axes[GP_LEFT_STICK_Y_AXIS - GP_AXES_RANGE_BEGIN] =
+        gamepad.axes[GP_LEFT_STICK_Y_AXIS] =
             scale_axis(SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_LEFTY));
-        gamepad.axes[GP_RIGHT_STICK_X_AXIS - GP_AXES_RANGE_BEGIN] =
+        gamepad.axes[GP_RIGHT_STICK_X_AXIS] =
             scale_axis(SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_RIGHTX));
-        gamepad.axes[GP_RIGHT_STICK_Y_AXIS - GP_AXES_RANGE_BEGIN] =
+        gamepad.axes[GP_RIGHT_STICK_Y_AXIS] =
             scale_axis(SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_RIGHTY));
-        gamepad.axes[GP_LEFT_TRIGGER_AXIS - GP_AXES_RANGE_BEGIN] =
+        gamepad.axes[GP_LEFT_TRIGGER_AXIS] =
             scale_axis(SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_TRIGGERLEFT));
-        gamepad.axes[GP_RIGHT_TRIGGER_AXIS - GP_AXES_RANGE_BEGIN] =
+        gamepad.axes[GP_RIGHT_TRIGGER_AXIS] =
             scale_axis(SDL_GameControllerGetAxis(controller, SDL_CONTROLLER_AXIS_TRIGGERRIGHT));
 
         gamepad.buttons[GP_DPAD_LEFT - GP_RANGE_BEGIN] =
@@ -460,19 +450,19 @@ private:
         // Just guess that the first four axes are equivalent to two analog sticks.
         int axes = SDL_JoystickNumAxes(joystick);
         if (axes > 0) {
-            gamepad.axes[GP_LEFT_STICK_X_AXIS - GP_AXES_RANGE_BEGIN] =
+            gamepad.axes[GP_LEFT_STICK_X_AXIS] =
                 scale_axis(SDL_JoystickGetAxis(joystick, 0));
         }
         if (axes > 1) {
-            gamepad.axes[GP_LEFT_STICK_Y_AXIS - GP_AXES_RANGE_BEGIN] =
+            gamepad.axes[GP_LEFT_STICK_Y_AXIS] =
                 scale_axis(SDL_JoystickGetAxis(joystick, 1));
         }
         if (axes > 2) {
-            gamepad.axes[GP_RIGHT_STICK_X_AXIS - GP_AXES_RANGE_BEGIN] =
+            gamepad.axes[GP_RIGHT_STICK_X_AXIS] =
                 scale_axis(SDL_JoystickGetAxis(joystick, 2));
         }
         if (axes > 3) {
-            gamepad.axes[GP_RIGHT_STICK_Y_AXIS - GP_AXES_RANGE_BEGIN] =
+            gamepad.axes[GP_RIGHT_STICK_Y_AXIS] =
                 scale_axis(SDL_JoystickGetAxis(joystick, 3));
         }
 
@@ -501,20 +491,20 @@ private:
     {
         gamepad.directions[0] =
             gamepad.buttons[GP_DPAD_LEFT - GP_RANGE_BEGIN] ||
-            gamepad.axes[GP_LEFT_STICK_X_AXIS - GP_AXES_RANGE_BEGIN] <= -0.5 ||
-            gamepad.axes[GP_RIGHT_STICK_X_AXIS - GP_AXES_RANGE_BEGIN] <= -0.5;
+            gamepad.axes[GP_LEFT_STICK_X_AXIS] <= -0.5 ||
+            gamepad.axes[GP_RIGHT_STICK_X_AXIS] <= -0.5;
         gamepad.directions[1] =
             gamepad.buttons[GP_DPAD_RIGHT - GP_RANGE_BEGIN] ||
-            gamepad.axes[GP_LEFT_STICK_X_AXIS - GP_AXES_RANGE_BEGIN] >= +0.5 ||
-            gamepad.axes[GP_RIGHT_STICK_X_AXIS - GP_AXES_RANGE_BEGIN] >= +0.5;
+            gamepad.axes[GP_LEFT_STICK_X_AXIS] >= +0.5 ||
+            gamepad.axes[GP_RIGHT_STICK_X_AXIS] >= +0.5;
         gamepad.directions[2] =
             gamepad.buttons[GP_DPAD_UP - GP_RANGE_BEGIN] ||
-            gamepad.axes[GP_LEFT_STICK_Y_AXIS - GP_AXES_RANGE_BEGIN] <= -0.5 ||
-            gamepad.axes[GP_RIGHT_STICK_Y_AXIS - GP_AXES_RANGE_BEGIN] <= -0.5;
+            gamepad.axes[GP_LEFT_STICK_Y_AXIS] <= -0.5 ||
+            gamepad.axes[GP_RIGHT_STICK_Y_AXIS] <= -0.5;
         gamepad.directions[3] =
             gamepad.buttons[GP_DPAD_DOWN - GP_RANGE_BEGIN] ||
-            gamepad.axes[GP_LEFT_STICK_Y_AXIS - GP_AXES_RANGE_BEGIN] >= +0.5 ||
-            gamepad.axes[GP_RIGHT_STICK_Y_AXIS - GP_AXES_RANGE_BEGIN] >= +0.5;
+            gamepad.axes[GP_LEFT_STICK_Y_AXIS] >= +0.5 ||
+            gamepad.axes[GP_RIGHT_STICK_Y_AXIS] >= +0.5;
     }
 };
 
@@ -537,12 +527,12 @@ string Gosu::Input::id_to_char(Button btn)
 {
     require_sdl_video();
 
-    if (btn.id() > KB_RANGE_END) return "";
+    if (btn > KB_RANGE_END) return "";
 
     // SDL_GetKeyName returns "Space" for this value, but we want the character value.
-    if (btn.id() == KB_SPACE) return " ";
+    if (btn == KB_SPACE) return " ";
 
-    SDL_Keycode keycode = SDL_GetKeyFromScancode(static_cast<SDL_Scancode>(btn.id()));
+    SDL_Keycode keycode = SDL_GetKeyFromScancode(static_cast<SDL_Scancode>(btn));
     if (keycode == SDLK_UNKNOWN) return "";
 
     const char* name = SDL_GetKeyName(keycode);
@@ -573,7 +563,7 @@ std::string Gosu::Input::button_name(Button btn)
 {
     require_sdl_video();
 
-    SDL_Keycode keycode = SDL_GetKeyFromScancode(static_cast<SDL_Scancode>(btn.id()));
+    SDL_Keycode keycode = SDL_GetKeyFromScancode(static_cast<SDL_Scancode>(btn));
     return SDL_GetKeyName(keycode);
 }
 
@@ -601,17 +591,17 @@ std::string Gosu::Input::gamepad_name(int index)
 
 bool Gosu::Input::down(Gosu::Button btn)
 {
-    if (btn == NO_BUTTON || btn.id() >= NUM_BUTTONS) return false;
+    if (btn == NO_BUTTON || btn >= NUM_BUTTONS) return false;
 
-    return button_states[btn.id()];
+    return button_states[btn];
 }
 
 double Gosu::Input::axis(Gosu::Button btn)
 {
-    unsigned axis_id = btn.id() - GP_LEFT_STICK_X_AXIS;
+    unsigned axis_id = btn - GP_LEFT_STICK_X_AXIS;
 
     if (axis_id >= axis_states.size()) {
-        throw std::out_of_range("Invalid axis ID: " + std::to_string(btn.id()));
+        throw std::out_of_range("Invalid axis ID: " + std::to_string(btn));
     }
 
     return axis_states[axis_id];

data/src/Resolution.cpp

@@ -18,12 +18,12 @@ static SDL_DisplayMode display_mode(Gosu::Window* window)
     return result;
 }
 
-unsigned Gosu::screen_width(Window* window)
+int Gosu::screen_width(Window* window)
 {
     return display_mode(window).w;
 }
 
-unsigned Gosu::screen_height(Window* window)
+int Gosu::screen_height(Window* window)
 {
     return display_mode(window).h;
 }
@@ -41,12 +41,12 @@ static NSSize max_window_size(Gosu::Window* window)
     return [NSWindow contentRectForFrameRect:screen_frame styleMask:style].size;
 }
 
-unsigned Gosu::available_width(Window* window)
+int Gosu::available_width(Window* window)
 {
     return max_window_size(window).width;
 }
 
-unsigned Gosu::available_height(Window* window)
+int Gosu::available_height(Window* window)
 {
     return max_window_size(window).height;
 }
@@ -90,12 +90,12 @@ static SIZE max_window_size(Gosu::Window* window)
     return size;
 }
 
-unsigned Gosu::available_width(Window* window)
+int Gosu::available_width(Window* window)
 {
     return max_window_size(window).cx;
 }
 
-unsigned Gosu::available_height(Window* window)
+int Gosu::available_height(Window* window)
 {
     return max_window_size(window).cy;
 }
@@ -104,12 +104,12 @@ unsigned Gosu::available_height(Window* window)
 #ifdef GOSU_IS_X
 // Pessimistic fallback implementation for available_width / available_height.
 // TODO: Look at this NET_WORKAREA based implementation: https://github.com/glfw/glfw/pull/989/files
-unsigned Gosu::available_width(Window* window)
+int Gosu::available_width(Window* window)
 {
     return static_cast<unsigned>(Gosu::screen_width(window) * 0.9);
 }
 
-unsigned Gosu::available_height(Window* window)
+int Gosu::available_height(Window* window)
 {
     return static_cast<unsigned>(Gosu::screen_height(window) * 0.8);
 }

data/src/RubyGosu.cxx

@@ -2174,22 +2174,21 @@ namespace Swig {
 
 /* -------- TYPES TABLE (BEGIN) -------- */
 
-#define SWIGTYPE_p_Gosu__Button swig_types[0]
-#define SWIGTYPE_p_Gosu__Channel 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__Song swig_types[7]
-#define SWIGTYPE_p_Gosu__TextInput swig_types[8]
-#define SWIGTYPE_p_Gosu__Window swig_types[9]
-#define SWIGTYPE_p_char swig_types[10]
-#define SWIGTYPE_p_double swig_types[11]
-#define SWIGTYPE_p_std__arrayT_double_16_t swig_types[12]
-#define SWIGTYPE_p_std__string 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__Channel swig_types[0]
+#define SWIGTYPE_p_Gosu__Color swig_types[1]
+#define SWIGTYPE_p_Gosu__Font swig_types[2]
+#define SWIGTYPE_p_Gosu__GLTexInfo swig_types[3]
+#define SWIGTYPE_p_Gosu__Image swig_types[4]
+#define SWIGTYPE_p_Gosu__Sample swig_types[5]
+#define SWIGTYPE_p_Gosu__Song swig_types[6]
+#define SWIGTYPE_p_Gosu__TextInput swig_types[7]
+#define SWIGTYPE_p_Gosu__Window swig_types[8]
+#define SWIGTYPE_p_char swig_types[9]
+#define SWIGTYPE_p_double swig_types[10]
+#define SWIGTYPE_p_std__arrayT_double_16_t swig_types[11]
+#define SWIGTYPE_p_std__string swig_types[12]
+static swig_type_info *swig_types[14];
+static swig_module_info swig_module = {swig_types, 13, 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)
 
@@ -2857,11 +2856,19 @@ SWIGINTERN Gosu::Font *new_Gosu_Font__SWIG_1(int height,VALUE options=0){
         
         return new Gosu::Font(height, font_name, font_flags);
     }
+SWIGINTERN double Gosu_Font_text_width(Gosu::Font *self,std::string const &markup,double scale_x=1.0){
+      static bool issued_warning = false;
+      if (scale_x != 1.0 && !issued_warning) {
+          issued_warning = true;
+          rb_warn("The second argument to Gosu::Font#text_width is deprecated, multiply the result instead");
+      }
+      return self->text_width(markup) * scale_x;
+    }
 SWIGINTERN double Gosu_Font_markup_width(Gosu::Font *self,std::string const &markup,double scale_x=1.0){
       static bool issued_warning = false;
       if (scale_x != 1.0 && !issued_warning) {
           issued_warning = true;
-          rb_warn("The second argument to Font#markup_width and Font#text_width is deprecated, multiply the result instead");
+          rb_warn("The second argument to Gosu::Font#markup_width is deprecated, multiply the result instead");
       }
       return self->markup_width(markup) * scale_x;
     }
@@ -2927,7 +2934,81 @@ SWIGINTERN Gosu::Image *Gosu_Image_subimage(Gosu::Image *self,int x,int y,int w,
         std::unique_ptr<Gosu::ImageData> image_data = self->data().subimage(x, y, w, h);
         return image_data.get() ? new Gosu::Image(std::move(image_data)) : nullptr;
     }
-SWIGINTERN Gosu::Image *Gosu_Image_from_text(std::string const &markup,double font_height,VALUE options=0){
+SWIGINTERN Gosu::Image *Gosu_Image_from_text(std::string const &text,double font_height,VALUE options=0){
+        std::string font = Gosu::default_font_name();
+        int width = -1;
+        double spacing = 0;
+        Gosu::Alignment align = Gosu::AL_LEFT;
+        unsigned image_flags = 0;
+        unsigned font_flags = 0;
+
+        if (options) {
+            Check_Type(options, T_HASH);
+
+            VALUE keys = rb_funcall(options, rb_intern("keys"), 0, NULL);
+            int keys_size = NUM2INT(rb_funcall(keys, rb_intern("size"), 0, NULL));
+
+            for (int i = 0; i < keys_size; ++i) {
+                VALUE key = rb_ary_entry(keys, i);
+                const char* key_string = Gosu::cstr_from_symbol(key);
+
+                VALUE value = rb_hash_aref(options, key);
+                if (!strcmp(key_string, "font")) {
+                    font = StringValuePtr(value);
+                }
+                else if (!strcmp(key_string, "bold")) {
+                    if (RTEST(value)) font_flags |= Gosu::FF_BOLD;
+                }
+                else if (!strcmp(key_string, "italic")) {
+                    if (RTEST(value)) font_flags |= Gosu::FF_ITALIC;
+                }
+                else if (!strcmp(key_string, "underline")) {
+                    if (RTEST(value)) font_flags |= Gosu::FF_UNDERLINE;
+                }
+                else if (!strcmp(key_string, "align")) {
+                    const char* cstr = Gosu::cstr_from_symbol(value);
+
+                    if (!strcmp(cstr, "left")) {
+                        align = Gosu::AL_LEFT;
+                    }
+                    else if (!strcmp(cstr, "center")) {
+                        align = Gosu::AL_CENTER;
+                    }
+                    else if (!strcmp(cstr, "right")) {
+                        align = Gosu::AL_RIGHT;
+                    }
+                    else if (!strcmp(cstr, "justify")) {
+                        align = Gosu::AL_JUSTIFY;
+                    }
+                    else {
+                        rb_raise(rb_eArgError, "Argument passed to :align must be a valid text "
+                                               "alignment (:left, :center, :right, :justify)");
+                    }
+                }
+                else if (!strcmp(key_string, "width")) {
+                    width = NUM2INT(value);
+                }
+                else if (!strcmp(key_string, "spacing")) {
+                    spacing = NUM2DBL(value);
+                }
+                else if (!strcmp(key_string, "retro")) {
+                    if (RTEST(value)) image_flags |= Gosu::IF_RETRO;
+                }
+                else {
+                    static bool issued_warning = false;
+                    if (!issued_warning) {
+                        issued_warning = true;
+                        rb_warn("Unknown keyword argument: :%s", key_string);
+                    }
+                }
+            }
+        }
+
+        Gosu::Bitmap bitmap = Gosu::layout_text(text, font, font_height, spacing, width,
+                                                align, font_flags);
+        return new Gosu::Image(bitmap, image_flags);
+    }
+SWIGINTERN Gosu::Image *Gosu_Image_from_markup(std::string const &markup,double font_height,VALUE options=0){
         std::string font = Gosu::default_font_name();
         int width = -1;
         double spacing = 0;
@@ -3219,7 +3300,7 @@ std::string SwigDirector_TextInput::filter(std::string text) const {
 }
 
 
-SwigDirector_Window::SwigDirector_Window(VALUE self,unsigned int width,unsigned int height,bool fullscreen,double update_interval,bool resizable): Gosu::Window(width, height, fullscreen, update_interval, resizable), Swig::Director(self) {
+SwigDirector_Window::SwigDirector_Window(VALUE self,int width,int height,unsigned int window_flags,double update_interval): Gosu::Window(width, height, window_flags, update_interval), Swig::Director(self) {
   
 }
 
@@ -3320,7 +3401,7 @@ void SwigDirector_Window::button_down(Gosu::Button arg0) {
   VALUE SWIGUNUSED result;
   
   {
-    obj0 = arg0 == Gosu::NO_BUTTON ? Qnil : LONG2NUM((&arg0)->id());
+    obj0 = arg0 == Gosu::NO_BUTTON ? Qnil : LONG2NUM(arg0);
   }
   result = rb_funcall(swig_get_self(), rb_intern("protected_button_down"), 1,obj0);
 }
@@ -3331,7 +3412,7 @@ void SwigDirector_Window::button_up(Gosu::Button arg0) {
   VALUE SWIGUNUSED result;
   
   {
-    obj0 = arg0 == Gosu::NO_BUTTON ? Qnil : LONG2NUM((&arg0)->id());
+    obj0 = arg0 == Gosu::NO_BUTTON ? Qnil : LONG2NUM(arg0);
   }
   result = rb_funcall(swig_get_self(), rb_intern("protected_button_up"), 1,obj0);
 }
@@ -5282,6 +5363,134 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Font_draw_text(int argc, VALUE *argv, VALUE self) {
+  Gosu::Font *arg1 = (Gosu::Font *) 0 ;
+  std::string *arg2 = 0 ;
+  double arg3 ;
+  double arg4 ;
+  Gosu::ZPos arg5 ;
+  double arg6 = (double) 1 ;
+  double arg7 = (double) 1 ;
+  Gosu::Color arg8 = (Gosu::Color) Gosu::Color::WHITE ;
+  Gosu::AlphaMode arg9 = (Gosu::AlphaMode) Gosu::AM_DEFAULT ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val5 ;
+  int ecode5 = 0 ;
+  double val6 ;
+  int ecode6 = 0 ;
+  double val7 ;
+  int ecode7 = 0 ;
+  
+  if ((argc < 4) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Font, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font const *","draw_text", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Font * >(argp1);
+  {
+    std::string *ptr = (std::string *)0;
+    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","draw_text", 2, argv[0] )); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","draw_text", 2, argv[0])); 
+    }
+    arg2 = ptr;
+  }
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","draw_text", 3, argv[1] ));
+  } 
+  arg3 = static_cast< double >(val3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","draw_text", 4, argv[2] ));
+  } 
+  arg4 = static_cast< double >(val4);
+  ecode5 = SWIG_AsVal_double(argv[3], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Gosu::ZPos","draw_text", 5, argv[3] ));
+  } 
+  arg5 = static_cast< Gosu::ZPos >(val5);
+  if (argc > 4) {
+    ecode6 = SWIG_AsVal_double(argv[4], &val6);
+    if (!SWIG_IsOK(ecode6)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","draw_text", 6, argv[4] ));
+    } 
+    arg6 = static_cast< double >(val6);
+  }
+  if (argc > 5) {
+    ecode7 = SWIG_AsVal_double(argv[5], &val7);
+    if (!SWIG_IsOK(ecode7)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","draw_text", 7, argv[5] ));
+    } 
+    arg7 = static_cast< double >(val7);
+  }
+  if (argc > 6) {
+    {
+      if (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) {
+        arg8 = Gosu::Color(NUM2ULONG(argv[6]));
+      }
+      else {
+        void* ptr;
+        int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+        if (!SWIG_IsOK(res)) {
+          SWIG_exception_fail(SWIG_ValueError, "invalid value");
+        }
+        else if (ptr == nullptr) {
+          SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
+        }
+        else {
+          arg8 = *reinterpret_cast<Gosu::Color*>(ptr);
+        }
+      }
+    }
+  }
+  if (argc > 7) {
+    {
+      const char* cstr = Gosu::cstr_from_symbol(argv[7]);
+      
+      if (!strcmp(cstr, "default")) {
+        arg9 = Gosu::AM_DEFAULT;
+      }
+      else if (!strcmp(cstr, "add") || !strcmp(cstr, "additive")) {
+        arg9 = Gosu::AM_ADD;
+      }
+      else if (!strcmp(cstr, "multiply")) {
+        arg9 = Gosu::AM_MULTIPLY;
+      }
+      else {
+        SWIG_exception_fail(SWIG_ValueError, "invalid alpha mode (expected one of :default, :add, "
+          ":multiply)");
+      }
+    }
+  }
+  {
+    try {
+      ((Gosu::Font const *)arg1)->draw_text((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return Qnil;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Font_draw_markup(int argc, VALUE *argv, VALUE self) {
   Gosu::Font *arg1 = (Gosu::Font *) 0 ;
@@ -5353,16 +5562,160 @@ _wrap_Font_draw_markup(int argc, VALUE *argv, VALUE self) {
     if (!SWIG_IsOK(ecode7)) {
       SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","draw_markup", 7, argv[5] ));
     } 
-    arg7 = static_cast< double >(val7);
+    arg7 = static_cast< double >(val7);
+  }
+  if (argc > 6) {
+    {
+      if (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) {
+        arg8 = Gosu::Color(NUM2ULONG(argv[6]));
+      }
+      else {
+        void* ptr;
+        int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+        if (!SWIG_IsOK(res)) {
+          SWIG_exception_fail(SWIG_ValueError, "invalid value");
+        }
+        else if (ptr == nullptr) {
+          SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
+        }
+        else {
+          arg8 = *reinterpret_cast<Gosu::Color*>(ptr);
+        }
+      }
+    }
+  }
+  if (argc > 7) {
+    {
+      const char* cstr = Gosu::cstr_from_symbol(argv[7]);
+      
+      if (!strcmp(cstr, "default")) {
+        arg9 = Gosu::AM_DEFAULT;
+      }
+      else if (!strcmp(cstr, "add") || !strcmp(cstr, "additive")) {
+        arg9 = Gosu::AM_ADD;
+      }
+      else if (!strcmp(cstr, "multiply")) {
+        arg9 = Gosu::AM_MULTIPLY;
+      }
+      else {
+        SWIG_exception_fail(SWIG_ValueError, "invalid alpha mode (expected one of :default, :add, "
+          ":multiply)");
+      }
+    }
+  }
+  {
+    try {
+      ((Gosu::Font const *)arg1)->draw_markup((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return Qnil;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Font_draw_text_rel(int argc, VALUE *argv, VALUE self) {
+  Gosu::Font *arg1 = (Gosu::Font *) 0 ;
+  std::string *arg2 = 0 ;
+  double arg3 ;
+  double arg4 ;
+  Gosu::ZPos arg5 ;
+  double arg6 ;
+  double arg7 ;
+  double arg8 = (double) 1 ;
+  double arg9 = (double) 1 ;
+  Gosu::Color arg10 = (Gosu::Color) Gosu::Color::WHITE ;
+  Gosu::AlphaMode arg11 = (Gosu::AlphaMode) Gosu::AM_DEFAULT ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val5 ;
+  int ecode5 = 0 ;
+  double val6 ;
+  int ecode6 = 0 ;
+  double val7 ;
+  int ecode7 = 0 ;
+  double val8 ;
+  int ecode8 = 0 ;
+  double val9 ;
+  int ecode9 = 0 ;
+  
+  if ((argc < 6) || (argc > 10)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Font, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font const *","draw_text_rel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Font * >(argp1);
+  {
+    std::string *ptr = (std::string *)0;
+    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","draw_text_rel", 2, argv[0] )); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","draw_text_rel", 2, argv[0])); 
+    }
+    arg2 = ptr;
+  }
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","draw_text_rel", 3, argv[1] ));
+  } 
+  arg3 = static_cast< double >(val3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","draw_text_rel", 4, argv[2] ));
+  } 
+  arg4 = static_cast< double >(val4);
+  ecode5 = SWIG_AsVal_double(argv[3], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Gosu::ZPos","draw_text_rel", 5, argv[3] ));
+  } 
+  arg5 = static_cast< Gosu::ZPos >(val5);
+  ecode6 = SWIG_AsVal_double(argv[4], &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","draw_text_rel", 6, argv[4] ));
+  } 
+  arg6 = static_cast< double >(val6);
+  ecode7 = SWIG_AsVal_double(argv[5], &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","draw_text_rel", 7, argv[5] ));
+  } 
+  arg7 = static_cast< double >(val7);
+  if (argc > 6) {
+    ecode8 = SWIG_AsVal_double(argv[6], &val8);
+    if (!SWIG_IsOK(ecode8)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","draw_text_rel", 8, argv[6] ));
+    } 
+    arg8 = static_cast< double >(val8);
+  }
+  if (argc > 7) {
+    ecode9 = SWIG_AsVal_double(argv[7], &val9);
+    if (!SWIG_IsOK(ecode9)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "double","draw_text_rel", 9, argv[7] ));
+    } 
+    arg9 = static_cast< double >(val9);
   }
-  if (argc > 6) {
+  if (argc > 8) {
     {
-      if (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) {
-        arg8 = Gosu::Color(NUM2ULONG(argv[6]));
+      if (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) {
+        arg10 = Gosu::Color(NUM2ULONG(argv[8]));
       }
       else {
         void* ptr;
-        int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_Gosu__Color, 0);
+        int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_Gosu__Color, 0);
         if (!SWIG_IsOK(res)) {
           SWIG_exception_fail(SWIG_ValueError, "invalid value");
         }
@@ -5370,23 +5723,23 @@ _wrap_Font_draw_markup(int argc, VALUE *argv, VALUE self) {
           SWIG_exception_fail(SWIG_ValueError, "invalid null reference of type Gosu::Color");
         }
         else {
-          arg8 = *reinterpret_cast<Gosu::Color*>(ptr);
+          arg10 = *reinterpret_cast<Gosu::Color*>(ptr);
         }
       }
     }
   }
-  if (argc > 7) {
+  if (argc > 9) {
     {
-      const char* cstr = Gosu::cstr_from_symbol(argv[7]);
+      const char* cstr = Gosu::cstr_from_symbol(argv[9]);
       
       if (!strcmp(cstr, "default")) {
-        arg9 = Gosu::AM_DEFAULT;
+        arg11 = Gosu::AM_DEFAULT;
       }
       else if (!strcmp(cstr, "add") || !strcmp(cstr, "additive")) {
-        arg9 = Gosu::AM_ADD;
+        arg11 = Gosu::AM_ADD;
       }
       else if (!strcmp(cstr, "multiply")) {
-        arg9 = Gosu::AM_MULTIPLY;
+        arg11 = Gosu::AM_MULTIPLY;
       }
       else {
         SWIG_exception_fail(SWIG_ValueError, "invalid alpha mode (expected one of :default, :add, "
@@ -5396,7 +5749,7 @@ _wrap_Font_draw_markup(int argc, VALUE *argv, VALUE self) {
   }
   {
     try {
-      ((Gosu::Font const *)arg1)->draw_markup((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+      ((Gosu::Font const *)arg1)->draw_text_rel((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
@@ -5767,6 +6120,62 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Font_text_width(int argc, VALUE *argv, VALUE self) {
+  Gosu::Font *arg1 = (Gosu::Font *) 0 ;
+  std::string *arg2 = 0 ;
+  double arg3 = (double) 1.0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Font, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Font *","text_width", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Font * >(argp1);
+  {
+    std::string *ptr = (std::string *)0;
+    res2 = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::string const &","text_width", 2, argv[0] )); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","text_width", 2, argv[0])); 
+    }
+    arg2 = ptr;
+  }
+  if (argc > 1) {
+    ecode3 = SWIG_AsVal_double(argv[1], &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","text_width", 3, argv[1] ));
+    } 
+    arg3 = static_cast< double >(val3);
+  }
+  {
+    try {
+      result = (double)Gosu_Font_text_width(arg1,(std::string const &)*arg2,arg3);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_double(static_cast< double >(result));
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return vresult;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Font_markup_width(int argc, VALUE *argv, VALUE self) {
   Gosu::Font *arg1 = (Gosu::Font *) 0 ;
@@ -7016,6 +7425,56 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Image_from_markup(int argc, VALUE *argv, VALUE self) {
+  std::string *arg1 = 0 ;
+  double arg2 ;
+  VALUE arg3 = (VALUE) 0 ;
+  int res1 = SWIG_OLDOBJ ;
+  double val2 ;
+  int ecode2 = 0 ;
+  Gosu::Image *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  {
+    std::string *ptr = (std::string *)0;
+    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::string const &","Gosu_Image_from_markup", 1, argv[0] )); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","Gosu_Image_from_markup", 1, argv[0])); 
+    }
+    arg1 = ptr;
+  }
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Gosu_Image_from_markup", 2, argv[1] ));
+  } 
+  arg2 = static_cast< double >(val2);
+  if (argc > 2) {
+    arg3 = argv[2];
+  }
+  {
+    try {
+      result = (Gosu::Image *)Gosu_Image_from_markup((std::string const &)*arg1,arg2,arg3);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Gosu__Image, SWIG_POINTER_OWN |  0 );
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return vresult;
+fail:
+  if (SWIG_IsNewObj(res1)) delete arg1;
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Image_load_tiles__SWIG_0(int argc, VALUE *argv, VALUE self) {
   VALUE arg1 = (VALUE) 0 ;
@@ -8739,44 +9198,41 @@ _wrap_Window_allocate(int argc, VALUE *argv, VALUE self)
 SWIGINTERN VALUE
 _wrap_new_Window(int argc, VALUE *argv, VALUE self) {
   VALUE arg1 = (VALUE) 0 ;
-  unsigned int arg2 ;
-  unsigned int arg3 ;
-  bool arg4 = (bool) false ;
+  int arg2 ;
+  int arg3 ;
+  unsigned int arg4 = (unsigned int) Gosu::WF_WINDOWED ;
   double arg5 = (double) 16.666666 ;
-  bool arg6 = (bool) false ;
-  unsigned int val2 ;
+  int val2 ;
   int ecode2 = 0 ;
-  unsigned int val3 ;
+  int val3 ;
   int ecode3 = 0 ;
-  bool val4 ;
+  unsigned int val4 ;
   int ecode4 = 0 ;
   double val5 ;
   int ecode5 = 0 ;
-  bool val6 ;
-  int ecode6 = 0 ;
   const char *classname SWIGUNUSED = "Gosu::Window";
   Gosu::Window *result = 0 ;
   
-  if ((argc < 2) || (argc > 5)) {
+  if ((argc < 2) || (argc > 4)) {
     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
   }
   arg1 = self;
-  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","Window", 2, argv[0] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Window", 2, argv[0] ));
   } 
-  arg2 = static_cast< unsigned int >(val2);
-  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
+  arg2 = static_cast< int >(val2);
+  ecode3 = SWIG_AsVal_int(argv[1], &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","Window", 3, argv[1] ));
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Window", 3, argv[1] ));
   } 
-  arg3 = static_cast< unsigned int >(val3);
+  arg3 = static_cast< int >(val3);
   if (argc > 2) {
-    ecode4 = SWIG_AsVal_bool(argv[2], &val4);
+    ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
     if (!SWIG_IsOK(ecode4)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Window", 4, argv[2] ));
+      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","Window", 4, argv[2] ));
     } 
-    arg4 = static_cast< bool >(val4);
+    arg4 = static_cast< unsigned int >(val4);
   }
   if (argc > 3) {
     ecode5 = SWIG_AsVal_double(argv[3], &val5);
@@ -8785,20 +9241,13 @@ _wrap_new_Window(int argc, VALUE *argv, VALUE self) {
     } 
     arg5 = static_cast< double >(val5);
   }
-  if (argc > 4) {
-    ecode6 = SWIG_AsVal_bool(argv[4], &val6);
-    if (!SWIG_IsOK(ecode6)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","Window", 6, argv[4] ));
-    } 
-    arg6 = static_cast< bool >(val6);
-  }
   {
     try {
       if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
         /* subclassed */
-        result = (Gosu::Window *)new SwigDirector_Window(arg1,arg2,arg3,arg4,arg5,arg6); 
+        result = (Gosu::Window *)new SwigDirector_Window(arg1,arg2,arg3,arg4,arg5); 
       } else {
-        result = (Gosu::Window *)new Gosu::Window(arg2,arg3,arg4,arg5,arg6); 
+        result = (Gosu::Window *)new Gosu::Window(arg2,arg3,arg4,arg5); 
       }
       
       DATA_PTR(self) = result;
@@ -8826,7 +9275,7 @@ _wrap_Window_width(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  unsigned int result;
+  int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -8839,13 +9288,13 @@ _wrap_Window_width(int argc, VALUE *argv, VALUE self) {
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      result = (unsigned int)((Gosu::Window const *)arg1)->width();
+      result = (int)((Gosu::Window const *)arg1)->width();
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -8857,7 +9306,7 @@ _wrap_Window_height(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  unsigned int result;
+  int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -8870,13 +9319,13 @@ _wrap_Window_height(int argc, VALUE *argv, VALUE self) {
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      result = (unsigned int)((Gosu::Window const *)arg1)->height();
+      result = (int)((Gosu::Window const *)arg1)->height();
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -8945,6 +9394,109 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_Window_resizablee___(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  bool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool 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), Ruby_Format_TypeError( "", "Gosu::Window *","set_resizable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","set_resizable", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  {
+    try {
+      (arg1)->set_resizable(arg2);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Window_borderlessq___(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","borderless", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  {
+    try {
+      result = (bool)((Gosu::Window const *)arg1)->borderless();
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_Window_borderlesse___(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  bool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool 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), Ruby_Format_TypeError( "", "Gosu::Window *","set_borderless", 1, self )); 
+  }
+  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","set_borderless", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  {
+    try {
+      (arg1)->set_borderless(arg2);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Window_update_interval(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
@@ -10125,7 +10677,7 @@ _wrap_screen_width(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) nullptr ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  unsigned int result;
+  int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 1)) {
@@ -10140,13 +10692,13 @@ _wrap_screen_width(int argc, VALUE *argv, VALUE self) {
   }
   {
     try {
-      result = (unsigned int)Gosu::screen_width(arg1);
+      result = (int)Gosu::screen_width(arg1);
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -10158,7 +10710,7 @@ _wrap_screen_height(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) nullptr ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  unsigned int result;
+  int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 1)) {
@@ -10173,13 +10725,13 @@ _wrap_screen_height(int argc, VALUE *argv, VALUE self) {
   }
   {
     try {
-      result = (unsigned int)Gosu::screen_height(arg1);
+      result = (int)Gosu::screen_height(arg1);
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -10191,7 +10743,7 @@ _wrap_available_width(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) nullptr ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  unsigned int result;
+  int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 1)) {
@@ -10206,13 +10758,13 @@ _wrap_available_width(int argc, VALUE *argv, VALUE self) {
   }
   {
     try {
-      result = (unsigned int)Gosu::available_width(arg1);
+      result = (int)Gosu::available_width(arg1);
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -10224,7 +10776,7 @@ _wrap_available_height(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) nullptr ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  unsigned int result;
+  int result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 1)) {
@@ -10239,13 +10791,13 @@ _wrap_available_height(int argc, VALUE *argv, VALUE self) {
   }
   {
     try {
-      result = (unsigned int)Gosu::available_height(arg1);
+      result = (int)Gosu::available_height(arg1);
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  vresult = SWIG_From_int(static_cast< int >(result));
   return vresult;
 fail:
   return Qnil;
@@ -10272,14 +10824,14 @@ _wrap_char_to_button_id(int argc, VALUE *argv, VALUE self) {
   }
   {
     try {
-      result = Gosu::char_to_button_id(arg1);
+      result = (Gosu::Button)Gosu::char_to_button_id(arg1);
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
   {
-    vresult = result == Gosu::NO_BUTTON ? Qnil : LONG2NUM((&result)->id());
+    vresult = result == Gosu::NO_BUTTON ? Qnil : LONG2NUM(result);
   }
   return vresult;
 fail:
@@ -11651,7 +12203,6 @@ fail:
 
 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
-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__Channel = {"_p_Gosu__Channel", "Gosu::Channel *", 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};
@@ -11667,7 +12218,6 @@ static swig_type_info _swigt__p_std__arrayT_double_16_t = {"_p_std__arrayT_doubl
 static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0};
 
 static swig_type_info *swig_type_initial[] = {
-  &_swigt__p_Gosu__Button,
   &_swigt__p_Gosu__Channel,
   &_swigt__p_Gosu__Color,
   &_swigt__p_Gosu__Font,
@@ -11683,7 +12233,6 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_std__string,
 };
 
-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__Channel[] = {  {&_swigt__p_Gosu__Channel, 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}};
@@ -11699,7 +12248,6 @@ static swig_cast_info _swigc__p_std__arrayT_double_16_t[] = {  {&_swigt__p_std__
 static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
 
 static swig_cast_info *swig_cast_initial[] = {
-  _swigc__p_Gosu__Button,
   _swigc__p_Gosu__Channel,
   _swigc__p_Gosu__Color,
   _swigc__p_Gosu__Font,
@@ -11969,9 +12517,9 @@ SWIGEXPORT void Init_gosu(void) {
   SWIG_RubyInitializeTrackings();
   rb_define_const(mGosu, "VERSION", SWIG_From_std_string(static_cast< std::string >(Gosu::VERSION)));
   rb_define_const(mGosu, "LICENSES", SWIG_From_std_string(static_cast< std::string >(Gosu::LICENSES)));
-  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 >(15)));
-  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(2)));
+  rb_define_const(mGosu, "MAJOR_VERSION", SWIG_From_int(static_cast< int >(1)));
+  rb_define_const(mGosu, "MINOR_VERSION", SWIG_From_int(static_cast< int >(1)));
+  rb_define_const(mGosu, "POINT_VERSION", SWIG_From_int(static_cast< int >(0)));
   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, "degrees_to_radians", VALUEFUNC(_wrap_degrees_to_radians), -1);
@@ -12029,9 +12577,12 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassFont.klass, "name", VALUEFUNC(_wrap_Font_name), -1);
   rb_define_method(SwigClassFont.klass, "height", VALUEFUNC(_wrap_Font_height), -1);
   rb_define_method(SwigClassFont.klass, "flags", VALUEFUNC(_wrap_Font_flags), -1);
+  rb_define_method(SwigClassFont.klass, "draw_text", VALUEFUNC(_wrap_Font_draw_text), -1);
   rb_define_method(SwigClassFont.klass, "draw_markup", VALUEFUNC(_wrap_Font_draw_markup), -1);
+  rb_define_method(SwigClassFont.klass, "draw_text_rel", VALUEFUNC(_wrap_Font_draw_text_rel), -1);
   rb_define_method(SwigClassFont.klass, "draw_markup_rel", VALUEFUNC(_wrap_Font_draw_markup_rel), -1);
   rb_define_method(SwigClassFont.klass, "set_image", VALUEFUNC(_wrap_Font_set_image), -1);
+  rb_define_method(SwigClassFont.klass, "text_width", VALUEFUNC(_wrap_Font_text_width), -1);
   rb_define_method(SwigClassFont.klass, "markup_width", VALUEFUNC(_wrap_Font_markup_width), -1);
   SwigClassFont.mark = 0;
   SwigClassFont.destroy = (void (*)(void *)) free_Gosu_Font;
@@ -12068,6 +12619,7 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassImage.klass, "gl_tex_info", VALUEFUNC(_wrap_Image_gl_tex_info), -1);
   rb_define_method(SwigClassImage.klass, "subimage", VALUEFUNC(_wrap_Image_subimage), -1);
   rb_define_singleton_method(SwigClassImage.klass, "from_text", VALUEFUNC(_wrap_Image_from_text), -1);
+  rb_define_singleton_method(SwigClassImage.klass, "from_markup", VALUEFUNC(_wrap_Image_from_markup), -1);
   rb_define_singleton_method(SwigClassImage.klass, "load_tiles", VALUEFUNC(_wrap_Image_load_tiles), -1);
   rb_define_method(SwigClassImage.klass, "to_blob", VALUEFUNC(_wrap_Image_to_blob), -1);
   rb_define_method(SwigClassImage.klass, "columns", VALUEFUNC(_wrap_Image_columns), -1);
@@ -12163,8 +12715,8 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_const(mGosu, "KB_DOWN", SWIG_From_int(static_cast< int >(Gosu::KB_DOWN)));
   rb_define_const(mGosu, "KB_HOME", SWIG_From_int(static_cast< int >(Gosu::KB_HOME)));
   rb_define_const(mGosu, "KB_END", SWIG_From_int(static_cast< int >(Gosu::KB_END)));
-  rb_define_const(mGosu, "KB_PRINTSCREEN", SWIG_From_int(static_cast< int >(Gosu::KB_PRINTSCREEN)));
-  rb_define_const(mGosu, "KB_SCROLLLOCK", SWIG_From_int(static_cast< int >(Gosu::KB_SCROLLLOCK)));
+  rb_define_const(mGosu, "KB_PRINT_SCREEN", SWIG_From_int(static_cast< int >(Gosu::KB_PRINT_SCREEN)));
+  rb_define_const(mGosu, "KB_SCROLL_LOCK", SWIG_From_int(static_cast< int >(Gosu::KB_SCROLL_LOCK)));
   rb_define_const(mGosu, "KB_PAUSE", SWIG_From_int(static_cast< int >(Gosu::KB_PAUSE)));
   rb_define_const(mGosu, "KB_INSERT", SWIG_From_int(static_cast< int >(Gosu::KB_INSERT)));
   rb_define_const(mGosu, "KB_DELETE", SWIG_From_int(static_cast< int >(Gosu::KB_DELETE)));
@@ -12182,7 +12734,7 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_const(mGosu, "KB_COMMA", SWIG_From_int(static_cast< int >(Gosu::KB_COMMA)));
   rb_define_const(mGosu, "KB_PERIOD", SWIG_From_int(static_cast< int >(Gosu::KB_PERIOD)));
   rb_define_const(mGosu, "KB_SLASH", SWIG_From_int(static_cast< int >(Gosu::KB_SLASH)));
-  rb_define_const(mGosu, "KB_CAPSLOCK", SWIG_From_int(static_cast< int >(Gosu::KB_CAPSLOCK)));
+  rb_define_const(mGosu, "KB_CAPS_LOCK", SWIG_From_int(static_cast< int >(Gosu::KB_CAPS_LOCK)));
   rb_define_const(mGosu, "KB_A", SWIG_From_int(static_cast< int >(Gosu::KB_A)));
   rb_define_const(mGosu, "KB_B", SWIG_From_int(static_cast< int >(Gosu::KB_B)));
   rb_define_const(mGosu, "KB_C", SWIG_From_int(static_cast< int >(Gosu::KB_C)));
@@ -12422,6 +12974,9 @@ SWIGEXPORT void Init_gosu(void) {
   rb_define_method(SwigClassWindow.klass, "height", VALUEFUNC(_wrap_Window_height), -1);
   rb_define_method(SwigClassWindow.klass, "fullscreen?", VALUEFUNC(_wrap_Window_fullscreenq___), -1);
   rb_define_method(SwigClassWindow.klass, "resizable?", VALUEFUNC(_wrap_Window_resizableq___), -1);
+  rb_define_method(SwigClassWindow.klass, "resizable=", VALUEFUNC(_wrap_Window_resizablee___), -1);
+  rb_define_method(SwigClassWindow.klass, "borderless?", VALUEFUNC(_wrap_Window_borderlessq___), -1);
+  rb_define_method(SwigClassWindow.klass, "borderless=", VALUEFUNC(_wrap_Window_borderlesse___), -1);
   rb_define_method(SwigClassWindow.klass, "update_interval", VALUEFUNC(_wrap_Window_update_interval), -1);
   rb_define_method(SwigClassWindow.klass, "update_interval=", VALUEFUNC(_wrap_Window_update_intervale___), -1);
   rb_define_method(SwigClassWindow.klass, "caption", VALUEFUNC(_wrap_Window_caption), -1);