aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--README.md1
-rw-r--r--src/win32/init.rs250
-rw-r--r--src/win32/make_current_guard.rs53
-rw-r--r--src/win32/mod.rs82
4 files changed, 216 insertions, 170 deletions
diff --git a/README.md b/README.md
index 7596402..9dab387 100644
--- a/README.md
+++ b/README.md
@@ -86,7 +86,6 @@ fn main() {
### Win32
- You must call `glFlush` before `swap_buffers`, or else on Windows 8 nothing will be visible on the window
- - Pixel formats are not implemented
- Changing the cursor (set_cursor) is not implemented
### X11
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);
+ }
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-23 19:51:37 +0000