gosu 0.10.9.pre1 → 0.11.0

data/Gosu/Platform.hpp

@@ -1,21 +1,20 @@
 //! \file Platform.hpp
 //! Macros and utility functions to facilitate programming on all of Gosu's supported platforms.
 
-#ifndef GOSU_PLATFORM_HPP
-#define GOSU_PLATFORM_HPP
+#pragma once
 
 #ifdef __BIG_ENDIAN__
 # define GOSU_IS_BIG_ENDIAN
-# define IDENTITY_FUN bigToNative
-# define IDENTITY_FUN2 nativeToBig
-# define CONV_FUN littleToNative
-# define CONV_FUN2 nativeToLittle
+# define IDENTITY_FUN big_to_native
+# define IDENTITY_FUN2 native_to_big
+# define CONV_FUN little_to_native
+# define CONV_FUN2 native_to_little
 #else
 # define GOSU_IS_LITTLE_ENDIAN
-# define IDENTITY_FUN littleToNative
-# define IDENTITY_FUN2 nativeToLittle
-# define CONV_FUN bigToNative
-# define CONV_FUN2 nativeToBig
+# define IDENTITY_FUN little_to_native
+# define IDENTITY_FUN2 native_to_little
+# define CONV_FUN big_to_native
+# define CONV_FUN2 native_to_big
 #endif
 
 #include <algorithm>
@@ -67,28 +66,10 @@ namespace Gosu
 # define GOSU_IS_MOBILE
 #endif
 
-#ifndef SWIG
-# if _MSC_VER >= 1700 || ((__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__GXX_EXPERIMENTAL_CXX0X__))
-#  define GOSU_CPP11_ENABLED
-# endif
-#endif
-
-#ifdef GOSU_CPP11_ENABLED
-# define GOSU_UNIQUE_PTR std::unique_ptr
-# define GOSU_MOVE_UNIQUE_PTR(ptr) std::move(ptr)
-#else
-# define GOSU_UNIQUE_PTR std::auto_ptr
-# define GOSU_MOVE_UNIQUE_PTR(ptr) (ptr)
-#endif
-
 #ifndef GOSU_DEPRECATED
 # if defined(GOSU_IS_WIN)
 #  define GOSU_DEPRECATED __declspec(deprecated)
-# elif (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
-#  define GOSU_DEPRECATED  __attribute__((__deprecated__))
 # else
-#  define GOSU_DEPRECATED
+#  define GOSU_DEPRECATED __attribute__((__deprecated__))
 # endif
 #endif
-
-#endif

data/Gosu/Text.hpp

@@ -1,8 +1,7 @@
 //! \file Text.hpp
 //! Functions to output text on bitmaps.
 
-#ifndef GOSU_TEXT_HPP
-#define GOSU_TEXT_HPP
+#pragma once
 
 #include <Gosu/Fwd.hpp>
 #include <Gosu/Color.hpp>
@@ -13,59 +12,51 @@ namespace Gosu
 {
     //! Returns the name of a neutral font that is available on the current
     //! platform.
-    std::wstring defaultFontName();
+    std::string default_font_name();
 
     //! Returns the width an unformatted line of text would span on a bitmap if it were drawn using
-    //! drawText with the same arguments. This is a very low-level function that does not understand
-    //! any of Gosu's HTML-like markup.
+    //! draw_text with the same arguments. This is a very low-level function that does not
+    //! understand any of Gosu's HTML-like markup.
     //! \param text Unformatted text.
-    //! \param fontName Name of a system font, or a filename to a TTF file (must contain '/').
-    unsigned textWidth(const std::wstring& text,
-        const std::wstring& fontName, unsigned fontHeight,
-        unsigned fontFlags = 0);
+    //! \param font_name Name of a system font, or a filename to a TTF file (must contain '/').
+    unsigned text_width(const std::string& text, const std::string& font_name, unsigned font_height,
+        unsigned font_flags = 0);
 
-    //! Draws a line of unformatted text on a bitmap. This is a very low-level function that does not understand
-    //! any of Gosu's HTML-like markup.
+    //! Draws a line of unformatted text on a bitmap. This is a very low-level function that does
+    //! not understand any of Gosu's HTML-like markup.
     //! \param text Unformatted text.
-    //! \param fontName Name of a system font, or a filename to a TTF file (must contain '/').
-    //! \param fontHeight Height, in pixels, of the text.
-    //! \param fontFlags Binary combination of members of the FontFlags
+    //! \param font_name Name of a system font, or a filename to a TTF file (must contain '/').
+    //! \param font_height Height, in pixels, of the text.
+    //! \param font_flags Binary combination of members of the FontFlags
     //! enum.
-    void drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
-        Color c, const std::wstring& fontName, unsigned fontHeight,
-        unsigned fontFlags = 0);
+    void draw_text(Bitmap& bitmap, const std::string& text, int x, int y, Color c,
+        const std::string& font_name, unsigned font_height, unsigned font_flags = 0);
 
     //! Creates a bitmap that is filled with a line of formatted text given to the function.
     //! The line can contain line breaks and HTML-like markup.
     //! \param text Formatted text.
-    //! \param fontName Name of a system font, or a filename to a TTF file (must contain '/').
-    //! \param fontHeight Height of the font in pixels.
-    //! \param fontFlags Binary combination of members of the FontFlags
+    //! \param font_name Name of a system font, or a filename to a TTF file (must contain '/').
+    //! \param font_height Height of the font in pixels.
+    //! \param font_flags Binary combination of members of the FontFlags
     //! enum.
-    Bitmap createText(const std::wstring& text,
-        const std::wstring& fontName, unsigned fontHeight,
-        unsigned fontFlags = 0);
+    Bitmap create_text(const std::string& text, const std::string& font_name, unsigned font_height,
+        unsigned font_flags = 0);
 
     //! 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 fontName Name of a system font, or a filename to a TTF file (must contain '/').
-    //! \param fontHeight Height of the font in pixels.
-    //! \param lineSpacing Spacing between two lines of text in pixels. Can be negative to make
+    //! \param font_name Name of a system font, or a filename to a TTF file (must contain '/').
+    //! \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
     //! text stick together more closely.
-    //! \param width Width of the bitmap that will be returned. Text
-    //! will be split into multiple lines to avoid drawing over the right
-    //! border. When a single word is too long, it will be truncated.
-    //! \param fontFlags Binary combination of members of the FontFlags
-    //! enum.
-    Bitmap createText(const std::wstring& text,
-        const std::wstring& fontName, unsigned fontHeight, 
-        int lineSpacing, unsigned width, TextAlign align,
-        unsigned fontFlags = 0);
+    //! \param width Width of the bitmap that will be returned. Text will be split into multiple
+    //! lines to avoid drawing over the right border. When a single word is too long, it will be
+    //! truncated.
+    //! \param font_flags Binary combination of members of the FontFlags enum.
+    Bitmap create_text(const std::string& text, const std::string& font_name, unsigned font_height,
+        int line_spacing, unsigned width, Alignment align, unsigned font_flags = 0);
     
     //! Registers a new HTML-style entity that can subsequently be used
-    //! with Gosu::Font and Gosu::createText. The name is given without & and ;.
-    void registerEntity(const std::wstring& name, const Bitmap& replacement);
+    //! with Gosu::Font and Gosu::create_text. The name is given without & and ;.
+    void register_entity(const std::string& name, const Bitmap& replacement);
 }
-
-#endif

data/Gosu/TextInput.hpp

@@ -1,12 +1,11 @@
 //! \file TextInput.hpp
 //! Interface of the TextInput class.
 
-#ifndef GOSU_TEXTINPUT_HPP
-#define GOSU_TEXTINPUT_HPP
+#pragma once
 
 #include <Gosu/Fwd.hpp>
 #include <Gosu/Platform.hpp>
-#include <Gosu/TR1.hpp>
+#include <memory>
 #include <string>
 
 namespace Gosu
@@ -14,57 +13,51 @@ namespace Gosu
     //! TextInput instances are invisible objects that build a text string from input,
     //! using the current operating system's keyboard layout.
     //! At its most basic form, you only need to create a new TextInput instance and
-    //! pass it to your window via setTextInput. Until you call this function again,
-    //! passing 0, the TextInput object will build a text that can be accessed via
+    //! pass it to your window via set_text_input. Until you call this function again,
+    //! passing nullptr, the TextInput object will build a text that can be accessed via
     //! TextInput::text().
-    //! A TextInput object is purely abstract, though; drawing the input field is left
-    //! to the user. As with most of Gosu, how this is handled is completely left open.
-    //! TextInput only aims to provide enough code for your own GUIs to build upon.
+    //! A TextInput object is purely abstract. It is up to you to actually draw a text field.
+    //! TextInput only provides a portable base for your own GUI to build upon.
     class TextInput
     {
         struct Impl;
-        const GOSU_UNIQUE_PTR<Impl> pimpl;
-    #if defined(GOSU_CPP11_ENABLED)
-        TextInput(TextInput&&) = delete;
-        TextInput& operator=(TextInput&&) = delete;
-        TextInput(const TextInput&) = delete;
-        TextInput& operator=(const TextInput&) = delete;
-    #endif
+        // Non-movable (const) to avoid dangling references to TextInput instances.
+        const std::unique_ptr<Impl> pimpl;
         
     public:
         TextInput();
         virtual ~TextInput();
 
-        std::wstring text() const;
+        std::string text() const;
 
         //! Replaces the current text by the given string and positions the cursor
         //! at the end of the text, with an empty selection.
-        void setText(const std::wstring& text);
-
-        //! Position of the caret as the index of the character that it's left to.
-        unsigned caretPos() const;
-        //! Sets the caret position as returned by caretPos.
-        //! You usually also want to use setSelectionStart.
-        void setCaretPos(unsigned pos);
-
-        //! If there is a selection, the selectionStart() member yields its beginning,
-        //! using the same indexing scheme as caretPos. If there is no selection,
-        //! selectionStart() is equal to caretPos().
-        unsigned selectionStart() const;
-        //! Sets the start of the selection as returned by selectionStart.
-        void setSelectionStart(unsigned pos);
+        void set_text(const std::string& text);
+
+        //! Index of the character that comes after the caret. When the text is empty, this is
+        //! always 0. For ease of use in C++, this counts bytes, not codepoints in the UTF-8 encoded
+        //! string.
+        unsigned caret_pos() const;
+        //! Sets the caret position as returned by caret_pos.
+        //! You usually also want to use set_selection_start.
+        void set_caret_pos(unsigned pos);
+
+        //! If there is a selection, the selection_start() member yields its beginning,
+        //! using the same indexing scheme as caret_pos. If there is no selection,
+        //! selection_start() is equal to caret_pos().
+        unsigned selection_start() const;
+        //! Sets the start of the selection as returned by selection_start.
+        void set_selection_start(unsigned pos);
         
         // Platform-specific communication with Gosu::Input.
-        bool feedSDLEvent(void* event);
+        bool feed_sdl_event(void* event);
 
         //! Overridable filter that is applied to all new text that is entered.
-        //! Allows for context-sensitive filtering/extending/... of the text.
-        //! The text will be inserted at caretPos afterwards.
-        virtual std::wstring filter(const std::wstring& text) const
+        //! Allows for context-sensitive filtering/extending/... of new characters.
+        //! The return value will be inserted at caret_pos.
+        virtual std::string filter(std::string text) const
         {
             return text;
         }
     };
 }
-
-#endif

data/Gosu/Timing.hpp

@@ -1,16 +1,14 @@
-//! \file Timing.hpp
-//! Functions for timing.
-
-#ifndef GOSU_TIMING_HPP
-#define GOSU_TIMING_HPP
-
-namespace Gosu
-{
-    //! Freezes the current thread for at least the specified time.
-    void sleep(unsigned milliseconds);
-
-    //! Incrementing, possibly wrapping millisecond timer.
-    unsigned long milliseconds();
-}
-
-#endif
+//! \file Timing.hpp
+//! Functions for timing.
+
+#pragma once
+
+namespace Gosu
+{
+    //! Freezes the current thread for at least the specified time.
+    void sleep(unsigned milliseconds);
+
+    //! Returns the milliseconds since first calling this function.
+    //! Can wrap after running for a long time.
+    unsigned long milliseconds();
+}

data/Gosu/Utility.hpp

@@ -1,28 +1,23 @@
 //! \file Utility.hpp
 //! General purpose utility functions.
 
-#ifndef GOSU_UTILITY_HPP
-#define GOSU_UTILITY_HPP
+#pragma once
 
 #include <string>
-#include <vector>
 
 namespace Gosu
 {
-    //! Converts an std::string into an std::wstring.
-    std::wstring utf8ToWstring(const std::string& utf8);
-    //! Converts an std::wstring into an std::string.
-    std::string wstringToUTF8(const std::wstring& ws);
+    //! Converts an UTF-8 to UCS-4 or UTF-16, depending on the platform's interpretation of wstring.
+    std::wstring utf8_to_wstring(const std::string& utf8);
+    //! Converts an UCS-4 or UTF-16 to UTF-8, depending on the platform's interpretation of wstring.
+    std::string wstring_to_utf8(const std::wstring& ws);
     
-    //! Converts an std::string into an std::wstring using local encoding.
-    std::wstring widen(const std::string& s);
-    //! Converts an std::wstring into an std::string using local encoding.
-    std::string narrow(const std::wstring& ws);
+    //! Returns true if the filename has the given extension.
+    //! The comparison is case-insensitive, but you must pass the extension in lower case.
+    bool has_extension(const std::string& filename, const char* extension);
     
     //! Returns the user's preferred language, at the moment of calling the function. Expect return
-    //! values such as 'en_US', 'de_DE.UTF-8', 'ja', 'zh-Hans'. You can rely only on the first two letters
-    //! being a common language abbreviation.
+    //! values such as 'en_US', 'de_DE.UTF-8', 'ja', 'zh-Hans'.
+    //! The first two letters will always be a language code.
     std::string language();
 }
-
-#endif

data/Gosu/Version.hpp

@@ -1,17 +1,16 @@
-#ifndef GOSU_VERSION_HPP
-#define GOSU_VERSION_HPP
+#pragma once
+
+#include <string>
 
 #define GOSU_MAJOR_VERSION 0
-#define GOSU_MINOR_VERSION 10
-#define GOSU_POINT_VERSION 9
-#define GOSU_VERSION "0.10.9.pre1"
+#define GOSU_MINOR_VERSION 11
+#define GOSU_POINT_VERSION 0
 
-#define GOSU_COPYRIGHT_NOTICE \
-    "This software uses the following third-party libraries:\n" \
-    "\n" \
-    "Gosu, https://www.libgosu.org, MIT License, http://opensource.org/licenses/MIT\n" \
-    "SDL 2, http://www.libsdl.org, MIT License, http://opensource.org/licenses/MIT\n" \
-    "libsndfile, http://www.mega-nerd.com/libsndfile, GNU LGPL 3, http://www.gnu.org/copyleft/lesser.html\n" \
-    "OpenAL Soft, http://kcat.strangesoft.net/openal.html, GNU LGPL 2, http://www.gnu.org/licenses/old-licenses/lgpl-2.0.html\n"
-  
-#endif
+namespace Gosu
+{
+    //! A string that contains the full version of the Gosu library, like "0.7.50" or "1.0.0.pre5".
+    extern const std::string VERSION;
+    
+    //! A block of legal copy that your game is obliged to display somewhere.
+    extern const std::string LICENSES;
+}

data/Gosu/Window.hpp

@@ -1,13 +1,11 @@
 //! \file Window.hpp
 //! Interface of the Window class.
 
-#ifndef GOSU_WINDOW_HPP
-#define GOSU_WINDOW_HPP
+#pragma once
 
 #include <Gosu/Fwd.hpp>
-#include <Gosu/Platform.hpp>
 #include <Gosu/Input.hpp>
-#include <Gosu/TR1.hpp>
+#include <Gosu/Platform.hpp>
 #include <memory>
 #include <string>
 
@@ -21,60 +19,59 @@
 namespace Gosu
 {
     //! Returns the width (in pixels) of the user's primary screen.
-    unsigned screenWidth();
+    unsigned screen_width();
     
     //! Returns the height (in pixels) of the user's primary screen.
-    unsigned screenHeight();
+    unsigned screen_height();
     
     //! 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.
-    unsigned availableWidth();
+    unsigned available_width();
     
     //! 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.
-    unsigned availableHeight();
+    unsigned available_height();
     
-    //! 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.
+    //! 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.
-    //! This may or may not change later.
     class Window
     {
         struct Impl;
-        const GOSU_UNIQUE_PTR<Impl> pimpl;
-#if defined(GOSU_CPP11_ENABLED)
-        Window(Window&&) = delete;
-        Window& operator=(Window&&) = delete;
-        Window(const Window&) = delete;
-        Window& operator=(const Window&) = delete;
-#endif
-	
+        // Non-movable (const) to avoid dangling internal references.
+        const std::unique_ptr<Impl> pimpl;
+
     public:
         //! Constructs a Window.
-        //! \param width Width of the window in points; that is, pixels on a normal display, and 'virtual pixels' on a
-        //! high-resolution display.
+        //! \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 updateInterval Interval in milliseconds between two calls
-        //! to the update member function.
+        //! \param update_interval Interval in milliseconds between two calls to the update member
+        //! function.
         Window(unsigned width, unsigned height, bool fullscreen = false,
-            double updateInterval = 16.666666);
+            double update_interval = 16.666666);
         virtual ~Window();
 
-        std::wstring caption() const;
-        void setCaption(const std::wstring& caption);
-        
-        double updateInterval() const;
+        unsigned width() const;
+        unsigned height() const;
+        bool fullscreen() const;
+        void resize(unsigned width, unsigned height, bool fullscreen);
         
+        double update_interval() const;
+        void set_update_interval(double update_interval);
+
+        std::string caption() const;
+        void set_caption(const std::string& caption);
+
         //! Enters a modal loop where the Window is visible on screen and
         //! receives calls to draw, update etc.
         virtual void show();
         
         //! Performs a single mainloop step.
-        //! This method is only useful if you want to integrate Gosu with
-        //! another library that has its own main loop.
-        //! This method implicitly shows the window if it was hidden before, and
-        //! returns false when the window has been closed.
+        //! This method is only useful if you want to integrate Gosu with another library that has
+        //! its own main loop.
+        //! This method implicitly shows the window if it was hidden before, and returns false when
+        //! the window has been closed.
         //! If you discard the return value and keep calling tick(), the window will be shown again,
         //! or keep being shown.
         virtual bool tick();
@@ -82,66 +79,54 @@ namespace Gosu
         //! Closes the window if it is currently shown.
         void close();
 
-        //! Called every updateInterval milliseconds while the window is being
-        //! shown. Your application's main game logic goes here.
+        //! Called every update_interval milliseconds while the window is being shown.
+        //! Your application's main game logic goes here.
         virtual void update() {}
-        //! Called after every update and when the OS wants the window to
-        //! repaint itself. Your application's rendering code goes here.
+        
+        //! Called after every update and when the OS wants the window to repaint itself.
+        //! Your application's rendering code goes here.
         virtual void draw() {}
         
         //! Gives the game a chance to say no to being redrawn.
-        //! This is not a definitive answer. The operating system can still force
-        //! the window to redraw itself.
+        //! This is not a definitive answer. The operating system can still force the window to
+        //! redraw itself.
         //! By default, the window is redrawn all the time.
-        virtual bool needsRedraw() const { return true; }
+        virtual bool needs_redraw() const { return true; }
 
-        //! If this function returns true, the system arrow cursor is drawn while
-        //! over the window.
-        virtual bool needsCursor() const { return false; }
+        //! If this function returns true, the system arrow cursor is drawn while over the window.
+        virtual bool needs_cursor() const { return false; }
         
         //! This function is called when the window loses focus on some platforms.
-        //! Most importantly, it is called on the iPhone or iPad when the user
-        //! locks the screen.
-        virtual void loseFocus() {}
+        //! Most importantly, it is called on the i_phone or i_pad when the user locks the screen.
+        virtual void lose_focus() {}
         
         //! This function is called when the operating system's memory is low.
         //! So far, it is only called in iOS applications.
-        virtual void releaseMemory() {}
+        virtual void release_memory() {}
 
-        //! Called before update when the user pressed a button while the
-        //! window had the focus.
-        virtual void buttonDown(Gosu::Button) {}
-        //! Same as buttonDown. Called then the user released a button.
-        virtual void buttonUp(Gosu::Button) {}
+        //! Called before update when the user pressed a button while the window had the focus.
+        virtual void button_down(Gosu::Button) {}
+        
+        //! Same as button_down. Called then the user released a button.
+        virtual void button_up(Gosu::Button) {}
         
         // Ignore when SWIG is wrapping this class for Ruby/Gosu.
         #ifndef SWIG
-        
         // Callbacks for touch events. So far these are only used on iOS.
-        virtual void touchBegan(Touch touch) {}
-        virtual void touchMoved(Touch touch) {}
-        virtual void touchEnded(Touch touch) {}
-        virtual void touchCancelled(Touch touch) {}
+        virtual void touch_began(Touch touch) {}
+        virtual void touch_moved(Touch touch) {}
+        virtual void touch_ended(Touch touch) {}
+        virtual void touch_cancelled(Touch touch) {}
         
         const Graphics& graphics() const;
         Graphics& graphics();
         
         const Input& input() const;
         Input& input();
+        #endif
         
         #ifdef GOSU_IS_IPHONE
         void* UIWindow() const;
-        #endif        
-        
-        GOSU_DEPRECATED const Audio& audio() const;
-        GOSU_DEPRECATED Audio& audio();
-
         #endif
     };
 }
-
-#ifdef GOSU_IS_IPHONE
-Gosu::Window& windowInstance();
-#endif
-
-#endif