2015-02-21 23:59:37 +11:00
|
|
|
use std::collections::vec_deque::IntoIter as VecDequeIter;
|
2015-02-16 19:29:37 +11:00
|
|
|
|
2018-06-15 09:42:18 +10:00
|
|
|
use {
|
|
|
|
CreationError,
|
|
|
|
EventsLoop,
|
|
|
|
Icon,
|
|
|
|
LogicalPosition,
|
|
|
|
LogicalSize,
|
|
|
|
MouseCursor,
|
|
|
|
PhysicalPosition,
|
|
|
|
PhysicalSize,
|
|
|
|
platform,
|
|
|
|
Window,
|
|
|
|
WindowBuilder,
|
|
|
|
WindowId,
|
|
|
|
};
|
2015-02-16 19:29:37 +11:00
|
|
|
|
2016-02-23 22:56:23 +11:00
|
|
|
impl WindowBuilder {
|
2015-02-16 19:29:37 +11:00
|
|
|
/// Initializes a new `WindowBuilder` with default values.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2016-02-23 22:56:23 +11:00
|
|
|
pub fn new() -> WindowBuilder {
|
2015-02-16 19:29:37 +11:00
|
|
|
WindowBuilder {
|
2015-09-21 21:15:43 +10:00
|
|
|
window: Default::default(),
|
2016-01-08 02:01:18 +11:00
|
|
|
platform_specific: Default::default(),
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Requests the window to be of specific dimensions.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn with_dimensions(mut self, size: LogicalSize) -> WindowBuilder {
|
|
|
|
self.window.dimensions = Some(size);
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
2017-06-22 05:10:23 +10:00
|
|
|
|
2015-11-09 20:42:54 +11:00
|
|
|
/// Sets a minimum dimension size for the window
|
|
|
|
#[inline]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn with_min_dimensions(mut self, min_size: LogicalSize) -> WindowBuilder {
|
|
|
|
self.window.min_dimensions = Some(min_size);
|
2015-11-09 20:42:54 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Sets a maximum dimension size for the window
|
|
|
|
#[inline]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn with_max_dimensions(mut self, max_size: LogicalSize) -> WindowBuilder {
|
|
|
|
self.window.max_dimensions = Some(max_size);
|
2015-11-09 20:42:54 +11:00
|
|
|
self
|
|
|
|
}
|
2015-02-16 19:29:37 +11:00
|
|
|
|
2018-06-03 00:51:24 +10:00
|
|
|
/// Sets whether the window is resizable or not
|
|
|
|
///
|
2018-06-12 08:47:50 +10:00
|
|
|
/// Note that making the window unresizable doesn't exempt you from handling `Resized`, as that event can still be
|
|
|
|
/// triggered by DPI scaling, entering fullscreen mode, etc.
|
|
|
|
///
|
2018-06-03 00:51:24 +10:00
|
|
|
/// ## Platform-specific
|
|
|
|
///
|
2018-06-12 08:47:50 +10:00
|
|
|
/// This only has an effect on desktop platforms.
|
|
|
|
///
|
|
|
|
/// Due to a bug in XFCE, this has no effect on Xfwm.
|
2018-06-03 00:51:24 +10:00
|
|
|
#[inline]
|
|
|
|
pub fn with_resizable(mut self, resizable: bool) -> WindowBuilder {
|
|
|
|
self.window.resizable = resizable;
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2015-02-16 19:29:37 +11:00
|
|
|
/// Requests a specific title for the window.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2016-09-20 02:53:28 +10:00
|
|
|
pub fn with_title<T: Into<String>>(mut self, title: T) -> WindowBuilder {
|
2016-05-08 17:28:42 +10:00
|
|
|
self.window.title = title.into();
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2017-09-07 18:33:46 +10:00
|
|
|
/// Sets the window fullscreen state. None means a normal window, Some(MonitorId)
|
|
|
|
/// means a fullscreen window on that specific monitor
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2017-09-07 18:33:46 +10:00
|
|
|
pub fn with_fullscreen(mut self, monitor: Option<MonitorId>) -> WindowBuilder {
|
|
|
|
self.window.fullscreen = monitor;
|
2015-02-16 19:29:37 +11:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2017-08-28 09:19:26 +10:00
|
|
|
/// Requests maximized mode.
|
|
|
|
#[inline]
|
|
|
|
pub fn with_maximized(mut self, maximized: bool) -> WindowBuilder {
|
|
|
|
self.window.maximized = maximized;
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2015-02-16 19:29:37 +11:00
|
|
|
/// Sets whether the window will be initially hidden or visible.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2016-02-23 22:56:23 +11:00
|
|
|
pub fn with_visibility(mut self, visible: bool) -> WindowBuilder {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.window.visible = visible;
|
2015-02-16 19:29:37 +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]
|
2016-02-23 22:56:23 +11:00
|
|
|
pub fn with_transparency(mut self, transparent: bool) -> WindowBuilder {
|
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]
|
2016-02-23 22:56:23 +11:00
|
|
|
pub fn with_decorations(mut self, decorations: bool) -> WindowBuilder {
|
2015-09-21 21:15:43 +10:00
|
|
|
self.window.decorations = decorations;
|
2015-05-15 23:19:33 +10:00
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2018-05-21 00:24:05 +10:00
|
|
|
/// Sets whether or not the window will always be on top of other windows.
|
|
|
|
#[inline]
|
|
|
|
pub fn with_always_on_top(mut self, always_on_top: bool) -> WindowBuilder {
|
|
|
|
self.window.always_on_top = always_on_top;
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2018-05-08 07:36:21 +10:00
|
|
|
/// Sets the window icon. On Windows and X11, this is typically the small icon in the top-left
|
|
|
|
/// corner of the titlebar.
|
|
|
|
///
|
|
|
|
/// ## Platform-specific
|
|
|
|
///
|
|
|
|
/// This only has an effect on Windows and X11.
|
|
|
|
///
|
|
|
|
/// On Windows, this sets `ICON_SMALL`. The base size for a window icon is 16x16, but it's
|
|
|
|
/// recommended to account for screen scaling and pick a multiple of that, i.e. 32x32.
|
|
|
|
///
|
|
|
|
/// X11 has no universal guidelines for icon sizes, so you're at the whims of the WM. That
|
|
|
|
/// said, it's usually in the same ballpark as on Windows.
|
|
|
|
#[inline]
|
|
|
|
pub fn with_window_icon(mut self, window_icon: Option<Icon>) -> WindowBuilder {
|
|
|
|
self.window.window_icon = window_icon;
|
|
|
|
self
|
|
|
|
}
|
|
|
|
|
2017-10-17 22:56:38 +11:00
|
|
|
/// Enables multitouch.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2016-02-23 22:56:23 +11:00
|
|
|
pub fn with_multitouch(mut self) -> WindowBuilder {
|
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.
|
2018-06-15 09:42:18 +10:00
|
|
|
#[inline]
|
2017-01-29 01:00:17 +11:00
|
|
|
pub fn build(mut self, events_loop: &EventsLoop) -> Result<Window, CreationError> {
|
2018-05-08 07:36:21 +10:00
|
|
|
self.window.dimensions = Some(self.window.dimensions.unwrap_or_else(|| {
|
2017-09-07 18:33:46 +10:00
|
|
|
if let Some(ref monitor) = self.window.fullscreen {
|
2018-05-08 07:36:21 +10:00
|
|
|
// resizing the window to the dimensions of the monitor when fullscreen
|
2018-06-15 09:42:18 +10:00
|
|
|
LogicalSize::from_physical(monitor.get_dimensions(), 1.0)
|
2018-05-08 07:36:21 +10:00
|
|
|
} else {
|
|
|
|
// default dimensions
|
2018-06-15 09:42:18 +10:00
|
|
|
(1024, 768).into()
|
2017-08-28 09:22:26 +10:00
|
|
|
}
|
2018-05-08 07:36:21 +10:00
|
|
|
}));
|
2015-02-16 19:29:37 +11:00
|
|
|
|
|
|
|
// building
|
2018-05-08 07:36:21 +10:00
|
|
|
platform::Window::new(
|
|
|
|
&events_loop.events_loop,
|
|
|
|
self.window,
|
|
|
|
self.platform_specific,
|
|
|
|
).map(|window| Window { window })
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Window {
|
2017-05-11 10:10:07 +10:00
|
|
|
/// Creates a new Window for platforms where this is appropriate.
|
2015-02-16 19:29:37 +11:00
|
|
|
///
|
2017-01-29 01:33:54 +11:00
|
|
|
/// This function is equivalent to `WindowBuilder::new().build(events_loop)`.
|
2015-02-16 19:29:37 +11:00
|
|
|
///
|
|
|
|
/// Error should be very rare and only occur in case of permission denied, incompatible system,
|
|
|
|
/// out of memory, etc.
|
|
|
|
#[inline]
|
2017-01-29 01:00:17 +11:00
|
|
|
pub fn new(events_loop: &EventsLoop) -> Result<Window, CreationError> {
|
2015-02-16 19:29:37 +11:00
|
|
|
let builder = WindowBuilder::new();
|
2017-01-29 01:00:17 +11:00
|
|
|
builder.build(events_loop)
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
/// 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]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn get_position(&self) -> Option<LogicalPosition> {
|
2015-02-16 19:29:37 +11:00
|
|
|
self.window.get_position()
|
|
|
|
}
|
|
|
|
|
2018-04-17 11:40:30 +10:00
|
|
|
/// Returns the position of the top-left hand corner of the window's client area relative to the
|
|
|
|
/// top-left hand corner of the desktop.
|
|
|
|
///
|
|
|
|
/// The same conditions that apply to `get_position` apply to this method.
|
|
|
|
#[inline]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn get_inner_position(&self) -> Option<LogicalPosition> {
|
2018-04-17 11:40:30 +10:00
|
|
|
self.window.get_inner_position()
|
|
|
|
}
|
|
|
|
|
2015-02-16 19:29:37 +11:00
|
|
|
/// Modifies the position of the window.
|
|
|
|
///
|
2017-10-17 22:56:38 +11:00
|
|
|
/// See `get_position` for more information about the coordinates.
|
2015-02-16 19:29:37 +11:00
|
|
|
///
|
|
|
|
/// This is a no-op if the window has already been closed.
|
|
|
|
#[inline]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn set_position(&self, position: LogicalPosition) {
|
|
|
|
self.window.set_position(position)
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
2018-06-15 09:42:18 +10:00
|
|
|
/// Returns the logical size of the window's client area.
|
2015-07-25 21:57:52 +10:00
|
|
|
///
|
|
|
|
/// The client area is the content of the window, excluding the title bar and borders.
|
2015-02-16 19:29:37 +11:00
|
|
|
///
|
2018-06-15 09:42:18 +10:00
|
|
|
/// Converting the returned `LogicalSize` to `PhysicalSize` produces the size your framebuffer should be.
|
2015-07-25 21:40:33 +10:00
|
|
|
///
|
|
|
|
/// Returns `None` if the window no longer exists.
|
|
|
|
#[inline]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn get_inner_size(&self) -> Option<LogicalSize> {
|
2017-10-17 22:56:38 +11:00
|
|
|
self.window.get_inner_size()
|
2015-07-25 21:40:33 +10:00
|
|
|
}
|
|
|
|
|
2018-06-15 09:42:18 +10:00
|
|
|
/// Returns the logical size of the entire window.
|
2015-02-16 19:29:37 +11:00
|
|
|
///
|
2018-06-15 09:42:18 +10:00
|
|
|
/// These dimensions include the title bar and borders. If you don't want that (and you usually don't),
|
|
|
|
/// use `get_inner_size` instead.
|
2015-02-16 19:29:37 +11:00
|
|
|
///
|
|
|
|
/// Returns `None` if the window no longer exists.
|
|
|
|
#[inline]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn get_outer_size(&self) -> Option<LogicalSize> {
|
2015-02-16 19:29:37 +11:00
|
|
|
self.window.get_outer_size()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Modifies the inner size of the window.
|
|
|
|
///
|
2017-10-17 22:56:38 +11:00
|
|
|
/// See `get_inner_size` for more information about the values.
|
2015-02-16 19:29:37 +11:00
|
|
|
///
|
|
|
|
/// This is a no-op if the window has already been closed.
|
|
|
|
#[inline]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn set_inner_size(&self, size: LogicalSize) {
|
|
|
|
self.window.set_inner_size(size)
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
2018-03-23 20:35:35 +11:00
|
|
|
/// Sets a minimum dimension size for the window.
|
|
|
|
#[inline]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn set_min_dimensions(&self, dimensions: Option<LogicalSize>) {
|
2018-03-23 20:35:35 +11:00
|
|
|
self.window.set_min_dimensions(dimensions)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Sets a maximum dimension size for the window.
|
|
|
|
#[inline]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn set_max_dimensions(&self, dimensions: Option<LogicalSize>) {
|
2018-03-23 20:35:35 +11:00
|
|
|
self.window.set_max_dimensions(dimensions)
|
|
|
|
}
|
|
|
|
|
2018-06-12 08:47:50 +10:00
|
|
|
/// Sets whether the window is resizable or not.
|
|
|
|
///
|
|
|
|
/// Note that making the window unresizable doesn't exempt you from handling `Resized`, as that event can still be
|
|
|
|
/// triggered by DPI scaling, entering fullscreen mode, etc.
|
|
|
|
///
|
|
|
|
/// ## Platform-specific
|
|
|
|
///
|
|
|
|
/// This only has an effect on desktop platforms.
|
|
|
|
///
|
|
|
|
/// Due to a bug in XFCE, this has no effect on Xfwm.
|
|
|
|
#[inline]
|
|
|
|
pub fn set_resizable(&self, resizable: bool) {
|
|
|
|
self.window.set_resizable(resizable)
|
|
|
|
}
|
|
|
|
|
2018-06-15 09:42:18 +10:00
|
|
|
/// Returns the DPI factor that can be used to map logical pixels to physical pixels, and vice versa.
|
|
|
|
///
|
|
|
|
/// See the [`dpi`](dpi/index.html) module for more information.
|
|
|
|
///
|
2018-07-17 00:44:29 +10:00
|
|
|
/// Note that this value can change depending on user action (for example if the window is
|
|
|
|
/// moved to another screen); as such, tracking `WindowEvent::HiDpiFactorChanged` events is
|
|
|
|
/// the most robust way to track the DPI you need to use to draw.
|
|
|
|
///
|
2018-06-15 09:42:18 +10:00
|
|
|
/// ## Platform-specific
|
|
|
|
///
|
|
|
|
/// - **X11:** Can be overridden using the `WINIT_HIDPI_FACTOR` environment variable.
|
|
|
|
/// - **Android:** Always returns 1.0.
|
2015-02-21 07:32:40 +11:00
|
|
|
#[inline]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn get_hidpi_factor(&self) -> f64 {
|
|
|
|
self.window.get_hidpi_factor()
|
2015-02-21 07:32:40 +11:00
|
|
|
}
|
|
|
|
|
2015-02-16 19:29:37 +11:00
|
|
|
/// Modifies the mouse cursor of the window.
|
|
|
|
/// Has no effect on Android.
|
2018-06-15 09:42:18 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn set_cursor(&self, cursor: MouseCursor) {
|
|
|
|
self.window.set_cursor(cursor);
|
|
|
|
}
|
|
|
|
|
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]
|
2018-06-20 00:30:15 +10:00
|
|
|
pub fn set_cursor_position(&self, position: LogicalPosition) -> Result<(), String> {
|
2018-06-15 09:42:18 +10:00
|
|
|
self.window.set_cursor_position(position)
|
2015-03-10 20:29:07 +11:00
|
|
|
}
|
2015-01-25 22:06:50 +11:00
|
|
|
|
2018-06-19 02:32:18 +10:00
|
|
|
/// Grabs the cursor, preventing it from leaving the window.
|
2015-03-27 03:04:01 +11:00
|
|
|
///
|
2018-06-19 02:32:18 +10:00
|
|
|
/// ## Platform-specific
|
|
|
|
///
|
|
|
|
/// On macOS, this presently merely locks the cursor in a fixed location, which looks visually awkward.
|
|
|
|
///
|
|
|
|
/// This has no effect on Android or iOS.
|
|
|
|
#[inline]
|
|
|
|
pub fn grab_cursor(&self, grab: bool) -> Result<(), String> {
|
|
|
|
self.window.grab_cursor(grab)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Hides the cursor, making it invisible but still usable.
|
|
|
|
///
|
|
|
|
/// ## Platform-specific
|
|
|
|
///
|
|
|
|
/// On Windows and X11, the cursor is only hidden within the confines of the window.
|
|
|
|
///
|
|
|
|
/// On macOS, the cursor is hidden as long as the window has input focus, even if the cursor is outside of the
|
|
|
|
/// window.
|
|
|
|
///
|
|
|
|
/// This has no effect on Android or iOS.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2018-06-19 02:32:18 +10:00
|
|
|
pub fn hide_cursor(&self, hide: bool) {
|
|
|
|
self.window.hide_cursor(hide)
|
2015-01-25 22:06:50 +11:00
|
|
|
}
|
2017-01-29 01:05:36 +11:00
|
|
|
|
2017-08-28 09:19:26 +10:00
|
|
|
/// Sets the window to maximized or back
|
|
|
|
#[inline]
|
|
|
|
pub fn set_maximized(&self, maximized: bool) {
|
|
|
|
self.window.set_maximized(maximized)
|
|
|
|
}
|
|
|
|
|
2017-08-28 09:22:26 +10:00
|
|
|
/// Sets the window to fullscreen or back
|
|
|
|
#[inline]
|
2017-09-07 18:33:46 +10:00
|
|
|
pub fn set_fullscreen(&self, monitor: Option<MonitorId>) {
|
|
|
|
self.window.set_fullscreen(monitor)
|
|
|
|
}
|
|
|
|
|
2017-12-22 23:50:46 +11:00
|
|
|
/// Turn window decorations on or off.
|
|
|
|
#[inline]
|
|
|
|
pub fn set_decorations(&self, decorations: bool) {
|
|
|
|
self.window.set_decorations(decorations)
|
|
|
|
}
|
|
|
|
|
2018-05-21 00:24:05 +10:00
|
|
|
/// Change whether or not the window will always be on top of other windows.
|
|
|
|
#[inline]
|
|
|
|
pub fn set_always_on_top(&self, always_on_top: bool) {
|
|
|
|
self.window.set_always_on_top(always_on_top)
|
|
|
|
}
|
|
|
|
|
2018-05-08 07:36:21 +10:00
|
|
|
/// Sets the window icon. On Windows and X11, this is typically the small icon in the top-left
|
|
|
|
/// corner of the titlebar.
|
|
|
|
///
|
|
|
|
/// For more usage notes, see `WindowBuilder::with_window_icon`.
|
|
|
|
///
|
|
|
|
/// ## Platform-specific
|
|
|
|
///
|
|
|
|
/// This only has an effect on Windows and X11.
|
|
|
|
#[inline]
|
|
|
|
pub fn set_window_icon(&self, window_icon: Option<Icon>) {
|
|
|
|
self.window.set_window_icon(window_icon)
|
|
|
|
}
|
|
|
|
|
2018-05-21 00:47:22 +10:00
|
|
|
/// Sets location of IME candidate box in client area coordinates relative to the top left.
|
2018-05-18 11:28:30 +10:00
|
|
|
#[inline]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn set_ime_spot(&self, position: LogicalPosition) {
|
|
|
|
self.window.set_ime_spot(position)
|
2018-05-18 11:28:30 +10:00
|
|
|
}
|
|
|
|
|
2018-04-14 04:51:10 +10:00
|
|
|
/// Returns the monitor on which the window currently resides
|
2018-06-15 09:42:18 +10:00
|
|
|
#[inline]
|
2017-09-07 18:33:46 +10:00
|
|
|
pub fn get_current_monitor(&self) -> MonitorId {
|
|
|
|
self.window.get_current_monitor()
|
2017-08-28 09:22:26 +10:00
|
|
|
}
|
|
|
|
|
2018-06-17 00:14:12 +10:00
|
|
|
/// Returns the list of all the monitors available on the system.
|
|
|
|
///
|
|
|
|
/// This is the same as `EventsLoop::get_available_monitors`, and is provided for convenience.
|
|
|
|
#[inline]
|
|
|
|
pub fn get_available_monitors(&self) -> AvailableMonitorsIter {
|
|
|
|
let data = self.window.get_available_monitors();
|
|
|
|
AvailableMonitorsIter { data: data.into_iter() }
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the primary monitor of the system.
|
|
|
|
///
|
|
|
|
/// This is the same as `EventsLoop::get_primary_monitor`, and is provided for convenience.
|
|
|
|
#[inline]
|
|
|
|
pub fn get_primary_monitor(&self) -> MonitorId {
|
|
|
|
MonitorId { inner: self.window.get_primary_monitor() }
|
|
|
|
}
|
|
|
|
|
2017-01-29 01:05:36 +11:00
|
|
|
#[inline]
|
2017-02-03 19:13:11 +11:00
|
|
|
pub fn id(&self) -> WindowId {
|
|
|
|
WindowId(self.window.id())
|
2017-01-29 01:05:36 +11:00
|
|
|
}
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
/// An iterator for the list of available monitors.
|
2017-10-17 22:56:38 +11:00
|
|
|
// Implementation note: we retrieve the list once, then serve each element by one by one.
|
2015-02-16 19:29:37 +11:00
|
|
|
// This may change in the future.
|
2018-06-17 00:14:12 +10:00
|
|
|
#[derive(Debug)]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub struct AvailableMonitorsIter {
|
2017-09-01 19:04:57 +10:00
|
|
|
pub(crate) 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> {
|
2017-08-30 16:49:18 +10:00
|
|
|
self.data.next().map(|id| MonitorId { inner: 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
|
|
|
}
|
|
|
|
|
|
|
|
/// Identifier for a monitor.
|
2018-05-14 22:14:57 +10:00
|
|
|
#[derive(Debug, Clone)]
|
2017-08-30 16:49:18 +10:00
|
|
|
pub struct MonitorId {
|
|
|
|
pub(crate) inner: 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.
|
2017-08-30 16:49:18 +10:00
|
|
|
///
|
|
|
|
/// Returns `None` if the monitor doesn't exist anymore.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2015-02-16 19:29:37 +11:00
|
|
|
pub fn get_name(&self) -> Option<String> {
|
2017-08-30 16:49:18 +10:00
|
|
|
self.inner.get_name()
|
2015-03-17 07:52:58 +11:00
|
|
|
}
|
|
|
|
|
2018-06-15 09:42:18 +10:00
|
|
|
/// Returns the monitor's resolution.
|
2015-09-21 22:42:05 +10:00
|
|
|
#[inline]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn get_dimensions(&self) -> PhysicalSize {
|
2017-08-30 16:49:18 +10:00
|
|
|
self.inner.get_dimensions()
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|
2017-09-07 18:33:46 +10:00
|
|
|
|
|
|
|
/// Returns the top-left corner position of the monitor relative to the larger full
|
|
|
|
/// screen area.
|
|
|
|
#[inline]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn get_position(&self) -> PhysicalPosition {
|
2017-09-07 18:33:46 +10:00
|
|
|
self.inner.get_position()
|
|
|
|
}
|
2017-10-17 22:56:38 +11:00
|
|
|
|
2018-06-15 09:42:18 +10:00
|
|
|
/// Returns the DPI factor that can be used to map logical pixels to physical pixels, and vice versa.
|
|
|
|
///
|
|
|
|
/// See the [`dpi`](dpi/index.html) module for more information.
|
2018-06-04 02:41:47 +10:00
|
|
|
///
|
|
|
|
/// ## Platform-specific
|
2018-06-15 09:42:18 +10:00
|
|
|
///
|
|
|
|
/// - **X11:** Can be overridden using the `WINIT_HIDPI_FACTOR` environment variable.
|
|
|
|
/// - **Android:** Always returns 1.0.
|
2017-10-17 22:56:38 +11:00
|
|
|
#[inline]
|
2018-06-15 09:42:18 +10:00
|
|
|
pub fn get_hidpi_factor(&self) -> f64 {
|
2017-10-17 22:56:38 +11:00
|
|
|
self.inner.get_hidpi_factor()
|
|
|
|
}
|
2015-02-16 19:29:37 +11:00
|
|
|
}
|