gosu 0.7.33 → 0.7.35

data/GosuImpl/Sockets/CommSocket.cpp

@@ -1,6 +1,6 @@
 #include <Gosu/Sockets.hpp>
+#include <Gosu/TR1.hpp>
 #include <GosuImpl/Sockets/Sockets.hpp>
-#include <boost/cstdint.hpp>
 #include <cassert>
 #include <cstring>
 #include <stdexcept>
@@ -15,7 +15,7 @@ struct Gosu::CommSocket::Impl
     Buffer inbox, outbox;
 
     void appendBuffer(const char* buffer, std::size_t size,
-        boost::function<void (const void*, std::size_t)>& event)
+        std::tr1::function<void (const void*, std::size_t)>& event)
     {
         switch (mode)
         {
@@ -35,7 +35,7 @@ struct Gosu::CommSocket::Impl
 
                 for (;;) // IMPR.
                 {
-                    const size_t sizeSize = sizeof(boost::uint32_t);
+                    const size_t sizeSize = 4;
 
                     // Not even enough bytes there to determine the size of the
                     // incoming message.
@@ -43,7 +43,7 @@ struct Gosu::CommSocket::Impl
                         break;
 
                     // Message size is already here, convert it.
-                    boost::uint32_t msgSize = *reinterpret_cast<boost::uint32_t*>(&inbox[0]);
+                    std::tr1::uint32_t msgSize = *reinterpret_cast<std::tr1::uint32_t*>(&inbox[0]);
                     msgSize = ntohl(msgSize);
 
                     // Can't really handle zero-size messages. IMPR?!
@@ -241,7 +241,7 @@ void Gosu::CommSocket::send(const void* buffer, std::size_t size)
     // In managed mode, also send the length of the buffer.
     if (mode() == cmManaged)
     {
-        boost::uint32_t netSize = htonl(size);
+        std::tr1::uint32_t netSize = htonl(size);
         const char* charBuf = reinterpret_cast<const char*>(&netSize);
         pimpl->outbox.insert(pimpl->outbox.end(), charBuf,
             charBuf + sizeof netSize);

data/GosuImpl/Sockets/Sockets.hpp

@@ -2,7 +2,6 @@
 #define GOSUIMPL_SOCKETS_HPP
 
 #include <Gosu/Platform.hpp>
-#include <boost/utility.hpp>
 
 #ifdef GOSU_IS_WIN
     #include "winsock2.h"
@@ -27,10 +26,11 @@
 namespace Gosu
 {
     // Owns a socket and manages library initialization.
-    class Socket : boost::noncopyable
-    {
+    class Socket    {
+        Socket(const Socket&);
+        Socket& operator=(const Socket&);
+        
         SocketHandle handle_;
-
     public:
         Socket();
         ~Socket();

data/GosuImpl/TimingApple.cpp

@@ -9,12 +9,11 @@ void Gosu::sleep(unsigned milliseconds)
 // Thanks to this blog for the unconvoluted code example:
 // http://shiftedbits.org/2008/10/01/mach_absolute_time-on-the-iphone/
 
-#include <boost/cstdint.hpp>
 #include <mach/mach_time.h>
 
 unsigned long Gosu::milliseconds()
 {
-    static boost::uint64_t firstTick = 0;
+    static uint64_t firstTick = 0;
     static mach_timebase_info_data_t info;
     
     if (firstTick == 0)
@@ -23,6 +22,6 @@ unsigned long Gosu::milliseconds()
         firstTick = mach_absolute_time();
     }
 
-    boost::uint64_t runtime = mach_absolute_time() - firstTick;
+    uint64_t runtime = mach_absolute_time() - firstTick;
 	return runtime * info.numer / info.denom / 1000000.0;
 }

data/GosuImpl/Utility.cpp

@@ -2,6 +2,8 @@
 #include <Gosu/Platform.hpp>
 #include <cstddef>
 #include <cstdlib>
+#include <cwctype>
+#include <cwchar>
 #include <stdexcept>
 #include <algorithm>
 #include <vector>
@@ -99,3 +101,19 @@ string Gosu::narrow(const wstring& ws)
 
     return string(buf.begin(), buf.end() - 1);
 }
+
+// TODO: This function needs to go into some internal header.
+namespace Gosu
+{
+    bool isExtension(const wchar_t* str, const wchar_t* ext)
+    {
+        size_t strLen = wcslen(str), extLen = wcslen(ext);
+        if (extLen > strLen)
+            return false;
+        str += strLen, ext += extLen;
+        while (extLen--)
+            if (towlower((wint_t)*--str) != *--ext)
+                return false;
+        return true;
+    }
+}

data/GosuImpl/WinMain.cpp

@@ -1,4 +1,3 @@
-#include <boost/lexical_cast.hpp>
 #include <windows.h>
 #include <exception>
 #include <string>

data/GosuImpl/WinUtility.cpp

@@ -5,7 +5,7 @@
 
 namespace
 {
-    typedef std::vector<boost::function<bool (MSG&)> > Hooks;
+    typedef std::vector<std::tr1::function<bool (MSG&)> > Hooks;
     Hooks hooks;
 
     bool handledByHook(MSG& message)
@@ -68,7 +68,7 @@ void Gosu::Win::processMessages()
         }
 }
 
-void Gosu::Win::registerMessageHook(const boost::function<bool (MSG&)>& hook)
+void Gosu::Win::registerMessageHook(const std::tr1::function<bool (MSG&)>& hook)
 {
     hooks.push_back(hook);
 }

data/GosuImpl/WindowMac.mm

@@ -1,17 +1,20 @@
-#import <Gosu/Window.hpp>
-#import <Gosu/Audio.hpp>
-#import <Gosu/Graphics.hpp>
-#import <Gosu/Input.hpp>
-#import <GosuImpl/MacUtility.hpp>
-#import <Gosu/Timing.hpp>
-#import <Gosu/Utility.hpp>
+#include <Gosu/Window.hpp>
+#include <Gosu/Audio.hpp>
+#include <Gosu/Graphics.hpp>
+#include <Gosu/Input.hpp>
+#include <GosuImpl/MacUtility.hpp>
+#include <Gosu/Timing.hpp>
+#include <Gosu/TR1.hpp>
+#include <Gosu/Utility.hpp>
+#include <OpenGL/OpenGL.h>
+#include <OpenGL/gl.h>
+#include <memory>
+#include <vector>
+using namespace std::tr1::placeholders;
+
 #import <AppKit/AppKit.h>
 #import <ApplicationServices/ApplicationServices.h>
 #import <Carbon/Carbon.h>
-#import <OpenGL/OpenGL.h>
-#import <OpenGL/gl.h>
-#import <boost/bind.hpp>
-#import <vector>
 
 namespace Gosu
 {
@@ -190,8 +193,8 @@ struct Gosu::Window::Impl
 	NSRect savedFrame;
     
     ObjRef<NSOpenGLContext> context;
-    boost::scoped_ptr<Graphics> graphics;
-    boost::scoped_ptr<Input> input;
+    std::auto_ptr<Graphics> graphics;
+    std::auto_ptr<Input> input;
     double interval;
     bool mouseViz;
     
@@ -302,8 +305,8 @@ Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen,
     pimpl->graphics->setResolution(width, height);
     
     pimpl->input.reset(new Input(pimpl->window.get()));
-    pimpl->input->onButtonDown = boost::bind(&Window::buttonDown, this, _1);
-    pimpl->input->onButtonUp = boost::bind(&Window::buttonUp, this, _1);
+    pimpl->input->onButtonDown = std::tr1::bind(&Window::buttonDown, this, _1);
+    pimpl->input->onButtonUp = std::tr1::bind(&Window::buttonUp, this, _1);
     pimpl->input->setMouseFactors(1.0 * width / realWidth, 1.0 * height / realHeight);
     if (fullscreen)
         [NSApp setInput: input()];
@@ -476,8 +479,8 @@ Gosu::Window::SharedContext Gosu::Window::createSharedContext()
             initWithFormat: pf
             shareContext: pimpl->context.obj()];
     
-    return SharedContext(new boost::function<void()>(boost::bind(makeCurrentContext, ctx)),
-        boost::bind(releaseContext, ctx));
+    return SharedContext(new std::tr1::function<void()>(std::tr1::bind(makeCurrentContext, ctx)),
+        std::tr1::bind(releaseContext, ctx));
 }
 
 namespace GosusDarkSide

data/GosuImpl/WindowTouch.mm

@@ -4,12 +4,13 @@
 #include <Gosu/Input.hpp>
 #include <GosuImpl/MacUtility.hpp>   
 #include <GosuImpl/Graphics/GosuView.hpp>
-#include <boost/bind.hpp>
 
 #import <CoreGraphics/CoreGraphics.h>
 #import <UIKit/UIKit.h>
 #import <OpenGLES/EAGL.h>
 
+using namespace std::tr1::placeholders;
+
 namespace Gosu
 {
     CGRect screenRect = [[UIScreen mainScreen] bounds];
@@ -35,9 +36,9 @@ class Gosu::Audio {};
 struct Gosu::Window::Impl {
     ObjRef<UIWindow> window;
     ObjRef<GosuViewController> controller;
-    boost::scoped_ptr<Graphics> graphics;
-    boost::scoped_ptr<Audio> audio;
-    boost::scoped_ptr<Input> input;
+    std::auto_ptr<Graphics> graphics;
+    std::auto_ptr<Audio> audio;
+    std::auto_ptr<Input> input;
     double interval;
 };
 
@@ -126,9 +127,9 @@ Gosu::Window::Window(unsigned width, unsigned height,
     pimpl->graphics->setResolution(screenHeight(), screenWidth());
     pimpl->audio.reset(new Audio());
     pimpl->input.reset(new Input(gosuView, updateInterval));
-    pimpl->input->onTouchBegan = boost::bind(&Window::touchBegan, this, _1);
-    pimpl->input->onTouchMoved = boost::bind(&Window::touchMoved, this, _1);
-    pimpl->input->onTouchEnded = boost::bind(&Window::touchEnded, this, _1);
+    pimpl->input->onTouchBegan = std::tr1::bind(&Window::touchBegan, this, _1);
+    pimpl->input->onTouchMoved = std::tr1::bind(&Window::touchMoved, this, _1);
+    pimpl->input->onTouchEnded = std::tr1::bind(&Window::touchEnded, this, _1);
     pimpl->interval = updateInterval;
 
     [pimpl->window.obj() makeKeyAndVisible];

data/GosuImpl/WindowWin.cpp

@@ -5,15 +5,19 @@
 #include <Gosu/Window.hpp>
 #include <Gosu/WinUtility.hpp>
 #include <Gosu/Timing.hpp>
+#include <Gosu/Audio.hpp>
 #include <Gosu/Graphics.hpp>
 #include <Gosu/Input.hpp>
 #include <Gosu/TextInput.hpp>
+#include <Gosu/TR1.hpp>
 #include <GosuImpl/Graphics/Common.hpp>
-#include <boost/bind.hpp>
 #include <cassert>
+#include <memory>
 #include <stdexcept>
 #include <vector>
 
+using namespace std::tr1::placeholders;
+
 // TODO: Put fullscreen logic in different file, track fullscreen state and
 // enable dynamic toggling between fullscreen and window.
 
@@ -173,8 +177,8 @@ struct Gosu::Window::Impl
 {
     HWND handle;
 	HDC hdc;
-    boost::scoped_ptr<Graphics> graphics;
-    boost::scoped_ptr<Input> input;
+    std::auto_ptr<Graphics> graphics;
+    std::auto_ptr<Input> input;
 	double updateInterval;
     bool iconified;
 
@@ -286,8 +290,8 @@ Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen,
 	graphics().setResolution(pimpl->originalWidth, pimpl->originalHeight);
     pimpl->input.reset(new Gosu::Input(handle()));
 	input().setMouseFactors(1.0 * pimpl->originalWidth / width, 1.0 * pimpl->originalHeight / height);
-    input().onButtonDown = boost::bind(&Window::buttonDown, this, _1);
-    input().onButtonUp = boost::bind(&Window::buttonUp, this, _1);
+    input().onButtonDown = std::tr1::bind(&Window::buttonDown, this, _1);
+    input().onButtonUp = std::tr1::bind(&Window::buttonUp, this, _1);
 
     pimpl->updateInterval = updateInterval;
 }
@@ -357,6 +361,7 @@ void Gosu::Window::show()
 			if (ms < lastTick || ms - lastTick >= static_cast<unsigned>(pimpl->updateInterval))
 			{
 				lastTick = ms;
+                Song::update();
 				input().update();
 				// TODO: Bad heuristic -- this causes flickering cursor on right and bottom border of the
 				// window.
@@ -463,7 +468,7 @@ LRESULT Gosu::Window::handleMessage(UINT message, WPARAM wparam, LPARAM lparam)
 
     if (message == WM_PAINT)
     {
-        if (pimpl->graphics && graphics().begin())
+        if (pimpl->graphics.get() && graphics().begin())
         {
             try
             {
@@ -496,7 +501,7 @@ LRESULT Gosu::Window::handleMessage(UINT message, WPARAM wparam, LPARAM lparam)
         }
     }
 
-    if (pimpl->input && input().textInput() && input().textInput()->feedMessage(message, wparam, lparam))
+    if (pimpl->input.get() && input().textInput() && input().textInput()->feedMessage(message, wparam, lparam))
         return 0;
 
     return DefWindowProc(handle(), message, wparam, lparam);

data/GosuImpl/WindowX.cpp

@@ -4,29 +4,34 @@
 // understand than that! --jlnr
 
 #include <Gosu/Window.hpp>
-#include <Gosu/Timing.hpp>
-#include <Gosu/Utility.hpp>
+#include <Gosu/Audio.hpp>
 #include <Gosu/Input.hpp>
 #include <Gosu/Graphics.hpp>
-#include <Gosu/Audio.hpp>
-#include <boost/bind.hpp>
-#include <stdexcept>
-#include <algorithm>
+#include <Gosu/Timing.hpp>
+#include <Gosu/TR1.hpp>
+#include <Gosu/Utility.hpp>
 #include <cstdio>
+#include <algorithm>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
 #include <vector>
 
 #include <GL/glx.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
+#include <X11/extensions/Xdamage.h>
 #include "X11vroot.h"
 
+using namespace std::tr1::placeholders;
+
 namespace
 {
     template<typename T>
     class scoped_resource
     {
         T* pointer;
-        typedef boost::function<void(T*)> Deleter;
+        typedef std::tr1::function<void(T*)> Deleter;
         Deleter deleter;
         
     public:
@@ -81,8 +86,8 @@ namespace Gosu
 
 struct Gosu::Window::Impl
 {
-    boost::scoped_ptr<Graphics> graphics;
-    boost::scoped_ptr<Input> input;
+    std::auto_ptr<Graphics> graphics;
+    std::auto_ptr<Input> input;
 
     ::Display* display;
     
@@ -94,6 +99,10 @@ struct Gosu::Window::Impl
     ::GLXContext context;
     ::Window window;
     ::XVisualInfo* visual;
+
+    // We use the XDamage extension to detect when we need to redraw ourselves
+    Damage damage;
+    int damageEvent, damageError;
     
     // Last set title
     std::wstring title;
@@ -113,7 +122,7 @@ struct Gosu::Window::Impl
         
     }
     
-    void executeAndWait(boost::function<void(Display*, ::Window)> function, int forMessage)
+    void executeAndWait(std::tr1::function<void(Display*, ::Window)> function, int forMessage)
     {
         XSelectInput(display, window, StructureNotifyMask);
         function(display, window);
@@ -133,7 +142,7 @@ struct Gosu::Window::Impl
         {
             XEvent event;
             XNextEvent(display, &event);
-            
+
             // Override redirect fix (thanks go to the Pyglet folks again):
             if (event.type == ButtonPress && fullscreen && !active)
                 XSetInputFocus(display, this->window, RevertToParent, CurrentTime);
@@ -156,6 +165,22 @@ struct Gosu::Window::Impl
                 else if (event.type == FocusOut)
                     active = false;
             }
+
+            // Force redraw on window damage; don't check needsRedraw()
+            if (event.type == damageEvent + XDamageNotify)
+            {
+                XDamageNotifyEvent* dev = (XDamageNotifyEvent*)&event;
+                XDamageSubtract(display, dev->damage, None, None);
+                // If there are more events queued up right after this one, we
+                // don't need to redraw just yet
+                if (dev->more == false &&
+                        window->graphics().begin(Colors::black))
+                {
+                    window->draw();
+                    window->graphics().end();
+                    glXSwapBuffers(display, this->window);
+                }
+            }
         }
         
         if (showingCursor && !window->needsCursor())
@@ -169,6 +194,7 @@ struct Gosu::Window::Impl
             showingCursor = true;
         }
         
+        Song::update();
         window->input().update();
         window->update();
 
@@ -180,6 +206,18 @@ struct Gosu::Window::Impl
             glXSwapBuffers(display, this->window);
         }
     }
+
+    // The ICCCM standard requires that compositing window managers acquire
+    // ownership of a selection named _NET_WM_CM_Sn, where n is the screen
+    // number
+    bool isComposited()
+    {
+        std::ostringstream atomName;
+        atomName << "_NET_WM_CM_S" << XDefaultScreen(display);
+        const std::string& tmp = atomName.str();
+        Atom selection = XInternAtom(display, tmp.c_str(), False);
+        return XGetSelectionOwner(display, selection) != None;
+    }
 };
 
 Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen,
@@ -267,8 +305,8 @@ Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen,
     // Now set up major Gosu components
     pimpl->graphics.reset(new Graphics(pimpl->width, pimpl->height, fullscreen));
     pimpl->input.reset(new Input(pimpl->display, pimpl->window));    
-    input().onButtonDown = boost::bind(&Window::buttonDown, this, _1);
-    input().onButtonUp = boost::bind(&Window::buttonUp, this, _1);
+    input().onButtonDown = std::tr1::bind(&Window::buttonDown, this, _1);
+    input().onButtonUp = std::tr1::bind(&Window::buttonUp, this, _1);
     
     // Fix coordinates for fullscreen screen-scaling
     if (fullscreen)
@@ -277,10 +315,21 @@ Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen,
         input().setMouseFactors(1.0 * width / pimpl->width,
                   1.0 * height / pimpl->height);
     }
+
+    // Composited windows, by nature, don't need to monitor XDamage
+    if (!pimpl->isComposited())
+    {
+        // Register our intent to monitor this window for damage
+        XDamageQueryExtension(pimpl->display, &pimpl->damageEvent, &pimpl->damageError);
+        pimpl->damage = XDamageCreate(pimpl->display, pimpl->window,
+                XDamageReportNonEmpty);
+    }
 }
 
 Gosu::Window::~Window()
-{    
+{
+    if (!pimpl->isComposited())
+        XDamageDestroy(pimpl->display, pimpl->damage);
     XFreeCursor(pimpl->display, pimpl->emptyCursor);
     XDestroyWindow(pimpl->display, pimpl->window);
     XSync(pimpl->display, false);
@@ -403,13 +452,13 @@ Gosu::Window::SharedContext Gosu::Window::createSharedContext() {
     if (!dpy2)
         throw std::runtime_error("Could not duplicate X display");
     
-	GLXContext ctx = glXCreateContext(dpy2, pimpl->visual, pimpl->context, True);
-	if (!ctx)
+    GLXContext ctx = glXCreateContext(dpy2, pimpl->visual, pimpl->context, True);
+    if (!ctx)
         throw std::runtime_error("Could not create shared GLX context");
     
     return SharedContext(
-        new boost::function<void()>(boost::bind(makeCurrentContext, dpy2, pimpl->window, ctx)),
-        boost::bind(releaseContext, dpy2, ctx));
+        new std::tr1::function<void()>(std::tr1::bind(makeCurrentContext, dpy2, pimpl->window, ctx)),
+            std::tr1::bind(releaseContext, dpy2, ctx));
 }
 
 // Deprecated.