gosu 0.7.25-i386-mingw32 → 0.7.26-i386-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 (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
+# define GOSU_DEPRECATED  __attribute__((__deprecated__))
+#elif defined(GOSU_IS_WIN)
+# define GOSU_DEPRECATED __declspec(deprecated)
+#else
+# define GOSU_DEPRECATED 
+#endif
+
+#endif

data/Gosu/Sockets.hpp

@@ -0,0 +1,139 @@
+//! \file Sockets.hpp
+//! Interface of the three socket classes, MessageSocket, CommSocket and ListenerSocket.
+
+#ifndef GOSU_SOCKETS_HPP
+#define GOSU_SOCKETS_HPP
+
+#include <boost/cstdint.hpp>
+#include <boost/function.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <cstddef>
+#include <string>
+
+namespace Gosu
+{
+    //! Addresses are returned from and given to Gosu functions in host byte order.
+    typedef boost::uint32_t SocketAddress;
+
+    //! Ports are returned from and given to Gosu functions in host byte order.
+    typedef boost::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;
+        boost::scoped_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.
+        boost::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;
+        boost::scoped_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;
+
+        boost::function<void (const void*, std::size_t)> onReceive;
+        boost::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;
+        boost::scoped_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.
+        boost::function<void (Socket&)> onConnection;
+    };
+}
+
+#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 <boost/scoped_ptr.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;
+        boost::scoped_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,25 @@
+//! \file Utility.hpp
+//! General purpose utility functions.
+
+// REDESIGN: Rename to StringConversion.hpp?
+
+#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);
+}
+
+#endif

data/Gosu/Version.hpp

@@ -0,0 +1,9 @@
+#ifndef GOSU_VERSION_HPP
+#define GOSU_VERSION_HPP
+
+#define GOSU_MAJOR_VERSION 0
+#define GOSU_MINOR_VERSION 7
+#define GOSU_POINT_VERSION 26
+#define GOSU_VERSION "0.7.26"
+
+#endif

data/Gosu/WinUtility.hpp

@@ -0,0 +1,76 @@
+//! \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 <boost/function.hpp>
+#include <boost/shared_ptr.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 boost::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 boost::shared_ptr.
+        template<typename T>
+        inline boost::shared_ptr<T> shareComPtr(T* ptr)
+        {
+            return boost::shared_ptr<T>(ptr, releaseComPtr<T>);
+        }
+
+        //! Returns the executable's filename.
+        std::wstring appFilename();
+
+        //! Returns the executable's containing directory.
+        std::wstring appDirectory();
+    }
+}
+
+#endif