gosu 0.10.9.pre1 → 0.11.0

data/src/WinUtility.cpp

@@ -1,39 +1,41 @@
-#include <Gosu/Utility.hpp>
+#include <Gosu/Platform.hpp>
+#if defined(GOSU_IS_WIN)
+
 #include "WinUtility.hpp"
+#include <Gosu/Utility.hpp>
 #include <stdexcept>
 #include <windows.h>
 
-void Gosu::Win::throwLastError(const std::string& action)
+void Gosu::throw_last_winapi_error(const std::string& action)
 {
     // Obtain error message from Windows.
-    char* buffer;
-    if (!::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
-        FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
-        ::GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-        reinterpret_cast<LPSTR>(&buffer), 0, 0) || buffer == 0)
-    {
-        // IMPR: Can we do better than this?
+    wchar_t* buffer;
+                 
+    if (!FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                        FORMAT_MESSAGE_FROM_SYSTEM |
+                        FORMAT_MESSAGE_IGNORE_INSERTS, 0, GetLastError(),
+                        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR) &buffer, 0, 0)
+            || buffer == nullptr) {
         throw std::runtime_error("Unknown error");
     }
 
-    // Move the message out of the ugly char* buffer.
+    // Safely move the message into a std::string.
     std::string message;
-    try
-    {
-        message = buffer;
+    try {
+        message = wstring_to_utf8(buffer);
     }
-    catch (...)
-    {
-        ::LocalFree(buffer);
+    catch (...) {
+        LocalFree(buffer);
         throw;
     }
-    ::LocalFree(buffer);
+    LocalFree(buffer);
     
     // Optionally prepend the action.
-    if (!action.empty())
-        message = "While " + action + ", the following error occured: " +
-            message;
+    if (!action.empty()) {
+        message = "While " + action + ", the following error occured: " + message;
+    }
 
-    // Now throw it.
     throw std::runtime_error(message);
- }
+}
+
+#endif

data/src/WinUtility.hpp

@@ -1,30 +1,21 @@
-#ifndef GOSU_WINUTILITY_HPP
-#define GOSU_WINUTILITY_HPP
+#pragma once
 
 #include <Gosu/Platform.hpp>
 #include <string>
 
 namespace Gosu
 {
-    //! Implementation helpers for the Windows platform.
-    namespace Win
-    {
-        //! Throws an exception according to the error which GetLastError()
-        //! returns, optionally prefixed with "While (action), the following
-        //! error occured: ".
-        GOSU_NORETURN void throwLastError(const std::string& action = "");
+    //! Throws an exception according to the error returned by  GetLastError(), optionally prefixed
+    //! with "While (action), the following error occured: ".
+    GOSU_NORETURN void throw_last_winapi_error(const std::string& action = "");
 
-        //! Small helper function that throws an exception whenever the value
-        //! passed through is false. Note that this doesn't make sense for all
-        //! Windows API functions, but for most of them.
-        template<typename T>
-        inline T check(T valToCheck, const std::string& action = "")
-        {
-            if (!valToCheck)
-                throwLastError(action);
-            return valToCheck;
+    //! Small helper function that throws the last Windows error when val_to_check is false.
+    template<typename T>
+    inline T winapi_check(T val_to_check, const std::string& action = "")
+    {
+        if (!val_to_check) {
+            throw_last_winapi_error(action);
         }
+        return val_to_check;
     }
 }
-
-#endif

data/src/Window.cpp

@@ -1,204 +1,247 @@
+#include <Gosu/Platform.hpp>
+#if !defined(GOSU_IS_IPHONE)
+
 #include <Gosu/Gosu.hpp>
-#include "Graphics/Common.hpp"
 #include <SDL.h>
 #include <cstdlib>
 #include <memory>
 #include <stdexcept>
 
-using namespace std::tr1::placeholders;
-
 namespace Gosu
 {
     namespace FPS
     {
-        void registerFrame();
+        void register_frame();
     }
     
-    void throwSDLError(const std::string& operation)
+    void throw_sdl_error(const std::string& operation)
     {
-        const char *error = SDL_GetError();
+        const char* error = SDL_GetError();
         throw std::runtime_error(operation + ": " + (error ? error : "(unknown error)"));
     }
 
     void cleanup();
 
-    SDL_Window* sharedWindow()
+    SDL_Window* shared_window()
     {
-        static SDL_Window *window = 0;
-        if (window == 0)
-        {
-            if (SDL_Init(SDL_INIT_VIDEO) < 0)
-                throwSDLError("Could not initialize SDL Video");
+        static SDL_Window* window = nullptr;
+        if (window == nullptr) {
+            if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+                throw_sdl_error("Could not initialize SDL Video");
+            }
 
             std::atexit(cleanup);
 
             Uint32 flags = SDL_WINDOW_OPENGL | SDL_WINDOW_HIDDEN;
             
-            #if SDL_VERSION_ATLEAST(2, 0, 1)
+        #if SDL_VERSION_ATLEAST(2, 0, 1)
             flags |= SDL_WINDOW_ALLOW_HIGHDPI;
-            #endif
+        #endif
             
-            window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 64, 64, flags);
-            if (window == 0)
-                throwSDLError("Could not create window");
+            window =
+                SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 64, 64, flags);
+            if (window == nullptr) {
+                throw_sdl_error("Could not create window");
+            }
         }
         return window;
     }
     
-    SDL_GLContext sharedGLContext()
+    SDL_GLContext shared_gl_context()
     {
-        static SDL_GLContext context = 0;
-        if (context == 0)
-        {
-            #ifdef GOSU_IS_OPENGLES
+        static SDL_GLContext context = nullptr;
+        if (context == nullptr) {
+        #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(sharedWindow());
+            context = SDL_GL_CreateContext(shared_window());
             
-            if (context == 0)
-                throwSDLError("Could not create OpenGL context");
+            if (context == nullptr) {
+                throw_sdl_error("Could not create OpenGL context");
+            }
         }
         return context;
     }
     
-    void ensureCurrentContext()
+    void ensure_current_context()
     {
-        SDL_GL_MakeCurrent(sharedWindow(), sharedGLContext());
+        SDL_GL_MakeCurrent(shared_window(), shared_gl_context());
     }
 
     void cleanup()
     {
-        SDL_GL_DeleteContext(sharedGLContext());
-        SDL_DestroyWindow(sharedWindow());
+        SDL_GL_DeleteContext(shared_gl_context());
+        SDL_DestroyWindow(shared_window());
         SDL_QuitSubSystem(SDL_INIT_VIDEO);
     }
 }
 
 struct Gosu::Window::Impl
 {
-    double updateInterval;
+    bool fullscreen;
+    double update_interval;
     
-    std::auto_ptr<Graphics> graphics;
-    std::auto_ptr<Input> input;
+    std::unique_ptr<Graphics> graphics;
+    std::unique_ptr<Input> input;
 };
 
-Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen, double updateInterval)
+Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen, double update_interval)
 : pimpl(new Impl)
 {
-    int actualWidth = width;
-    int actualHeight = height;
-    double scaleFactor = 1.0;
-    double blackBarWidth = 0;
-    double blackBarHeight = 0;
+    // This will implicitly create graphics() and input(), and make the OpenGL context current.
+    resize(width, height, fullscreen);
+    
+    SDL_GL_SetSwapInterval(1);
+
+    pimpl->update_interval = update_interval;
+
+    if (!fullscreen) {
+        SDL_SetWindowPosition(shared_window(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
+    }
+    
+    input().on_button_down = [this](Gosu::Button button) { button_down(button); };
+    input().on_button_up = [this](Gosu::Button button) { button_up(button); };
+}
+
+Gosu::Window::~Window()
+{
+    SDL_HideWindow(shared_window());
+}
+
+unsigned Gosu::Window::width() const
+{
+    return graphics().width();
+}
+
+unsigned Gosu::Window::height() const
+{
+    return graphics().height();
+}
+
+bool Gosu::Window::fullscreen() const
+{
+    return pimpl->fullscreen;
+}
+
+void Gosu::Window::resize(unsigned width, unsigned height, bool fullscreen)
+{
+    pimpl->fullscreen = fullscreen;
+    
+    int actual_width = width;
+    int actual_height = height;
+    double scale_factor = 1.0;
+    double black_bar_width = 0;
+    double black_bar_height = 0;
     
     if (fullscreen) {
-        actualWidth = Gosu::screenWidth();
-        actualHeight = Gosu::screenHeight();
+        actual_width = Gosu::screen_width();
+        actual_height = Gosu::screen_height();
 
-        double scaleX = 1.0 * actualWidth / width;
-        double scaleY = 1.0 * actualHeight / height;
-        scaleFactor = std::min(scaleX, scaleY);
+        double scale_x = 1.0 * actual_width / width;
+        double scale_y = 1.0 * actual_height / height;
+        scale_factor = std::min(scale_x, scale_y);
 
-        if (scaleX < scaleY) {
-            blackBarHeight = (actualHeight / scaleX - height) / 2;
+        if (scale_x < scale_y) {
+            black_bar_height = (actual_height / scale_x - height) / 2;
         }
-        else if (scaleY < scaleX) {
-            blackBarWidth = (actualWidth / scaleY - width) / 2;
+        else if (scale_y < scale_x) {
+            black_bar_width = (actual_width / scale_y - width) / 2;
         }
     }
     else {
-        double maxWidth = Gosu::availableWidth();
-        double maxHeight = Gosu::availableHeight();
+        double max_width = Gosu::available_width();
+        double max_height = Gosu::available_height();
         
-        if (width > maxWidth || height > maxHeight) {
-            scaleFactor = std::min(maxWidth / width, maxHeight / height);
-            actualWidth = width * scaleFactor;
-            actualHeight = height * scaleFactor;
+        if (width > max_width || height > max_height) {
+            scale_factor = std::min(max_width / width, max_height / height);
+            actual_width = width * scale_factor;
+            actual_height = height * scale_factor;
         }
     }
     
-    SDL_SetWindowTitle(sharedWindow(), "");
-    SDL_SetWindowSize(sharedWindow(), actualWidth, actualHeight);
-    SDL_SetWindowPosition(sharedWindow(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
-    if (fullscreen)
-    {
-        SDL_SetWindowFullscreen(sharedWindow(), fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
-    }
+    SDL_SetWindowFullscreen(shared_window(), fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
+    SDL_SetWindowSize(shared_window(), actual_width, actual_height);
     
-    #if SDL_VERSION_ATLEAST(2, 0, 1)
-    SDL_GL_GetDrawableSize(sharedWindow(), &actualWidth, &actualHeight);
-    #endif
+#if SDL_VERSION_ATLEAST(2, 0, 1)
+    SDL_GL_GetDrawableSize(shared_window(), &actual_width, &actual_height);
+#endif
     
-    ensureCurrentContext();
-    SDL_GL_SetSwapInterval(1);
+    ensure_current_context();
+    
+    if (pimpl->graphics.get() == nullptr) {
+        pimpl->graphics.reset(new Graphics(actual_width, actual_height));
+    }
+    else {
+        pimpl->graphics->set_physical_resolution(actual_width, actual_height);
+    }
+    pimpl->graphics->set_resolution(width, height, black_bar_width, black_bar_height);
     
-    pimpl->graphics.reset(new Graphics(actualWidth, actualHeight, fullscreen));
-    pimpl->graphics->setResolution(width, height, blackBarWidth, blackBarHeight);
-    pimpl->input.reset(new Input(sharedWindow()));
-    pimpl->input->setMouseFactors(1 / scaleFactor, 1 / scaleFactor, blackBarWidth, blackBarHeight);
-    input().onButtonDown = std::tr1::bind(&Window::buttonDown, this, _1);
-    input().onButtonUp = std::tr1::bind(&Window::buttonUp, this, _1);
-    pimpl->updateInterval = updateInterval;
+    if (pimpl->input.get() == nullptr) {
+        pimpl->input.reset(new Input(shared_window()));
+    }
+    pimpl->input->set_mouse_factors(1 / scale_factor, 1 / scale_factor,
+                                    black_bar_width, black_bar_height);
 }
 
-Gosu::Window::~Window()
+double Gosu::Window::update_interval() const
 {
-    SDL_HideWindow(sharedWindow());
+    return pimpl->update_interval;
 }
 
-std::wstring Gosu::Window::caption() const
+void Gosu::Window::set_update_interval(double update_interval)
 {
-    return utf8ToWstring(SDL_GetWindowTitle(sharedWindow()));
+    pimpl->update_interval = update_interval;
 }
 
-void Gosu::Window::setCaption(const std::wstring& caption)
+std::string Gosu::Window::caption() const
 {
-    std::string utf8 = wstringToUTF8(caption);
-    SDL_SetWindowTitle(sharedWindow(), utf8.c_str());
+    const char* title = SDL_GetWindowTitle(shared_window());
+    return title ? title : "";
 }
 
-double Gosu::Window::updateInterval() const
+void Gosu::Window::set_caption(const std::string& caption)
 {
-    return pimpl->updateInterval;
+    SDL_SetWindowTitle(shared_window(), caption.c_str());
 }
 
 void Gosu::Window::show()
 {
-    unsigned long timeBeforeTick = milliseconds();
+    unsigned long time_before_tick = milliseconds();
     
     while (tick()) {
         // Sleep to keep this loop from eating 100% CPU.
-        unsigned long tickTime = milliseconds() - timeBeforeTick;
-        if (tickTime < updateInterval())
-            sleep(updateInterval() - tickTime);
+        unsigned long tick_time = milliseconds() - time_before_tick;
+        if (tick_time < update_interval()) {
+            sleep(update_interval() - tick_time);
+        }
         
-        timeBeforeTick = milliseconds();
+        time_before_tick = milliseconds();
     }
 }
 
 bool Gosu::Window::tick()
 {
-    if (SDL_GetWindowFlags(sharedWindow()) & SDL_WINDOW_HIDDEN) {
-        SDL_ShowWindow(sharedWindow());
+    if (SDL_GetWindowFlags(shared_window()) & SDL_WINDOW_HIDDEN) {
+        SDL_ShowWindow(shared_window());
 
         // SDL_GL_GetDrawableSize returns different values before and after showing the window.
         // -> When first showing the window, update the physical size of Graphics (=glViewport).
         // Fixes https://github.com/gosu/gosu/issues/318
         int width, height;
-        SDL_GL_GetDrawableSize(sharedWindow(), &width, &height);
-        graphics().setPhysicalResolution(width, height);
+        SDL_GL_GetDrawableSize(shared_window(), &width, &height);
+        graphics().set_physical_resolution(width, height);
     }
     
     SDL_Event e;
     while (SDL_PollEvent(&e)) {
         if (e.type == SDL_QUIT) {
-            SDL_HideWindow(sharedWindow());
+            SDL_HideWindow(shared_window());
             return false;
         }
         else {
-            input().feedSDLEvent(&e);
+            input().feed_sdl_event(&e);
         }
     }
     
@@ -208,17 +251,17 @@ bool Gosu::Window::tick()
     
     update();
     
-    SDL_ShowCursor(needsCursor());
+    SDL_ShowCursor(needs_cursor());
     
-    if (needsRedraw()) {
-        ensureCurrentContext();
+    if (needs_redraw()) {
+        ensure_current_context();
         if (graphics().begin()) {
             draw();
             graphics().end();
-            FPS::registerFrame();
+            FPS::register_frame();
         }
         
-        SDL_GL_SwapWindow(sharedWindow());
+        SDL_GL_SwapWindow(shared_window());
     }
     
     return true;
@@ -251,17 +294,4 @@ Gosu::Input& Gosu::Window::input()
     return *pimpl->input;
 }
 
-// Deprecated.
-
-class Gosu::Audio {};
-namespace { Gosu::Audio dummyAudio; }
-
-const Gosu::Audio& Gosu::Window::audio() const
-{
-    return dummyAudio;
-}
-
-Gosu::Audio& Gosu::Window::audio()
-{
-    return dummyAudio;
-}
+#endif