Help problem with changing to version 0.9-8.1 from 0.3.14 and GLWidget

 public class GLWidget : DrawingArea, IDisposable
    {
        static PlatformID platformID = System.Environment.OSVersion.Platform;
 
        bool doubleBuffer = true;
        public new bool DoubleBuffered
        {
            get { return doubleBuffer; }
            set { doubleBuffer = value; }
        }
 
        byte colorBits = 24;
        public byte ColorBits
        {
            get { return colorBits; }
            set { colorBits = value; }
        }
 
        byte alphaBits = 0;
        public byte AlphaBits
        {
            get { return alphaBits; }
            set { alphaBits = value; }
        }
 
        byte depthBits = 32;
        public byte DepthBits
        {
            get { return depthBits; }
            set { depthBits = value; }
        }
 
        byte stencilBits = 0;
        public byte StencilBits
        {
            get { return stencilBits; }
            set { stencilBits = value; }
        }
 
        HandleRef renderingContextHandle;
        public HandleRef RenderingContextHandle
        {
            get { return renderingContextHandle; }
        }
 
        Gdk.Visual visual = null;
        static GLWidget globalSharedContextWidget = null;	
        GLWidget sharedContextWidget;
 
        public GLWidget()
			 : this(null)
        {
			if( globalSharedContextWidget == null)
			{
				globalSharedContextWidget = this;
			}
			else
			{
				sharedContextWidget = globalSharedContextWidget;
			}
        }
 
        public GLWidget(GLWidget sharedContextWidget)
        {
            base.DoubleBuffered = false;
            Realized += new EventHandler(HandleRealized);
			ExposeEvent += new ExposeEventHandler(HandleExposeEvent);
 
            this.sharedContextWidget = sharedContextWidget;
 
        }
 
        public override void Dispose()
        {
            base.Dispose();
 
            glXDestroyContext(gdk_x11_display_get_xdisplay(visual.Screen.Display.Handle), renderingContextHandle);
        }
 
        void HandleRealized(object sender, EventArgs eventArgs)
        {
           int[] attributeList = new int[24];
           int attributeIndex = 0;
 
           attributeList[attributeIndex++] = GLX_RGBA;
           if (doubleBuffer) attributeList[attributeIndex++] = GLX_DOUBLEBUFFER;
 
           attributeList[attributeIndex++] = GLX_RED_SIZE;
           attributeList[attributeIndex++] = 1;
 
           attributeList[attributeIndex++] = GLX_GREEN_SIZE;
           attributeList[attributeIndex++] = 1;
 
           attributeList[attributeIndex++] = GLX_BLUE_SIZE;
           attributeList[attributeIndex++] = 1;
 
           if (alphaBits != 0)
           {
               attributeList[attributeIndex++] = GLX_ALPHA_SIZE;
               attributeList[attributeIndex++] = 1;
           }
 
           if (depthBits != 0)
           {
              attributeList[attributeIndex++] = GLX_DEPTH_SIZE;
              attributeList[attributeIndex++] = 1;
           }
 
           if (stencilBits != 0)
           {
              attributeList[attributeIndex++] = GLX_STENCIL_SIZE;
              attributeList[attributeIndex++] = 1;
           }
 
           attributeList[attributeIndex++] = GLX_NONE;
 
           IntPtr xDisplay = gdk_x11_display_get_xdisplay(Screen.Display.Handle);
           IntPtr visualIntPtr = IntPtr.Zero;
 
           try
           {
               visualIntPtr = glXChooseVisual(xDisplay, Screen.Number, attributeList);
           }
           catch (DllNotFoundException e)
           {
               throw new Exception("OpenGL dll not found!", e);
           }
           catch (EntryPointNotFoundException enf)
           {
               throw new Exception("Glx entry point not found!", enf);
           }
 
           if (visualIntPtr == IntPtr.Zero)
           {
             throw new Exception("Visual");
           }
 
           XVisualInfo xVisualInfo = (XVisualInfo)Marshal.PtrToStructure(visualIntPtr, typeof(XVisualInfo));
 
           IntPtr xRenderingContext = IntPtr.Zero;
 
 
 
           if (sharedContextWidget != null)
           {
               GLWidget primaryWidget = sharedContextWidget;
               while (primaryWidget.sharedContextWidget != null) primaryWidget = primaryWidget.sharedContextWidget;
 
               if (primaryWidget.RenderingContextHandle.Handle != IntPtr.Zero)
               {
                  xRenderingContext = glXCreateContext(xDisplay, visualIntPtr, primaryWidget.RenderingContextHandle, true);
               }
                else
               {
                   xRenderingContext = glXCreateContext(xDisplay, visualIntPtr, new HandleRef(null, IntPtr.Zero), true);
                   this.sharedContextWidget = null;
                   primaryWidget.sharedContextWidget = this;
               }
           }
           else
           {
                  xRenderingContext = glXCreateContext(xDisplay, visualIntPtr, new HandleRef(null, IntPtr.Zero), true);
           }
 
 
           if (xRenderingContext == IntPtr.Zero)
           {
              throw new Exception("Unable to create rendering context");
           }
 
           renderingContextHandle = new HandleRef(this, xRenderingContext);
           visual = (Gdk.Visual)GLib.Object.GetObject(gdk_x11_screen_lookup_visual(Screen.Handle, xVisualInfo.visualid));
 
           if (visualIntPtr != IntPtr.Zero)
           {
               XFree(visualIntPtr);
           }
	  OpenTK.Graphics.GraphicsContext.CreateDummyContext(); ********* I thought here but it doesnt seem to make a difference *********************88 
        }
 
		void HandleExposeEvent(object o, ExposeEventArgs args)
		{
			MakeCurrent();
 
			OnRender();
 
			SwapBuffers();
		}
 
		public event EventHandler Render;
		public virtual void OnRender()
		{
			if( Render != null )
			{
				try
				{
					Render(this, EventArgs.Empty);
				}
				catch( NullReferenceException ) { }
			}
		}
 
        public bool MakeCurrent()
        {
           return glXMakeCurrent(gdk_x11_display_get_xdisplay(GdkWindow.Display.Handle), gdk_x11_drawable_get_xid(GdkWindow.Handle), renderingContextHandle);
        }
 
        public void SwapBuffers()
        {
           glXSwapBuffers(gdk_x11_display_get_xdisplay(GdkWindow.Display.Handle), gdk_x11_drawable_get_xid(GdkWindow.Handle));
        }
 
 
        #region X
 
		const string linux_libgl_name = "libGL.so.1";
		const string linux_libx11_name = "libX11.so.6";
		const string linux_libgdk_x11_name = "libgdk-x11-2.0.so.0";
 
        [SuppressUnmanagedCodeSecurity, DllImport(linux_libx11_name)]
        static extern void XFree(IntPtr handle);
 
        [SuppressUnmanagedCodeSecurity, DllImport(linux_libx11_name)]
        internal static extern uint XVisualIDFromVisual(IntPtr visual);
 
        [SuppressUnmanagedCodeSecurity, DllImport(linux_libgl_name)]
        static extern IntPtr glXCreateContext(IntPtr display, IntPtr visualInfo, HandleRef shareList, bool direct);
 
        [SuppressUnmanagedCodeSecurity, DllImport(linux_libgl_name)]
        static extern IntPtr glXChooseVisual(IntPtr display, int screen, int[] attr);
 
        [SuppressUnmanagedCodeSecurity, DllImport(linux_libgl_name)]
        static extern void glXDestroyContext(IntPtr display, HandleRef ctx);
 
        [SuppressUnmanagedCodeSecurity, DllImport(linux_libgl_name)]
        static extern bool glXMakeCurrent(IntPtr display, uint xdrawable, HandleRef ctx);
 
        [SuppressUnmanagedCodeSecurity, DllImport(linux_libgl_name)]
        static extern void glXSwapBuffers(IntPtr display, uint drawable);
 
        [SuppressUnmanagedCodeSecurity, DllImport(linux_libgdk_x11_name)]
        static extern uint gdk_x11_drawable_get_xid(IntPtr d);
 
        [SuppressUnmanagedCodeSecurity, DllImport(linux_libgdk_x11_name)]
        static extern IntPtr gdk_x11_display_get_xdisplay(IntPtr d);
 
        //[SuppressUnmanagedCodeSecurity, DllImport(linux_libgdk_x11_name)]
        //static extern IntPtr gdk_x11_visual_get_xvisual(IntPtr d);
 
        [SuppressUnmanagedCodeSecurity, DllImport(linux_libgdk_x11_name)]
        static extern IntPtr gdk_x11_screen_lookup_visual(IntPtr screen, uint xvisualid);
 
        const int GLX_NONE = 0;
        const int GLX_USE_GL = 1;
        const int GLX_BUFFER_SIZE = 2;
        const int GLX_LEVEL = 3;
        const int GLX_RGBA = 4;
        const int GLX_DOUBLEBUFFER = 5;
        const int GLX_STEREO = 6;
        const int GLX_AUX_BUFFERS = 7;
        const int GLX_RED_SIZE = 8;
        const int GLX_GREEN_SIZE = 9;
        const int GLX_BLUE_SIZE = 10;
        const int GLX_ALPHA_SIZE = 11;
        const int GLX_DEPTH_SIZE = 12;
        const int GLX_STENCIL_SIZE = 13;
        const int GLX_ACCUM_RED_SIZE = 14;
        const int GLX_ACCUM_GREEN_SIZE = 15;
        const int GLX_ACCUM_BLUE_SIZE = 16;
        const int GLX_ACCUM_ALPHA_SIZE = 17;
 
        [StructLayout(LayoutKind.Sequential)]
        private struct XVisualInfo
        {
            public IntPtr visual;
            public uint visualid;
            public int screen;
            public int depth;
            public int c_class;
            public uint red_mask;
            public uint blue_mask;
            public uint green_mask;
            public int colormap_size;
            public int bits_per_rgb;
        }
        #endregion
    }

namespace OpenTK.Compute.CL10
{
    using System;
    using System.Runtime.InteropServices;
    ...
    public static unsafe IntPtr EnqueueMapBuffer(..., [Out] int* errcode_ret) { ... }
}

public static IWindowInfo CreateWindowInfo(Graphics.GraphicsMode mode, IntPtr windowHandle, IntPtr display)
private static IWindowInfo CreateX11WindowInfo(Graphics.GraphicsMode mode, IntPtr windowHandle, IntPtr display)