1 files changed, 81 insertions, 18 deletions

diff --git a/src/x11/mod.rs b/src/x11/mod.rs
index 0311b9a..d2619c9 100644
--- a/src/x11/mod.rs
+++ b/src/x11/mod.rs
@@ -40,7 +40,6 @@ impl Window {
     pub fn new(builder: WindowBuilder) -> Result<Window, String> {
         // TODO: temporary
         let dimensions = builder.dimensions;
-        let title = builder.title.as_slice();
 
         // calling XOpenDisplay
         let display = unsafe {
@@ -51,23 +50,46 @@ impl Window {
             display
         };
 
-        // TODO: set error handler
-
-        static VISUAL_ATTRIBUTES: [libc::c_int, ..5] = [
-            ffi::GLX_RGBA,
-            ffi::GLX_DEPTH_SIZE,
-            24,
-            ffi::GLX_DOUBLEBUFFER,
-            0
-        ];
+        // TODO: set error handler?
+
+        // getting the FBConfig
+        let fb_config = unsafe {
+            static VISUAL_ATTRIBUTES: [libc::c_int, ..23] = [
+                ffi::GLX_X_RENDERABLE,  1,
+                ffi::GLX_DRAWABLE_TYPE, ffi::GLX_WINDOW_BIT,
+                ffi::GLX_RENDER_TYPE,   ffi::GLX_RGBA_BIT,
+                ffi::GLX_X_VISUAL_TYPE, ffi::GLX_TRUE_COLOR,
+                ffi::GLX_RED_SIZE,      8,
+                ffi::GLX_GREEN_SIZE,    8,
+                ffi::GLX_BLUE_SIZE,     8,
+                ffi::GLX_ALPHA_SIZE,    8,
+                ffi::GLX_DEPTH_SIZE,    24,
+                ffi::GLX_STENCIL_SIZE,  8,
+                ffi::GLX_DOUBLEBUFFER,  1,
+                0
+            ];
+
+            let mut num_fb: libc::c_int = mem::uninitialized();
+
+            let fb = ffi::glXChooseFBConfig(display, ffi::XDefaultScreen(display),
+                VISUAL_ATTRIBUTES.as_ptr(), &mut num_fb);
+            if fb.is_null() {
+                return Err(format!("glXChooseFBConfig failed"));
+            }
+            let preferred_fb = *fb;     // TODO: choose more wisely
+            ffi::XFree(fb as *const libc::c_void);
+            preferred_fb
+        };
 
         // getting the visual infos
         let visual_infos = unsafe {
-            let vi = ffi::glXChooseVisual(display, 0, VISUAL_ATTRIBUTES.as_ptr());
+            let vi = ffi::glXGetVisualFromFBConfig(display, fb_config);
             if vi.is_null() {
                 return Err(format!("glXChooseVisual failed"));
             }
-            vi
+            let vi_copy = *vi;
+            ffi::XFree(vi as *const libc::c_void);
+            vi_copy
         };
 
         // getting the root window
@@ -76,7 +98,7 @@ impl Window {
         // creating the color map
         let cmap = unsafe {
             let cmap = ffi::XCreateColormap(display, root,
-                (*visual_infos).visual, ffi::AllocNone);
+                visual_infos.visual, ffi::AllocNone);
             // TODO: error checking?
             cmap
         };
@@ -97,8 +119,8 @@ impl Window {
             let dimensions = dimensions.unwrap_or((800, 600));
 
             let win = ffi::XCreateWindow(display, root, 50, 50, dimensions.val0() as libc::c_uint,
-                dimensions.val1() as libc::c_uint, 0, (*visual_infos).depth, ffi::InputOutput,
-                (*visual_infos).visual, ffi::CWColormap | ffi::CWEventMask,
+                dimensions.val1() as libc::c_uint, 0, visual_infos.depth, ffi::InputOutput,
+                visual_infos.visual, ffi::CWColormap | ffi::CWEventMask,
                 &mut set_win_attr);
             win
         };
@@ -111,13 +133,30 @@ impl Window {
             let mut wm_delete_window = ffi::XInternAtom(display,
                 "WM_DELETE_WINDOW".to_c_str().as_ptr() as *const libc::c_char, 0);
             ffi::XSetWMProtocols(display, window, &mut wm_delete_window, 1);
-            ffi::XStoreName(display, window, mem::transmute(title.as_slice().as_ptr()));
+            ffi::XStoreName(display, window, mem::transmute(builder.title.as_slice().as_ptr()));
             ffi::XFlush(display);
 
             wm_delete_window
         };
 
-        // creating 
+        // getting the pointer to glXCreateContextAttribs
+        let create_context_attribs = unsafe {
+            let mut addr = unsafe { ffi::glXGetProcAddress(b"glXCreateContextAttribs".as_ptr()
+                as *const u8) } as *const ();
+
+            if addr.is_null() {
+                addr = unsafe { ffi::glXGetProcAddress(b"glXCreateContextAttribsARB".as_ptr()
+                    as *const u8) } as *const ();
+            }
+            
+            addr.to_option().map(|addr| {
+                let addr: extern "system" fn(*mut ffi::Display, ffi::GLXFBConfig, ffi::GLXContext,
+                    ffi::Bool, *const libc::c_int) -> ffi::GLXContext = unsafe { mem::transmute(addr) };
+                addr
+            })
+        };
+
+        // creating IM
         let im = unsafe {
             let im = ffi::XOpenIM(display, ptr::null(), ptr::mut_null(), ptr::mut_null());
             if im.is_null() {
@@ -142,7 +181,31 @@ impl Window {
 
         // creating GL context
         let context = unsafe {
-            ffi::glXCreateContext(display, visual_infos, ptr::null(), 1)
+            let mut attributes = Vec::new();
+
+            if builder.gl_version.is_some() {
+                let version = builder.gl_version.as_ref().unwrap();
+                attributes.push(ffi::GLX_CONTEXT_MAJOR_VERSION);
+                attributes.push(version.val0() as libc::c_int);
+                attributes.push(ffi::GLX_CONTEXT_MINOR_VERSION);
+                attributes.push(version.val1() as libc::c_int);
+            }
+
+            attributes.push(0);
+ 
+            let context = if create_context_attribs.is_some() {
+                let create_context_attribs = create_context_attribs.unwrap();
+                create_context_attribs(display, fb_config, ptr::null(), 1,
+                    attributes.as_ptr())
+            } else {
+                ffi::glXCreateNewContext(display, fb_config, ffi::GLX_RGBA_TYPE, ptr::null(), 1)
+            };
+
+            if context.is_null() {
+                return Err(format!("GL context creation failed"));
+            }
+
+            context
         };
 
         // returning