gosu 1.1.0 → 1.1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c00e9925256d5f0c158716eeb225fd8bc5b9af17335f2a3b67b892a1c7d87d7
-  data.tar.gz: 3e2edbae0cf3ae45cf926ff228fd621c2d092c0e1ccbf425884b0ba01c984199
+  metadata.gz: 444c045288619f5db21634cb5bbdd24bf16c93799d16dc84147cab982282804b
+  data.tar.gz: cab4e8823a7b19893cfd3f5b280176ed2b99f76c76278859fe5957bec8aa283a
 SHA512:
-  metadata.gz: ab8f4550f297ae89f321e133b3ca9e0b5f77ab64b9c66415e379270eb90ac1c000de685b175e3dbfb5a9de34afa3cfb4eda3d8a5e40ebe9dd18b25ef22964dcf
-  data.tar.gz: 87803f08a8a4a13ec027ee265cc08be511eb95c30bc1494766310485d757799bffc794427f2fe1002142b00b1282b4ade6b90b985f01f00f3b03db041a12299b
+  metadata.gz: c4c1168ca82b6e0c969ca8943469010d1eeadc32908ac3b78fc4b61567e0905076dedc2e4509bb55abedccf9ba4f3ccf79ae900093f1de996112548bc0fbad31
+  data.tar.gz: 6f7b1cea866fecc2b8bde836790f684fff6990dc89844a66f7a304f7f405625a33200bb6ffe2db987444ecc53e7a8ddee26cb75f7e77f7891393fd564e2ae81b

data/COPYING

@@ -1,4 +1,4 @@
-Copyright (C) 2001-2020 Julian Raschke, Jan Lücker and all contributors.
+Copyright (C) 2001-2021 Julian Raschke, Jan Lücker and all contributors.
 
 Permission is hereby granted, free of charge, to any person obtaining a
 copy of this software and associated documentation files (the "Software"),

data/ext/gosu/extconf.rb

@@ -51,7 +51,7 @@ if windows
   else
     $LDFLAGS << "  -L../../dependencies/al_soft/x86 -L../../dependencies/SDL/lib/x86"
   end
-  $LDFLAGS << " -lgdi32 -lwinmm -lOpenGL32 -lOpenAL32 -lSDL2"
+  $LDFLAGS << " -lgdi32 -lwinmm -ldwmapi -lOpenGL32 -lOpenAL32 -lSDL2"
   # Link libstdc++ statically to avoid having another DLL dependency when using Ocra.
   $LDFLAGS << " -static-libstdc++"
 elsif macos
@@ -62,6 +62,10 @@ elsif macos
   # rvm will sometimes try to override this:
   # https://github.com/shawn42/gamebox/issues/96
   $CXXFLAGS << " -stdlib=libc++"
+
+  # Disable an error that is disabled by default and prevents Gosu from building with universal Ruby:
+  # https://trac.macports.org/ticket/58255 / https://github.com/gosu/gosu/issues/424
+  $CXXFLAGS << " -Wno-reserved-user-defined-literal"
   
   # Dependencies.
   $CFLAGS << " #{`sdl2-config --cflags`.chomp}"

data/include/Gosu/Font.hpp

@@ -22,11 +22,9 @@ namespace Gosu
 
     public:
         //! Constructs a font that can be drawn onto the graphics object.
-        //! \param font_name Name of a system font, or a filename to a TTF
-        //!        file (must contain '/', does not work on Linux).
-        //! \param font_height Height of the font, in pixels.
-        //! \param font_flags Flags used to render individual characters of
-        //!        the font.
+        //! \param name   Name of a system font, or a filename to a TTF file.
+        //! \param height Height of the font, in pixels.
+        //! \param flags  Flags used to render individual characters of the font.
         Font(int height, const std::string& name = default_font_name(), unsigned flags = 0);
         
         //! Returns the name of the font that was used to create it.

data/include/Gosu/Text.hpp

@@ -20,7 +20,7 @@ namespace Gosu
     double text_width(const std::u32string& text, const std::string& font_name, double font_height,
                       unsigned font_flags = 0);
 
-    //! Draws a line of unformatted text on a bitmap. This is a low-level function that does not
+    //! Draws a line of plain text on a bitmap. This is a low-level function that does not
     //! understand any of Gosu's HTML-like markup.
     //! \param text A UCS-4 string, normalization: NFC.
     //! \param font_name Name of a system font, or filename of a TTF file (must contain '/' or '.').
@@ -29,9 +29,9 @@ namespace Gosu
     double draw_text(Bitmap& bitmap, double x, double y, Color c, const std::u32string& text,
                      const std::string& font_name, double font_height, unsigned font_flags = 0);
 
-    //! Creates a bitmap that is filled with the formatted text given to the function.
+    //! Creates a bitmap that is filled with the plain text given to the function.
     //! The line can contain line breaks and HTML-like markup.
-    //! \param text Formatted text.
+    //! \param text Plain text.
     //! \param font_name Name of a system font, or filename of a TTF file (must contain '/' or '.').
     //! \param font_height Height of the font in pixels.
     //! \param line_spacing Spacing between two lines of text in pixels. Can be negative to make
@@ -48,7 +48,7 @@ namespace Gosu
     
     //! Creates a bitmap that is filled with the formatted text given to the function.
     //! The line can contain line breaks and HTML-like markup.
-    //! \param text Formatted text.
+    //! \param markup Formatted text.
     //! \param font_name Name of a system font, or filename of a TTF file (must contain '/' or '.').
     //! \param font_height Height of the font in pixels.
     //! \param line_spacing Spacing between two lines of text in pixels. Can be negative to make

data/include/Gosu/Version.hpp

@@ -4,7 +4,7 @@
 
 #define GOSU_MAJOR_VERSION 1
 #define GOSU_MINOR_VERSION 1
-#define GOSU_POINT_VERSION 0
+#define GOSU_POINT_VERSION 1
 
 namespace Gosu
 {

data/src/Macro.cpp

@@ -1,168 +1,125 @@
 #include "Macro.hpp"
 #include "DrawOpQueue.hpp"
 #include <Gosu/Image.hpp>
-#include <cmath>
-#include <algorithm>
-#include <functional>
-#include <memory>
 #include <stdexcept>
 using namespace std;
 
 struct Gosu::Macro::Impl
 {
-    typedef double Float;
-    
     VertexArrays vertex_arrays;
     int width, height;
-    
-    Transform find_transform_for_target(Float x1, Float y1, Float x2, Float y2,
-        Float x3, Float y3, Float x4, Float y4) const
+
+    // Solves the 2x2 linear system for x:
+    // (a11 a12) (x1) = (b1)
+    // (a21 a22) (x2) = (b2)
+    // x1, x2 are output parameters. Returns false if the matrix is singular.
+    static bool solve_2x2(double a11, double a12, double a21, double a22, double b1, double b2,
+                          double& x1, double& x2)
+    {
+        const double det = a11 * a22 - a21 * a12;
+        if (det == 0) return false;
+        x1 = (a22 * b1 - a12 * b2) / det;
+        x2 = (a11 * b2 - a21 * b1) / det;
+        return true;
+    }
+
+    Transform find_transform_for_target(double x1, double y1, double x2, double y2,
+        double x3, double y3, double x4, double y4) const
     {
         // Transformation logic follows a discussion on the ImageMagick mailing
         // list (on which ImageMagick's perspective_transform.pl is based).
-        
+
         // To draw a macro at an arbitrary position, we solve the following system:
-        
-        // 0, 0, 1, 0, 0, 0,    0,    0 | x1
-        // 0, 0, 0, 0, 0, 1,    0,    0 | y1
-        // w, 0, 1, 0, 0, 0, -x2w,    0 | x2
-        // 0, 0, 0, w, 0, 1, -y2w,    0 | y2
-        // 0, h, 1, 0, 0, 0,    0, -x3h | x3
-        // 0, 0, 0, 0, h, 1,    0, -y3h | y3
-        // w, h, 1, 0, 0, 0, -x4w, -x4h | x4
-        // 0, 0, 0, w, h, 1, -y4w, -y4h | y4
-        
+
+        // 0, 0, 1, 0, 0, 0,     0,     0 | x1
+        // 0, 0, 0, 0, 0, 1,     0,     0 | y1
+        // w, 0, 1, 0, 0, 0, -x2 w,     0 | x2
+        // 0, 0, 0, w, 0, 1, -y2 w,     0 | y2
+        // 0, h, 1, 0, 0, 0,     0, -x3 h | x3
+        // 0, 0, 0, 0, h, 1,     0, -y3 h | y3
+        // w, h, 1, 0, 0, 0, -x4 w, -x4 h | x4
+        // 0, 0, 0, w, h, 1, -y4 w, -y4 h | y4
+
         // Equivalent:
-        
-        // 0, 0, 1, 0, 0, 0,        0,        0 | x1
-        // 0, 0, 0, 0, 0, 1,        0,        0 | y1
-        // w, 0, 0, 0, 0, 0,     -x2w,        0 | x2-x1
-        // 0, 0, 0, w, 0, 0,     -y2w,        0 | y2-y1
-        // 0, h, 0, 0, 0, 0,        0,     -x3h | x3-x1
-        // 0, 0, 0, 0, h, 0,        0,     -y3h | y3-y1
-        // 0, 0, 0, 0, 0, 0, (x2-x4)w, (x3-x4)h | x1-x2-x3+x4
-        // 0, 0, 0, 0, 0, 0, (y2-y4)w, (y3-y4)h | y1-y2-y3+y4
-        
-        // Since this matrix is relatively sparse, we unroll all three solving paths.
-        
-        static const Transform null_transform = {{ 0 }};
-        
-        // Row 7 is completely useless
-        if (x2 == x4 && x3 == x4) return null_transform;
-        // Row 8 is completely useless
-        if (y2 == y3 && y3 == y4) return null_transform;
-        // Col 7 is completely useless
-        if (x2 == x4 && y2 == y4) return null_transform;
-        // Col 8 is completely useless
-        if (x3 == x4 && y3 == y4) return null_transform;
-        
-        Float c[8];
-        
-        // Rows 1, 2
+
+        // 0, 0, 1, 0, 0, 0,         0,         0 | x1
+        // 0, 0, 0, 0, 0, 1,         0,         0 | y1
+        // w, 0, 0, 0, 0, 0,     -x2 w,         0 | x2-x1
+        // 0, 0, 0, w, 0, 0,     -y2 w,         0 | y2-y1
+        // 0, h, 0, 0, 0, 0,         0,     -x3 h | x3-x1
+        // 0, 0, 0, 0, h, 0,         0,     -y3 h | y3-y1
+        // 0, 0, 0, 0, 0, 0, (x2-x4) w, (x3-x4) h | x1-x2-x3+x4
+        // 0, 0, 0, 0, 0, 0, (y2-y4) w, (y3-y4) h | y1-y2-y3+y4
+
+        // The last two rows only involve the last two variables.
+        // We can directly solve this as a separate 2x2 linear system.
+
+        // Set up 2x2 linear system of the lower right corner entries.
+        const double a11 = (x2 - x4) * width;
+        const double a12 = (x3 - x4) * height;
+        const double a21 = (y2 - y4) * width;
+        const double a22 = (y3 - y4) * height;
+        const double b1 = x1 - x2 - x3 + x4;
+        const double b2 = y1 - y2 - y3 + y4;
+
+        // Solve:
+        double qx, qy;
+        if (!solve_2x2(a11, a12, a21, a22, b1, b2, qx, qy)) return Transform{{0}};
+
+        // Updating the last two rows with the computed solution yields
+
+        // 0, 0, 1, 0, 0, 0,     0,     0 | x1
+        // 0, 0, 0, 0, 0, 1,     0,     0 | y1
+        // w, 0, 0, 0, 0, 0, -x2 w,     0 | x2-x1
+        // 0, 0, 0, w, 0, 0, -y2 w,     0 | y2-y1
+        // 0, h, 0, 0, 0, 0,     0, -x3 h | x3-x1
+        // 0, 0, 0, 0, h, 0,     0, -y3 h | y3-y1
+        // 0, 0, 0, 0, 0, 0,     1,     0 | qx
+        // 0, 0, 0, 0, 0, 0,     0,     1 | qy
+
+        // We can use the last two rows to eliminate entries in rows 3, 4, 5, and 6:
+
+        // 0, 0, 1, 0, 0, 0, 0, 0 | x1
+        // 0, 0, 0, 0, 0, 1, 0, 0 | y1
+        // w, 0, 0, 0, 0, 0, 0, 0 | x2-x1 + qx x2 w
+        // 0, 0, 0, w, 0, 0, 0, 0 | y2-y1 + qx y2 w
+        // 0, h, 0, 0, 0, 0, 0, 0 | x3-x1 + qy x3 h
+        // 0, 0, 0, 0, h, 0, 0, 0 | y3-y1 + qy y3 h
+        // 0, 0, 0, 0, 0, 0, 1, 0 | qx
+        // 0, 0, 0, 0, 0, 0, 0, 1 | qy
+
+        // Normalize and reorder rows so we can read off the solution:
+
+        // 1, 0, 0, 0, 0, 0, 0, 0 | (x2-x1) / w + qx x2
+        // 0, 1, 0, 0, 0, 0, 0, 0 | (x3-x1) / h + qy x3
+        // 0, 0, 1, 0, 0, 0, 0, 0 | x1
+        // 0, 0, 0, 1, 0, 0, 0, 0 | (y2-y1) / w + qx y2
+        // 0, 0, 0, 0, 1, 0, 0, 0 | (y3-y1) / h + qy y3
+        // 0, 0, 0, 0, 0, 1, 0, 0 | y1
+        // 0, 0, 0, 0, 0, 0, 1, 0 | qx
+        // 0, 0, 0, 0, 0, 0, 0, 1 | qy
+
+        double c[8];
+        c[0] = (x2 - x1) / width  + qx * x2;
+        c[1] = (x3 - x1) / height + qy * x3;
         c[2] = x1;
+        c[3] = (y2 - y1) / width  + qx * y2;
+        c[4] = (y3 - y1) / height + qy * y3;
         c[5] = y1;
-        
-        // The logic below assumes x2 != x4, i.e. row7 can be used to eliminate
-        // the leftmost value in row 8 and afterwards the values in rows 3 & 4.
-        // If x2 == x4, we need to exchange rows 7 and 8.
-        
-        // TODO: x2==x4 is the normal case where an image is
-        // drawn upright; the code should rather swap in the rare case that x3==x4!
-        
-        Float left_cell7 = (x2 - x4) * width;
-        Float right_cell7 = (x3 - x4) * height;
-        Float orig_right_side7 = (x1 - x2 - x3 + x4);
-        Float left_cell8 = (y2 - y4) * width;
-        Float right_cell8 = (y3 - y4) * height;
-        Float orig_right_side8 = (y1 - y2 - y3 + y4);
-        
-        bool swap_rows78 = x2 == x4;
-        if (swap_rows78) {
-            swap(left_cell7, left_cell8);
-            swap(right_cell7, right_cell8);
-            swap(orig_right_side7, orig_right_side8);
-        }
-        
-        // 0, 0, 1, 0, 0, 0,         0,           0 | x1
-        // 0, 0, 0, 0, 0, 1,         0,           0 | y1
-        // w, 0, 0, 0, 0, 0,      -x2w,           0 | x2-x1
-        // 0, 0, 0, w, 0, 0,      -y2w,           0 | y2-y1
-        // 0, h, 0, 0, 0, 0,         0,        -x3h | x3-x1
-        // 0, 0, 0, 0, h, 0,         0,        -y3h | y3-y1
-        // 0, 0, 0, 0, 0, 0, left_cell7, right_cell7 | orig_right_side7
-        // 0, 0, 0, 0, 0, 0, left_cell8, right_cell8 | orig_right_side8
-        
-        // Use row 7 to eliminate the left cell in row 8
-        // Row8 = Row8 - factor78 * Row7
-        Float factor78 = left_cell8 / left_cell7;
-        Float rem_cell8 = right_cell8 - right_cell7 * factor78;
-        Float right_side8 = orig_right_side8 - orig_right_side7 * factor78;
-        c[7] = right_side8 / rem_cell8;
-        
-        // 0, 0, 1, 0, 0, 0,         0,          0 | x1
-        // 0, 0, 0, 0, 0, 1,         0,          0 | y1
-        // w, 0, 0, 0, 0, 0,      -x2w,          0 | x2-x1
-        // 0, 0, 0, w, 0, 0,      -y2w,          0 | y2-y1
-        // 0, h, 0, 0, 0, 0,         0,       -x3h | x3-x1
-        // 0, 0, 0, 0, h, 0,         0,       -y3h | y3-y1
-        // 0, 0, 0, 0, 0, 0, left_cell7, right_cell7 | orig_right_side7
-        // 0, 0, 0, 0, 0, 0,         0,   rem_cell8 | right_side8
-        
-        // Use the remaining value in row 8 to eliminate the right value in row 7.
-        // Row7 = Row7 - factor87 * Row8
-        Float factor87 = right_cell7 / rem_cell8;
-        Float rem_cell7 = left_cell7;
-        Float right_side7 = orig_right_side7 - right_side8 * factor87;
-        c[6] = right_side7 / rem_cell7;
-        
-        // 0, 0, 1, 0, 0, 0,        0,        0 | x1
-        // 0, 0, 0, 0, 0, 1,        0,        0 | y1
-        // w, 0, 0, 0, 0, 0,     -x2w,        0 | x2-x1
-        // 0, 0, 0, w, 0, 0,     -y2w,        0 | y2-y1
-        // 0, h, 0, 0, 0, 0,        0,     -x3h | x3-x1
-        // 0, 0, 0, 0, h, 0,        0,     -y3h | y3-y1
-        // 0, 0, 0, 0, 0, 0, rem_cell7,        0 | right_side7
-        // 0, 0, 0, 0, 0, 0,        0, rem_cell8 | right_side8
-        
-        // Use the new rows 7 and 8 to calculate c0, c1, c3 & c4.
-        // Row3 = Row3 - factor73 * Row7
-        Float factor73 = -x2 * width / rem_cell7;
-        Float rem_cell3 = width;
-        Float right_side3 = (x2 - x1) - right_side7 * factor73;
-        c[0] = right_side3 / rem_cell3;
-        // Row4 = Row4 - factor74 * Row7
-        Float factor74 = -y2 * width / rem_cell7;
-        Float rem_cell4 = width;
-        Float right_side4 = (y2 - y1) - right_side7 * factor74;
-        c[3] = right_side4 / rem_cell4;
-        // Row5 = Row5 - factor85 * Row7
-        Float factor85 = -x3 * height / rem_cell8;
-        Float rem_cell5 = height;
-        Float right_side5 = (x3 - x1) - right_side8 * factor85;
-        c[1] = right_side5 / rem_cell5;
-        // Row6 = Row6 - factor86 * Row8
-        Float factor86 = -y3 * height / rem_cell8;
-        Float rem_cell6 = height;
-        Float right_side6 = (y3 - y1) - right_side8 * factor86;
-        c[4] = right_side6 / rem_cell6;
-        
-        if (swap_rows78) {
-            swap(c[6], c[7]);
-        }
-        
-        // Let's hope I never have to debug/understand this again! :D
-        
+        c[6] = qx;
+        c[7] = qy;
+
         Transform result = {{
             c[0], c[3], 0, c[6],
             c[1], c[4], 0, c[7],
-            0, 0, 1, 0,
+            0,    0,    1, 0,
             c[2], c[5], 0, 1
         }};
         return result;
     }
-    
-    void draw_vertex_arrays(Float x1, Float y1, Float x2, Float y2, Float x3, Float y3,
-        Float x4, Float y4) const
+
+    void draw_vertex_arrays(double x1, double y1, double x2, double y2, double x3, double y3,
+        double x4, double y4) const
     {
         // TODO: Macros should not be split up just because they have different transforms.
         // They should be premultiplied and have the same transform by definition. Then the

data/src/Resolution.cpp

@@ -11,7 +11,7 @@ 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);
@@ -31,88 +31,136 @@ int 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;
-}
-
-int Gosu::available_width(Window* window)
-{
-    return max_window_size(window).width;
-}
-
-int 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;
-}
 
-int 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
 
-int 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
 int Gosu::available_width(Window* window)
 {
-    return static_cast<unsigned>(Gosu::screen_width(window) * 0.9);
+    return max_window_size(window).w;
 }
 
 int Gosu::available_height(Window* window)
 {
-    return static_cast<unsigned>(Gosu::screen_height(window) * 0.8);
+    return max_window_size(window).h;
 }
 #endif
-
-#endif

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gosu
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1.1
 platform: ruby
 authors:
 - Julian Raschke
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-20 00:00:00.000000000 Z
+date: 2021-02-13 00:00:00.000000000 Z
 dependencies: []
 description: |2
       2D game development library.
@@ -316,7 +316,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: 2D game development library.