gosu 1.0.0 → 1.1.1.1

data/src/Resolution.cpp

@@ -11,19 +11,19 @@ static SDL_DisplayMode display_mode(Gosu::Window* window)
         VideoSubsystem()  { SDL_InitSubSystem(SDL_INIT_VIDEO); };
         ~VideoSubsystem() { SDL_QuitSubSystem(SDL_INIT_VIDEO); };
     } subsystem;
-    
+
     int index = window ? SDL_GetWindowDisplayIndex(Gosu::shared_window()) : 0;
     SDL_DisplayMode result;
     SDL_GetDesktopDisplayMode(index, &result);
     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;
 }
@@ -31,88 +31,136 @@ unsigned Gosu::screen_height(Window* window)
 #ifdef GOSU_IS_MAC
 #import <AppKit/AppKit.h>
 
-static NSSize max_window_size(Gosu::Window* window)
+static SDL_Rect max_window_size(Gosu::Window* window)
 {
-    // Keep in sync with SDL_cocoawindow.m.
-    auto style = NSTitledWindowMask|NSClosableWindowMask|NSMiniaturizableWindowMask;
+    // The extra size that a window needs depends on its style.
+    // This logic must be kept in sync with SDL_cocoawindow.m to be 100% accurate.
+    NSUInteger style;
+    if (window && window->borderless()) {
+        style = NSWindowStyleMaskBorderless;
+    }
+    else {
+        style = NSWindowStyleMaskTitled | NSWindowStyleMaskClosable | NSWindowStyleMaskMiniaturizable;
+    }
+    if (window && window->resizable()) {
+        style |= NSWindowStyleMaskResizable;
+    }
 
     auto index = window ? SDL_GetWindowDisplayIndex(Gosu::shared_window()) : 0;
-    auto screen_frame = NSScreen.screens[index].visibleFrame;
-    return [NSWindow contentRectForFrameRect:screen_frame styleMask:style].size;
-}
-
-unsigned Gosu::available_width(Window* window)
-{
-    return max_window_size(window).width;
-}
-
-unsigned Gosu::available_height(Window* window)
-{
-    return max_window_size(window).height;
+    NSRect screen_frame = NSScreen.screens[index].visibleFrame;
+    NSRect content_rect = [NSWindow contentRectForFrameRect:screen_frame styleMask:style];
+
+    SDL_Rect result;
+    result.x = 0;
+    result.y = 0;
+    result.w = content_rect.size.width;
+    result.h = content_rect.size.height;
+    return result;
 }
 #endif
 
+// TODO: Remove this implementation and remove ifdef for GOSU_IS_X once WIN_GetWindowBordersSize is patched
 #ifdef GOSU_IS_WIN
 #include <windows.h>
 #include <SDL_syswm.h>
+#include <dwmapi.h>
+#pragma comment (lib, "Dwmapi.lib")
 
-static SIZE max_window_size(Gosu::Window* window)
+static SDL_Rect max_window_size(Gosu::Window* window)
 {
-    RECT work_area;
-    
-    if (window == nullptr) {
-        // Easy case: Return the work area of the primary monitor.
-        SystemParametersInfo(SPI_GETWORKAREA, 0, &work_area, 0);
-    }
-    else {
-        // Return the work area of the monitor the window is on.
-        SDL_SysWMinfo wm_info;
-        SDL_VERSION(&wm_info.version);
-        SDL_GetWindowWMInfo(Gosu::shared_window(), &wm_info);
-        HMONITOR monitor = MonitorFromWindow(wm_info.info.win.window, MONITOR_DEFAULTTONEAREST);
-        
-        MONITORINFO monitor_info;
-        monitor_info.cbSize = sizeof(monitor_info);
-        GetMonitorInfo(monitor, &monitor_info);
-        work_area = monitor_info.rcWork;
+    // Replicate SDL's WIN_GetWindowBordersSize implementation (https://github.com/libsdl-org/SDL/blob/9f71a809e9bd6fbb5fa401a45c1537fc26abc1b4/src/video/windows/SDL_windowswindow.c#L514-L554)
+    // until it's patched to ignore the window drop shadow (window border is 1px but with drop shadow it's reported as 8px)
+    // REF: https://github.com/libsdl-org/SDL/issues/3835
+
+    static struct VideoSubsystem {
+        VideoSubsystem() { SDL_InitSubSystem(SDL_INIT_VIDEO); };
+        ~VideoSubsystem() { SDL_QuitSubSystem(SDL_INIT_VIDEO); };
+    } subsystem;
+
+    int index = window ? SDL_GetWindowDisplayIndex(Gosu::shared_window()) : 0;
+    SDL_Rect rect;
+    SDL_GetDisplayUsableBounds(index, &rect);
+
+    if (window) {
+        SDL_SysWMinfo info;
+        SDL_VERSION(&info.version);
+        SDL_GetWindowWMInfo(Gosu::shared_window(), &info);
+        HWND hwnd = info.info.win.window;
+
+        RECT rcClient, rcWindow;
+        POINT ptDiff;
+        int top = 0, left = 0, bottom = 0, right = 0;
+
+        /* rcClient stores the size of the inner window, while rcWindow stores the outer size relative to the top-left
+         * screen position; so the top/left values of rcClient are always {0,0} and bottom/right are {height,width} */
+        GetClientRect(hwnd, &rcClient);
+        DwmGetWindowAttribute(hwnd, DWMWA_EXTENDED_FRAME_BOUNDS, &rcWindow, sizeof(rcWindow));
+
+        /* convert the top/left values to make them relative to
+         * the window; they will end up being slightly negative */
+        ptDiff.y = rcWindow.top;
+        ptDiff.x = rcWindow.left;
+
+        ScreenToClient(hwnd, &ptDiff);
+
+        rcWindow.top = ptDiff.y;
+        rcWindow.left = ptDiff.x;
+
+        /* convert the bottom/right values to make them relative to the window,
+         * these will be slightly bigger than the inner width/height */
+        ptDiff.y = rcWindow.bottom;
+        ptDiff.x = rcWindow.right;
+
+        ScreenToClient(hwnd, &ptDiff);
+
+        rcWindow.bottom = ptDiff.y;
+        rcWindow.right = ptDiff.x;
+
+        /* Now that both the inner and outer rects use the same coordinate system we can substract them to get the border size.
+         * Keep in mind that the top/left coordinates of rcWindow are negative because the border lies slightly before {0,0},
+         * so switch them around because SDL2 wants them in positive. */
+        top = rcClient.top - rcWindow.top;
+        left = rcClient.left - rcWindow.left;
+        bottom = rcWindow.bottom - rcClient.bottom;
+        right = rcWindow.right - rcClient.right;
+
+        rect.w -= left + right;
+        rect.h -= top + bottom;
     }
-    
-    RECT window_size = work_area;
-    // Keep in sync with STYLE_NORMAL in SDL_windowswindow.c.
-    DWORD style = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
-    AdjustWindowRectEx(&window_size, style, FALSE, 0);
-    
-    // Because AdjustWindowRectEx will make our rect larger, not smaller, we need to perform some
-    // unintuitive math here.
-    SIZE size;
-    size.cx = 2 * (work_area.right - work_area.left) - (window_size.right - window_size.left);
-    size.cy = 2 * (work_area.bottom - work_area.top) - (window_size.bottom - window_size.top);
-    return size;
-}
 
-unsigned Gosu::available_width(Window* window)
-{
-    return max_window_size(window).cx;
+    // Return a rect to have one less Gosu::available_width/height implementation.
+    return rect;
 }
+#endif
 
-unsigned Gosu::available_height(Window* window)
+#ifdef GOSU_IS_X
+static SDL_Rect max_window_size(Gosu::Window* window)
 {
-    return max_window_size(window).cy;
+    static struct VideoSubsystem {
+        VideoSubsystem() { SDL_InitSubSystem(SDL_INIT_VIDEO); };
+        ~VideoSubsystem() { SDL_QuitSubSystem(SDL_INIT_VIDEO); };
+    } subsystem;
+
+    int index = window ? SDL_GetWindowDisplayIndex(Gosu::shared_window()) : 0;
+    SDL_Rect rect;
+    int top, left, bottom, right;
+    SDL_GetDisplayUsableBounds(index, &rect);
+    SDL_GetWindowBordersSize(Gosu::shared_window(), &top, &left, &bottom, &right);
+
+    rect.w -= left + right;
+    rect.h -= top + bottom;
+
+    return rect;
 }
 #endif
 
-#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);
+    return max_window_size(window).w;
 }
 
-unsigned Gosu::available_height(Window* window)
+int Gosu::available_height(Window* window)
 {
-    return static_cast<unsigned>(Gosu::screen_height(window) * 0.8);
+    return max_window_size(window).h;
 }
 #endif
-
-#endif

data/src/RubyGosu.cxx

@@ -3300,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) {
   
 }
 
@@ -9198,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);
@@ -9244,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;
@@ -9285,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)) {
@@ -9298,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;
@@ -9316,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)) {
@@ -9329,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;
@@ -9404,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 ;
@@ -10584,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)) {
@@ -10599,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;
@@ -10617,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)) {
@@ -10632,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;
@@ -10650,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)) {
@@ -10665,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;
@@ -10683,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)) {
@@ -10698,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;
@@ -12425,7 +12518,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 +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);