Merge pull request #302 from tomaka/win32

Win32

3 files changed, 216 insertions, 169 deletions

diff --git a/src/win32/init.rs b/src/win32/init.rs
index 260b0ab..b458d95 100644
--- a/src/win32/init.rs
+++ b/src/win32/init.rs
@@ -2,9 +2,14 @@ use std::sync::atomic::AtomicBool;
 use std::ptr;
 use std::mem;
 use std::os;
+use std::thread;
+
 use super::callback;
 use super::Window;
 use super::MonitorID;
+use super::ContextWrapper;
+use super::WindowWrapper;
+use super::make_current_guard::CurrentContextGuard;
 
 use Api;
 use BuilderAttribs;
@@ -32,42 +37,43 @@ pub fn new_window(builder: BuilderAttribs<'static>, builder_sharelists: Option<C
 {
     // initializing variables to be sent to the task
     let title = builder.title.as_slice().utf16_units()
-        .chain(Some(0).into_iter()).collect::<Vec<u16>>();    // title to utf16
-    //let hints = hints.clone();
-    let (tx, rx) = channel();
+                       .chain(Some(0).into_iter()).collect::<Vec<u16>>();    // title to utf16
 
-    // GetMessage must be called in the same thread as CreateWindow,
-    //  so we create a new thread dedicated to this window.
-    // This is the only safe method. Using `nosend` wouldn't work for non-native runtime.
-    ::std::thread::Thread::spawn(move || {
-        // sending
-        match init(title, builder, builder_sharelists) {
-            Ok(w) => tx.send(Ok(w)).ok(),
-            Err(e) => {
-                tx.send(Err(e)).ok();
-                return;
-            }
-        };
-
-        // now that the `Window` struct is initialized, the main `Window::new()` function will
-        //  return and this events loop will run in parallel
-        loop {
-            let mut msg = unsafe { mem::uninitialized() };
+    let (tx, rx) = channel();
 
-            if unsafe { user32::GetMessageW(&mut msg, ptr::null_mut(), 0, 0) } == 0 {
-                break;
+    // `GetMessage` must be called in the same thread as CreateWindow, so we create a new thread
+    // dedicated to this window.
+    thread::spawn(move || {
+        unsafe {
+            // creating and sending the `Window`
+            match init(title, builder, builder_sharelists) {
+                Ok(w) => tx.send(Ok(w)).ok(),
+                Err(e) => {
+                    tx.send(Err(e)).ok();
+                    return;
+                }
+            };
+
+            // now that the `Window` struct is initialized, the main `Window::new()` function will
+            //  return and this events loop will run in parallel
+            loop {
+                let mut msg = mem::uninitialized();
+
+                if user32::GetMessageW(&mut msg, ptr::null_mut(), 0, 0) == 0 {
+                    break;
+                }
+
+                user32::TranslateMessage(&msg);
+                user32::DispatchMessageW(&msg);   // calls `callback` (see the callback module)
             }
-
-            unsafe { user32::TranslateMessage(&msg) };
-            unsafe { user32::DispatchMessageW(&msg) };     // calls `callback` (see below)
         }
     });
 
     rx.recv().unwrap()
 }
 
-fn init(title: Vec<u16>, builder: BuilderAttribs<'static>, builder_sharelists: Option<ContextHack>)
-        -> Result<Window, CreationError>
+unsafe fn init(title: Vec<u16>, builder: BuilderAttribs<'static>,
+               builder_sharelists: Option<ContextHack>) -> Result<Window, CreationError>
 {
     let builder_sharelists = builder_sharelists.map(|s| s.0);
 
@@ -85,7 +91,7 @@ fn init(title: Vec<u16>, builder: BuilderAttribs<'static>, builder_sharelists: O
     //  and change the monitor's resolution if necessary
     if builder.monitor.is_some() {
         let monitor = builder.monitor.as_ref().unwrap();
-        switch_to_fullscreen(&mut rect, monitor);
+        try!(switch_to_fullscreen(&mut rect, monitor));
     }
 
     // computing the style and extended style of the window
@@ -97,12 +103,13 @@ fn init(title: Vec<u16>, builder: BuilderAttribs<'static>, builder_sharelists: O
     };
 
     // adjusting the window coordinates using the style
-    unsafe { user32::AdjustWindowRectEx(&mut rect, style, 0, ex_style) };
+    user32::AdjustWindowRectEx(&mut rect, style, 0, ex_style);
 
-    // getting the address of wglCreateContextAttribsARB
+    // the first step is to create a dummy window and a dummy context which we will use
+    // to load the pointers to some functions in the OpenGL driver in `extra_functions`
     let extra_functions = {
-        // creating a dummy invisible window for GL initialization
-        let dummy_window = unsafe {
+        // creating a dummy invisible window
+        let dummy_window = {
             let handle = user32::CreateWindowExW(ex_style, class_name.as_ptr(),
                 title.as_ptr() as winapi::LPCWSTR,
                 style | winapi::WS_CLIPSIBLINGS | winapi::WS_CLIPCHILDREN,
@@ -113,62 +120,44 @@ fn init(title: Vec<u16>, builder: BuilderAttribs<'static>, builder_sharelists: O
 
             if handle.is_null() {
                 return Err(OsError(format!("CreateWindowEx function failed: {}",
-                    os::error_string(os::errno()))));
+                                           os::error_string(os::errno()))));
             }
 
-            handle
-        };
-
-        // getting the HDC of the dummy window
-        let dummy_hdc = {
-            let hdc = unsafe { user32::GetDC(dummy_window) };
+            let hdc = user32::GetDC(handle);
             if hdc.is_null() {
                 let err = Err(OsError(format!("GetDC function failed: {}",
-                    os::error_string(os::errno()))));
-                unsafe { user32::DestroyWindow(dummy_window); }
+                                              os::error_string(os::errno()))));
                 return err;
             }
-            hdc
+
+            WindowWrapper(handle, hdc)
         };
 
         // getting the pixel format that we will use and setting it
         {
-            let formats = enumerate_native_pixel_formats(dummy_hdc);
+            let formats = enumerate_native_pixel_formats(&dummy_window);
             let (id, _) = builder.choose_pixel_format(formats.into_iter().map(|(a, b)| (b, a)));
-            try!(set_pixel_format(dummy_hdc, id));
+            try!(set_pixel_format(&dummy_window, id));
         }
 
-        // creating the dummy OpenGL context
-        let dummy_context = try!(create_context(None, dummy_hdc, None));
-
-        // making context current
-        unsafe { gl::wgl::MakeCurrent(dummy_hdc as *const libc::c_void, dummy_context as *const libc::c_void); }
+        // creating the dummy OpenGL context and making it current
+        let dummy_context = try!(create_context(None, &dummy_window, None));
+        let current_context = try!(CurrentContextGuard::make_current(&dummy_window,
+                                                                     &dummy_context));
 
         // loading the extra WGL functions
-        let extra_functions = gl::wgl_extra::Wgl::load_with(|addr| {
+        gl::wgl_extra::Wgl::load_with(|addr| {
             use libc;
 
-            let addr = CString::from_slice(addr.as_bytes());
+            let addr = CString::new(addr.as_bytes()).unwrap();
             let addr = addr.as_ptr();
 
-            unsafe {
-                gl::wgl::GetProcAddress(addr) as *const libc::c_void
-            }
-        });
-
-        // removing current context
-        unsafe { gl::wgl::MakeCurrent(ptr::null(), ptr::null()); }
-
-        // destroying the context and the window
-        unsafe { gl::wgl::DeleteContext(dummy_context as *const libc::c_void); }
-        unsafe { user32::DestroyWindow(dummy_window); }
-
-        // returning the address
-        extra_functions
+            gl::wgl::GetProcAddress(addr) as *const libc::c_void
+        })
     };
 
-    // creating the real window this time
-    let real_window = unsafe {
+    // creating the real window this time, by using the functions in `extra_functions`
+    let real_window = {
         let (width, height) = if builder.monitor.is_some() || builder.dimensions.is_some() {
             (Some(rect.right - rect.left), Some(rect.bottom - rect.top))
         } else {
@@ -192,50 +181,45 @@ fn init(title: Vec<u16>, builder: BuilderAttribs<'static>, builder_sharelists: O
 
         if handle.is_null() {
             return Err(OsError(format!("CreateWindowEx function failed: {}",
-                os::error_string(os::errno()))));
+                                       os::error_string(os::errno()))));
         }
 
-        handle
-    };
-
-    // getting the HDC of the window
-    let hdc = {
-        let hdc = unsafe { user32::GetDC(real_window) };
+        let hdc = user32::GetDC(handle);
         if hdc.is_null() {
-            let err = Err(OsError(format!("GetDC function failed: {}",
-                os::error_string(os::errno()))));
-            unsafe { user32::DestroyWindow(real_window); }
-            return err;
+            return Err(OsError(format!("GetDC function failed: {}",
+                                       os::error_string(os::errno()))));
         }
-        hdc
+
+        WindowWrapper(handle, hdc)
     };
 
     // calling SetPixelFormat
     {
         let formats = if extra_functions.GetPixelFormatAttribivARB.is_loaded() {
-            enumerate_arb_pixel_formats(&extra_functions, hdc)
+            enumerate_arb_pixel_formats(&extra_functions, &real_window)
         } else {
-            enumerate_native_pixel_formats(hdc)
+            enumerate_native_pixel_formats(&real_window)
         };
 
         let (id, _) = builder.choose_pixel_format(formats.into_iter().map(|(a, b)| (b, a)));
-        try!(set_pixel_format(hdc, id));
+        try!(set_pixel_format(&real_window, id));
     }
 
     // creating the OpenGL context
-    let context = try!(create_context(Some((&extra_functions, &builder)), hdc, builder_sharelists));
+    let context = try!(create_context(Some((&extra_functions, &builder)), &real_window,
+                                      builder_sharelists));
 
     // calling SetForegroundWindow if fullscreen
     if builder.monitor.is_some() {
-        unsafe { user32::SetForegroundWindow(real_window) };
+        user32::SetForegroundWindow(real_window.0);
     }
 
-    // filling the WINDOW task-local storage
+    // filling the WINDOW task-local storage so that we can start receiving events
     let events_receiver = {
         let (tx, rx) = channel();
         let mut tx = Some(tx);
         callback::WINDOW.with(|window| {
-            (*window.borrow_mut()) = Some((real_window, tx.take().unwrap()));
+            (*window.borrow_mut()) = Some((real_window.0, tx.take().unwrap()));
         });
         rx
     };
@@ -246,23 +230,17 @@ fn init(title: Vec<u16>, builder: BuilderAttribs<'static>, builder_sharelists: O
     // handling vsync
     if builder.vsync {
         if extra_functions.SwapIntervalEXT.is_loaded() {
-            unsafe { gl::wgl::MakeCurrent(hdc as *const libc::c_void, context as *const libc::c_void) };
-            if unsafe { extra_functions.SwapIntervalEXT(1) } == 0 {
-                unsafe { gl::wgl::DeleteContext(context as *const libc::c_void); }
-                unsafe { user32::DestroyWindow(real_window); }
+            let guard = try!(CurrentContextGuard::make_current(&real_window, &context));
+
+            if extra_functions.SwapIntervalEXT(1) == 0 {
                 return Err(OsError(format!("wglSwapIntervalEXT failed")));
             }
-
-            // it is important to remove the current context, otherwise you get very weird
-            // errors
-            unsafe { gl::wgl::MakeCurrent(ptr::null(), ptr::null()); }
         }
     }
 
     // building the struct
     Ok(Window {
         window: real_window,
-        hdc: hdc as winapi::HDC,
         context: context,
         gl_library: gl_library,
         events_receiver: events_receiver,
@@ -270,7 +248,7 @@ fn init(title: Vec<u16>, builder: BuilderAttribs<'static>, builder_sharelists: O
     })
 }
 
-fn register_window_class() -> Vec<u16> {
+unsafe fn register_window_class() -> Vec<u16> {
     let class_name: Vec<u16> = "Window Class".utf16_units().chain(Some(0).into_iter())
                                              .collect::<Vec<u16>>();
     
@@ -280,7 +258,7 @@ fn register_window_class() -> Vec<u16> {
         lpfnWndProc: Some(callback::callback),
         cbClsExtra: 0,
         cbWndExtra: 0,
-        hInstance: unsafe { kernel32::GetModuleHandleW(ptr::null()) },
+        hInstance: kernel32::GetModuleHandleW(ptr::null()),
         hIcon: ptr::null_mut(),
         hCursor: ptr::null_mut(),
         hbrBackground: ptr::null_mut(),
@@ -293,12 +271,14 @@ fn register_window_class() -> Vec<u16> {
     //  an error, and because errors here are detected during CreateWindowEx anyway.
     // Also since there is no weird element in the struct, there is no reason for this
     //  call to fail.
-    unsafe { user32::RegisterClassExW(&class) };
+    user32::RegisterClassExW(&class);
 
     class_name
 }
 
-fn switch_to_fullscreen(rect: &mut winapi::RECT, monitor: &MonitorID) -> Result<(), CreationError> {
+unsafe fn switch_to_fullscreen(rect: &mut winapi::RECT, monitor: &MonitorID)
+                               -> Result<(), CreationError>
+{
     // adjusting the rect
     {
         let pos = monitor.get_position();
@@ -309,15 +289,16 @@ fn switch_to_fullscreen(rect: &mut winapi::RECT, monitor: &MonitorID) -> Result<
     }
 
     // changing device settings
-    let mut screen_settings: winapi::DEVMODEW = unsafe { mem::zeroed() };
+    let mut screen_settings: winapi::DEVMODEW = mem::zeroed();
     screen_settings.dmSize = mem::size_of::<winapi::DEVMODEW>() as winapi::WORD;
     screen_settings.dmPelsWidth = (rect.right - rect.left) as winapi::DWORD;
     screen_settings.dmPelsHeight = (rect.bottom - rect.top) as winapi::DWORD;
     screen_settings.dmBitsPerPel = 32;      // TODO: ?
     screen_settings.dmFields = winapi::DM_BITSPERPEL | winapi::DM_PELSWIDTH | winapi::DM_PELSHEIGHT;
 
-    let result = unsafe { user32::ChangeDisplaySettingsExW(monitor.get_system_name().as_ptr(),
-        &mut screen_settings, ptr::null_mut(), winapi::CDS_FULLSCREEN, ptr::null_mut()) };
+    let result = user32::ChangeDisplaySettingsExW(monitor.get_system_name().as_ptr(),
+                                                  &mut screen_settings, ptr::null_mut(),
+                                                  winapi::CDS_FULLSCREEN, ptr::null_mut());
     
     if result != winapi::DISP_CHANGE_SUCCESSFUL {
         return Err(OsError(format!("ChangeDisplaySettings failed: {}", result)));
@@ -326,9 +307,9 @@ fn switch_to_fullscreen(rect: &mut winapi::RECT, monitor: &MonitorID) -> Result<
     Ok(())
 }
 
-fn create_context(extra: Option<(&gl::wgl_extra::Wgl, &BuilderAttribs<'static>)>,
-                  hdc: winapi::HDC, share: Option<winapi::HGLRC>)
-                  -> Result<winapi::HGLRC, CreationError>
+unsafe fn create_context(extra: Option<(&gl::wgl_extra::Wgl, &BuilderAttribs<'static>)>,
+                         hdc: &WindowWrapper, share: Option<winapi::HGLRC>)
+                         -> Result<ContextWrapper, CreationError>
 {
     let share = share.unwrap_or(ptr::null_mut());
 
@@ -360,11 +341,10 @@ fn create_context(extra: Option<(&gl::wgl_extra::Wgl, &BuilderAttribs<'static>)>
 
             attributes.push(0);
 
-            Some(unsafe {
-                extra_functions.CreateContextAttribsARB(hdc as *const libc::c_void,
-                                                        share as *const libc::c_void,
-                                                        attributes.as_slice().as_ptr())
-            })
+            Some(extra_functions.CreateContextAttribsARB(hdc.1 as *const libc::c_void,
+                                                         share as *const libc::c_void,
+                                                         attributes.as_slice().as_ptr()))
+
         } else {
             None
         }
@@ -375,13 +355,11 @@ fn create_context(extra: Option<(&gl::wgl_extra::Wgl, &BuilderAttribs<'static>)>
     let ctxt = match ctxt {
         Some(ctxt) => ctxt,
         None => {
-            unsafe {
-                let ctxt = gl::wgl::CreateContext(hdc as *const libc::c_void);
-                if !ctxt.is_null() && !share.is_null() {
-                    gl::wgl::ShareLists(share as *const libc::c_void, ctxt);
-                };
-                ctxt
-            }
+            let ctxt = gl::wgl::CreateContext(hdc.1 as *const libc::c_void);
+            if !ctxt.is_null() && !share.is_null() {
+                gl::wgl::ShareLists(share as *const libc::c_void, ctxt);
+            };
+            ctxt
         }
     };
 
@@ -390,21 +368,19 @@ fn create_context(extra: Option<(&gl::wgl_extra::Wgl, &BuilderAttribs<'static>)>
                            os::error_string(os::errno()))));
     }
 
-    Ok(ctxt as winapi::HGLRC)
+    Ok(ContextWrapper(ctxt as winapi::HGLRC))
 }
 
-fn enumerate_native_pixel_formats(hdc: winapi::HDC) -> Vec<(PixelFormat, libc::c_int)> {
+unsafe fn enumerate_native_pixel_formats(hdc: &WindowWrapper) -> Vec<(PixelFormat, libc::c_int)> {
     let size_of_pxfmtdescr = mem::size_of::<winapi::PIXELFORMATDESCRIPTOR>() as u32;
-    let num = unsafe { gdi32::DescribePixelFormat(hdc, 1, size_of_pxfmtdescr, ptr::null_mut()) };
+    let num = gdi32::DescribePixelFormat(hdc.1, 1, size_of_pxfmtdescr, ptr::null_mut());
 
     let mut result = Vec::new();
 
     for index in (0 .. num) {
-        let mut output: winapi::PIXELFORMATDESCRIPTOR = unsafe { mem::zeroed() };
+        let mut output: winapi::PIXELFORMATDESCRIPTOR = mem::zeroed();
         
-        if unsafe { gdi32::DescribePixelFormat(hdc, index, size_of_pxfmtdescr,
-                                               &mut output) } == 0
-        {
+        if gdi32::DescribePixelFormat(hdc.1, index, size_of_pxfmtdescr, &mut output) == 0 {
             continue;
         }
 
@@ -438,14 +414,14 @@ fn enumerate_native_pixel_formats(hdc: winapi::HDC) -> Vec<(PixelFormat, libc::c
     result
 }
 
-fn enumerate_arb_pixel_formats(extra: &gl::wgl_extra::Wgl, hdc: winapi::HDC)
-                               -> Vec<(PixelFormat, libc::c_int)>
+unsafe fn enumerate_arb_pixel_formats(extra: &gl::wgl_extra::Wgl, hdc: &WindowWrapper)
+                                      -> Vec<(PixelFormat, libc::c_int)>
 {
     let get_info = |index: u32, attrib: u32| {
-        let mut value = unsafe { mem::uninitialized() };
-        unsafe { extra.GetPixelFormatAttribivARB(hdc as *const libc::c_void, index as libc::c_int,
-                                                 0, 1, [attrib as libc::c_int].as_ptr(),
-                                                 &mut value) };
+        let mut value = mem::uninitialized();
+        extra.GetPixelFormatAttribivARB(hdc.1 as *const libc::c_void, index as libc::c_int,
+                                        0, 1, [attrib as libc::c_int].as_ptr(),
+                                        &mut value);
         value as u32
     };
 
@@ -489,17 +465,17 @@ fn enumerate_arb_pixel_formats(extra: &gl::wgl_extra::Wgl, hdc: winapi::HDC)
     result
 }
 
-fn set_pixel_format(hdc: winapi::HDC, id: libc::c_int) -> Result<(), CreationError> {
-    let mut output: winapi::PIXELFORMATDESCRIPTOR = unsafe { mem::zeroed() };
+unsafe fn set_pixel_format(hdc: &WindowWrapper, id: libc::c_int) -> Result<(), CreationError> {
+    let mut output: winapi::PIXELFORMATDESCRIPTOR = mem::zeroed();
 
-    if unsafe { gdi32::DescribePixelFormat(hdc, id,
-        mem::size_of::<winapi::PIXELFORMATDESCRIPTOR>() as winapi::UINT, &mut output) } == 0
+    if gdi32::DescribePixelFormat(hdc.1, id, mem::size_of::<winapi::PIXELFORMATDESCRIPTOR>()
+                                  as winapi::UINT, &mut output) == 0
     {
         return Err(OsError(format!("DescribePixelFormat function failed: {}",
                                    os::error_string(os::errno()))));
     }
 
-    if unsafe { gdi32::SetPixelFormat(hdc, id, &output) } == 0 {
+    if gdi32::SetPixelFormat(hdc.1, id, &output) == 0 {
         return Err(OsError(format!("SetPixelFormat function failed: {}",
                                    os::error_string(os::errno()))));
     }
@@ -507,11 +483,11 @@ fn set_pixel_format(hdc: winapi::HDC, id: libc::c_int) -> Result<(), CreationErr
     Ok(())
 }
 
-fn load_opengl32_dll() -> Result<winapi::HMODULE, CreationError> {
+unsafe fn load_opengl32_dll() -> Result<winapi::HMODULE, CreationError> {
     let name = "opengl32.dll".utf16_units().chain(Some(0).into_iter())
                              .collect::<Vec<u16>>().as_ptr();
 
-    let lib = unsafe { kernel32::LoadLibraryW(name) };
+    let lib = kernel32::LoadLibraryW(name);
 
     if lib.is_null() {
         return Err(OsError(format!("LoadLibrary function failed: {}",
diff --git a/src/win32/make_current_guard.rs b/src/win32/make_current_guard.rs
new file mode 100644
index 0000000..d6bcc8e
--- /dev/null
+++ b/src/win32/make_current_guard.rs
@@ -0,0 +1,53 @@
+use std::marker::PhantomData;
+use std::os;
+
+use libc;
+use winapi;
+use CreationError;
+
+use super::gl;
+use super::ContextWrapper;
+use super::WindowWrapper;
+
+/// A guard for when you want to make the context current. Destroying the guard restores the
+/// previously-current context.
+pub struct CurrentContextGuard<'a, 'b> {
+    previous_hdc: winapi::HDC,
+    previous_hglrc: winapi::HGLRC,
+    marker1: PhantomData<&'a ()>,
+    marker2: PhantomData<&'b ()>,
+}
+
+impl<'a, 'b> CurrentContextGuard<'a, 'b> {
+    pub unsafe fn make_current(window: &'a WindowWrapper, context: &'b ContextWrapper)
+                               -> Result<CurrentContextGuard<'a, 'b>, CreationError>
+    {
+        let previous_hdc = gl::wgl::GetCurrentDC() as winapi::HDC;
+        let previous_hglrc = gl::wgl::GetCurrentContext() as winapi::HGLRC;
+
+        let result = gl::wgl::MakeCurrent(window.1 as *const libc::c_void,
+                                          context.0 as *const libc::c_void);
+
+        if result == 0 {
+            return Err(CreationError::OsError(format!("wglMakeCurrent function failed: {}",
+                                                      os::error_string(os::errno()))));
+        }
+
+        Ok(CurrentContextGuard {
+            previous_hdc: previous_hdc,
+            previous_hglrc: previous_hglrc,
+            marker1: PhantomData,
+            marker2: PhantomData,
+        })
+    }
+}
+
+#[unsafe_destructor]
+impl<'a, 'b> Drop for CurrentContextGuard<'a, 'b> {
+    fn drop(&mut self) {
+        unsafe {
+            gl::wgl::MakeCurrent(self.previous_hdc as *const libc::c_void,
+                                 self.previous_hglrc as *const libc::c_void);
+        }
+    }
+}
diff --git a/src/win32/mod.rs b/src/win32/mod.rs
index 4846d59..327b71d 100644
--- a/src/win32/mod.rs
+++ b/src/win32/mod.rs
@@ -21,18 +21,16 @@ mod event;
 mod gl;
 mod headless;
 mod init;
+mod make_current_guard;
 mod monitor;
 
 /// The Win32 implementation of the main `Window` object.
 pub struct Window {
     /// Main handle for the window.
-    window: winapi::HWND,
-
-    /// This represents a "draw context" for the surface of the window.
-    hdc: winapi::HDC,
+    window: WindowWrapper,
 
     /// OpenGL context.
-    context: winapi::HGLRC,
+    context: ContextWrapper,
 
     /// Binded to `opengl32.dll`.
     ///
@@ -50,12 +48,25 @@ pub struct Window {
 unsafe impl Send for Window {}
 unsafe impl Sync for Window {}
 
-impl Window {
-    /// See the docs in the crate root file.
-    pub fn new(builder: BuilderAttribs) -> Result<Window, CreationError> {
-        let (builder, sharing) = builder.extract_non_static();
-        let sharing = sharing.map(|w| init::ContextHack(w.context));
-        init::new_window(builder, sharing)
+/// A simple wrapper that destroys the context when it is destroyed.
+struct ContextWrapper(pub winapi::HGLRC);
+
+impl Drop for ContextWrapper {
+    fn drop(&mut self) {
+        unsafe {
+            gl::wgl::DeleteContext(self.0 as *const libc::c_void);
+        }
+    }
+}
+
+/// A simple wrapper that destroys the window when it is destroyed.
+struct WindowWrapper(pub winapi::HWND, pub winapi::HDC);
+
+impl Drop for WindowWrapper {
+    fn drop(&mut self) {
+        unsafe {
+            user32::DestroyWindow(self.0);
+        }
     }
 }
 
@@ -70,6 +81,13 @@ impl WindowProxy {
 
 impl Window {
     /// See the docs in the crate root file.
+    pub fn new(builder: BuilderAttribs) -> Result<Window, CreationError> {
+        let (builder, sharing) = builder.extract_non_static();
+        let sharing = sharing.map(|w| init::ContextHack(w.context.0));
+        init::new_window(builder, sharing)
+    }
+
+    /// See the docs in the crate root file.
     pub fn is_closed(&self) -> bool {
         use std::sync::atomic::Ordering::Relaxed;
         self.is_closed.load(Relaxed)
@@ -80,7 +98,7 @@ impl Window {
     /// Calls SetWindowText on the HWND.
     pub fn set_title(&self, text: &str) {
         unsafe {
-            user32::SetWindowTextW(self.window,
+            user32::SetWindowTextW(self.window.0,
                 text.utf16_units().chain(Some(0).into_iter())
                 .collect::<Vec<u16>>().as_ptr() as winapi::LPCWSTR);
         }
@@ -88,13 +106,13 @@ impl Window {
 
     pub fn show(&self) {
         unsafe {
-            user32::ShowWindow(self.window, winapi::SW_SHOW);
+            user32::ShowWindow(self.window.0, winapi::SW_SHOW);
         }
     }
 
     pub fn hide(&self) {
         unsafe {
-            user32::ShowWindow(self.window, winapi::SW_HIDE);
+            user32::ShowWindow(self.window.0, winapi::SW_HIDE);
         }
     }
 
@@ -105,7 +123,7 @@ impl Window {
         let mut placement: winapi::WINDOWPLACEMENT = unsafe { mem::zeroed() };
         placement.length = mem::size_of::<winapi::WINDOWPLACEMENT>() as winapi::UINT;
 
-        if unsafe { user32::GetWindowPlacement(self.window, &mut placement) } == 0 {
+        if unsafe { user32::GetWindowPlacement(self.window.0, &mut placement) } == 0 {
             return None
         }
 
@@ -118,9 +136,9 @@ impl Window {
         use libc;
 
         unsafe {
-            user32::SetWindowPos(self.window, ptr::null_mut(), x as libc::c_int, y as libc::c_int,
+            user32::SetWindowPos(self.window.0, ptr::null_mut(), x as libc::c_int, y as libc::c_int,
                 0, 0, winapi::SWP_NOZORDER | winapi::SWP_NOSIZE);
-            user32::UpdateWindow(self.window);
+            user32::UpdateWindow(self.window.0);
         }
     }
 
@@ -129,7 +147,7 @@ impl Window {
         use std::mem;
         let mut rect: winapi::RECT = unsafe { mem::uninitialized() };
 
-        if unsafe { user32::GetClientRect(self.window, &mut rect) } == 0 {
+        if unsafe { user32::GetClientRect(self.window.0, &mut rect) } == 0 {
             return None
         }
 
@@ -144,7 +162,7 @@ impl Window {
         use std::mem;
         let mut rect: winapi::RECT = unsafe { mem::uninitialized() };
 
-        if unsafe { user32::GetWindowRect(self.window, &mut rect) } == 0 {
+        if unsafe { user32::GetWindowRect(self.window.0, &mut rect) } == 0 {
             return None
         }
 
@@ -159,9 +177,9 @@ impl Window {
         use libc;
 
         unsafe {
-            user32::SetWindowPos(self.window, ptr::null_mut(), 0, 0, x as libc::c_int,
+            user32::SetWindowPos(self.window.0, ptr::null_mut(), 0, 0, x as libc::c_int,
                 y as libc::c_int, winapi::SWP_NOZORDER | winapi::SWP_NOREPOSITION);
-            user32::UpdateWindow(self.window);
+            user32::UpdateWindow(self.window.0);
         }
     }
 
@@ -186,12 +204,13 @@ impl Window {
     /// See the docs in the crate root file.
     pub unsafe fn make_current(&self) {
         // TODO: check return value
-        gl::wgl::MakeCurrent(self.hdc as *const libc::c_void, self.context as *const libc::c_void);
+        gl::wgl::MakeCurrent(self.window.1 as *const libc::c_void,
+                             self.context.0 as *const libc::c_void);
     }
 
     /// See the docs in the crate root file.
     pub fn get_proc_address(&self, addr: &str) -> *const () {
-        let addr = CString::from_slice(addr.as_bytes());
+        let addr = CString::new(addr.as_bytes()).unwrap();
         let addr = addr.as_ptr();
 
         unsafe {
@@ -204,7 +223,7 @@ impl Window {
     /// See the docs in the crate root file.
     pub fn swap_buffers(&self) {
         unsafe {
-            gdi32::SwapBuffers(self.hdc);
+            gdi32::SwapBuffers(self.window.1);
         }
     }
 
@@ -213,7 +232,7 @@ impl Window {
     }
 
     pub fn platform_window(&self) -> *mut libc::c_void {
-        self.window as *mut libc::c_void
+        self.window.0 as *mut libc::c_void
     }
 
     /// See the docs in the crate root file.
@@ -224,7 +243,7 @@ impl Window {
     pub fn set_window_resize_callback(&mut self, _: Option<fn(u32, u32)>) {
     }
 
-    pub fn set_cursor(&self, cursor: MouseCursor) {
+    pub fn set_cursor(&self, _cursor: MouseCursor) {
         unimplemented!()
     }
 
@@ -280,11 +299,10 @@ impl<'a> Iterator for WaitEventsIterator<'a> {
 #[unsafe_destructor]
 impl Drop for Window {
     fn drop(&mut self) {
-        use std::ptr;
-        // we don't call MakeCurrent(0, 0) because we are not sure that the context
-        // is still the current one
-        unsafe { user32::PostMessageW(self.window, winapi::WM_DESTROY, 0, 0); }
-        unsafe { gl::wgl::DeleteContext(self.context as *const libc::c_void); }
-        unsafe { user32::DestroyWindow(self.window); }
+        unsafe {
+            // we don't call MakeCurrent(0, 0) because we are not sure that the context
+            // is still the current one
+            user32::PostMessageW(self.window.0, winapi::WM_DESTROY, 0, 0);
+        }
     }
 }