diff --git a/include/osgViewer/api/Win32/GraphicsWindowWin32 b/include/osgViewer/api/Win32/GraphicsWindowWin32
index d66d222d0..69c8d6e31 100644
--- a/include/osgViewer/api/Win32/GraphicsWindowWin32
+++ b/include/osgViewer/api/Win32/GraphicsWindowWin32
@@ -29,7 +29,7 @@
 namespace osgViewer
 {
 
-class GraphicsWindowWin32 : public osgViewer::GraphicsWindow
+class OSGVIEWER_EXPORT GraphicsWindowWin32 : public osgViewer::GraphicsWindow
 {
     public:
 
diff --git a/include/osgViewer/api/X11/GraphicsWindowX11 b/include/osgViewer/api/X11/GraphicsWindowX11
index 03f4bdf49..d344753c9 100644
--- a/include/osgViewer/api/X11/GraphicsWindowX11
+++ b/include/osgViewer/api/X11/GraphicsWindowX11
@@ -29,7 +29,7 @@
 namespace osgViewer
 {
 
-class GraphicsWindowX11 : public osgViewer::GraphicsWindow
+class OSGVIEWER_EXPORT GraphicsWindowX11 : public osgViewer::GraphicsWindow
 {
     public:
 
diff --git a/include/osgViewer/api/X11/PixelBufferX11 b/include/osgViewer/api/X11/PixelBufferX11
new file mode 100644
index 000000000..cfd75e5f9
--- /dev/null
+++ b/include/osgViewer/api/X11/PixelBufferX11
@@ -0,0 +1,130 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
+ *
+ * This library is open source and may be redistributed and/or modified under  
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
+ * OpenSceneGraph Public License for more details.
+*/
+
+/* Note, elements of PixelBufferX11 have used Prodcer/RenderSurface_X11.cpp as both
+ * a guide to use of X11/GLX and copiying directly in the case of setBorder().
+ * These elements are license under OSGPL as above, with Copyright (C) 2001-2004  Don Burns.
+ */
+
+#ifndef OSGVIEWER_PIXELBUFFERX11
+#define OSGVIEWER_PIXELBUFFERX11 1
+
+#include <osg/GraphicsContext>
+#include <osgViewer/Export>
+
+#define GLX_GLXEXT_PROTOTYPES  1
+
+#include <X11/X.h>
+#include <GL/glx.h>
+
+namespace osgViewer
+{
+
+class OSGVIEWER_EXPORT PixelBufferX11 : public osg::GraphicsContext
+{
+    public:
+
+        PixelBufferX11(osg::GraphicsContext::Traits* traits):
+            _valid(false),
+            _display(0),
+            _parent(0),
+            _window(0),
+            _visualInfo(0),
+            _glxContext(0),
+            _initialized(false),
+            _realized(false)
+        {
+            _traits = traits;
+
+            init();
+            
+            if (valid())
+            {
+                setState( new osg::State );
+                getState()->setGraphicsContext(this);
+
+                if (_traits.valid() && _traits->sharedContext)
+                {
+                    getState()->setContextID( _traits->sharedContext->getState()->getContextID() );
+                    incrementContextIDUsageCount( getState()->getContextID() );   
+                }
+                else
+                {
+                    getState()->setContextID( osg::GraphicsContext::createNewContextID() );
+                }
+
+            }
+        }
+    
+        virtual bool isSameKindAs(const Object* object) const { return dynamic_cast<const PixelBufferX11*>(object)!=0; }
+        virtual const char* libraryName() const { return "osgViewer"; }
+        virtual const char* className() const { return "PixelBufferX11"; }
+
+        virtual bool valid() const { return _valid; }
+
+        /** Realise the GraphicsContext.*/
+        virtual bool realizeImplementation();
+
+        /** Return true if the graphics context has been realised and is ready to use.*/
+        virtual bool isRealizedImplementation() const { return _realized; }
+
+        /** Close the graphics context.*/
+        virtual void closeImplementation();
+
+        /** Make this graphics context current.*/
+        virtual bool makeCurrentImplementation();
+
+        /** Make this graphics context current with specified read context implementation. */
+        virtual bool makeContextCurrentImplementation(osg::GraphicsContext* readContext);
+
+        /** Release the graphics context.*/
+        virtual bool releaseContextImplementation();
+
+        /** Bind the graphics context to associated texture implementation.*/
+        virtual void bindPBufferToTextureImplementation(GLenum buffer);
+
+        /** Swap the front and back buffers.*/
+        virtual void swapBuffersImplementation();
+
+    public:
+    
+        // X11 specific aces functions
+
+        Display* getDisplay() const { return _display; }
+        
+        Window& getParent() { return _parent; }
+        Window& getWindow() { return _window; }
+        GLXContext& getGLXContext() { return _glxContext; }
+
+    protected:
+    
+        ~PixelBufferX11();
+    
+        bool createVisualInfo();
+        
+        void init();
+
+        bool            _valid;
+        Display*        _display;
+        Window          _parent;
+        Window          _window;
+        XVisualInfo*    _visualInfo;
+        GLXContext      _glxContext;
+
+        bool            _initialized;
+        bool            _realized;
+};
+
+}
+
+#endif
diff --git a/src/osgViewer/CMakeLists.txt b/src/osgViewer/CMakeLists.txt
index 4b23661a1..3410c3f5c 100644
--- a/src/osgViewer/CMakeLists.txt
+++ b/src/osgViewer/CMakeLists.txt
@@ -46,8 +46,14 @@ ELSE(WIN32)
     ELSE(APPLE)
     
         # X11 for everybody else
-        SET(LIB_PUBLIC_HEADERS ${LIB_PUBLIC_HEADERS} ${HEADER_PATH}/api/X11/GraphicsWindowX11)
-        SET(LIB_COMMON_FILES ${LIB_COMMON_FILES} GraphicsWindowX11.cpp)
+        SET(LIB_PUBLIC_HEADERS ${LIB_PUBLIC_HEADERS}
+            ${HEADER_PATH}/api/X11/GraphicsWindowX11
+            ${HEADER_PATH}/api/X11/PixelBufferX11
+        )
+        SET(LIB_COMMON_FILES ${LIB_COMMON_FILES} 
+            GraphicsWindowX11.cpp 
+            PixelBufferX11.cpp
+        )
         
     ENDIF(APPLE)
 ENDIF(WIN32)
diff --git a/src/osgViewer/GraphicsWindowX11.cpp b/src/osgViewer/GraphicsWindowX11.cpp
index 91db38d5d..754dc81ab 100644
--- a/src/osgViewer/GraphicsWindowX11.cpp
+++ b/src/osgViewer/GraphicsWindowX11.cpp
@@ -17,6 +17,7 @@
  */
 
 #include <osgViewer/api/X11/GraphicsWindowX11>
+#include <osgViewer/api/X11/PixelBufferX11>
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
@@ -33,66 +34,6 @@
 
 using namespace osgViewer;
 
-namespace osgViewer
-{
-
-class GraphicsContextX11 : public osg::GraphicsContext
-{
-    public:
-
-        GraphicsContextX11(osg::GraphicsContext::Traits* traits):
-            _valid(false),
-            _display(0),
-            _parent(0),
-            _window(0)
-        {
-            _traits = traits;
-        }
-    
-        virtual bool valid() const { return _valid; }
-
-        /** Realise the GraphicsContext implementation, 
-          * Pure virtual - must be implemented by concrate implementations of GraphicsContext. */
-        virtual bool realizeImplementation() { osg::notify(osg::NOTICE)<<"GraphicsWindow::realizeImplementation() not implemented."<<std::endl; return false; }
-
-        /** Return true if the graphics context has been realised, and is ready to use, implementation.
-          * Pure virtual - must be implemented by concrate implementations of GraphicsContext. */
-        virtual bool isRealizedImplementation() const  { osg::notify(osg::NOTICE)<<"GraphicsWindow::isRealizedImplementation() not implemented."<<std::endl; return false; }
-
-        /** Close the graphics context implementation.
-          * Pure virtual - must be implemented by concrate implementations of GraphicsContext. */
-        virtual void closeImplementation()  { osg::notify(osg::NOTICE)<<"GraphicsWindow::closeImplementation() not implemented."<<std::endl; }
-
-        /** Make this graphics context current implementation.
-          * Pure virtual - must be implemented by concrate implementations of GraphicsContext. */
-        virtual bool makeCurrentImplementation()  { osg::notify(osg::NOTICE)<<"GraphicsWindow::makeCurrentImplementation() not implemented."<<std::endl; return false;}
-        
-        /** Make this graphics context current with specified read context implementation.
-          * Pure virtual - must be implemented by concrate implementations of GraphicsContext. */
-        virtual bool makeContextCurrentImplementation(GraphicsContext* /*readContext*/)  { osg::notify(osg::NOTICE)<<"GraphicsWindow::makeContextCurrentImplementation(..) not implemented."<<std::endl; return false; }
-
-        /** Release the graphics context.*/
-        virtual bool releaseContextImplementation() {  osg::notify(osg::NOTICE)<<"GraphicsWindow::releaseContextImplementation(..) not implemented."<<std::endl; return false; }
-
-        /** Pure virtual, Bind the graphics context to associated texture implementation.
-          * Pure virtual - must be implemented by concrate implementations of GraphicsContext. */
-        virtual void bindPBufferToTextureImplementation(GLenum /*buffer*/)  { osg::notify(osg::NOTICE)<<"GraphicsWindow::void bindPBufferToTextureImplementation(..) not implemented."<<std::endl; }
-
-        /** Swap the front and back buffers implementation.
-          * Pure virtual - must be implemented by Concrate implementations of GraphicsContext. */
-        virtual void swapBuffersImplementation()  { osg::notify(osg::NOTICE)<<"GraphicsWindow:: swapBuffersImplementation() not implemented."<<std::endl; }
-        
-    protected:
-        
-        bool        _valid;
-        Display*    _display;
-        Window      _parent;
-        Window      _window;
-
-};
-
-}
-
 class X11KeyboardMap
 {
     public:
@@ -559,16 +500,25 @@ void GraphicsWindowX11::init()
     }
     
     
-    GraphicsWindowX11* sharedContextX11 = dynamic_cast<GraphicsWindowX11*>(_traits->sharedContext);
-    if (sharedContextX11) 
+    GLXContext sharedContextGLX = NULL;
+
+    // get any shared GLX contexts    
+    GraphicsWindowX11* graphicsWindowX11 = dynamic_cast<GraphicsWindowX11*>(_traits->sharedContext);
+    if (graphicsWindowX11) 
     {
-        _glxContext = glXCreateContext( _display, _visualInfo, sharedContextX11->getGLXContext(), True );
+        sharedContextGLX = graphicsWindowX11->getGLXContext();
     }
     else
     {
-        _glxContext = glXCreateContext( _display, _visualInfo, NULL, True );
+        PixelBufferX11* pixelBufferX11 = dynamic_cast<PixelBufferX11*>(_traits->sharedContext);
+        if (pixelBufferX11)
+        {
+            sharedContextGLX = pixelBufferX11->getGLXContext();
+        }
     }
     
+    _glxContext = glXCreateContext( _display, _visualInfo, sharedContextGLX, True );
+    
     if (!_glxContext)
     {
         osg::notify(osg::NOTICE)<<"Error: Unable to create OpenGL graphics context."<<std::endl;
@@ -695,7 +645,7 @@ bool GraphicsWindowX11::makeCurrentImplementation()
         return false;
     }
 
-    // osg::notify(osg::NOTICE)<<"makeCurrentImplementation "<<this<<" "<<OpenThreads::Thread::CurrentThread()<<std::endl;
+    // osg::notify(osg::NOTICE)<<"GraphicsWindowX11::makeCurrentImplementation "<<this<<" "<<OpenThreads::Thread::CurrentThread()<<std::endl;
     // osg::notify(osg::NOTICE)<<"   glXMakeCurrent ("<<_display<<","<<_window<<","<<_glxContext<<std::endl;
 
     return glXMakeCurrent( _display, _window, _glxContext )==True;
@@ -709,8 +659,8 @@ bool GraphicsWindowX11::releaseContextImplementation()
         return false;
     }
 
-    // osg::notify(osg::NOTICE)<<"makeCurrentImplementation "<<this<<" "<<OpenThreads::Thread::CurrentThread()<<std::endl;
-    // osg::notify(osg::NOTICE)<<"   glXMakeCurrent ("<<_display<<","<<_window<<","<<_glxContext<<std::endl;
+    // osg::notify(osg::NOTICE)<<"GraphicsWindowX11::releaseContextImplementation() "<<this<<" "<<OpenThreads::Thread::CurrentThread()<<std::endl;
+    // osg::notify(osg::NOTICE)<<"   glXMakeCurrent ("<<_display<<std::endl;
 
     return glXMakeCurrent( _display, None, NULL )==True;
 }
@@ -1268,9 +1218,15 @@ struct X11WindowingSystemInterface : public osg::GraphicsContext::WindowingSyste
     {
         if (traits->pbuffer)
         {
-            osg::ref_ptr<osgViewer::GraphicsContextX11> pbuffer = new GraphicsContextX11(traits);
+#if 1
+            osg::ref_ptr<osgViewer::PixelBufferX11> pbuffer = new PixelBufferX11(traits);
             if (pbuffer->valid()) return pbuffer.release();
             else return 0;
+#else
+            osg::ref_ptr<osgViewer::GraphicsWindowX11> window = new GraphicsWindowX11(traits);
+            if (window->valid()) return window.release();
+            else return 0;
+#endif
         }
         else
         {
diff --git a/src/osgViewer/PixelBufferX11.cpp b/src/osgViewer/PixelBufferX11.cpp
new file mode 100644
index 000000000..15a0036f4
--- /dev/null
+++ b/src/osgViewer/PixelBufferX11.cpp
@@ -0,0 +1,331 @@
+/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
+ *
+ * This library is open source and may be redistributed and/or modified under  
+ * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
+ * (at your option) any later version.  The full license is in LICENSE file
+ * included with this distribution, and on the openscenegraph.org website.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
+ * OpenSceneGraph Public License for more details.
+*/
+
+/* Note, elements of PixelBufferX11 have used Prodcer/RenderSurface_X11.cpp as both
+ * a guide to use of X11/GLX and copiying directly in the case of setBorder().
+ * These elements are license under OSGPL as above, with Copyright (C) 2001-2004  Don Burns.
+ */
+
+#include <osgViewer/api/X11/PixelBufferX11>
+#include <osgViewer/api/X11/GraphicsWindowX11>
+
+#include <X11/Xlib.h>
+
+#include <unistd.h>
+
+using namespace osgViewer;
+
+PixelBufferX11::~PixelBufferX11()
+{
+    close(true);
+}
+
+bool PixelBufferX11::createVisualInfo()
+{
+    typedef std::vector<int> Attributes;
+    Attributes attributes;
+    
+    attributes.push_back(GLX_USE_GL);
+    
+    attributes.push_back(GLX_RGBA);
+    
+    if (_traits->doubleBuffer) attributes.push_back(GLX_DOUBLEBUFFER);
+    
+    attributes.push_back(GLX_RED_SIZE); attributes.push_back(_traits->red);
+    attributes.push_back(GLX_GREEN_SIZE); attributes.push_back(_traits->green);
+    attributes.push_back(GLX_BLUE_SIZE); attributes.push_back(_traits->blue);
+    attributes.push_back(GLX_DEPTH_SIZE); attributes.push_back(_traits->depth);
+    
+    if (_traits->alpha) { attributes.push_back(GLX_ALPHA_SIZE); attributes.push_back(_traits->alpha); }
+    
+    if (_traits->stencil) { attributes.push_back(GLX_STENCIL_SIZE); attributes.push_back(_traits->stencil); }
+
+#if defined(GLX_SAMPLE_BUFFERS) && defined (GLX_SAMPLES)
+
+    if (_traits->sampleBuffers) { attributes.push_back(GLX_SAMPLE_BUFFERS); attributes.push_back(_traits->sampleBuffers); }
+    if (_traits->sampleBuffers) { attributes.push_back(GLX_SAMPLES); attributes.push_back(_traits->samples); }
+
+#endif
+    // TODO
+    //  GLX_AUX_BUFFERS
+    //  GLX_ACCUM_RED_SIZE
+    //  GLX_ACCUM_GREEN_SIZE
+    
+    attributes.push_back(None);
+    
+    _visualInfo = glXChooseVisual( _display, _traits->screenNum, &(attributes.front()) );
+
+    return _visualInfo != 0;
+}
+
+void PixelBufferX11::init()
+{
+    if (_initialized) return;
+
+    if (!_traits)
+    {
+        _valid = false;
+        return;
+    }
+    
+    if (_traits->target != 0)
+    {
+        // we don't support Pbuffer render to texture under GLX.
+        _valid = false;
+        return;
+    }
+
+
+    _display = XOpenDisplay(_traits->displayName().c_str());
+    
+    unsigned int screen = _traits->screenNum;
+
+    if (!_display)
+    {
+        osg::notify(osg::NOTICE)<<"Error: Unable to open display \"" << XDisplayName(_traits->displayName().c_str()) << "\"."<<std::endl;
+        _valid = false;
+        return;
+    }
+
+     // Query for GLX extension
+    int errorBase, eventBase;
+    if( glXQueryExtension( _display, &errorBase, &eventBase)  == False )
+    {
+        osg::notify(osg::NOTICE)<<"Error: " << XDisplayName(_traits->displayName().c_str()) <<" has no GLX extension." << std::endl;
+
+        XCloseDisplay( _display );
+        _display = 0;
+        _valid = false;
+        return;
+    }
+    
+    // osg::notify(osg::NOTICE)<<"GLX extension, errorBase="<<errorBase<<" eventBase="<<eventBase<<std::endl;
+
+    if (!createVisualInfo())
+    {
+        _traits->red /= 2; 
+        _traits->green /= 2; 
+        _traits->blue /= 2; 
+        _traits->alpha /= 2; 
+        _traits->depth /= 2; 
+        
+        osg::notify(osg::INFO)<<"Relaxing traits"<<std::endl;
+
+        if (!createVisualInfo())
+        {
+            osg::notify(osg::NOTICE)<<"Error: Not able to create requested visual." << std::endl;
+            XCloseDisplay( _display );
+            _display = 0;
+            _valid = false;
+            return;
+        }    
+    }
+    
+    GLXContext sharedContextGLX = NULL;
+
+    // get any shared GLX contexts    
+    GraphicsWindowX11* graphicsWindowX11 = dynamic_cast<GraphicsWindowX11*>(_traits->sharedContext);
+    if (graphicsWindowX11) 
+    {
+        sharedContextGLX = graphicsWindowX11->getGLXContext();
+    }
+    else
+    {
+        PixelBufferX11* pixelBufferX11 = dynamic_cast<PixelBufferX11*>(_traits->sharedContext);
+        if (pixelBufferX11)
+        {
+            sharedContextGLX = pixelBufferX11->getGLXContext();
+        }
+    }
+    
+    _glxContext = glXCreateContext( _display, _visualInfo, sharedContextGLX, True );
+
+    if (!_glxContext)
+    {
+        osg::notify(osg::NOTICE)<<"Error: Unable to create OpenGL graphics context."<<std::endl;
+        XCloseDisplay( _display );
+        _display = 0;
+        _valid = false;
+        return;
+    }
+    
+    _parent = RootWindow( _display, screen );
+
+    XWindowAttributes watt;
+    XGetWindowAttributes( _display, _parent, &watt );
+    // unsigned int parentWindowHeight = watt.height;
+
+    XSetWindowAttributes swatt;
+    swatt.colormap = XCreateColormap( _display, _parent, _visualInfo->visual, AllocNone);
+    //swatt.colormap = DefaultColormap( _dpy, 10 );
+    swatt.background_pixel = 0;
+    swatt.border_pixel = 0;
+    swatt.event_mask =  0;
+    unsigned long mask = CWBackPixel | CWBorderPixel | CWEventMask | CWColormap;
+
+    bool overrideRedirect = false;
+    if (overrideRedirect)
+    {
+        swatt.override_redirect = true;
+        mask |= CWOverrideRedirect;
+    }
+
+    _window = XCreateWindow( _display, _parent,
+                             _traits->x,
+                             _traits->y,
+                             _traits->width, _traits->height, 0,
+                             _visualInfo->depth, InputOutput,
+                             _visualInfo->visual, mask, &swatt );
+                             
+    if (!_window)
+    {
+        osg::notify(osg::NOTICE)<<"Error: Unable to create Window."<<std::endl;
+        XCloseDisplay( _display );
+        _display = 0;
+        _glxContext = 0;
+        _valid = false;
+        return;
+    }
+
+
+
+    XFlush( _display );
+    XSync( _display, 0 );
+
+    // now update the window dimensions to account for any size changes made by the window manager,
+    XGetWindowAttributes( _display, _window, &watt );
+    
+    if (_traits->width != watt.width && _traits->height != watt.height)
+    {
+        resized( _traits->x, _traits->y, _traits->width, _traits->height );
+    }
+        
+
+    _valid = true;
+    _initialized = true;
+}
+
+bool PixelBufferX11::realizeImplementation()
+{
+    if (_realized)
+    {
+        osg::notify(osg::NOTICE)<<"PixelBufferX11::realizeImplementation() Already realized"<<std::endl;
+        return true;
+    }
+
+    if (!_initialized) init();
+    
+    if (!_initialized) return false;
+    
+    XMapWindow( _display, _window );
+    
+//    Window temp = _window;
+//    XSetWMColormapWindows( _display, _window, &temp, 1);
+    
+    _realized = true;
+
+    return true;
+}
+
+bool PixelBufferX11::makeCurrentImplementation()
+{
+    if (!_realized)
+    {
+        osg::notify(osg::NOTICE)<<"Warning: GraphicsWindow not realized, cannot do makeCurrent."<<std::endl;
+        return false;
+    }
+
+    osg::notify(osg::NOTICE)<<"PixelBufferX11::makeCurrentImplementation "<<this<<" "<<OpenThreads::Thread::CurrentThread()<<std::endl;
+    osg::notify(osg::NOTICE)<<"   glXMakeCurrent ("<<_display<<","<<_window<<","<<_glxContext<<std::endl;
+
+    return glXMakeCurrent( _display, _window, _glxContext )==True;
+}
+
+bool PixelBufferX11::makeContextCurrentImplementation(osg::GraphicsContext* readContext)
+{
+    osg::notify(osg::NOTICE)<<"PixelBufferX11::makeContextCurrentImplementation() not implementation yet."<<std::endl;
+    makeCurrentImplementation();
+}
+
+
+bool PixelBufferX11::releaseContextImplementation()
+{
+    if (!_realized)
+    {
+        osg::notify(osg::NOTICE)<<"Warning: GraphicsWindow not realized, cannot do makeCurrent."<<std::endl;
+        return false;
+    }
+
+    osg::notify(osg::NOTICE)<<"PixelBufferX11::releaseContextImplementation() "<<this<<" "<<OpenThreads::Thread::CurrentThread()<<std::endl;
+    osg::notify(osg::NOTICE)<<"   glXMakeCurrent ("<<_display<<std::endl;
+
+    return glXMakeCurrent( _display, None, NULL )==True;
+}
+
+
+void PixelBufferX11::bindPBufferToTextureImplementation(GLenum buffer)
+{
+    osg::notify(osg::NOTICE)<<"PixelBufferX11::bindPBufferToTextureImplementation() not implementation yet."<<std::endl;
+}
+
+
+void PixelBufferX11::closeImplementation()
+{
+    // osg::notify(osg::NOTICE)<<"Closing PixelBufferX11"<<std::endl;
+
+    if (_display)
+    {
+        if (_glxContext)
+        {
+            glXDestroyContext(_display, _glxContext );
+        }
+    
+        if (_window)
+        {
+            XDestroyWindow(_display, _window);
+        }
+
+        XFlush( _display );
+        XSync( _display,0 );
+    }
+    
+    _window = 0;
+    _parent = 0;
+    _glxContext = 0;
+
+    if (_visualInfo)
+    {
+        XFree(_visualInfo);
+        _visualInfo = 0;
+    }
+
+
+    if (_display)
+    {
+        XCloseDisplay( _display );
+        _display = 0;
+    }
+
+    _initialized = false;
+    _realized = false;
+    _valid = false;
+}
+
+void PixelBufferX11::swapBuffersImplementation()
+{
+    if (!_realized) return;
+
+    osg::notify(osg::NOTICE)<<"PixelBufferX11::swapBuffersImplementation "<<this<<" "<<OpenThreads::Thread::CurrentThread()<<std::endl;
+
+    glXSwapBuffers(_display, _window); 
+}