gosu 0.7.39-x86-mingw32

data/Gosu/Platform.hpp

@@ -0,0 +1,73 @@
+//! \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
+
+#ifdef __BIG_ENDIAN__
+# define GOSU_IS_BIG_ENDIAN
+# define IDENTITY_FUN bigToNative
+# define IDENTITY_FUN2 nativeToBig
+# define CONV_FUN littleToNative
+# define CONV_FUN2 nativeToLittle
+#else
+# define GOSU_IS_LITTLE_ENDIAN
+# define IDENTITY_FUN littleToNative
+# define IDENTITY_FUN2 nativeToLittle
+# define CONV_FUN bigToNative
+# define CONV_FUN2 nativeToBig
+#endif
+
+#include <algorithm>
+
+namespace Gosu
+{
+    template<typename T> T IDENTITY_FUN(T t) { return t; }
+    template<typename T> T IDENTITY_FUN2(T t) { return t; }
+    
+    template<typename T>
+    T CONV_FUN(T t)
+    {
+        char* begin = reinterpret_cast<char*>(&t);
+        std::reverse(begin, begin + sizeof t);
+        return t;
+    }
+
+    template<typename T> T CONV_FUN2(T t) { return CONV_FUN(t); }
+}
+
+#undef IDENTITY_FUN
+#undef IDENTITY_FUN2
+#undef CONV_FUN
+#undef CONV_FUN2
+
+#if defined(_MSC_VER)
+# define GOSU_NORETURN __declspec(noreturn)
+#elif defined(__GNUC__)
+# define GOSU_NORETURN __attribute__ ((noreturn))
+#endif
+
+#if defined(WIN32)
+# define GOSU_IS_WIN
+#else
+# define GOSU_IS_UNIX
+# if defined(__linux) || defined(__FreeBSD__)
+#  define GOSU_IS_X
+# else
+#  define GOSU_IS_MAC
+#  include <TargetConditionals.h>
+#  if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
+#   define GOSU_IS_IPHONE
+#  endif
+# endif
+#endif
+
+#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 
+#endif
+
+#endif

data/Gosu/Sockets.hpp

@@ -0,0 +1,137 @@
+//! \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>
+
+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 std::auto_ptr<Impl> pimpl;
+
+    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 std::auto_ptr<Impl> pimpl;
+
+    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 std::auto_ptr<Impl> pimpl;
+
+    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,44 @@
+//! \file TR1.hpp
+//! Includes all parts of C++03 (TR1) that are relevant for Gosu.
+
+#ifndef GOSU_TR1_HPP
+#define GOSU_TR1_HPP
+
+#ifdef _MSC_VER
+    #include <array>
+    #include <memory>
+    #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;
+        }
+    }
+#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 maxWidth 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 maxWidth, 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 std::auto_ptr<Impl> pimpl;
+        
+    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.
+        #if defined(GOSU_IS_MAC)
+        bool feedNSEvent(void* event);
+        #elif defined(GOSU_IS_WIN)
+        bool feedMessage(unsigned long message, unsigned long wparam, unsigned long lparam);
+        #elif defined(GOSU_IS_X)
+        bool feedXEvent(void* display, void* event);
+        #endif
+
+        //! 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& textIn) const
+        {
+            return textIn;
+        }
+    };
+}
+
+#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