gosu 0.7.10.1

data/GosuImpl/WindowWin.cpp

@@ -0,0 +1,447 @@
+#include <Gosu/Window.hpp>
+#include <Gosu/WinUtility.hpp>
+#include <Gosu/Timing.hpp>
+#include <Gosu/Graphics.hpp>
+#include <Gosu/Audio.hpp>
+#include <Gosu/Input.hpp>
+#include <Gosu/TextInput.hpp>
+#include <GosuImpl/Graphics/Common.hpp>
+#include <boost/bind.hpp>
+#include <cassert>
+#include <stdexcept>
+#include <vector>
+
+// TODO: Put fullscreen logic in different file, track fullscreen state and
+// enable dynamic toggling between fullscreen and window.
+
+namespace Gosu
+{
+    namespace
+    {
+        // Mode guessing experimentally adapted from GLFW library.
+        // http://glfw.sourceforge.net/
+
+        int findClosestVideoMode(int *w, int *h, int *bpp, int *refresh)
+        {
+            int     mode, bestmode, match, bestmatch, rr, bestrr, success;
+            DEVMODE dm;
+
+            // Find best match
+            bestmatch = 0x7fffffff;
+            bestrr    = 0x7fffffff;
+            mode = bestmode = 0;
+            do
+            {
+                dm.dmSize = sizeof(DEVMODE);
+                success = EnumDisplaySettings(NULL, mode, &dm);
+                if( success )
+                {
+                    match = dm.dmBitsPerPel - *bpp;
+                    if( match < 0 ) match = -match;
+                    match = (match << 25) |
+                            ((dm.dmPelsWidth - *w) * (dm.dmPelsWidth - *w) +
+                             (dm.dmPelsHeight - *h) * (dm.dmPelsHeight - *h));
+                    if( match < bestmatch )
+                    {
+                        bestmatch = match;
+                        bestmode  = mode;
+                        bestrr = (dm.dmDisplayFrequency - *refresh) *
+                                 (dm.dmDisplayFrequency - *refresh);
+                    }
+                    else if( match == bestmatch && *refresh > 0 )
+                    {
+                        rr = (dm.dmDisplayFrequency - *refresh) *
+                             (dm.dmDisplayFrequency - *refresh);
+                        if( rr < bestrr )
+                        {
+                            bestmatch = match;
+                            bestmode  = mode;
+                            bestrr    = rr;
+                        }
+                    }
+                }
+                ++mode;
+            }
+            while (success);
+
+            // Get the parameters for the best matching display mode
+            dm.dmSize = sizeof(DEVMODE);
+            EnumDisplaySettings( NULL, bestmode, &dm );
+
+            *w = dm.dmPelsWidth;
+            *h = dm.dmPelsHeight;
+            *bpp = dm.dmBitsPerPel;
+            *refresh = dm.dmDisplayFrequency;
+
+            return bestmode;
+        }
+
+        void setVideoMode(int mode)
+        {
+            // Get the parameters for the best matching display mode
+            DEVMODE dm;
+            dm.dmSize = sizeof(DEVMODE);
+            EnumDisplaySettings(NULL, mode, &dm);
+
+            // Set which fields we want to specify
+            dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
+
+            // Change display setting
+            dm.dmSize = sizeof(DEVMODE);
+            if (ChangeDisplaySettings(&dm, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
+                throw std::runtime_error("Could not set fullscreen mode");
+        }
+
+        void setupVSync()
+        {
+            char* extensions = (char*)glGetString(GL_EXTENSIONS);
+            if (!strstr(extensions, "WGL_EXT_swap_control"))
+                return;
+            typedef void (APIENTRY *PFNWGLEXTSWAPCONTROLPROC) (int);
+            PFNWGLEXTSWAPCONTROLPROC wglSwapIntervalEXT =
+                (PFNWGLEXTSWAPCONTROLPROC) wglGetProcAddress("wglSwapIntervalEXT");
+            if (!wglSwapIntervalEXT)
+                return;
+            wglSwapIntervalEXT(1);
+        }
+
+        LRESULT CALLBACK windowProc(HWND wnd, UINT message, WPARAM wparam,
+            LPARAM lparam)
+        {
+            LONG_PTR lptr = GetWindowLongPtr(wnd, GWLP_USERDATA);
+
+            if (lptr)
+            {
+                Window* obj = reinterpret_cast<Window*>(lptr);
+                return obj->handleMessage(message, wparam, lparam);
+            }
+            else
+                return DefWindowProc(wnd, message, wparam, lparam);
+        }
+
+        LPCTSTR windowClass()
+        {
+            static LPCTSTR name = 0;
+            if (name)
+                return name;
+            
+            WNDCLASS wc;
+            wc.lpszClassName = L"Gosu::Window";
+            wc.style = CS_OWNDC;
+            wc.lpfnWndProc = windowProc;
+            wc.cbClsExtra = 0;
+            wc.cbWndExtra = 0;
+            wc.hInstance = Win::instance();
+            wc.hIcon = 0;
+            wc.hCursor = 0;
+            wc.hbrBackground = 0;
+            wc.lpszMenuName = 0;
+            
+            name = reinterpret_cast<LPCTSTR>(::RegisterClass(&wc));
+            Win::check(name, "registering a window class");
+            return name;
+        }
+    }
+}
+
+struct Gosu::Window::Impl
+{
+    HWND handle;
+	HDC hdc;
+    boost::scoped_ptr<Graphics> graphics;
+    boost::scoped_ptr<Audio> audio;
+    boost::scoped_ptr<Input> input;
+	double updateInterval;
+    bool iconified;
+
+    Impl()
+    : handle(0), hdc(0), iconified(false)
+    {
+    }
+
+    ~Impl()
+    {
+        if (hdc)
+            ReleaseDC(handle, hdc);
+        if (handle)
+            DestroyWindow(handle);
+    }
+};
+
+Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen,
+    double updateInterval)
+: pimpl(new Impl)
+{
+    // Select window styles depending on mode.fullscreen.
+    DWORD style = WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
+    DWORD styleEx = WS_EX_APPWINDOW;
+    if (fullscreen)
+    {
+        style |= WS_POPUP;
+        styleEx |= WS_EX_TOPMOST;
+    }
+    else
+    {
+        style |= WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
+        styleEx |= WS_EX_WINDOWEDGE;
+    }
+
+    pimpl->handle = CreateWindowEx(styleEx, windowClass(), 0, style,
+        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 0, 0,
+        Win::instance(), 0);
+    Win::check(pimpl->handle);
+
+	pimpl->hdc = GetDC(handle());
+    Win::check(pimpl->hdc);
+
+	PIXELFORMATDESCRIPTOR pfd;
+	ZeroMemory(&pfd, sizeof pfd);
+    pfd.nSize        = sizeof pfd;
+    pfd.nVersion     = 1;
+    pfd.dwFlags      = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
+    pfd.iLayerType   = PFD_MAIN_PLANE;
+    pfd.iPixelType   = PFD_TYPE_RGBA;
+    pfd.cColorBits   = 32;
+	int pf = ChoosePixelFormat(pimpl->hdc, &pfd);
+    Win::check(pf);
+    Win::check(SetPixelFormat(pimpl->hdc, pf, &pfd));
+
+	HGLRC hrc = Win::check(wglCreateContext(pimpl->hdc), "creating rendering context");
+    Win::check(wglMakeCurrent(pimpl->hdc, hrc), "selecting the rendering context");
+
+    setupVSync();
+
+    SetLastError(0);
+    SetWindowLongPtr(handle(), GWLP_USERDATA,
+        reinterpret_cast<LONG_PTR>(this));
+    if (GetLastError() != 0)
+        Win::throwLastError("setting the window's GWLP_USERDATA pointer");
+
+    // Determine the size the window needs to have.
+    RECT rc = { 0, 0, width, height };
+    AdjustWindowRectEx(&rc, style, FALSE, styleEx);
+    unsigned windowW = rc.right - rc.left;
+    unsigned windowH = rc.bottom - rc.top;
+
+    int windowX = 0;
+    int windowY = 0;
+
+    if (!fullscreen)
+    {
+        // Center the window.
+        HWND desktopWindow = GetDesktopWindow();
+        RECT desktopRect;
+        GetClientRect(desktopWindow, &desktopRect);
+        int desktopW = desktopRect.right - desktopRect.left;
+        int desktopH = desktopRect.bottom - desktopRect.top;
+        windowX = (desktopW - windowW) / 2;
+        windowY = (desktopH - windowH) / 2;
+    }
+
+    MoveWindow(handle(), windowX, windowY, windowW, windowH, false);
+
+    pimpl->graphics.reset(new Gosu::Graphics(width, height, fullscreen));
+    pimpl->input.reset(new Gosu::Input(handle()));
+    input().onButtonDown = boost::bind(&Window::buttonDown, this, _1);
+    input().onButtonUp = boost::bind(&Window::buttonUp, this, _1);
+
+    pimpl->updateInterval = updateInterval;
+}
+
+Gosu::Window::~Window()
+{
+    wglMakeCurrent(0, 0);
+}
+
+std::wstring Gosu::Window::caption() const
+{
+    int bufLen = GetWindowTextLength(handle()) + 1;
+
+    if (bufLen < 2)
+        return L"";
+
+    std::vector<TCHAR> buf(bufLen);
+    GetWindowText(handle(), &buf.front(), bufLen);
+    return &buf.front();
+}
+
+void Gosu::Window::setCaption(const std::wstring& value)
+{
+    SetWindowText(handle(), value.c_str());
+}
+
+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::show()
+{
+    int w = graphics().width(), h = graphics().height(), bpp = 32, rr = 60;
+    if (pimpl->graphics->fullscreen())
+        setVideoMode(findClosestVideoMode(&w, &h, &bpp, &rr));
+    ShowWindow(handle(), SW_SHOW);
+    try
+    {
+        Win::processMessages();
+
+		unsigned lastTick = 0;
+		bool lastFrameSkipped = false;
+
+		for (;;) 
+	    {
+			Win::processMessages();
+
+            if (GosusDarkSide::oncePerTick) GosusDarkSide::oncePerTick();
+
+			if (!::IsWindowVisible(handle()))
+				return;
+
+			unsigned ms = milliseconds();
+
+			if (ms < lastTick || ms - lastTick >= pimpl->updateInterval)
+			{
+				lastTick = ms;
+				input().update();
+			    update();
+				::InvalidateRect(handle(), 0, FALSE);
+                lastFrameSkipped = false;
+			}
+		}
+    }
+    catch (...)
+    {
+        close();
+        throw;
+    }
+}
+
+void Gosu::Window::close()
+{
+    ShowWindow(handle(), SW_HIDE);
+    if (graphics().fullscreen())
+        ChangeDisplaySettings(NULL, CDS_FULLSCREEN);
+}
+
+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(handle()));
+    return *pimpl->audio;
+}
+
+Gosu::Audio& Gosu::Window::audio()
+{
+    if (!pimpl->audio)
+        pimpl->audio.reset(new Gosu::Audio(handle()));
+    return *pimpl->audio;
+}
+
+const Gosu::Input& Gosu::Window::input() const
+{
+    return *pimpl->input;
+}
+
+Gosu::Input& Gosu::Window::input()
+{
+    return *pimpl->input;
+}
+
+HWND Gosu::Window::handle() const
+{
+    return pimpl->handle;
+}
+
+LRESULT Gosu::Window::handleMessage(UINT message, WPARAM wparam, LPARAM lparam)
+{
+    if (message == WM_SETFOCUS && graphics().fullscreen() && IsWindowVisible(pimpl->handle))
+    {
+        if (pimpl->iconified)
+        {
+            OpenIcon(pimpl->handle);
+            int w = graphics().width(), h = graphics().height(), bpp = 32, rr = 60;
+            setVideoMode(findClosestVideoMode(&w, &h, &bpp, &rr));
+            pimpl->iconified = false;
+        }
+        return 0;
+    }
+
+    if (message == WM_KILLFOCUS && graphics().fullscreen() && IsWindowVisible(pimpl->handle))
+    {
+        if (!pimpl->iconified)
+        {
+            ChangeDisplaySettings(NULL, CDS_FULLSCREEN);
+            CloseWindow(pimpl->handle);
+            pimpl->iconified = true;
+        }
+        return 0;
+    }
+
+    if (message == WM_CLOSE)
+    {
+        close();
+        return 0;
+    }
+
+    if (message == WM_PAINT)
+    {
+        if (pimpl->graphics && graphics().begin())
+        {
+            try
+            {
+                draw();
+            }
+            catch (...)
+            {
+                graphics().end();
+                throw;
+            }
+            graphics().end();
+        }
+        SwapBuffers(pimpl->hdc);
+        ValidateRect(handle(), 0);
+        return 0;
+    }
+
+    if (message == WM_SETCURSOR && LOWORD(lparam) == HTCLIENT)
+    {
+        SetCursor(0);
+        return TRUE;
+    }
+
+    if (message == WM_SYSCOMMAND)
+    {
+        switch(wparam)
+        {
+            case SC_SCREENSAVE:
+            case SC_MONITORPOWER:
+                if (graphics().fullscreen())
+                    return 0;
+                else
+                    break;
+            case SC_KEYMENU:
+                return 0;
+        }
+    }
+
+    if (pimpl->input && input().textInput() && input().textInput()->feedMessage(message, wparam, lparam))
+    {
+        return 0;
+    }
+
+    return DefWindowProc(handle(), message, wparam, lparam);
+}

data/GosuImpl/WindowX.cpp

@@ -0,0 +1,392 @@
+// While (re)writing this file, I have been looking at many other libraries since all the
+// "official" documentation was horrible, at least those parts that I was able to find.
+// Kudos to the Pyglet folks (http://www.pyglet.org/) who wrote code that was much easier to
+// understand than that!
+
+#include <Gosu/Window.hpp>
+#include <Gosu/Timing.hpp>
+#include <Gosu/Utility.hpp>
+#include <Gosu/Input.hpp>
+#include <Gosu/Graphics.hpp>
+#include <Gosu/Audio.hpp>
+#include <boost/bind.hpp>
+#include <stdexcept>
+#include <algorithm>
+#include <vector>
+
+#include <GL/glx.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include "X11vroot.h"
+
+namespace
+{
+    template<typename T>
+    class scoped_resource
+    {
+        T* pointer;
+        typedef boost::function<void(T*)> Deleter;
+        Deleter deleter;
+        
+    public:
+        scoped_resource(T* pointer, const Deleter& deleter)
+        : pointer(pointer), deleter(deleter)
+        {
+        }
+        
+        void reset(T* newPointer = 0)
+        {
+            if (pointer)
+                deleter(pointer);
+            pointer = newPointer;
+        }
+        
+        T* get() const
+        {
+            return pointer;
+        }
+        
+        T* operator->() const
+        {
+            return get();
+        }
+        
+        ~scoped_resource()
+        {
+            reset(0);
+        }
+    };
+}
+
+struct Gosu::Window::Impl
+{
+    boost::scoped_ptr<Graphics> graphics;
+    boost::scoped_ptr<Input> input;
+    boost::scoped_ptr<Audio> audio;
+
+    ::Display* display;
+    
+    bool mapped, showing, active;
+    
+    ::GLXContext context;
+    ::Window window;
+    ::XVisualInfo* visual;
+    
+    // Last set title
+    std::wstring title;
+    // Last known position
+    int x, y;
+    // Last known size
+    int width, height;
+
+
+    double updateInterval;
+    bool fullscreen;
+
+    Impl(unsigned width, unsigned height, unsigned fullscreen, double updateInterval)
+    :   mapped(false), showing(false), active(true),
+        x(0), y(0), width(width), height(height),
+        updateInterval(updateInterval), fullscreen(fullscreen)
+    {
+        
+    }
+    
+    void executeAndWait(boost::function<void(Display*, ::Window)> function, int forMessage)
+    {
+        XSelectInput(display, window, StructureNotifyMask);
+        function(display, window);
+        while (true)
+        {
+            ::XEvent event;
+            XNextEvent(display, &event);
+            if (event.type == forMessage)
+                break;
+        }
+        XSelectInput(display, window, 0x1ffffff & ~PointerMotionHintMask & ~ResizeRedirectMask);
+    }
+
+    void doTick(Window* window)
+    {
+        while (::XPending(display))
+        {
+            ::XEvent event;
+            XNextEvent(display, &event);
+            
+            // Override redirect fix (thanks for Pyglet folks again):
+            if (event.type == ButtonPress && fullscreen && !active)
+                XSetInputFocus(display, this->window, RevertToParent, CurrentTime);
+            
+            if (!window->input().feedXEvent(event, window))
+            {
+                if (event.type == ConfigureNotify)
+                {
+                    // Only boring stuff to do? Let's do something random:
+                    glXMakeCurrent(display, this->window, context);
+                }
+                else if (event.type == ClientMessage)
+                {
+                    if (static_cast<unsigned>(event.xclient.data.l[0]) ==
+                            XInternAtom(display, "WM_DELETE_WINDOW", false))
+                        window->close();
+                }
+                else if (event.type == FocusIn)
+                    active = true;
+                else if (event.type == FocusOut)
+                    active = false;
+            }
+        }
+
+        if (window->graphics().begin(Colors::black))
+        {
+            window->draw();
+            window->graphics().end();
+            glXSwapBuffers(display, this->window);
+        }
+
+        window->input().update();
+        window->update();
+    }
+};
+
+Gosu::Window::Window(unsigned width, unsigned height, bool fullscreen,
+        double updateInterval)
+:   pimpl(new Impl(width, height, fullscreen, updateInterval))
+{
+    pimpl->display = XOpenDisplay(NULL);
+    if (!pimpl->display)
+        throw std::runtime_error("Cannot find display");
+    
+    ::Window root = DefaultRootWindow(pimpl->display);
+
+    // Setup GLX visual
+    static int glxAttributes[] =
+    {
+        GLX_RGBA,
+        GLX_DOUBLEBUFFER,
+        GLX_RED_SIZE, 1,
+        GLX_GREEN_SIZE, 1,
+        GLX_BLUE_SIZE, 1,
+        GLX_DEPTH_SIZE, 1,
+        None
+    };
+    pimpl->visual = glXChooseVisual(pimpl->display, DefaultScreen(pimpl->display), glxAttributes);
+
+    // Create GLX context    
+    pimpl->context = glXCreateContext(pimpl->display, pimpl->visual, 0, GL_TRUE);
+
+    // Set up window attributes (& mask)
+    XSetWindowAttributes windowAttributes;
+    windowAttributes.colormap = XCreateColormap(pimpl->display, root, pimpl->visual->visual, AllocNone);
+    windowAttributes.bit_gravity = NorthWestGravity;
+    windowAttributes.background_pixel = 0;
+    unsigned mask = CWColormap | CWBitGravity | CWBackPixel;
+
+    // Create window
+    pimpl->window = XCreateWindow(pimpl->display, root, 0, 0, width, height, 0,
+        pimpl->visual->depth, InputOutput, pimpl->visual->visual,
+        mask, &windowAttributes);    
+
+    // Request a close button for the window
+    Atom atoms[] = { XInternAtom(pimpl->display, "WM_DELETE_WINDOW", false) };
+    XSetWMProtocols(pimpl->display, pimpl->window, atoms, 1);
+
+    Screen* screen = XScreenOfDisplay(pimpl->display,
+                        DefaultScreen(pimpl->display));
+
+    if (fullscreen)
+    {
+        pimpl->width = screen->width;
+        pimpl->height = screen->height;
+        XMoveResizeWindow(pimpl->display, pimpl->window, 0, 0,
+            screen->width, screen->height);
+            
+        XSetWindowAttributes windowAttributes;
+        windowAttributes.override_redirect = true;
+        unsigned mask = CWOverrideRedirect;
+        XChangeWindowAttributes(pimpl->display, pimpl->window, mask, &windowAttributes);
+    }
+    else
+        ; // Window already has requested size
+
+    // Set window to be non resizable
+    scoped_resource<XSizeHints> sizeHints(XAllocSizeHints(), XFree);
+    sizeHints->flags = PMinSize | PMaxSize;
+    sizeHints->min_width = sizeHints->max_width = pimpl->width;
+    sizeHints->min_height = sizeHints->max_height = pimpl->height;
+    XSetWMNormalHints(pimpl->display, pimpl->window, sizeHints.get());
+    sizeHints.reset();
+
+    // TODO: Window style (_MOTIF_WM_HINTS)?        
+
+    XColor black, dummy;
+    XAllocNamedColor(pimpl->display, screen->cmap, "black", &black, &dummy);    
+    char emptyData[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+    Pixmap emptyBitmap =
+        XCreateBitmapFromData(pimpl->display, pimpl->window, emptyData, 8, 8);
+    Cursor emptyCursor = XCreatePixmapCursor(pimpl->display, emptyBitmap,
+        emptyBitmap, &black, &black, 0, 0);
+    XDefineCursor(pimpl->display, pimpl->window, emptyCursor);
+    XFreeCursor(pimpl->display, emptyCursor);
+
+    // Must be current already so that Graphics' constructor can set up things
+    glXMakeCurrent(pimpl->display, pimpl->window, pimpl->context);
+
+    // Now set up major Gosu components
+    pimpl->graphics.reset(new Gosu::Graphics(pimpl->width, pimpl->height, fullscreen));
+    pimpl->input.reset(new Gosu::Input(pimpl->display));    
+    input().onButtonDown = boost::bind(&Window::buttonDown, this, _1);
+    input().onButtonUp = boost::bind(&Window::buttonUp, this, _1);
+    
+    // Fix coordinates for fullscreen screen-scaling
+    if (fullscreen)
+    {
+        graphics().setResolution(width, height);
+        input().setMouseFactors(1.0 * width / pimpl->width,
+                  1.0 * height / pimpl->height);
+    }
+}
+
+Gosu::Window::~Window()
+{    
+    XDestroyWindow(pimpl->display, pimpl->window);
+    XSync(pimpl->display, false);
+}
+
+std::wstring Gosu::Window::caption() const
+{
+    return pimpl->title;
+}
+
+void Gosu::Window::setCaption(const std::wstring& caption)
+{
+    // TODO: Update to _NET_WM_NAME
+
+    pimpl->title = caption;
+
+    // TODO: Why?!
+    //if (!pimpl->showing)
+    //    return;
+
+    std::string tmpString(pimpl->title.begin(), pimpl->title.end());
+    std::vector<char> title(pimpl->title.size() + 1);
+    std::copy(tmpString.begin(), tmpString.end(), title.begin());
+    title.back() = 0;
+
+    XTextProperty titleprop;
+    char* titlePtr = &title[0];
+    XStringListToTextProperty(&titlePtr, 1, &titleprop);
+
+    XSetWMName(pimpl->display, pimpl->window, &titleprop);
+    XFree(titleprop.value);
+    XSync(pimpl->display, false);
+}
+
+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;
+}
+
+// TODO: Some exception safety
+
+void Gosu::Window::show()
+{
+    // Map window
+    pimpl->executeAndWait(XMapRaised, MapNotify);
+    pimpl->mapped = true;
+    
+    // Make glx current
+    glXMakeCurrent(pimpl->display, pimpl->window, pimpl->context);
+    
+    if (pimpl->fullscreen)
+        XSetInputFocus(pimpl->display, pimpl->window, RevertToParent, CurrentTime);
+
+    setCaption(pimpl->title);
+
+    unsigned startTime, endTime;
+
+    pimpl->showing = true;
+    while (pimpl->showing)
+    {
+        startTime = milliseconds();
+        pimpl->doTick(this);
+        if (GosusDarkSide::oncePerTick) GosusDarkSide::oncePerTick();
+        endTime = milliseconds();
+
+        if (startTime < endTime && (endTime - startTime) < pimpl->updateInterval)
+            sleep(pimpl->updateInterval - (endTime - startTime));
+    }
+
+    glXMakeCurrent(pimpl->display, 0, 0);
+    pimpl->executeAndWait(XUnmapWindow, UnmapNotify);
+    pimpl->mapped = false;
+}
+
+void Gosu::Window::close()
+{
+    pimpl->showing = false;
+}
+
+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(Display* dpy, GLXDrawable drawable, GLXContext context) {
+        if (!glXMakeCurrent(dpy, drawable, context))
+            printf("glXMakeCurrent failed\n");
+    }
+
+    void releaseContext(Display* dpy, GLXContext context) {
+        glXDestroyContext(dpy, context);
+    }
+}
+
+Gosu::Window::SharedContext Gosu::Window::createSharedContext() {
+    const char* displayName = DisplayString( pimpl->display );
+    Display* dpy2 = XOpenDisplay( displayName );
+    if (!dpy2)
+        throw std::runtime_error("Could not duplicate X display");
+    
+	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));
+}