Merge branch 'master' of https://github.com/tomaka/gl-init-rs

src/lib.rs

@@ -2,25 +2,48 @@
 #![feature(globs)]
 #![unstable]
 
+//! The purpose of this library is to provide an OpenGL context on as many
+//!  platforms as possible.
+//!
+//! # Building a window
+//! 
+//! There are two ways to create a window:
+//! 
+//!  - Calling `Window::new()`.
+//!  - Calling `let builder = WindowBuilder::new()` then `builder.build()`.
+//!
+//! The first way is the simpliest way and will give you default values.
+//!
+//! The second way allows you to customize the way your window and GL context
+//!  will look and behave.
+
 extern crate libc;
 
 pub use events::*;
 
 #[cfg(windows)]
 use winimpl = win32;
-#[cfg(unix)]
+#[cfg(target_os = "linux")]
 use winimpl = x11;
+#[cfg(target_os = "macos")]
+use winimpl = osx;
 
-#[cfg(windows)]
+#[cfg(target_os = "win32")]
 mod win32;
-#[cfg(unix)]
+#[cfg(target_os = "linux")]
 mod x11;
+#[cfg(target_os = "macos")]
+mod osx;
 
 #[allow(dead_code)]
 //mod egl;
 
 mod events;
 
+#[cfg(not(target_os = "win32"), not(target_os = "linux"), not(target_os = "macos"))]
+#[static_assert]
+static this_platform_is_not_supposed: bool = false;
+
 /// Identifier for a monitor.
 pub struct MonitorID(winimpl::MonitorID);
 
@@ -99,7 +122,7 @@ impl WindowBuilder {
 ///
 /// # Example
 ///
-/// ```
+/// ```ignore
 /// let window = Window::new().unwrap();
 /// 
 /// unsafe { window.make_current() };

src/osx/mod.rs

@@ -0,0 +1,79 @@
+//! Dummy implementation for OS/X to make gl-init-rs compile on this platform
+
+use {Event, WindowBuilder};
+
+pub struct Window;
+
+pub struct MonitorID;
+
+pub fn get_available_monitors() -> Vec<MonitorID> {
+    unimplemented!()
+}
+
+pub fn get_primary_monitor() -> MonitorID {
+    unimplemented!()
+}
+
+impl MonitorID {
+    pub fn get_name(&self) -> Option<String> {
+        unimplemented!()
+    }
+
+    pub fn get_dimensions(&self) -> (uint, uint) {
+        unimplemented!()
+    }
+}
+
+impl Window {
+    pub fn new(_builder: WindowBuilder) -> Result<Window, String> {
+        unimplemented!()
+    }
+
+    pub fn is_closed(&self) -> bool {
+        unimplemented!()
+    }
+
+    pub fn set_title(&self, _title: &str) {
+        unimplemented!()
+    }
+
+    pub fn get_position(&self) -> Option<(int, int)> {
+        unimplemented!()
+    }
+
+    pub fn set_position(&self, _x: uint, _y: uint) {
+        unimplemented!()
+    }
+
+    pub fn get_inner_size(&self) -> Option<(uint, uint)> {
+        unimplemented!()
+    }
+
+    pub fn get_outer_size(&self) -> Option<(uint, uint)> {
+        unimplemented!()
+    }
+
+    pub fn set_inner_size(&self, _x: uint, _y: uint) {
+        unimplemented!()
+    }
+
+    pub fn poll_events(&self) -> Vec<Event> {
+        unimplemented!()
+    }
+
+    pub fn wait_events(&self) -> Vec<Event> {
+        unimplemented!()
+    }
+
+    pub unsafe fn make_current(&self) {
+        unimplemented!()
+    }
+
+    pub fn get_proc_address(&self, _addr: &str) -> *const () {
+        unimplemented!()
+    }
+
+    pub fn swap_buffers(&self) {
+        unimplemented!()
+    }
+}

src/win32/mod.rs

@@ -133,6 +133,7 @@ impl Window {
             }
         }
 
+        // if one of the received events is `Closed`, setting `is_closed` to true
         if events.iter().find(|e| match e { &&::Closed => true, _ => false }).is_some() {
             use std::sync::atomics::Relaxed;
             self.is_closed.store(true, Relaxed);
@@ -146,10 +147,21 @@ impl Window {
     pub fn wait_events(&self) -> Vec<Event> {
         match self.events_receiver.recv_opt() {
             Ok(ev) => {
+                // if the received event is `Closed`, setting `is_closed` to true
+                match ev {
+                    ::Closed => {
+                        use std::sync::atomics::Relaxed;
+                        self.is_closed.store(true, Relaxed);
+                    },
+                    _ => ()
+                };
+
+                // looing for other possible events in the queue
                 let mut result = self.poll_events();
                 result.insert(0, ev);
                 result
             },
+
             Err(_) => {
                 use std::sync::atomics::Relaxed;
                 self.is_closed.store(true, Relaxed);
@@ -187,6 +199,9 @@ impl Window {
 #[unsafe_destructor]
 impl Drop for Window {
     fn drop(&mut self) {
+        use std::ptr;
+        unsafe { ffi::wglMakeCurrent(ptr::mut_null(), ptr::mut_null()); }
+        unsafe { ffi::wglDeleteContext(self.context); }
         unsafe { ffi::DestroyWindow(self.window); }
     }
 }