1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
use std::sync::atomics::AtomicBool;
use std::ptr;
use {Event, WindowBuilder};
pub use self::monitor::{MonitorID, get_available_monitors, get_primary_monitor};
mod event;
mod ffi;
mod init;
mod monitor;
/// The Win32 implementation of the main `Window` object.
pub struct Window {
/// Main handle for the window.
window: ffi::HWND,
/// This represents a "draw context" for the surface of the window.
hdc: ffi::HDC,
/// OpenGL context.
context: ffi::HGLRC,
/// Binded to `opengl32.dll`.
///
/// `wglGetProcAddress` returns null for GL 1.1 functions because they are
/// already defined by the system. This module contains them.
gl_library: ffi::HMODULE,
/// Receiver for the events dispatched by the window callback.
events_receiver: Receiver<Event>,
/// True if a `Closed` event has been received.
is_closed: AtomicBool,
}
impl Window {
/// See the docs in the crate root file.
pub fn new(builder: WindowBuilder) -> Result<Window, String> {
init::new_window(builder)
}
/// See the docs in the crate root file.
pub fn is_closed(&self) -> bool {
use std::sync::atomics::Relaxed;
self.is_closed.load(Relaxed)
}
/// See the docs in the crate root file.
///
/// Calls SetWindowText on the HWND.
pub fn set_title(&self, text: &str) {
unsafe {
ffi::SetWindowTextW(self.window,
text.utf16_units().collect::<Vec<u16>>().append_one(0).as_ptr() as ffi::LPCWSTR);
}
}
/// See the docs in the crate root file.
pub fn get_position(&self) -> Option<(int, int)> {
use std::mem;
let mut placement: ffi::WINDOWPLACEMENT = unsafe { mem::zeroed() };
placement.length = mem::size_of::<ffi::WINDOWPLACEMENT>() as ffi::UINT;
if unsafe { ffi::GetWindowPlacement(self.window, &mut placement) } == 0 {
return None
}
let ref rect = placement.rcNormalPosition;
Some((rect.left as int, rect.top as int))
}
/// See the docs in the crate root file.
pub fn set_position(&self, x: int, y: int) {
use libc;
unsafe {
ffi::SetWindowPos(self.window, ptr::mut_null(), x as libc::c_int, y as libc::c_int,
0, 0, ffi::SWP_NOZORDER | ffi::SWP_NOSIZE);
ffi::UpdateWindow(self.window);
}
}
/// See the docs in the crate root file.
pub fn get_inner_size(&self) -> Option<(uint, uint)> {
use std::mem;
let mut rect: ffi::RECT = unsafe { mem::uninitialized() };
if unsafe { ffi::GetClientRect(self.window, &mut rect) } == 0 {
return None
}
Some((
(rect.right - rect.left) as uint,
(rect.bottom - rect.top) as uint
))
}
/// See the docs in the crate root file.
pub fn get_outer_size(&self) -> Option<(uint, uint)> {
use std::mem;
let mut rect: ffi::RECT = unsafe { mem::uninitialized() };
if unsafe { ffi::GetWindowRect(self.window, &mut rect) } == 0 {
return None
}
Some((
(rect.right - rect.left) as uint,
(rect.bottom - rect.top) as uint
))
}
/// See the docs in the crate root file.
pub fn set_inner_size(&self, x: uint, y: uint) {
use libc;
unsafe {
ffi::SetWindowPos(self.window, ptr::mut_null(), 0, 0, x as libc::c_int,
y as libc::c_int, ffi::SWP_NOZORDER | ffi::SWP_NOREPOSITION);
ffi::UpdateWindow(self.window);
}
}
/// See the docs in the crate root file.
// TODO: return iterator
pub fn poll_events(&self) -> Vec<Event> {
let mut events = Vec::new();
loop {
match self.events_receiver.try_recv() {
Ok(ev) => events.push(ev),
Err(_) => break
}
}
// 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);
}
events
}
/// See the docs in the crate root file.
// TODO: return iterator
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);
vec![]
}
}
}
/// See the docs in the crate root file.
pub unsafe fn make_current(&self) {
ffi::wglMakeCurrent(self.hdc, self.context)
}
/// See the docs in the crate root file.
pub fn get_proc_address(&self, addr: &str) -> *const () {
use std::c_str::ToCStr;
unsafe {
addr.with_c_str(|s| {
let p = ffi::wglGetProcAddress(s) as *const ();
if !p.is_null() { return p; }
ffi::GetProcAddress(self.gl_library, s) as *const ()
})
}
}
/// See the docs in the crate root file.
pub fn swap_buffers(&self) {
unsafe {
// calling glFlush is necessary on Windows 8
ffi::glFlush();
ffi::SwapBuffers(self.hdc);
}
}
}
#[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); }
}
}
|
