gosu 0.8.6-x64-mingw32

data/Gosu/Sockets.hpp

@@ -0,0 +1,156 @@
+//! \file Sockets.hpp
+//! Interface of the three socket classes, MessageSocket, CommSocket and ListenerSocket.
+
+#ifndef GOSU_SOCKETS_HPP
+#define GOSU_SOCKETS_HPP
+
+#include <Gosu/TR1.hpp>
+#include <cstddef>
+#include <string>
+#include <Gosu/Platform.hpp>
+
+namespace Gosu
+{
+    //! Addresses are returned from and given to Gosu functions in host byte order.
+    typedef std::tr1::uint32_t SocketAddress;
+
+    //! Ports are returned from and given to Gosu functions in host byte order.
+    typedef std::tr1::uint16_t SocketPort;
+    
+    //! Constant that can be used as a placeholder for an arbitrary port, e.g. when
+    //! starting to listen.
+    const SocketPort anyPort = 0;
+    
+    //! Tries to convert a dotted IP4 string into an address suitable for
+    //! socket functions. If the string supplied is not such a string, it
+    //! tries to look up the host via DNS. If both methods fail, zero is
+    //! returned.
+    SocketAddress stringToAddress(const std::string& s);
+    //! Converts an address into a dotted IP4 string.
+    std::string addressToString(SocketAddress address);
+
+    //! Wraps an UDP socket. Message sockets can send data to and receive
+    //! data from arbitrary addresses. Also, message sockets send messages
+    //! (packets) which are limited in size and can arrive in any order, or
+    //! not at all.
+    class MessageSocket
+    {
+        struct Impl;
+        const GOSU_UNIQUE_PTR<Impl> pimpl;
+#if defined(GOSU_CPP11_ENABLED)
+        MessageSocket(const MessageSocket&) = delete;
+        MessageSocket& operator=(const MessageSocket&) = delete;
+        MessageSocket(MessageSocket&&) = delete;
+        MessageSocket& operator=(MessageSocket&&) = delete;
+#endif
+
+    public:
+        //! Opens a message socket for listening at the specified port.
+        //! Gosu::anyPort may be passed to have the message socket use
+        //! a random free port.
+        explicit MessageSocket(SocketPort port);
+        ~MessageSocket();
+
+        //! Returns the local address of the socket.
+        SocketAddress address() const;
+        //! Returns the local port of the socket.
+        SocketPort port() const;
+        //! Returns the maximum size, in bytes, of a packet that can be sent
+        //! from this socket.
+        std::size_t maxMessageSize() const;
+
+        //! Collects all the packets that were sent to this socket and
+        //! calls onReceive for each of them.
+        void update();
+
+        //! Sends something to the given port of the computer identified
+        //! by the address.
+        void send(SocketAddress address, SocketPort port,
+            const void* buffer, std::size_t size);
+        /*void broadcast(SocketPort port, const void* buffer,
+            std::size_t size);*/
+
+        //! If assigned, will be called by update for every packet received.
+        std::tr1::function<void (SocketAddress, SocketPort, const void*,
+            std::size_t)> onReceive;
+    };
+    
+    //! Defines the way in which data is collected until the onReceive event
+    //! is called for CommSockets.
+    enum CommMode
+    {
+        cmRaw,
+        //cmLines,
+        cmManaged
+    };
+    
+    class Socket;
+    
+    //! Wraps a TCP socket that is used for one part of bi-directional
+    //! communication.
+    class CommSocket
+    {
+        struct Impl;
+        const GOSU_UNIQUE_PTR<Impl> pimpl;
+#if defined(GOSU_CPP11_ENABLED)
+        CommSocket(const CommSocket&) = delete;
+        CommSocket& operator=(const CommSocket&) = delete;
+        CommSocket(CommSocket&&) = delete;
+        CommSocket& operator=(CommSocket&&) = delete;
+#endif
+
+    public:
+        CommSocket(CommMode mode, SocketAddress targetAddress,
+            SocketPort targetPort);
+        CommSocket(CommMode mode, Socket& socket);
+        ~CommSocket();
+
+        SocketAddress address() const;
+        SocketPort port() const;
+        SocketAddress remoteAddress() const;
+        SocketPort remotePort() const;
+        CommMode mode() const;
+
+        bool connected() const;
+        void disconnect();
+        bool keepAlive() const;
+        void setKeepAlive(bool value);
+
+        void update();
+        void send(const void* buffer, std::size_t size);
+        void sendPendingData();
+        std::size_t pendingBytes() const;
+
+        std::tr1::function<void (const void*, std::size_t)> onReceive;
+        std::tr1::function<void ()> onDisconnection;
+    };
+    
+    //! Wraps a TCP socket that waits on a specific port and can create
+    //! CommSocket instances via its onConnection event.
+    class ListenerSocket
+    {
+        struct Impl;
+        const GOSU_UNIQUE_PTR<Impl> pimpl;
+#if defined(GOSU_CPP11_ENABLED)
+        ListenerSocket(const ListenerSocket&) = delete;
+        ListenerSocket& operator=(const ListenerSocket&) = delete;
+        ListenerSocket(ListenerSocket&&) = delete;
+        ListenerSocket& operator=(ListenerSocket&&) = delete;
+#endif
+
+    public:
+        ListenerSocket(SocketPort port);
+        ~ListenerSocket();
+
+        SocketAddress address() const;
+        SocketPort port() const;
+
+        void update();
+
+        //! This signal is fired by update() whenever someone connects
+        //! to the port which is currently listened on.
+        std::tr1::function<void (Socket&)> onConnection;
+    };
+}
+
+#endif

data/Gosu/TR1.hpp

@@ -0,0 +1,56 @@
+//! \file TR1.hpp
+//! Includes all parts of C++03 (TR1) that are relevant for Gosu. It makes available the following members of the std::tr1 namespace: array, bind, function, shared_ptr, uint*_t and int*_t.
+
+#ifndef GOSU_TR1_HPP
+#define GOSU_TR1_HPP
+
+#include <memory>
+
+#if defined(_MSC_VER) || defined(_LIBCPP_MEMORY)
+    #include <array>
+    #include <functional>
+    namespace std
+    {
+        namespace tr1
+        {
+            typedef unsigned char uint8_t;
+            typedef unsigned short uint16_t;
+            typedef unsigned int uint32_t;
+            typedef unsigned long long uint64_t;
+            typedef signed char int8_t;
+            typedef signed short int16_t;
+            typedef signed int int32_t;
+            typedef signed long long int64_t;
+            
+            #ifdef _LIBCPP_MEMORY
+            namespace placeholders
+            {
+                using namespace std::placeholders;
+            }
+            using std::array;
+            using std::bind;
+            using std::function;
+            using std::shared_ptr;
+            #endif
+        }        
+    }
+#else
+    #include <tr1/array>
+    #include <tr1/memory>
+    #include <tr1/functional>
+    #if defined(__GNUC__) && (__GNUC__ < 4 || __GNUC_MINOR__ < 2)
+        #include <stdint.h>
+        namespace std
+        {
+            namespace tr1
+            {
+                using ::int8_t; using ::int16_t; using ::int32_t; using ::int64_t;
+                using ::uint8_t; using ::uint16_t; using ::uint32_t; using ::uint64_t;
+            }
+        }
+    #else
+        #include <tr1/cstdint>
+    #endif
+#endif
+
+#endif

data/Gosu/Text.hpp

@@ -0,0 +1,71 @@
+//! \file Text.hpp
+//! Functions to output text on bitmaps.
+
+#ifndef GOSU_TEXT_HPP
+#define GOSU_TEXT_HPP
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/Color.hpp>
+#include <Gosu/GraphicsBase.hpp>
+#include <string>
+
+namespace Gosu
+{
+    //! Returns the name of a neutral font that is available on the current
+    //! platform.
+    std::wstring defaultFontName();
+
+    //! 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.
+    //! \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);
+
+    //! 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
+    //! enum.
+    void drawText(Bitmap& bitmap, const std::wstring& text, int x, int y,
+        Color c, const std::wstring& fontName, unsigned fontHeight,
+        unsigned fontFlags = 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
+    //! enum.
+    Bitmap createText(const std::wstring& text,
+        const std::wstring& fontName, unsigned fontHeight,
+        unsigned fontFlags = 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
+    //! 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);
+    
+    //! 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);
+}
+
+#endif

data/Gosu/TextInput.hpp

@@ -0,0 +1,70 @@
+//! \file TextInput.hpp
+//! Interface of the TextInput class.
+
+#ifndef GOSU_TEXTINPUT_HPP
+#define GOSU_TEXTINPUT_HPP
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/Platform.hpp>
+#include <Gosu/TR1.hpp>
+#include <string>
+
+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
+    //! 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.
+    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
+        
+    public:
+        TextInput();
+        virtual ~TextInput();
+
+        std::wstring 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);
+        
+        // Platform-specific communication with Gosu::Input.
+        bool feedSDLEvent(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
+        {
+            return text;
+        }
+    };
+}
+
+#endif

data/Gosu/Timing.hpp

@@ -0,0 +1,16 @@
+//! \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

data/Gosu/Utility.hpp

@@ -0,0 +1,28 @@
+//! \file Utility.hpp
+//! General purpose utility functions.
+
+#ifndef GOSU_UTILITY_HPP
+#define GOSU_UTILITY_HPP
+
+#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 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 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.
+    std::string language();
+}
+
+#endif

data/Gosu/Version.hpp

@@ -0,0 +1,19 @@
+#ifndef GOSU_VERSION_HPP
+#define GOSU_VERSION_HPP
+
+#define GOSU_MAJOR_VERSION 0
+#define GOSU_MINOR_VERSION 8
+#define GOSU_POINT_VERSION 6
+#define GOSU_VERSION "0.8.6"
+
+#define GOSU_COPYRIGHT_NOTICE \
+    "This software uses the following third-party libraries:\n" \
+    "\n" \
+    "Gosu, http://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" \
+    "FreeImage, http://freeimage.sourceforge.net, FreeImage Public License\n" \
+    "libogg & libvorbis, http://www.xiph.org, BSD License, 3-Clause Version, http://www.xiph.org/licenses/bsd\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

data/Gosu/WinUtility.hpp

@@ -0,0 +1,75 @@
+//! \file WinUtility.hpp
+//! Contains some functions which are used to implement Gosu on Windows and
+//! might be useful for advanced users who try to integrate Gosu in a Win32
+//! application.
+
+#ifndef GOSU_WINUTILITY_HPP
+#define GOSU_WINUTILITY_HPP
+
+#include <windows.h>
+#include <Gosu/Platform.hpp>
+#include <Gosu/TR1.hpp>
+#include <string>
+
+namespace Gosu
+{
+    //! Implementation helpers for the Windows platform.
+    namespace Win
+    {
+        //! Returns the instance handle of the application.
+        HINSTANCE instance();
+
+        //! Blocking function which waits for the next message, processes it,
+        //! then returns.
+        void handleMessage();
+
+        //! Non-blocking function which processes all waiting messages but does
+        //! not wait for further incoming messages.
+        void processMessages();
+
+        //! Registers a function to be called by handleMessage and
+        //! processMessages. Every message is passed to the hooks and not
+        //! processed further if any hook function returns true.
+        void registerMessageHook(const std::tr1::function<bool (MSG&)>& hook);
+        
+        //! 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 = "");
+
+        //! 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;
+        }
+
+        // IMPR: Why can't I use mem_fn for releasing objects even though it is
+        // shown like that in the shared_ptr documentation?
+        template<typename T>
+        void releaseComPtr(T* ptr)
+        {
+            ptr->Release();
+        }
+
+        //! Small helper function that transfers ownership of a COM interface
+        //! to a std::tr1::shared_ptr.
+        template<typename T>
+        inline std::tr1::shared_ptr<T> shareComPtr(T* ptr)
+        {
+            return std::tr1::shared_ptr<T>(ptr, releaseComPtr<T>);
+        }
+
+        //! Returns the executable's filename.
+        std::wstring appFilename();
+
+        //! Returns the executable's containing directory.
+        std::wstring appDirectory();
+    }
+}
+
+#endif