2015-02-21 23:59:37 +11:00
|
|
|
use std::collections::vec_deque::IntoIter as VecDequeIter;
|
2015-02-16 19:29:37 +11:00
|
|
|
use std::default::Default;
|
|
|
|
|
|
|
|
use Api;
|
2015-06-16 18:15:31 +10:00
|
|
|
use ContextError;
|
2015-02-16 19:29:37 +11:00
|
|
|
use CreationError;
|
2015-03-27 03:04:01 +11:00
|
|
|
use CursorState;
|
2015-02-16 19:29:37 +11:00
|
|
|
use Event;
|
2015-09-21 21:15:43 +10:00
|
|
|
use GlAttributes;
|
2015-04-30 21:23:37 +10:00
|
|
|
use GlContext;
|
2015-05-01 13:06:22 +10:00
|
|
|
use GlProfile;
|
2015-02-19 02:49:53 +11:00
|
|
|
use GlRequest;
|
2015-02-16 19:29:37 +11:00
|
|
|
use MouseCursor;
|
2015-04-11 17:06:08 +10:00
|
|
|
use PixelFormat;
|
2015-09-21 21:15:43 +10:00
|
|
|
use PixelFormatRequirements;
|
2015-06-23 01:58:32 +10:00
|
|
|
use Robustness;
|
2015-09-26 02:04:55 +10:00
|
|
|
use Window;
|
2015-09-21 21:15:43 +10:00
|
|
|
use WindowAttributes;
|
2015-03-19 08:16:35 +11:00
|
|
|
use native_monitor::NativeMonitorId;
|
2015-02-16 19:29:37 +11:00
|
|
|
|
|
|
|
use libc;
|
2015-04-02 17:27:32 +11:00
|
|
|
use platform;
|
2015-02-16 19:29:37 +11:00
|
|
|
|
|
|
|
/// Object that allows you to build windows.
|
|
|
|
pub struct WindowBuilder<'a> {
|
2015-09-21 23:42:24 +10:00
|
|
|
/// The attributes to use to create the window.
|
|
|
|
pub window: WindowAttributes,
|
|
|
|
|
|
|
|
/// The attributes to use to create the context.
|
|
|
|
pub opengl: GlAttributes<&'a platform::Window>,
|
|
|
|
|
|
|
|
// Should be made public once it's stabilized.
|
2015-09-21 21:15:43 +10:00
|
|
|
pf_reqs: PixelFormatRequirements,
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> WindowBuilder<'a> {
|
|
|
|
/// Initializes a new `WindowBuilder` with default values.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn new() -> WindowBuilder<'a> {
|
|
|
|
WindowBuilder {
|
2015-09-21 21:15:43 +10:00
|
|
|
pf_reqs: Default::default(),
|
|
|
|
window: Default::default(),
|
|
|
|
opengl: Default::default(),
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Requests the window to be of specific dimensions.
|
|
|
|
///
|
|
|
|
/// Width and height are in pixels.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn with_dimensions(mut self, width: u32, height: u32) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.window.dimensions = Some((width, height));
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Requests a specific title for the window.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn with_title(mut self, title: String) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.window.title = title;
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Requests fullscreen mode.
|
|
|
|
///
|
|
|
|
/// If you don't specify dimensions for the window, it will match the monitor's.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-09-24 17:11:59 +10:00
|
|
|
pub fn with_fullscreen(mut self, monitor: MonitorId) -> WindowBuilder<'a> {
|
|
|
|
let MonitorId(monitor) = monitor;
|
2015-09-21 21:15:43 +10:00
|
|
|
self.window.monitor = Some(monitor);
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
/// The created window will share all its OpenGL objects with the window in the parameter.
|
|
|
|
///
|
|
|
|
/// There are some exceptions, like FBOs or VAOs. See the OpenGL documentation.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn with_shared_lists(mut self, other: &'a Window) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.opengl.sharing = Some(&other.window);
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2015-02-19 02:49:53 +11:00
|
|
|
/// Sets how the backend should choose the OpenGL API and version.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-19 02:49:53 +11:00
|
|
|
pub fn with_gl(mut self, request: GlRequest) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.opengl.version = request;
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2015-05-01 13:06:22 +10:00
|
|
|
/// Sets the desired OpenGL context profile.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-05-01 13:06:22 +10:00
|
|
|
pub fn with_gl_profile(mut self, profile: GlProfile) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.opengl.profile = Some(profile);
|
2015-04-30 13:05:47 +10:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2015-02-16 19:29:37 +11:00
|
|
|
/// Sets the *debug* flag for the OpenGL context.
|
|
|
|
///
|
2015-04-02 19:13:01 +11:00
|
|
|
/// The default value for this flag is `cfg!(debug_assertions)`, which means that it's enabled
|
2015-02-16 19:29:37 +11:00
|
|
|
/// when you run `cargo build` and disabled when you run `cargo build --release`.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn with_gl_debug_flag(mut self, flag: bool) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.opengl.debug = flag;
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2015-06-23 01:58:32 +10:00
|
|
|
/// Sets the robustness of the OpenGL context. See the docs of `Robustness`.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-06-23 01:58:32 +10:00
|
|
|
pub fn with_gl_robustness(mut self, robustness: Robustness) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.opengl.robustness = robustness;
|
2015-06-23 01:58:32 +10:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2015-02-16 19:29:37 +11:00
|
|
|
/// Requests that the window has vsync enabled.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn with_vsync(mut self) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.opengl.vsync = true;
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Sets whether the window will be initially hidden or visible.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn with_visibility(mut self, visible: bool) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.window.visible = visible;
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Sets the multisampling level to request.
|
|
|
|
///
|
|
|
|
/// # Panic
|
|
|
|
///
|
|
|
|
/// Will panic if `samples` is not a power of two.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn with_multisampling(mut self, samples: u16) -> WindowBuilder<'a> {
|
|
|
|
assert!(samples.is_power_of_two());
|
2015-09-21 21:15:43 +10:00
|
|
|
self.pf_reqs.multisampling = Some(samples);
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Sets the number of bits in the depth buffer.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn with_depth_buffer(mut self, bits: u8) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.pf_reqs.depth_bits = Some(bits);
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Sets the number of bits in the stencil buffer.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn with_stencil_buffer(mut self, bits: u8) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.pf_reqs.stencil_bits = Some(bits);
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Sets the number of bits in the color buffer.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn with_pixel_format(mut self, color_bits: u8, alpha_bits: u8) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.pf_reqs.color_bits = Some(color_bits);
|
|
|
|
self.pf_reqs.alpha_bits = Some(alpha_bits);
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Request the backend to be stereoscopic.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn with_stereoscopy(mut self) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.pf_reqs.stereoscopy = true;
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2015-05-01 13:06:22 +10:00
|
|
|
/// Sets whether sRGB should be enabled on the window. `None` means "I don't care".
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-05-01 13:06:22 +10:00
|
|
|
pub fn with_srgb(mut self, srgb_enabled: Option<bool>) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.pf_reqs.srgb = srgb_enabled;
|
2015-04-03 23:02:33 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2015-05-15 23:19:33 +10:00
|
|
|
/// Sets whether the background of the window should be transparent.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-05-15 23:19:33 +10:00
|
|
|
pub fn with_transparency(mut self, transparent: bool) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.window.transparent = transparent;
|
2015-05-15 23:19:33 +10:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Sets whether the window should have a border, a title bar, etc.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-05-15 23:19:33 +10:00
|
|
|
pub fn with_decorations(mut self, decorations: bool) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.window.decorations = decorations;
|
2015-05-15 23:19:33 +10:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2015-06-05 23:38:21 +10:00
|
|
|
/// Enables multitouch
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-06-05 23:38:21 +10:00
|
|
|
pub fn with_multitouch(mut self) -> WindowBuilder<'a> {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.window.multitouch = true;
|
2015-06-05 23:38:21 +10:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2015-02-16 19:29:37 +11:00
|
|
|
/// Builds the window.
|
|
|
|
///
|
|
|
|
/// Error should be very rare and only occur in case of permission denied, incompatible system,
|
2015-05-15 23:19:33 +10:00
|
|
|
/// out of memory, etc.
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn build(mut self) -> Result<Window, CreationError> {
|
|
|
|
// resizing the window to the dimensions of the monitor when fullscreen
|
2015-09-21 21:15:43 +10:00
|
|
|
if self.window.dimensions.is_none() && self.window.monitor.is_some() {
|
|
|
|
self.window.dimensions = Some(self.window.monitor.as_ref().unwrap().get_dimensions())
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
// default dimensions
|
2015-09-21 21:15:43 +10:00
|
|
|
if self.window.dimensions.is_none() {
|
|
|
|
self.window.dimensions = Some((1024, 768));
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
// building
|
2015-09-21 21:15:43 +10:00
|
|
|
platform::Window::new(&self.window, &self.pf_reqs, &self.opengl)
|
|
|
|
.map(|w| Window { window: w })
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Builds the window.
|
|
|
|
///
|
|
|
|
/// The context is build in a *strict* way. That means that if the backend couldn't give
|
|
|
|
/// you what you requested, an `Err` will be returned.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-09-21 21:15:43 +10:00
|
|
|
pub fn build_strict(self) -> Result<Window, CreationError> {
|
2015-02-16 19:29:37 +11:00
|
|
|
self.build()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
impl Default for Window {
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
fn default() -> Window {
|
|
|
|
Window::new().unwrap()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Window {
|
|
|
|
/// Creates a new OpenGL context, and a Window for platforms where this is appropriate.
|
|
|
|
///
|
|
|
|
/// This function is equivalent to `WindowBuilder::new().build()`.
|
|
|
|
///
|
|
|
|
/// Error should be very rare and only occur in case of permission denied, incompatible system,
|
|
|
|
/// out of memory, etc.
|
|
|
|
#[inline]
|
|
|
|
pub fn new() -> Result<Window, CreationError> {
|
|
|
|
let builder = WindowBuilder::new();
|
|
|
|
builder.build()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Modifies the title of the window.
|
|
|
|
///
|
|
|
|
/// This is a no-op if the window has already been closed.
|
|
|
|
#[inline]
|
|
|
|
pub fn set_title(&self, title: &str) {
|
|
|
|
self.window.set_title(title)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Shows the window if it was hidden.
|
|
|
|
///
|
|
|
|
/// ## Platform-specific
|
|
|
|
///
|
|
|
|
/// - Has no effect on Android
|
|
|
|
///
|
|
|
|
#[inline]
|
|
|
|
pub fn show(&self) {
|
|
|
|
self.window.show()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Hides the window if it was visible.
|
|
|
|
///
|
|
|
|
/// ## Platform-specific
|
|
|
|
///
|
|
|
|
/// - Has no effect on Android
|
|
|
|
///
|
|
|
|
#[inline]
|
|
|
|
pub fn hide(&self) {
|
|
|
|
self.window.hide()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the position of the top-left hand corner of the window relative to the
|
|
|
|
/// top-left hand corner of the desktop.
|
|
|
|
///
|
2015-03-26 14:44:21 +11:00
|
|
|
/// Note that the top-left hand corner of the desktop is not necessarily the same as
|
2015-02-16 19:29:37 +11:00
|
|
|
/// the screen. If the user uses a desktop with multiple monitors, the top-left hand corner
|
|
|
|
/// of the desktop is the top-left hand corner of the monitor at the top-left of the desktop.
|
|
|
|
///
|
|
|
|
/// The coordinates can be negative if the top-left hand corner of the window is outside
|
|
|
|
/// of the visible screen region.
|
|
|
|
///
|
|
|
|
/// Returns `None` if the window no longer exists.
|
|
|
|
#[inline]
|
|
|
|
pub fn get_position(&self) -> Option<(i32, i32)> {
|
|
|
|
self.window.get_position()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Modifies the position of the window.
|
|
|
|
///
|
|
|
|
/// See `get_position` for more informations about the coordinates.
|
|
|
|
///
|
|
|
|
/// This is a no-op if the window has already been closed.
|
|
|
|
#[inline]
|
|
|
|
pub fn set_position(&self, x: i32, y: i32) {
|
|
|
|
self.window.set_position(x, y)
|
|
|
|
}
|
|
|
|
|
2015-07-25 21:57:52 +10:00
|
|
|
/// Returns the size in points of the client area of the window.
|
|
|
|
///
|
|
|
|
/// The client area is the content of the window, excluding the title bar and borders.
|
|
|
|
/// To get the dimensions of the frame buffer when calling `glViewport`, multiply with hidpi factor.
|
|
|
|
///
|
|
|
|
/// Returns `None` if the window no longer exists.
|
|
|
|
///
|
|
|
|
/// DEPRECATED
|
|
|
|
#[inline]
|
|
|
|
pub fn get_inner_size(&self) -> Option<(u32, u32)> {
|
|
|
|
self.window.get_inner_size()
|
|
|
|
}
|
|
|
|
|
2015-07-25 20:01:20 +10:00
|
|
|
/// Returns the size in points of the client area of the window.
|
2015-02-16 19:29:37 +11:00
|
|
|
///
|
|
|
|
/// The client area is the content of the window, excluding the title bar and borders.
|
2015-07-25 20:01:20 +10:00
|
|
|
/// To get the dimensions of the frame buffer when calling `glViewport`, multiply with hidpi factor.
|
2015-02-16 19:29:37 +11:00
|
|
|
///
|
|
|
|
/// Returns `None` if the window no longer exists.
|
|
|
|
#[inline]
|
2015-07-25 21:40:33 +10:00
|
|
|
pub fn get_inner_size_points(&self) -> Option<(u32, u32)> {
|
2015-02-16 19:29:37 +11:00
|
|
|
self.window.get_inner_size()
|
|
|
|
}
|
|
|
|
|
2015-07-25 21:57:52 +10:00
|
|
|
|
2015-07-25 21:40:33 +10:00
|
|
|
/// Returns the size in pixels of the client area of the window.
|
|
|
|
///
|
|
|
|
/// The client area is the content of the window, excluding the title bar and borders.
|
|
|
|
/// These are the dimensions of the frame buffer, and the dimensions that you should use
|
|
|
|
/// when you call `glViewport`.
|
|
|
|
///
|
|
|
|
/// Returns `None` if the window no longer exists.
|
|
|
|
#[inline]
|
|
|
|
pub fn get_inner_size_pixels(&self) -> Option<(u32, u32)> {
|
|
|
|
self.window.get_inner_size().map(|(x, y)| {
|
|
|
|
let hidpi = self.hidpi_factor();
|
|
|
|
((x as f32 * hidpi) as u32, (y as f32 * hidpi) as u32)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2015-02-16 19:29:37 +11:00
|
|
|
/// Returns the size in pixels of the window.
|
|
|
|
///
|
|
|
|
/// These dimensions include title bar and borders. If you don't want these, you should use
|
|
|
|
/// use `get_inner_size` instead.
|
|
|
|
///
|
|
|
|
/// Returns `None` if the window no longer exists.
|
|
|
|
#[inline]
|
|
|
|
pub fn get_outer_size(&self) -> Option<(u32, u32)> {
|
|
|
|
self.window.get_outer_size()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Modifies the inner size of the window.
|
|
|
|
///
|
|
|
|
/// See `get_inner_size` for more informations about the values.
|
|
|
|
///
|
|
|
|
/// This is a no-op if the window has already been closed.
|
|
|
|
#[inline]
|
|
|
|
pub fn set_inner_size(&self, x: u32, y: u32) {
|
|
|
|
self.window.set_inner_size(x, y)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns an iterator that poll for the next event in the window's events queue.
|
|
|
|
/// Returns `None` if there is no event in the queue.
|
|
|
|
///
|
|
|
|
/// Contrary to `wait_events`, this function never blocks.
|
|
|
|
#[inline]
|
|
|
|
pub fn poll_events(&self) -> PollEventsIterator {
|
|
|
|
PollEventsIterator(self.window.poll_events())
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns an iterator that returns events one by one, blocking if necessary until one is
|
|
|
|
/// available.
|
|
|
|
///
|
|
|
|
/// The iterator never returns `None`.
|
|
|
|
#[inline]
|
|
|
|
pub fn wait_events(&self) -> WaitEventsIterator {
|
|
|
|
WaitEventsIterator(self.window.wait_events())
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Sets the context as the current context.
|
|
|
|
#[inline]
|
2015-06-16 18:15:31 +10:00
|
|
|
pub unsafe fn make_current(&self) -> Result<(), ContextError> {
|
2015-02-16 19:29:37 +11:00
|
|
|
self.window.make_current()
|
|
|
|
}
|
|
|
|
|
2015-03-04 17:38:55 +11:00
|
|
|
/// Returns true if this context is the current one in this thread.
|
|
|
|
#[inline]
|
|
|
|
pub fn is_current(&self) -> bool {
|
|
|
|
self.window.is_current()
|
|
|
|
}
|
|
|
|
|
2015-02-16 19:29:37 +11:00
|
|
|
/// Returns the address of an OpenGL function.
|
|
|
|
///
|
|
|
|
/// Contrary to `wglGetProcAddress`, all available OpenGL functions return an address.
|
|
|
|
#[inline]
|
2015-11-04 21:27:50 +11:00
|
|
|
pub fn get_proc_address(&self, addr: &str) -> *const () {
|
|
|
|
self.window.get_proc_address(addr)
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Swaps the buffers in case of double or triple buffering.
|
|
|
|
///
|
|
|
|
/// You should call this function every time you have finished rendering, or the image
|
|
|
|
/// may not be displayed on the screen.
|
|
|
|
///
|
|
|
|
/// **Warning**: if you enabled vsync, this function will block until the next time the screen
|
|
|
|
/// is refreshed. However drivers can choose to override your vsync settings, which means that
|
|
|
|
/// you can't know in advance whether `swap_buffers` will block or not.
|
|
|
|
#[inline]
|
2015-06-16 18:15:31 +10:00
|
|
|
pub fn swap_buffers(&self) -> Result<(), ContextError> {
|
2015-02-16 19:29:37 +11:00
|
|
|
self.window.swap_buffers()
|
|
|
|
}
|
|
|
|
|
2015-09-26 02:04:55 +10:00
|
|
|
/// DEPRECATED. Gets the native platform specific display for this window.
|
2015-02-16 19:29:37 +11:00
|
|
|
/// This is typically only required when integrating with
|
|
|
|
/// other libraries that need this information.
|
|
|
|
#[inline]
|
|
|
|
pub unsafe fn platform_display(&self) -> *mut libc::c_void {
|
|
|
|
self.window.platform_display()
|
|
|
|
}
|
|
|
|
|
2015-09-26 02:04:55 +10:00
|
|
|
/// DEPRECATED. Gets the native platform specific window handle. This is
|
2015-02-21 07:32:40 +11:00
|
|
|
/// typically only required when integrating with other libraries
|
|
|
|
/// that need this information.
|
|
|
|
#[inline]
|
|
|
|
pub unsafe fn platform_window(&self) -> *mut libc::c_void {
|
|
|
|
self.window.platform_window()
|
|
|
|
}
|
|
|
|
|
2015-02-16 19:29:37 +11:00
|
|
|
/// Returns the API that is currently provided by this window.
|
|
|
|
///
|
|
|
|
/// - On Windows and OS/X, this always returns `OpenGl`.
|
|
|
|
/// - On Android, this always returns `OpenGlEs`.
|
|
|
|
/// - On Linux, it must be checked at runtime.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn get_api(&self) -> Api {
|
|
|
|
self.window.get_api()
|
|
|
|
}
|
|
|
|
|
2015-04-11 17:06:08 +10:00
|
|
|
/// Returns the pixel format of this window.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-04-11 17:06:08 +10:00
|
|
|
pub fn get_pixel_format(&self) -> PixelFormat {
|
|
|
|
self.window.get_pixel_format()
|
|
|
|
}
|
|
|
|
|
2015-02-16 19:29:37 +11:00
|
|
|
/// Create a window proxy for this window, that can be freely
|
|
|
|
/// passed to different threads.
|
|
|
|
#[inline]
|
|
|
|
pub fn create_window_proxy(&self) -> WindowProxy {
|
|
|
|
WindowProxy {
|
|
|
|
proxy: self.window.create_window_proxy()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Sets a resize callback that is called by Mac (and potentially other
|
|
|
|
/// operating systems) during resize operations. This can be used to repaint
|
|
|
|
/// during window resizing.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn set_window_resize_callback(&mut self, callback: Option<fn(u32, u32)>) {
|
|
|
|
self.window.set_window_resize_callback(callback);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Modifies the mouse cursor of the window.
|
|
|
|
/// Has no effect on Android.
|
|
|
|
pub fn set_cursor(&self, cursor: MouseCursor) {
|
|
|
|
self.window.set_cursor(cursor);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the ratio between the backing framebuffer resolution and the
|
|
|
|
/// window size in screen pixels. This is typically one for a normal display
|
|
|
|
/// and two for a retina display.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn hidpi_factor(&self) -> f32 {
|
|
|
|
self.window.hidpi_factor()
|
|
|
|
}
|
2015-03-10 20:29:07 +11:00
|
|
|
|
|
|
|
/// Changes the position of the cursor in window coordinates.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-03-10 20:29:07 +11:00
|
|
|
pub fn set_cursor_position(&self, x: i32, y: i32) -> Result<(), ()> {
|
|
|
|
self.window.set_cursor_position(x, y)
|
|
|
|
}
|
2015-01-25 22:06:50 +11:00
|
|
|
|
2015-03-27 03:04:01 +11:00
|
|
|
/// Sets how glutin handles the cursor. See the documentation of `CursorState` for details.
|
|
|
|
///
|
2015-01-25 22:06:50 +11:00
|
|
|
/// Has no effect on Android.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-03-27 03:04:01 +11:00
|
|
|
pub fn set_cursor_state(&self, state: CursorState) -> Result<(), String> {
|
|
|
|
self.window.set_cursor_state(state)
|
2015-01-25 22:06:50 +11:00
|
|
|
}
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
2015-04-30 21:23:37 +10:00
|
|
|
impl GlContext for Window {
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-06-16 18:15:31 +10:00
|
|
|
unsafe fn make_current(&self) -> Result<(), ContextError> {
|
2015-04-30 21:23:37 +10:00
|
|
|
self.make_current()
|
|
|
|
}
|
|
|
|
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-04-30 21:23:37 +10:00
|
|
|
fn is_current(&self) -> bool {
|
|
|
|
self.is_current()
|
|
|
|
}
|
|
|
|
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-11-04 21:27:50 +11:00
|
|
|
fn get_proc_address(&self, addr: &str) -> *const () {
|
2015-04-30 21:23:37 +10:00
|
|
|
self.get_proc_address(addr)
|
|
|
|
}
|
|
|
|
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-06-16 18:15:31 +10:00
|
|
|
fn swap_buffers(&self) -> Result<(), ContextError> {
|
2015-04-30 21:23:37 +10:00
|
|
|
self.swap_buffers()
|
|
|
|
}
|
|
|
|
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-04-30 21:23:37 +10:00
|
|
|
fn get_api(&self) -> Api {
|
|
|
|
self.get_api()
|
|
|
|
}
|
|
|
|
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-04-30 21:23:37 +10:00
|
|
|
fn get_pixel_format(&self) -> PixelFormat {
|
|
|
|
self.get_pixel_format()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-16 19:29:37 +11:00
|
|
|
/// Represents a thread safe subset of operations that can be called
|
|
|
|
/// on a window. This structure can be safely cloned and sent between
|
|
|
|
/// threads.
|
|
|
|
#[derive(Clone)]
|
|
|
|
pub struct WindowProxy {
|
2015-04-02 17:27:32 +11:00
|
|
|
proxy: platform::WindowProxy,
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
impl WindowProxy {
|
|
|
|
/// Triggers a blocked event loop to wake up. This is
|
|
|
|
/// typically called when another thread wants to wake
|
|
|
|
/// up the blocked rendering thread to cause a refresh.
|
|
|
|
#[inline]
|
|
|
|
pub fn wakeup_event_loop(&self) {
|
|
|
|
self.proxy.wakeup_event_loop();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/// An iterator for the `poll_events` function.
|
2015-04-02 17:27:32 +11:00
|
|
|
pub struct PollEventsIterator<'a>(platform::PollEventsIterator<'a>);
|
2015-02-16 19:29:37 +11:00
|
|
|
|
|
|
|
impl<'a> Iterator for PollEventsIterator<'a> {
|
|
|
|
type Item = Event;
|
2015-03-16 23:50:23 +11:00
|
|
|
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
fn next(&mut self) -> Option<Event> {
|
|
|
|
self.0.next()
|
|
|
|
}
|
2015-03-16 23:50:23 +11:00
|
|
|
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-03-16 23:50:23 +11:00
|
|
|
fn size_hint(&self) -> (usize, Option<usize>) {
|
|
|
|
self.0.size_hint()
|
|
|
|
}
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
/// An iterator for the `wait_events` function.
|
2015-04-02 17:27:32 +11:00
|
|
|
pub struct WaitEventsIterator<'a>(platform::WaitEventsIterator<'a>);
|
2015-02-16 19:29:37 +11:00
|
|
|
|
|
|
|
impl<'a> Iterator for WaitEventsIterator<'a> {
|
|
|
|
type Item = Event;
|
2015-03-16 23:50:23 +11:00
|
|
|
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
fn next(&mut self) -> Option<Event> {
|
|
|
|
self.0.next()
|
|
|
|
}
|
2015-03-16 23:50:23 +11:00
|
|
|
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-03-16 23:50:23 +11:00
|
|
|
fn size_hint(&self) -> (usize, Option<usize>) {
|
|
|
|
self.0.size_hint()
|
|
|
|
}
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
/// An iterator for the list of available monitors.
|
|
|
|
// Implementation note: we retreive the list once, then serve each element by one by one.
|
|
|
|
// This may change in the future.
|
|
|
|
pub struct AvailableMonitorsIter {
|
2015-09-24 17:11:59 +10:00
|
|
|
data: VecDequeIter<platform::MonitorId>,
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Iterator for AvailableMonitorsIter {
|
2015-09-24 17:11:59 +10:00
|
|
|
type Item = MonitorId;
|
2015-03-16 23:50:23 +11:00
|
|
|
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-09-24 17:11:59 +10:00
|
|
|
fn next(&mut self) -> Option<MonitorId> {
|
|
|
|
self.data.next().map(|id| MonitorId(id))
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
2015-03-16 23:50:23 +11:00
|
|
|
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-03-16 23:50:23 +11:00
|
|
|
fn size_hint(&self) -> (usize, Option<usize>) {
|
|
|
|
self.data.size_hint()
|
|
|
|
}
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the list of all available monitors.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn get_available_monitors() -> AvailableMonitorsIter {
|
2015-04-02 17:27:32 +11:00
|
|
|
let data = platform::get_available_monitors();
|
2015-02-16 19:29:37 +11:00
|
|
|
AvailableMonitorsIter{ data: data.into_iter() }
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the primary monitor of the system.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-09-24 17:11:59 +10:00
|
|
|
pub fn get_primary_monitor() -> MonitorId {
|
|
|
|
MonitorId(platform::get_primary_monitor())
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Identifier for a monitor.
|
2015-09-24 17:11:59 +10:00
|
|
|
pub struct MonitorId(platform::MonitorId);
|
2015-02-16 19:29:37 +11:00
|
|
|
|
2015-09-24 17:11:59 +10:00
|
|
|
impl MonitorId {
|
2015-02-16 19:29:37 +11:00
|
|
|
/// Returns a human-readable name of the monitor.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn get_name(&self) -> Option<String> {
|
2015-09-24 17:11:59 +10:00
|
|
|
let &MonitorId(ref id) = self;
|
2015-02-16 19:29:37 +11:00
|
|
|
id.get_name()
|
|
|
|
}
|
|
|
|
|
2015-03-17 07:52:58 +11:00
|
|
|
/// Returns the native platform identifier for this monitor.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-03-19 08:16:35 +11:00
|
|
|
pub fn get_native_identifier(&self) -> NativeMonitorId {
|
2015-09-24 17:11:59 +10:00
|
|
|
let &MonitorId(ref id) = self;
|
2015-03-17 07:52:58 +11:00
|
|
|
id.get_native_identifier()
|
|
|
|
}
|
|
|
|
|
2015-02-16 19:29:37 +11:00
|
|
|
/// Returns the number of pixels currently displayed on the monitor.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn get_dimensions(&self) -> (u32, u32) {
|
2015-09-24 17:11:59 +10:00
|
|
|
let &MonitorId(ref id) = self;
|
2015-02-16 19:29:37 +11:00
|
|
|
id.get_dimensions()
|
|
|
|
}
|
|
|
|
}
|