gosu 0.7.10.1

data/GosuImpl/TimingWin.cpp

@@ -0,0 +1,28 @@
+#include <Gosu/Timing.hpp>
+#include <windows.h>
+#include <cstdlib>
+
+void Gosu::sleep(unsigned milliseconds)
+{
+    ::Sleep(milliseconds);
+}
+
+namespace
+{
+    void resetTGT()
+    {
+        ::timeEndPeriod(1);
+    }
+}
+
+unsigned long Gosu::milliseconds()
+{
+    static bool init = false;
+    if (!init)
+    {
+        if (::timeBeginPeriod(1) != TIMERR_NOERROR)
+            std::atexit(resetTGT);
+        init = true;
+    }
+    return ::timeGetTime();
+}

data/GosuImpl/Utility.cpp

@@ -0,0 +1,140 @@
+#include <Gosu/Utility.hpp>
+#include <Gosu/Platform.hpp>
+#include <cstddef>
+#include <cstdlib>
+#include <stdexcept>
+#include <algorithm>
+#include <vector>
+using namespace std;
+
+#ifdef __APPLE__
+// We want Apple's iconv
+#include </usr/include/iconv.h>
+#include <errno.h>
+namespace
+{
+    extern const char UTF_8[] = "UTF-8";
+    extern const char UCS_2_INTERNAL[] = "UCS-2-INTERNAL";
+    extern const char UCS_4_INTERNAL[] = "UCS-4-INTERNAL";
+    extern const char CHAR[] = "char";
+    extern const char MACROMAN[] = "MacRoman";
+
+    template<typename Out, const char* to, const char* from, typename In>
+    Out iconvert(const In& in)
+    {
+        if (in.empty())
+            return Out();
+    
+        const size_t bufferLen = 128;
+        typedef typename In::value_type InElem;
+        typedef typename Out::value_type OutElem;
+
+        static iconv_t cd = iconv_open(to, from);
+        
+        Out result;
+        OutElem buffer[bufferLen];
+        
+        char* inbuf = const_cast<char*>(reinterpret_cast<const char*>(&in[0]));
+        size_t inbytesleft = in.size() * sizeof(InElem);
+        char* outbuf = reinterpret_cast<char*>(buffer);
+        size_t outbytesleft = sizeof buffer;
+        
+        for (;;)
+        {
+            size_t ret = ::iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
+            if (ret == static_cast<size_t>(-1) && errno == EILSEQ)
+            {
+                // Skip illegal sequence part, repeat loop.
+                // TODO: Or retry w/ different encoding?
+                ++inbuf;
+                --inbytesleft;
+            }
+            else if (ret == static_cast<size_t>(-1) && errno == E2BIG)
+            {
+                // Append new characters, reset out buffer, then repeat loop.
+                result.insert(result.end(), buffer, buffer + bufferLen);
+                outbuf = reinterpret_cast<char*>(buffer);
+                outbytesleft = sizeof buffer;
+            }
+            else
+            {
+                // Append what's new in the buffer, then LEAVE loop.
+                result.insert(result.end(), buffer, buffer + bufferLen - outbytesleft / sizeof(OutElem));
+                return result;
+            }
+        }        
+    }
+}
+wstring Gosu::utf8ToWstring(const string& s)
+{
+    return iconvert<wstring, UCS_4_INTERNAL, UTF_8>(s);
+}
+string Gosu::wstringToUTF8(const std::wstring& ws)
+{
+    return iconvert<string, UTF_8, UCS_4_INTERNAL>(ws);
+}
+// This is only necessary on OS X (for text output)
+namespace Gosu {
+wstring macRomanToWstring(const string& s)
+{
+    return iconvert<wstring, UCS_4_INTERNAL, MACROMAN>(s);
+}
+vector<unsigned short> wstringToUniChars(const wstring& ws)
+{
+    return iconvert<vector<unsigned short>, UCS_2_INTERNAL, UCS_4_INTERNAL>(ws);
+}
+}
+#elif defined(GOSU_IS_WIN)
+#include <windows.h>
+wstring Gosu::utf8ToWstring(const string& utf8)
+{
+	vector<wchar_t> buffer(utf8.size() + 1);
+	MultiByteToWideChar(CP_UTF8, 0, utf8.c_str(), utf8.size() + 1, &buffer[0], buffer.size());
+	return &buffer[0];
+}	
+string Gosu::wstringToUTF8(const wstring& ws)
+{
+	unsigned size = WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), ws.size(), 0, 0, 0, 0);
+	vector<char> buffer(size + 1);
+	WideCharToMultiByte(CP_UTF8, 0, ws.c_str(), ws.size(), &buffer[0], buffer.size(), 0, 0);
+	return &buffer[0];
+}
+#else
+// On Linux, everything ought to be UTF8 anyway -- forward to locale widening/narrowing
+std::wstring Gosu::utf8ToWstring(const std::string& utf8)
+{
+    return widen(utf8);
+}
+std::string Gosu::wstringToUTF8(const std::wstring& ws)
+{
+    return narrow(ws);
+}
+#endif
+
+wstring Gosu::widen(const string& s)
+{
+#ifdef GOSU_IS_X
+    setlocale(LC_ALL, "");
+#endif
+
+    size_t wideLen = std::mbstowcs(0, s.c_str(), 0);
+    if (wideLen == static_cast<size_t>(-1))
+        throw std::runtime_error("Could not convert from string to wstring: " + s);
+
+    vector<wchar_t> buf(wideLen + 1);
+    mbstowcs(&buf.front(), s.c_str(), buf.size());
+
+    return wstring(buf.begin(), buf.end() - 1);
+}
+
+string Gosu::narrow(const wstring& ws)
+{
+    size_t narrowLen = std::wcstombs(0, ws.c_str(), 0);
+    if (narrowLen == static_cast<size_t>(-1))
+        throw std::runtime_error("Could not convert from wstring to string: " + string(ws.begin(), ws.end()));
+
+    vector<char> buf(narrowLen + 1);
+    wcstombs(&buf.front(), ws.c_str(), buf.size());
+
+    return string(buf.begin(), buf.end() - 1);
+}

data/GosuImpl/WinMain.cpp

@@ -0,0 +1,69 @@
+#include <boost/lexical_cast.hpp>
+#include <windows.h>
+#include <exception>
+#include <string>
+#include <vector>
+using namespace std;
+
+// IMPR: Check for security issues. I hacked this together.
+vector<string> splitCmdLine()
+{
+    vector<string> result;
+
+    const char* cmdLine = ::GetCommandLineA();
+
+    const char* argBegin = 0;
+    bool isQuotedArg = false;
+
+    while (*cmdLine)
+    {
+        if (*cmdLine == '"')
+        {
+            if (argBegin == 0)
+            {
+                argBegin = cmdLine + 1;
+                isQuotedArg = true;
+            }
+            else if (isQuotedArg)
+            {
+                result.push_back(std::string(argBegin, cmdLine));
+                argBegin = 0;
+            }
+        }
+        else if (!isspace(*cmdLine) && argBegin == 0)
+        {
+            argBegin = cmdLine;
+            isQuotedArg = false;
+        }
+        else if (isspace(*cmdLine) && argBegin != 0 && !isQuotedArg)
+        {
+            result.push_back(std::string(argBegin, cmdLine + 1));
+            argBegin = 0;
+        }
+        ++cmdLine;
+    }
+
+    if (argBegin != 0)
+        result.push_back(argBegin);
+
+    return result;
+}
+
+int main(int argc, char* argv[]);
+
+int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
+{
+    try
+    {
+        vector<string> arguments = splitCmdLine();
+        vector<char*> argv(arguments.size());
+        for (unsigned i = 0; i < argv.size(); ++i)
+            argv[i] = const_cast<char*>(arguments[i].c_str());
+	    return main(argv.size(), &argv[0]);
+    }
+    catch (const std::exception& e)
+    {
+        ::MessageBoxA(0, e.what(), "Uncaught Exception", MB_OK | MB_ICONERROR);
+        return EXIT_FAILURE;
+    }
+}

data/GosuImpl/WinUtility.cpp

@@ -0,0 +1,137 @@
+#include <Gosu/WinUtility.hpp>
+#include <Gosu/Utility.hpp>
+#include <stdexcept>
+#include <vector>
+
+namespace
+{
+    typedef std::vector<boost::function<bool (MSG&)> > Hooks;
+    Hooks hooks;
+
+    bool handledByHook(MSG& message)
+    {
+        for (Hooks::iterator i = hooks.begin(); i != hooks.end(); ++i)
+            if ((*i)(message))
+                return true;
+
+        return false;
+    }
+}
+
+HINSTANCE Gosu::Win::instance()
+{
+    return check(::GetModuleHandle(0), "getting the module handle");
+}
+
+void Gosu::Win::handleMessage()
+{
+    MSG message;
+    BOOL ret = ::GetMessage(&message, 0, 0, 0);
+
+    switch (ret)
+    {
+        case -1:
+        {
+            // GetMessage() failed.
+            throwLastError("trying to get the next message");
+        }
+
+        case 0:
+        {
+            // GetMessage() found a WM_QUIT message.
+            // IMPR: Is there a better way to respond to this?
+            break;
+        }
+
+        default:
+        {
+            // Normal behaviour, if the message does not get handled by
+            // something else.
+            if (!handledByHook(message))
+            {
+                ::TranslateMessage(&message);
+                ::DispatchMessage(&message);
+            }
+        }
+    }
+}
+
+void Gosu::Win::processMessages()
+{
+    MSG message;
+
+    while (::PeekMessage(&message, 0, 0, 0, PM_REMOVE))
+        if (!handledByHook(message))
+        {
+            ::TranslateMessage(&message);
+            ::DispatchMessage(&message);
+        }
+}
+
+void Gosu::Win::registerMessageHook(const boost::function<bool (MSG&)>& hook)
+{
+    hooks.push_back(hook);
+}
+
+void Gosu::Win::throwLastError(const std::string& action)
+{
+    // Obtain error message from Windows.
+    char* buffer;
+    if (!::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+        FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
+        ::GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        reinterpret_cast<LPSTR>(&buffer), 0, 0))
+    {
+        // IMPR: Can we do better than this?
+        throw std::runtime_error("Unknown error");
+    }
+
+    // Move the message out of the ugly char* buffer.
+    std::string message;
+    try
+    {
+        message = buffer;
+    }
+    catch (...)
+    {
+        ::LocalFree(buffer);
+        throw;
+    }
+    ::LocalFree(buffer);
+    
+    // Optionally prepend the action.
+    if (!action.empty())
+        message = "While " + action + ", the following error occured: " +
+            message;
+
+    // Now throw it.
+    throw std::runtime_error(message);
+ }
+
+std::wstring Gosu::Win::appFilename()
+{
+    static std::wstring result;
+    if (!result.empty())
+        return result;
+
+    wchar_t buffer[MAX_PATH * 2];
+    check(::GetModuleFileName(0, buffer, MAX_PATH * 2),
+        "getting the module filename");
+    result = buffer;
+    return result;
+}
+
+std::wstring Gosu::Win::appDirectory()
+{
+    static std::wstring result;
+    if (!result.empty())
+        return result;
+
+    result = appFilename();
+    std::wstring::size_type lastDelim = result.find_last_of(L"\\/");
+    if (lastDelim != std::wstring::npos)
+        result.resize(lastDelim + 1);
+    else
+        result = L"";
+    return result;
+}

data/GosuImpl/WindowMac.mm

@@ -0,0 +1,466 @@
+#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 <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>
+
+// Workaround for Apple NSScreen bug :(
+@interface NSScreen (NSScreenAccess)
+- (void) setFrame:(NSRect)frame;
+@end
+
+@implementation NSScreen (NSScreenAccess)
+- (void) setFrame:(NSRect)frame;
+{
+    _frame = frame;
+}
+@end
+
+// Necessary to catch input events in fullscreen mode
+@interface GosuApplication : NSApplication
+{
+    Gosu::Input* input;
+}
+- (void)sendEvent:(NSEvent *)anEvent;
+- (void)setInput:(Gosu::Input&)ipt;
+@end
+@implementation GosuApplication
+- (void)sendEvent:(NSEvent *)anEvent
+{
+    switch ([anEvent type])
+    {
+        case NSLeftMouseDown:
+        case NSLeftMouseUp:
+        case NSRightMouseDown:
+        case NSRightMouseUp:
+        case NSScrollWheel:
+        case NSKeyUp:
+        case NSKeyDown:
+        case NSFlagsChanged:
+            input->feedNSEvent(anEvent);
+            break;
+        default:
+            [super sendEvent:anEvent];
+    }
+}
+- (void)setInput:(Gosu::Input&)ipt
+{
+    input = &ipt;
+}
+@end
+
+namespace 
+{
+    void cgCheck(CGDisplayErr err, const char* action)
+    {
+        if (err != CGDisplayNoErr)
+            throw std::runtime_error(std::string("Core Graphics error while ") + action);
+    }
+}
+
+typedef void (*WindowProc)(Gosu::Window&);
+
+@interface GosuForwarder : NSObject
+{
+    Gosu::Window* win;
+    WindowProc pr;
+}
+- (id)initWithWindow: (Gosu::Window*)window withProc:(WindowProc)proc;
+- (void)doTick: (NSTimer*)timer;
+- (BOOL)windowShouldClose: (id)sender;
+@end
+
+@implementation GosuForwarder
+- (id)initWithWindow: (Gosu::Window*)window withProc:(WindowProc)proc
+{
+    if (![super init])
+        return nil;
+    win = window;
+    pr = proc;
+    return self;
+}
+
+- (void)doTick: (NSTimer*)timer
+{
+    pr(*win);
+}
+
+- (BOOL)windowShouldClose: (id)sender
+{
+    [NSApp stop: nil];
+    return YES;
+}
+@end
+
+#define OVERRIDE_METHOD(method)       \
+    - (void) method: (NSEvent*) event \
+    {                                 \
+        _input->feedNSEvent(event);   \
+    }
+
+@interface GosuWindow : NSWindow
+{
+    Gosu::Input* _input;
+}
+@end
+@implementation GosuWindow
+- (void) setInput: (Gosu::Input*)input
+{
+    _input = input;
+}
+
+OVERRIDE_METHOD(keyDown);
+OVERRIDE_METHOD(keyUp);
+OVERRIDE_METHOD(flagsChanged);
+OVERRIDE_METHOD(mouseDown);
+OVERRIDE_METHOD(mouseUp);
+OVERRIDE_METHOD(rightMouseDown);
+OVERRIDE_METHOD(rightMouseUp);
+OVERRIDE_METHOD(scrollWheel);
+@end
+
+@interface GosuView : NSView
+{
+    Gosu::Input* _input;
+}
+@end
+@implementation GosuView
+- (void) setInput: (Gosu::Input*)input
+{
+    _input = input;
+    
+}
+- (BOOL)acceptsFirstResponder
+{
+    return YES;
+}
+OVERRIDE_METHOD(keyDown);
+OVERRIDE_METHOD(keyUp);
+OVERRIDE_METHOD(flagsChanged);
+OVERRIDE_METHOD(mouseDown);
+OVERRIDE_METHOD(mouseUp);
+OVERRIDE_METHOD(rightMouseDown);
+OVERRIDE_METHOD(rightMouseUp);
+OVERRIDE_METHOD(scrollWheel);
+@end
+
+#undef OVERRIDE_METHOD
+
+struct Gosu::Window::Impl
+{
+    ObjRef<NSAutoreleasePool> pool;
+    
+    // Windowed mode: NSWindow subclass and delegate that forwards events to it.
+    ObjRef<GosuWindow> window;
+    ObjRef<GosuForwarder> forwarder;
+    
+    // Fullscreen mode. Also remember old display mode.
+    CFDictionaryRef newMode, savedMode;
+	NSRect savedFrame;
+    
+    ObjRef<NSOpenGLContext> context;
+    boost::scoped_ptr<Graphics> graphics;
+    boost::scoped_ptr<Audio> audio;
+    boost::scoped_ptr<Input> input;
+    double interval;
+    bool mouseViz;
+    
+    void createWindow(unsigned width, unsigned height)
+    {
+        NSRect rect = NSMakeRect(0, 0, width, height);
+        unsigned style = NSTitledWindowMask | NSMiniaturizableWindowMask | NSClosableWindowMask;
+        window.reset([[GosuWindow alloc] initWithContentRect: rect styleMask:style 
+                                                            backing:NSBackingStoreBuffered defer:NO]);
+        [window.obj() retain]; // ...or is it autorelease?
+        
+        [window.obj() setContentView: [[GosuView alloc] init]];
+
+        [window.obj() center];
+        [window.obj() makeKeyAndOrderFront:nil];
+    }
+    
+    static void doTick(Window& window);
+};
+
+Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen,
+                     double updateInterval)
+: pimpl(new Impl)
+{
+    pimpl->pool.reset([[NSAutoreleasePool alloc] init]); // <- necessary...?
+    
+    // Create NSApp global variable
+    if (fullscreen)
+        [GosuApplication sharedApplication];
+    else
+        [NSApplication sharedApplication];
+    
+    // Settings, depending on fullscreen or not
+    NSOpenGLPixelFormatAttribute attrs[] =
+    {
+        NSOpenGLPFADoubleBuffer,
+        NSOpenGLPFAScreenMask,
+        (NSOpenGLPixelFormatAttribute)CGDisplayIDToOpenGLDisplayMask(CGMainDisplayID()),
+        NSOpenGLPFAFullScreen,
+        NSOpenGLPFADepthSize,
+        (NSOpenGLPixelFormatAttribute)16,
+        (NSOpenGLPixelFormatAttribute)0
+    };
+    // Create pixel format and OpenGL context
+    ObjRef<NSOpenGLPixelFormat> fmt([[NSOpenGLPixelFormat alloc] initWithAttributes:attrs]);
+    assert(fmt.get() != nil);
+    pimpl->context.reset([[NSOpenGLContext alloc] initWithFormat: fmt.obj() shareContext:nil]);
+    assert(pimpl->context.get() != nil);
+    
+    if (fullscreen) {
+        // Fullscreen: Create no window, instead change resolution.
+
+        // Save old mode and retrieve BPP
+        pimpl->savedMode = CGDisplayCurrentMode(kCGDirectMainDisplay);
+		pimpl->savedFrame = [[NSScreen mainScreen] frame];
+        int bpp;
+        CFNumberGetValue((CFNumberRef)CFDictionaryGetValue(pimpl->savedMode, kCGDisplayBitsPerPixel),
+                         kCFNumberIntType, &bpp);
+        pimpl->newMode =
+            CGDisplayBestModeForParameters(kCGDirectMainDisplay, bpp, width, height, 0);
+        CFNumberGetValue((CFNumberRef)CFDictionaryGetValue(pimpl->newMode, kCGDisplayWidth),
+                         kCFNumberIntType, &width);
+        CFNumberGetValue((CFNumberRef)CFDictionaryGetValue(pimpl->newMode, kCGDisplayHeight),
+                         kCFNumberIntType, &height);
+
+        // Actual changing postponed until show().
+    }
+    else
+    {
+        // Windowed: Create window large enough to display stuff
+        // TODO: Shrink resolution when screen too small
+        pimpl->createWindow(width, height);
+        
+        // Tell context to draw on this window.
+        [pimpl->context.obj() setView:[pimpl->window.obj() contentView]];
+    }
+    
+    CGLEnable((CGLContextObj)[pimpl->context.obj() CGLContextObj], kCGLCEMPEngine);
+    
+    [pimpl->context.obj() makeCurrentContext];
+    
+    pimpl->graphics.reset(new Gosu::Graphics(width, height, fullscreen));
+    
+    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);
+    if (fullscreen)
+        [NSApp setInput: input()];
+    
+    pimpl->forwarder.reset([[GosuForwarder alloc] initWithWindow: this withProc: &Impl::doTick]);
+    
+    if (!fullscreen)
+    {
+        [pimpl->window.obj() setDelegate: pimpl->forwarder.obj()];
+        [pimpl->window.obj() setInput: pimpl->input.get()];
+        [(GosuView*)[pimpl->window.obj() contentView] setInput: pimpl->input.get()];
+    }
+    
+    pimpl->interval = updateInterval;
+    pimpl->mouseViz = true;
+}
+
+Gosu::Window::~Window()
+{
+    if (graphics().fullscreen())
+    {
+        CGDisplaySwitchToMode(kCGDirectMainDisplay, pimpl->savedMode);
+		[[NSScreen mainScreen] setFrame:pimpl->savedFrame]; 
+        CGReleaseAllDisplays();
+    }
+}
+
+std::wstring Gosu::Window::caption() const
+{
+    if (!pimpl->window.get())
+        return L"";
+    
+    NSString* str = [pimpl->window.obj() title];
+    std::vector<unichar> unibuf([str length]);
+    [str getCharacters: &unibuf[0]];
+    return std::wstring(unibuf.begin(), unibuf.end());
+}
+
+void Gosu::Window::setCaption(const std::wstring& caption)
+{
+    if (!pimpl->window.get())
+        return;
+    
+    // This truncates the values... why on earth does a compiler use 32bit wchar_ts
+    // on an UTF16 based system?
+    std::vector<unichar> unibuf(caption.begin(), caption.end());
+    [pimpl->window.obj() setTitle:
+        [NSString stringWithCharacters: &unibuf[0] length: unibuf.size()]];
+}
+
+void Gosu::Window::show()
+{
+	// This is for Ruby/Gosu and misc. hackery:
+	// Usually, applications on the Mac can only get keyboard and mouse input if
+	// run by double-clicking an .app. So if this is run from the Terminal (i.e.
+	// during Ruby/Gosu game development), tell the OS we need input in any case.
+	ProcessSerialNumber psn = { 0, kCurrentProcess };
+	TransformProcessType(&psn, kProcessTransformToForegroundApplication);
+    SetFrontProcess(&psn);
+
+    [NSThread setThreadPriority: 1.0];
+ 
+    if (graphics().fullscreen())
+    {
+        [NSCursor hide];
+
+        // Set new mode
+        cgCheck(CGDisplayCapture(kCGDirectMainDisplay), "capturing display");
+        cgCheck(CGDisplaySwitchToMode(kCGDirectMainDisplay, pimpl->newMode), "switching mode");
+        
+        // Start drawing in fullscreen
+        [pimpl->context.obj() setFullScreen];
+    }
+
+    NSTimer* timer = [NSTimer scheduledTimerWithTimeInterval: pimpl->interval / 1000.0
+                            target:pimpl->forwarder.obj() selector:@selector(doTick:)
+                            userInfo:nil repeats:YES];
+    [NSApp run];
+    [timer invalidate];
+    
+    if (graphics().fullscreen())
+    {
+        [NSCursor unhide];
+
+        // Resetting the mod shouldn't be all too important according to the docs.
+        // Let's leave it in until time for testing comes, though.
+        CGDisplaySwitchToMode(kCGDirectMainDisplay, pimpl->savedMode);
+        CGDisplayRelease(kCGDirectMainDisplay);
+    }
+}
+
+void Gosu::Window::close()
+{
+    [NSApp stop:nil];
+}
+
+const Gosu::Graphics& Gosu::Window::graphics() const
+{
+    return *pimpl->graphics;
+}
+
+Gosu::Graphics& Gosu::Window::graphics()
+{
+    return *pimpl->graphics;
+}
+
+const Gosu::Audio& Gosu::Window::audio() const
+{
+    if (!pimpl->audio)
+        pimpl->audio.reset(new Gosu::Audio);
+    return *pimpl->audio;
+}
+ 
+Gosu::Audio& Gosu::Window::audio()
+{
+    if (!pimpl->audio)
+        pimpl->audio.reset(new Gosu::Audio);
+    return *pimpl->audio;
+}
+ 
+const Gosu::Input& Gosu::Window::input() const
+{
+    return *pimpl->input;
+}
+
+Gosu::Input& Gosu::Window::input()
+{
+    return *pimpl->input;
+}
+
+namespace
+{
+    void makeCurrentContext(NSOpenGLContext* context)
+    {
+        [context makeCurrentContext];
+    }
+    
+    void releaseContext(NSOpenGLContext* context)
+    {
+        [context release];
+    }
+}
+
+Gosu::Window::SharedContext Gosu::Window::createSharedContext()
+{
+    NSOpenGLPixelFormatAttribute attributes[] = {
+        NSOpenGLPFADoubleBuffer,
+        NSOpenGLPFAScreenMask,
+        (NSOpenGLPixelFormatAttribute)CGDisplayIDToOpenGLDisplayMask(CGMainDisplayID()),
+        NSOpenGLPFAFullScreen,
+        NSOpenGLPFANoRecovery,
+        (NSOpenGLPixelFormatAttribute)0
+    };
+    
+    NSOpenGLPixelFormat* pf =
+        [[[NSOpenGLPixelFormat alloc]
+            initWithAttributes:attributes] autorelease];
+
+    NSOpenGLContext* ctx = [[NSOpenGLContext alloc]
+            initWithFormat: pf
+            shareContext: pimpl->context.obj()];
+    
+    return SharedContext(new boost::function<void()>(boost::bind(makeCurrentContext, ctx)),
+        boost::bind(releaseContext, ctx));
+}
+
+namespace GosusDarkSide
+{
+    // TODO: Find a way for this to fit into Gosu's design.
+    // This can point to a function that wants to be called every
+    // frame, e.g. rb_thread_schedule.
+    typedef void (*HookOfHorror)();
+    HookOfHorror oncePerTick = 0;
+}
+
+void Gosu::Window::Impl::doTick(Window& window)
+{
+    GLint value = 1;
+    [window.pimpl->context.obj() setValues: &value forParameter: NSOpenGLCPSwapInterval];
+    
+    if (!window.graphics().fullscreen())
+    {
+        if (NSPointInRect([window.pimpl->window.obj() mouseLocationOutsideOfEventStream],
+                          [[window.pimpl->window.obj() contentView] frame]) &&
+            [NSApp isActive])
+        {
+            if (window.pimpl->mouseViz)
+                [NSCursor hide];
+            window.pimpl->mouseViz = false;
+        }
+        else
+        {
+            if (!window.pimpl->mouseViz)
+                [NSCursor unhide];
+            window.pimpl->mouseViz = true;
+        }
+    }
+    
+    window.input().update();
+    window.update();
+    if (window.graphics().begin())
+    {
+        window.draw();
+        window.graphics().end();
+        [window.pimpl->context.obj() flushBuffer];
+    }
+    
+    if (GosusDarkSide::oncePerTick) GosusDarkSide::oncePerTick();
+}