gosu 1.0.0 → 1.1.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c9b393a63015707256dca78e9079b01dbc004d85b89c6bf68d021085f65a905
-  data.tar.gz: 60396892082e2fa81a7ab03f8662fe00630745f84b1e0a47e9abcd7bed5c7692
+  metadata.gz: 54c79a5d22ee53e69f48bcd2c1ffb20bf35672ee30d6f08890a9c3037a39fe24
+  data.tar.gz: 6a5e06a31f1a7ad257be143a37a1163b324e7124cb56a97154c9eba9fb0686d8
 SHA512:
-  metadata.gz: fb477140be8f524abfeb3694277bd815690c4c0ae432ac011956a43640f49309aca3c0a9b3619c17cc83461ae5c9c9b6fb1bfa155e72f1be19b4f166e23b3022
-  data.tar.gz: 24707e94f193a4fe949a447a01b732057860eb271a8a0d61ba6c45a0b1b5da8c2894ffc65d3ff3fe2b97fe7e8b9c5b38b9995d4d443d014fe6059f520f900393
+  metadata.gz: 7db1b37245a24e569bbc623ec025a3e2d13fd61c7a011272e30cca9d4cf6970a2326ec159ee839236fc246ed177702c3de6942e46ba9297c50e51078f61cb564
+  data.tar.gz: 0a75ca1ddf6de40050638cc33e8c41acdd68808b1c3942aaecff2219aaf44e8148398bdd27991d5f5d4e1757b8fec651f59c7b9bba82b140dffdcda7df5ab632

data/include/Gosu/Version.hpp

@@ -3,7 +3,7 @@
 #include <string>
 
 #define GOSU_MAJOR_VERSION 1
-#define GOSU_MINOR_VERSION 0
+#define GOSU_MINOR_VERSION 1
 #define GOSU_POINT_VERSION 0
 
 namespace Gosu

data/include/Gosu/Window.hpp

@@ -8,6 +8,14 @@
 
 namespace Gosu
 {
+    enum WindowFlags
+    {
+        WF_WINDOWED,
+        WF_FULLSCREEN = 1,
+        WF_RESIZABLE  = 2,
+        WF_BORDERLESS = 4
+    };
+
     //! Convenient all-in-one class that serves as the foundation of a standard Gosu application.
     //! Manages initialization of all of Gosu's core components and provides timing functionality.
     //! Note that you should really only use one instance of this class at the same time.
@@ -21,17 +29,23 @@ namespace Gosu
         //! \param width Width of the window in points; that is, pixels on a normal display, and
         //! 'points' on a high-resolution display.
         //! \param height See width.
+        //! \param window_flags A bitmask of values from Gosu::WindowFlags.
         //! \param update_interval Interval in milliseconds between two calls to the update member
         //! function.
-        Window(unsigned width, unsigned height, bool fullscreen = false,
-            double update_interval = 16.666666, bool resizable = false);
+        Window(int width, int height, unsigned window_flags = WF_WINDOWED,
+               double update_interval = 16.666666);
         virtual ~Window();
 
-        unsigned width() const;
-        unsigned height() const;
+        int width() const;
+        int height() const;
         bool fullscreen() const;
+        void resize(int width, int height, bool fullscreen);
+
         bool resizable() const;
-        void resize(unsigned width, unsigned height, bool fullscreen);
+        void set_resizable(bool resizable);
+
+        bool borderless() const;
+        void set_borderless(bool borderless);
 
         double update_interval() const;
         void set_update_interval(double update_interval);
@@ -129,22 +143,22 @@ namespace Gosu
     //! Returns the width (in pixels) of a screen.
     //! \param window The result describes the screen on which the window is shown, or the
     //!               primary screen if no window is given.
-    unsigned screen_width(Window* window = nullptr);
+    int screen_width(Window* window = nullptr);
 
     //! Returns the height (in pixels) of the user's primary screen.
     //! \param window The result describes the screen on which the window is shown, or the
     //!               primary screen if no window is given.
-    unsigned screen_height(Window* window = nullptr);
+    int screen_height(Window* window = nullptr);
 
     //! Returns the maximum width (in 'points') that is available for a non-fullscreen Window.
     //! All windows larger than this size will automatically be shrunk to fit.
     //! \param window The result describes the screen on which the window is shown, or the
     //!               primary screen if no window is given.
-    unsigned available_width(Window* window = nullptr);
+    int available_width(Window* window = nullptr);
 
     //! Returns the maximum height (in 'points') that is available for a non-fullscreen Window.
     //! All windows larger than this size will automatically be shrunk to fit.
     //! \param window The result describes the screen on which the window is shown, or the
     //!               primary screen if no window is given.
-    unsigned available_height(Window* window = nullptr);
+    int available_height(Window* window = nullptr);
 }

data/lib/gosu/swig_patches.rb

@@ -3,19 +3,16 @@
 # compatible, but I just call protected_update etc. in the Ruby wrapper so I can add this
 # custom debugging help:
 class Gosu::Window
-  alias_method :initialize_without_hash, :initialize
+  alias_method :initialize_with_options_hash, :initialize
 
   def initialize width, height, *args
     if args.empty? or args.first.is_a? Hash
       options = args.first || {}
-      fullscreen = options[:fullscreen]
-      update_interval = options[:update_interval]
-      resizable = options[:resizable]
     else
-      fullscreen, update_interval = *args
+      options = { fullscreen: args[0], update_interval: args[1] }
     end
     $gosu_gl_blocks = nil
-    initialize_without_hash width, height, !!fullscreen, update_interval || 16.666666, !!resizable
+    initialize_with_options_hash width, height, options
   end
 
   %w(update draw needs_redraw? needs_cursor?

data/rdoc/gosu.rb

@@ -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
 

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

@@ -3218,6 +3218,45 @@ SWIGINTERN void Gosu_TextInput_set_selection_start(Gosu::TextInput *self,VALUE s
         std::string prefix = StringValueCStr(rb_prefix);
         self->set_selection_start(std::min(prefix.length(), self->text().length()));
     }
+SWIGINTERN Gosu::Window *new_Gosu_Window(VALUE self,int width,int height,VALUE options=0){
+        unsigned flags = 0;
+        double update_interval = 16.666666;
+
+        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, "fullscreen")) {
+                    if (RTEST(value)) flags |= Gosu::WF_FULLSCREEN;
+                }
+                else if (!strcmp(key_string, "resizable")) {
+                    if (RTEST(value)) flags |= Gosu::WF_RESIZABLE;
+                }
+                else if (!strcmp(key_string, "borderless")) {
+                    if (RTEST(value)) flags |= Gosu::WF_BORDERLESS;
+                }
+                else if (!strcmp(key_string, "update_interval")) {
+                    update_interval = NUM2DBL(value);
+                }
+                else {
+                    static bool issued_warning = false;
+                    if (!issued_warning) {
+                        issued_warning = true;
+                        rb_warn("Unknown keyword argument: :%s", key_string);
+                    }
+                }
+            }
+        }
+
+        return new Gosu::Window(width, height, flags, update_interval);
+    }
 SWIGINTERN void Gosu_Window_set_width(Gosu::Window *self,unsigned int width){
         self->resize(width, self->height(), self->fullscreen());
     }
@@ -3300,12 +3339,6 @@ 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() {
 }
 
@@ -9180,112 +9213,50 @@ fail:
 
 static swig_class SwigClassWindow;
 
-SWIGINTERN VALUE
-#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
-_wrap_Window_allocate(VALUE self)
-#else
-_wrap_Window_allocate(int argc, VALUE *argv, VALUE self)
-#endif
-{
-  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Gosu__Window);
-#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
-  rb_obj_call_init(vresult, argc, argv);
-#endif
-  return vresult;
+SWIGINTERN void
+free_Gosu_Window(void *self) {
+    Gosu::Window *arg1 = (Gosu::Window *)self;
+    SWIG_RubyRemoveTracking(arg1);
+    delete arg1;
 }
 
-
 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 ;
-  double arg5 = (double) 16.666666 ;
-  bool arg6 = (bool) false ;
-  unsigned int val2 ;
-  int ecode2 = 0 ;
-  unsigned int val3 ;
-  int ecode3 = 0 ;
-  bool val4 ;
-  int ecode4 = 0 ;
-  double val5 ;
-  int ecode5 = 0 ;
-  bool val6 ;
-  int ecode6 = 0 ;
-  const char *classname SWIGUNUSED = "Gosu::Window";
-  Gosu::Window *result = 0 ;
+_wrap_Window_width(int argc, VALUE *argv, VALUE self) {
+  Gosu::Window *arg1 = (Gosu::Window *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
   
-  if ((argc < 2) || (argc > 5)) {
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
-  }
-  arg1 = self;
-  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","Window", 2, argv[0] ));
-  } 
-  arg2 = static_cast< unsigned int >(val2);
-  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","Window", 3, argv[1] ));
-  } 
-  arg3 = static_cast< unsigned int >(val3);
-  if (argc > 2) {
-    ecode4 = SWIG_AsVal_bool(argv[2], &val4);
-    if (!SWIG_IsOK(ecode4)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Window", 4, argv[2] ));
-    } 
-    arg4 = static_cast< bool >(val4);
-  }
-  if (argc > 3) {
-    ecode5 = SWIG_AsVal_double(argv[3], &val5);
-    if (!SWIG_IsOK(ecode5)) {
-      SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","Window", 5, argv[3] ));
-    } 
-    arg5 = static_cast< double >(val5);
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
   }
-  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);
+  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 *","width", 1, self )); 
   }
+  arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
-        /* subclassed */
-        result = (Gosu::Window *)new SwigDirector_Window(arg1,arg2,arg3,arg4,arg5,arg6); 
-      } else {
-        result = (Gosu::Window *)new Gosu::Window(arg2,arg3,arg4,arg5,arg6); 
-      }
-      
-      DATA_PTR(self) = result;
-      SWIG_RubyAddTracking(result, self);
+      result = (int)((Gosu::Window const *)arg1)->width();
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
     }
   }
-  return self;
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
 fail:
   return Qnil;
 }
 
 
-SWIGINTERN void
-free_Gosu_Window(void *self) {
-    Gosu::Window *arg1 = (Gosu::Window *)self;
-    SWIG_RubyRemoveTracking(arg1);
-    delete arg1;
-}
-
 SWIGINTERN VALUE
-_wrap_Window_width(int argc, VALUE *argv, VALUE self) {
+_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)) {
@@ -9293,18 +9264,18 @@ _wrap_Window_width(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","width", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","height", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      result = (unsigned int)((Gosu::Window const *)arg1)->width();
+      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;
@@ -9312,11 +9283,11 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_height(int argc, VALUE *argv, VALUE self) {
+_wrap_Window_fullscreenq___(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  unsigned int result;
+  bool result;
   VALUE vresult = Qnil;
   
   if ((argc < 0) || (argc > 0)) {
@@ -9324,18 +9295,18 @@ _wrap_Window_height(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","height", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","fullscreen", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      result = (unsigned int)((Gosu::Window const *)arg1)->height();
+      result = (bool)((Gosu::Window const *)arg1)->fullscreen();
     }
     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_bool(static_cast< bool >(result));
   return vresult;
 fail:
   return Qnil;
@@ -9343,7 +9314,7 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_fullscreenq___(int argc, VALUE *argv, VALUE self) {
+_wrap_Window_resizableq___(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -9355,12 +9326,12 @@ _wrap_Window_fullscreenq___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","fullscreen", 1, self )); 
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","resizable", 1, self )); 
   }
   arg1 = reinterpret_cast< Gosu::Window * >(argp1);
   {
     try {
-      result = (bool)((Gosu::Window const *)arg1)->fullscreen();
+      result = (bool)((Gosu::Window const *)arg1)->resizable();
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
@@ -9374,7 +9345,43 @@ fail:
 
 
 SWIGINTERN VALUE
-_wrap_Window_resizableq___(int argc, VALUE *argv, VALUE self) {
+_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 ;
@@ -9386,12 +9393,12 @@ _wrap_Window_resizableq___(int argc, VALUE *argv, VALUE self) {
   }
   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Gosu__Window, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Gosu::Window const *","resizable", 1, self )); 
+    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)->resizable();
+      result = (bool)((Gosu::Window const *)arg1)->borderless();
     }
     catch (const std::exception& e) {
       SWIG_exception(SWIG_RuntimeError, e.what());
@@ -9404,6 +9411,42 @@ fail:
 }
 
 
+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 ;
@@ -10167,6 +10210,67 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_Window_allocate(VALUE self)
+#else
+_wrap_Window_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Gosu__Window);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_Window(int argc, VALUE *argv, VALUE self) {
+  VALUE arg1 = (VALUE) 0 ;
+  int arg2 ;
+  int arg3 ;
+  VALUE arg4 = (VALUE) 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  const char *classname SWIGUNUSED = "Gosu::Window";
+  Gosu::Window *result = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  arg1 = self;
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Window", 2, argv[0] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  ecode3 = SWIG_AsVal_int(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Window", 3, argv[1] ));
+  } 
+  arg3 = static_cast< int >(val3);
+  if (argc > 2) {
+    arg4 = argv[2];
+  }
+  {
+    try {
+      result = (Gosu::Window *)new_Gosu_Window(arg1,arg2,arg3,arg4);
+      DATA_PTR(self) = result;
+      SWIG_RubyAddTracking(result, self);
+    }
+    catch (const std::exception& e) {
+      SWIG_exception(SWIG_RuntimeError, e.what());
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_Window_widthe___(int argc, VALUE *argv, VALUE self) {
   Gosu::Window *arg1 = (Gosu::Window *) 0 ;
@@ -10584,7 +10688,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)) {
@@ -10599,13 +10703,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;
@@ -10617,7 +10721,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)) {
@@ -10632,13 +10736,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;
@@ -10650,7 +10754,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)) {
@@ -10665,13 +10769,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;
@@ -10683,7 +10787,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)) {
@@ -10698,13 +10802,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;
@@ -12425,7 +12529,7 @@ SWIGEXPORT void Init_gosu(void) {
   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 >(1)));
-  rb_define_const(mGosu, "MINOR_VERSION", SWIG_From_int(static_cast< int >(0)));
+  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);
@@ -12881,6 +12985,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);