gosu 1.3.0 → 1.4.0

data/src/TrueTypeFontUnix.cpp

@@ -1,22 +1,18 @@
 #include <Gosu/Platform.hpp>
 #if defined(GOSU_IS_X)
 
-#include "TrueTypeFont.hpp"
-#include "Log.hpp"
-
 #include <Gosu/IO.hpp>
 #include <Gosu/Text.hpp>
 #include <Gosu/Utility.hpp>
-
+#include "Log.hpp"
+#include "TrueTypeFont.hpp"
 #include <fontconfig/fontconfig.h>
-
 #include <map>
-using namespace std;
 
-const unsigned char* Gosu::ttf_data_by_name(const string& font_name, unsigned font_flags)
+const unsigned char* Gosu::ttf_data_by_name(const std::string& font_name, unsigned font_flags)
 {
     // TODO: Make this cache thread-safe.
-    static map<pair<string, unsigned>, const unsigned char*> ttf_file_cache;
+    static std::map<std::pair<std::string, unsigned>, const unsigned char*> ttf_file_cache;
 
     auto& ttf_ptr = ttf_file_cache[make_pair(font_name, font_flags)];
     if (ttf_ptr) return ttf_ptr;
@@ -26,27 +22,27 @@ const unsigned char* Gosu::ttf_data_by_name(const string& font_name, unsigned fo
     static FcConfig* config = FcInitLoadConfigAndFonts();
     if (config) {
         FcPattern* pattern;
-            // Our search pattern does not include weight or slant so that we can compromise on these.
-            pattern = FcPatternBuild(nullptr,
-                                     FC_FAMILY, FcTypeString, font_name.empty() ? "sans-serif" : font_name.c_str(),
-                                     FC_OUTLINE, FcTypeBool, FcTrue, // exclude bitmap fonts
-                                     nullptr);
+        // Our search pattern does not include weight or slant so that we can compromise on these.
+        pattern = FcPatternBuild(nullptr, FC_FAMILY, FcTypeString,
+                                 font_name.empty() ? "sans-serif" : font_name.c_str(), FC_OUTLINE,
+                                 FcTypeBool, FcTrue, // exclude bitmap fonts
+                                 nullptr);
 
         FcObjectSet* props = FcObjectSetBuild(FC_FILE, FC_WEIGHT, FC_SLANT, nullptr);
 
         if (FcFontSet* fonts = FcFontList(config, pattern, props)) {
             log("Looking for the best candidate among %d matching fonts", (int) fonts->nfont);
-            
+
             // Among all matching fonts, find the variant that is the best fit for our font_flags.
-            string best_filename;
+            std::string best_filename;
             int best_diff;
-            
+
             for (int i = 0; i < fonts->nfont; ++i) {
                 int weight, slant;
-                
+
                 FcPatternGetInteger(fonts->fonts[i], FC_WEIGHT, 0, &weight);
                 FcPatternGetInteger(fonts->fonts[i], FC_SLANT, 0, &slant);
-                
+
                 // Difference between found font weight/slant and desired weight/slant.
                 // Lower is better, so find the font with the lowest diff.
                 int diff = 0;
@@ -62,14 +58,14 @@ const unsigned char* Gosu::ttf_data_by_name(const string& font_name, unsigned fo
                 else {
                     diff += abs(slant - FC_SLANT_ROMAN);
                 }
-                
+
                 // Penalize OTF fonts since we are not really good at handling these.
-                FcChar8 *file;
+                FcChar8* file;
                 FcPatternGetString(fonts->fonts[i], FC_FILE, 0, &file);
                 if (has_extension(reinterpret_cast<char*>(file), ".otf")) {
                     diff += 10000;
                 }
-                
+
                 if (best_filename.empty() || diff < best_diff) {
                     best_filename = reinterpret_cast<char*>(file);
                     best_diff = diff;
@@ -79,10 +75,10 @@ const unsigned char* Gosu::ttf_data_by_name(const string& font_name, unsigned fo
                 log("Loading best candidate '%s'", best_filename.c_str());
                 ttf_ptr = ttf_data_from_file(best_filename.c_str());
             }
-            
+
             FcFontSetDestroy(fonts);
         }
-        
+
         FcObjectSetDestroy(props);
         FcPatternDestroy(pattern);
     }
@@ -126,7 +122,7 @@ const unsigned char* Gosu::ttf_fallback_data()
     // Unifont has pretty good Unicode coverage, but looks extremely ugly.
     static const unsigned char* unifont = ttf_data_by_name("Unifont", 0);
     if (unifont) return unifont;
-    
+
     // If none of the fonts above work, try to use the default sans-serif font.
     static const unsigned char* default_font = ttf_data_of_default_sans_serif_font();
     if (default_font) return default_font;
@@ -135,7 +131,7 @@ const unsigned char* Gosu::ttf_fallback_data()
     return ttf_data_from_file("/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf");
 }
 
-string Gosu::default_font_name()
+std::string Gosu::default_font_name()
 {
     // Liberation Sans was designed to have the same metrics as Arial, which is the default
     // font on macOS and Windows.
@@ -143,4 +139,3 @@ string Gosu::default_font_name()
 }
 
 #endif
-

data/src/TrueTypeFontWin.cpp

@@ -1,54 +1,54 @@
 #include <Gosu/Platform.hpp>
 #if defined(GOSU_IS_WIN)
 
-#include "TrueTypeFont.hpp"
 #include "Log.hpp"
+#include "TrueTypeFont.hpp"
 
 #define _WIN32_WINNT 0x0500
-#include <windows.h>
-
-#include "WinUtility.hpp"
-
 #include <Gosu/IO.hpp>
 #include <Gosu/Text.hpp>
 #include <Gosu/Utility.hpp>
-
+#include "WinUtility.hpp"
 #include <cstdlib>
 #include <cwchar>
 #include <map>
 #include <memory>
-using namespace std;
+#include <windows.h>
 
-const unsigned char* Gosu::ttf_data_by_name(const string& font_name, unsigned font_flags)
+const unsigned char* Gosu::ttf_data_by_name(const std::string& font_name, unsigned font_flags)
 {
     // TODO: Make this cache thread-safe.
-    static map<pair<string, unsigned>, shared_ptr<Buffer>> ttf_file_cache;
-    
+    static std::map<std::pair<std::string, unsigned>, std::shared_ptr<Buffer>> ttf_file_cache;
+
     auto& buffer_ptr = ttf_file_cache[make_pair(font_name, font_flags)];
     if (buffer_ptr) return static_cast<const unsigned char*>(buffer_ptr->data());
 
     log("Trying to find a font named '%s', flags=%x", font_name.c_str(), font_flags);
 
-    LOGFONT logfont = {
-        0, 0, 0, 0,
-        (font_flags & Gosu::FF_BOLD) ? FW_BOLD : FW_NORMAL,
-        static_cast<BYTE>((font_flags & Gosu::FF_ITALIC) ? TRUE : FALSE),
-        static_cast<BYTE>((font_flags & Gosu::FF_UNDERLINE) ? TRUE : FALSE),
-        0 /* no strikethrough */,
-        ANSI_CHARSET, OUT_OUTLINE_PRECIS, CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY,
-        DEFAULT_PITCH
-    };
-    
-    wstring wfont_name = utf8_to_utf16(font_name);
-    wcsncpy(logfont.lfFaceName, wfont_name.c_str(), LF_FACESIZE);
+    LOGFONT logfont = {0,
+                       0,
+                       0,
+                       0,
+                       (font_flags & Gosu::FF_BOLD) ? FW_BOLD : FW_NORMAL,
+                       static_cast<BYTE>((font_flags & Gosu::FF_ITALIC) ? TRUE : FALSE),
+                       static_cast<BYTE>((font_flags & Gosu::FF_UNDERLINE) ? TRUE : FALSE),
+                       0 /* no strikethrough */,
+                       ANSI_CHARSET,
+                       OUT_OUTLINE_PRECIS,
+                       CLIP_DEFAULT_PRECIS,
+                       ANTIALIASED_QUALITY,
+                       DEFAULT_PITCH};
+
+    std::wstring wfont_name = utf8_to_utf16(font_name);
+    std::wcsncpy(logfont.lfFaceName, wfont_name.c_str(), LF_FACESIZE);
     logfont.lfFaceName[LF_FACESIZE - 1] = 0;
-    
+
     if (HFONT font = CreateFontIndirect(&logfont)) {
         if (HDC hdc = GetDC(0)) {
             HFONT last_font = (HFONT) SelectObject(hdc, (HGDIOBJ) font);
             auto ttf_buffer_size = GetFontData(hdc, 0, 0, nullptr, 0);
             if (ttf_buffer_size != GDI_ERROR) {
-                auto buffer = make_shared<Gosu::Buffer>();
+                auto buffer = std::make_shared<Gosu::Buffer>();
                 buffer->resize(ttf_buffer_size);
                 if (GetFontData(hdc, 0, 0, buffer->data(), buffer->size()) != GDI_ERROR) {
                     auto data = static_cast<const unsigned char*>(buffer->data());
@@ -75,18 +75,18 @@ const unsigned char* Gosu::ttf_fallback_data()
     // Prefer Arial Unicode MS as a fallback because it covers a lot of Unicode.
     static const unsigned char* arial_unicode = ttf_data_by_name("Arial Unicode MS", 0);
     if (arial_unicode) return arial_unicode;
-    
+
     // Otherwise, just try to find *any* font.
     static const unsigned char* any_font = ttf_data_by_name("", 0);
     if (any_font) return any_font;
-    
-    static const char* windir = getenv("WINDIR");
-    if (windir) return ttf_data_from_file(string(windir) + "/Fonts/arial.ttf");
-    
+
+    static const char* windir = std::getenv("WINDIR");
+    if (windir) return ttf_data_from_file(std::string(windir) + "/Fonts/arial.ttf");
+
     return ttf_data_from_file("C:/Windows/Fonts/arial.ttf");
 }
 
-string Gosu::default_font_name()
+std::string Gosu::default_font_name()
 {
     return "Arial";
 }

data/src/Window.cpp

@@ -2,16 +2,15 @@
 #if !defined(GOSU_IS_IPHONE)
 
 #if defined(GOSU_IS_WIN)
+#define NOMINMAX
 #include <windows.h>
 #endif
 
 #include <Gosu/Gosu.hpp>
 #include "GraphicsImpl.hpp"
 #include <SDL.h>
-#include <cstdlib>
 #include <algorithm>
 #include <stdexcept>
-using namespace std;
 
 namespace Gosu
 {
@@ -20,14 +19,15 @@ namespace Gosu
         void register_frame();
     }
 
-    static void throw_sdl_error(const string& operation)
+    [[noreturn]] static void throw_sdl_error(const std::string& operation)
     {
         const char* error = SDL_GetError();
-        throw runtime_error(operation + ": " + (error ? error : "(unknown error)"));
+        throw std::runtime_error{operation + ": " + (error ? error : "(unknown error)")};
     }
 
     SDL_Window* shared_window()
     {
+        // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
         static SDL_Window* window = nullptr;
         if (window == nullptr) {
             if (SDL_Init(SDL_INIT_VIDEO) < 0) {
@@ -36,8 +36,8 @@ namespace Gosu
 
             Uint32 flags = SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN | SDL_WINDOW_ALLOW_HIGHDPI;
 
-            window =
-                SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 64, 64, flags);
+            window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 64, 64,
+                                      flags);
             if (window == nullptr) {
                 throw_sdl_error("Could not create window");
             }
@@ -50,10 +50,10 @@ namespace Gosu
     {
         static SDL_GLContext context = nullptr;
         if (context == nullptr) {
-        #ifdef GOSU_IS_OPENGLES
+#ifdef GOSU_IS_OPENGLES
             SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
             SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
-        #endif
+#endif
 
             context = SDL_GL_CreateContext(shared_window());
 
@@ -64,36 +64,41 @@ namespace Gosu
         return context;
     }
 
-    void ensure_current_context()
+    void ensure_current_context() //
     {
         SDL_GL_MakeCurrent(shared_window(), shared_gl_context());
     }
 }
 
-struct Gosu::Window::Impl
+struct Gosu::Window::Impl : Gosu::Noncopyable
 {
-    bool fullscreen;
-    double update_interval;
-    bool resizable;
+    bool fullscreen = false;
+    double update_interval = 0;
+    bool resizable = false;
     bool resizing = false;
 
     // A single `bool open` is not good enough to support the tick() method: When close() is called
     // from outside the window's call graph, the next call to tick() must return false (transition
-    // from CLOSING to CLOSED), but the call after that must return show the window again
-    // (transition from CLOSED to OPEN).
-    enum { CLOSED, OPEN, CLOSING } state = CLOSED;
+    // from CLOSING to CLOSED), but the call after that must show the window again (transition from
+    // CLOSED to OPEN).
+    enum
+    {
+        CLOSED,
+        OPEN,
+        CLOSING
+    } state = CLOSED;
 
-    unique_ptr<Graphics> graphics;
-    unique_ptr<Input> input;
+    std::unique_ptr<Graphics> graphics;
+    std::unique_ptr<Input> input;
 };
 
 Gosu::Window::Window(int width, int height, unsigned window_flags, double update_interval)
-: pimpl(new Impl)
+: m_impl(new Impl)
 {
     set_borderless(window_flags & WF_BORDERLESS);
     set_resizable(window_flags & WF_RESIZABLE);
 
-    // Even in fullscreen mode, temporarily show the window in windowed mode to centre it.
+    // Even in fullscreen mode, temporarily show the window in windowed mode to center it.
     // This ensures that the window will be centered correctly when exiting fullscreen mode.
     // Fixes https://github.com/gosu/gosu/issues/369
     // (This will implicitly create graphics() and input(), and make the OpenGL context current.)
@@ -105,11 +110,11 @@ Gosu::Window::Window(int width, int height, unsigned window_flags, double update
 
     SDL_GL_SetSwapInterval(1);
 
-    pimpl->update_interval = update_interval;
+    m_impl->update_interval = update_interval;
 
     input().on_button_down = [this](Button button) { button_down(button); };
-    input().on_button_up   = [this](Button button) { button_up(button); };
-    input().on_gamepad_connected    = [this](int index) { gamepad_connected(index); };
+    input().on_button_up = [this](Button button) { button_up(button); };
+    input().on_gamepad_connected = [this](int index) { gamepad_connected(index); };
     input().on_gamepad_disconnected = [this](int index) { gamepad_disconnected(index); };
 }
 
@@ -130,12 +135,12 @@ int Gosu::Window::height() const
 
 bool Gosu::Window::fullscreen() const
 {
-    return pimpl->fullscreen;
+    return m_impl->fullscreen;
 }
 
 void Gosu::Window::resize(int width, int height, bool fullscreen)
 {
-    pimpl->fullscreen = fullscreen;
+    m_impl->fullscreen = fullscreen;
 
     int actual_width = width;
     int actual_height = height;
@@ -144,19 +149,19 @@ void Gosu::Window::resize(int width, int height, bool fullscreen)
     double black_bar_height = 0;
 
     if (fullscreen) {
-        actual_width  = Gosu::screen_width(this);
+        actual_width = Gosu::screen_width(this);
         actual_height = Gosu::screen_height(this);
 
         if (resizable()) {
             // Resizable fullscreen windows stubbornly follow the desktop resolution.
-            width  = actual_width;
+            width = actual_width;
             height = actual_height;
         }
         else {
             // Scale the window to fill the desktop resolution.
             double scale_x = 1.0 * actual_width / width;
             double scale_y = 1.0 * actual_height / height;
-            scale_factor = min(scale_x, scale_y);
+            scale_factor = std::min(scale_x, scale_y);
             // Add black bars to preserve the aspect ratio, if necessary.
             if (scale_x < scale_y) {
                 black_bar_height = (actual_height / scale_x - height) / 2;
@@ -167,24 +172,24 @@ void Gosu::Window::resize(int width, int height, bool fullscreen)
         }
     }
     else {
-        int max_width  = Gosu::available_width(this);
+        int max_width = Gosu::available_width(this);
         int max_height = Gosu::available_height(this);
 
         if (resizable()) {
             // If the window is resizable, limit its size, without preserving the aspect ratio.
-            width  = actual_width  = min(width,  max_width);
-            height = actual_height = min(height, max_height);
+            width = actual_width = std::min(width, max_width);
+            height = actual_height = std::min(height, max_height);
         }
         else if (width > max_width || height > max_height) {
             // If the window cannot fit on the screen, shrink its contents.
-            scale_factor = min(1.0 * max_width / width, 1.0 * max_height / height);
-            actual_width  = width  * scale_factor;
-            actual_height = height * scale_factor;
+            scale_factor = std::min(1.0 * max_width / width, 1.0 * max_height / height);
+            actual_width = static_cast<int>(width * scale_factor);
+            actual_height = static_cast<int>(height * scale_factor);
         }
     }
 
     SDL_SetWindowFullscreen(shared_window(), fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
-    if (!pimpl->resizing) {
+    if (!m_impl->resizing) {
         SDL_SetWindowSize(shared_window(), actual_width, actual_height);
     }
 
@@ -192,37 +197,39 @@ void Gosu::Window::resize(int width, int height, bool fullscreen)
 
     ensure_current_context();
 
-    if (!pimpl->graphics) {
-        pimpl->graphics.reset(new Graphics(actual_width, actual_height));
+    if (!m_impl->graphics) {
+        m_impl->graphics.reset(new Graphics(actual_width, actual_height));
     }
     else {
-        pimpl->graphics->set_physical_resolution(actual_width, actual_height);
+        m_impl->graphics->set_physical_resolution(actual_width, actual_height);
     }
-    pimpl->graphics->set_resolution(width, height, black_bar_width, black_bar_height);
+    m_impl->graphics->set_resolution(width, height, black_bar_width, black_bar_height);
 
-    if (!pimpl->input) {
-        pimpl->input.reset(new Input(shared_window()));
+    if (!m_impl->input) {
+        m_impl->input.reset(new Input(shared_window()));
     }
-    pimpl->input->set_mouse_factors(1 / scale_factor, 1 / scale_factor,
-                                    black_bar_width, black_bar_height);
+    m_impl->input->set_mouse_factors(1 / scale_factor, 1 / scale_factor, black_bar_width,
+                                     black_bar_height);
 }
 
 bool Gosu::Window::resizable() const
 {
-    return pimpl->resizable;
+    return m_impl->resizable;
 }
 
 void Gosu::Window::set_resizable(bool resizable)
 {
-    pimpl->resizable = resizable;
+    m_impl->resizable = resizable;
     SDL_SetWindowResizable(shared_window(), resizable ? SDL_TRUE : SDL_FALSE);
 }
 
+// NOLINTNEXTLINE(readability-convert-member-functions-to-static)
 bool Gosu::Window::borderless() const
 {
     return SDL_GetWindowFlags(shared_window()) & SDL_WINDOW_BORDERLESS;
 }
 
+// NOLINTNEXTLINE(readability-convert-member-functions-to-static)
 void Gosu::Window::set_borderless(bool borderless)
 {
     SDL_SetWindowBordered(shared_window(), borderless ? SDL_FALSE : SDL_TRUE);
@@ -230,21 +237,23 @@ void Gosu::Window::set_borderless(bool borderless)
 
 double Gosu::Window::update_interval() const
 {
-    return pimpl->update_interval;
+    return m_impl->update_interval;
 }
 
 void Gosu::Window::set_update_interval(double update_interval)
 {
-    pimpl->update_interval = update_interval;
+    m_impl->update_interval = update_interval;
 }
 
-string Gosu::Window::caption() const
+// NOLINTNEXTLINE(readability-convert-member-functions-to-static)
+std::string Gosu::Window::caption() const
 {
     const char* title = SDL_GetWindowTitle(shared_window());
     return title ? title : "";
 }
 
-void Gosu::Window::set_caption(const string& caption)
+// NOLINTNEXTLINE(readability-convert-member-functions-to-static)
+void Gosu::Window::set_caption(const std::string& caption)
 {
     SDL_SetWindowTitle(shared_window(), caption.c_str());
 }
@@ -264,16 +273,17 @@ void Gosu::Window::show()
         while (tick()) {
             // Sleep to keep this loop from eating 100% CPU.
             unsigned long tick_time = milliseconds() - time_before_tick;
-            if (tick_time < update_interval()) {
-                sleep(update_interval() - tick_time);
+            double sleep_time = tick_time - update_interval();
+            if (sleep_time >= 1) {
+                sleep(static_cast<unsigned long>(sleep_time));
             }
 
             time_before_tick = milliseconds();
         }
     } catch (...) {
-    #ifdef GOSU_IS_WIN
+#ifdef GOSU_IS_WIN
         if (previous_affinity) SetThreadAffinityMask(GetCurrentThread(), previous_affinity);
-    #endif
+#endif
         throw;
     }
 
@@ -281,19 +291,19 @@ void Gosu::Window::show()
     if (previous_affinity) SetThreadAffinityMask(GetCurrentThread(), previous_affinity);
 #endif
 
-    pimpl->state = Impl::CLOSED;
+    m_impl->state = Impl::CLOSED;
 }
 
 bool Gosu::Window::tick()
 {
-    if (pimpl->state == Impl::CLOSING) {
-        pimpl->state = Impl::CLOSED;
+    if (m_impl->state == Impl::CLOSING) {
+        m_impl->state = Impl::CLOSED;
         return false;
     }
 
-    if (pimpl->state == Impl::CLOSED) {
+    if (m_impl->state == Impl::CLOSED) {
         SDL_ShowWindow(shared_window());
-        pimpl->state = Impl::OPEN;
+        m_impl->state = Impl::OPEN;
 
         // SDL_GL_GetDrawableSize returns different values before and after showing the window.
         // -> When first showing the window, update the physical size of Graphics (=glViewport).
@@ -305,15 +315,15 @@ bool Gosu::Window::tick()
 
     SDL_Event e;
     while (SDL_PollEvent(&e)) {
-
         switch (e.type) {
             case SDL_WINDOWEVENT: {
                 switch (e.window.event) {
                     case SDL_WINDOWEVENT_SIZE_CHANGED: {
-                        if (pimpl->resizable && (width() != e.window.data1 || height() != e.window.data2)) {
-                            pimpl->resizing = true;
+                        if (m_impl->resizable &&
+                            (width() != e.window.data1 || height() != e.window.data2)) {
+                            m_impl->resizing = true;
                             resize(e.window.data1, e.window.data2, fullscreen());
-                            pimpl->resizing = false;
+                            m_impl->resizing = false;
                         }
                         break;
                     }
@@ -336,10 +346,9 @@ bool Gosu::Window::tick()
                 break;
             }
             case SDL_DROPFILE: {
-                char* dropped_filedir = e.drop.file;
-                if (dropped_filedir == nullptr) break;
-                drop(string(dropped_filedir));
-                SDL_free(dropped_filedir);
+                std::shared_ptr<char> dropped_file{e.drop.file, SDL_free};
+                if (dropped_file == nullptr) break;
+                drop(dropped_file.get());
                 break;
             }
             default: {
@@ -367,16 +376,16 @@ bool Gosu::Window::tick()
         SDL_GL_SwapWindow(shared_window());
     }
 
-    if (pimpl->state == Impl::CLOSING) {
-        pimpl->state = Impl::CLOSED;
+    if (m_impl->state == Impl::CLOSING) {
+        m_impl->state = Impl::CLOSED;
     }
 
-    return pimpl->state == Impl::OPEN;
+    return m_impl->state == Impl::OPEN;
 }
 
 void Gosu::Window::close()
 {
-    pimpl->state = Impl::CLOSING;
+    m_impl->state = Impl::CLOSING;
     SDL_HideWindow(shared_window());
 }
 
@@ -389,23 +398,23 @@ void Gosu::Window::button_down(Button button)
 #ifdef GOSU_IS_MAC
     // cmd+F and cmd+ctrl+F are both common shortcuts for toggling fullscreen mode on macOS.
     toggle_fullscreen = button == KB_F &&
-        (Input::down(KB_LEFT_META) || Input::down(KB_RIGHT_META)) &&
-        !Input::down(KB_LEFT_SHIFT) && !Input::down(KB_RIGHT_SHIFT) &&
-        !Input::down(KB_LEFT_ALT) && !Input::down(KB_RIGHT_ALT);
+                        (Input::down(KB_LEFT_META) || Input::down(KB_RIGHT_META)) &&
+                        !Input::down(KB_LEFT_SHIFT) && !Input::down(KB_RIGHT_SHIFT) &&
+                        !Input::down(KB_LEFT_ALT) && !Input::down(KB_RIGHT_ALT);
 #else
     // Alt+Enter and Alt+Return toggle fullscreen mode on all other platforms.
     toggle_fullscreen = (button == KB_RETURN || button == KB_ENTER) &&
-        (Input::down(KB_LEFT_ALT)     || Input::down(KB_RIGHT_ALT)) &&
-        !Input::down(KB_LEFT_CONTROL) && !Input::down(KB_RIGHT_CONTROL) &&
-        !Input::down(KB_LEFT_META)    && !Input::down(KB_RIGHT_META) &&
-        !Input::down(KB_LEFT_SHIFT)   && !Input::down(KB_RIGHT_SHIFT);
+                        (Input::down(KB_LEFT_ALT) || Input::down(KB_RIGHT_ALT)) &&
+                        !Input::down(KB_LEFT_CONTROL) && !Input::down(KB_RIGHT_CONTROL) &&
+                        !Input::down(KB_LEFT_META) && !Input::down(KB_RIGHT_META) &&
+                        !Input::down(KB_LEFT_SHIFT) && !Input::down(KB_RIGHT_SHIFT);
 #endif
     // F11 is supported as a shortcut for fullscreen mode on all platforms.
-    if (!toggle_fullscreen && button == KB_F11 &&
-        !Input::down(KB_LEFT_ALT)     && !Input::down(KB_RIGHT_ALT) &&
-        !Input::down(KB_LEFT_CONTROL) && !Input::down(KB_RIGHT_CONTROL) &&
-        !Input::down(KB_LEFT_META)    && !Input::down(KB_RIGHT_META) &&
-        !Input::down(KB_LEFT_SHIFT)   && !Input::down(KB_RIGHT_SHIFT)) {
+    if (!toggle_fullscreen && button == KB_F11 && !Input::down(KB_LEFT_ALT) &&
+        !Input::down(KB_RIGHT_ALT) && !Input::down(KB_LEFT_CONTROL) &&
+        !Input::down(KB_RIGHT_CONTROL) && !Input::down(KB_LEFT_META) &&
+        !Input::down(KB_RIGHT_META) && !Input::down(KB_LEFT_SHIFT) &&
+        !Input::down(KB_RIGHT_SHIFT)) {
         toggle_fullscreen = true;
     }
 
@@ -416,22 +425,22 @@ void Gosu::Window::button_down(Button button)
 
 const Gosu::Graphics& Gosu::Window::graphics() const
 {
-    return *pimpl->graphics;
+    return *m_impl->graphics;
 }
 
 Gosu::Graphics& Gosu::Window::graphics()
 {
-    return *pimpl->graphics;
+    return *m_impl->graphics;
 }
 
 const Gosu::Input& Gosu::Window::input() const
 {
-    return *pimpl->input;
+    return *m_impl->input;
 }
 
 Gosu::Input& Gosu::Window::input()
 {
-    return *pimpl->input;
+    return *m_impl->input;
 }
 
 #endif