2019-02-06 02:30:33 +11:00
|
|
|
//! Types useful for interacting with a user's monitors.
|
|
|
|
//!
|
|
|
|
//! If you want to get basic information about a monitor, you can use the [`MonitorHandle`][monitor_id]
|
2019-10-06 00:49:24 +10:00
|
|
|
//! type. This is retreived from one of the following methods, which return an iterator of
|
|
|
|
//! [`MonitorHandle`][monitor_id]:
|
2019-05-30 11:29:54 +10:00
|
|
|
//! - [`EventLoop::available_monitors`][loop_get]
|
|
|
|
//! - [`Window::available_monitors`][window_get].
|
2019-02-06 02:30:33 +11:00
|
|
|
//!
|
|
|
|
//! [monitor_id]: ./struct.MonitorHandle.html
|
2019-05-30 11:29:54 +10:00
|
|
|
//! [loop_get]: ../event_loop/struct.EventLoop.html#method.available_monitors
|
|
|
|
//! [window_get]: ../window/struct.Window.html#method.available_monitors
|
2019-06-22 01:33:15 +10:00
|
|
|
use crate::{
|
|
|
|
dpi::{PhysicalPosition, PhysicalSize},
|
|
|
|
platform_impl,
|
|
|
|
};
|
2019-02-06 02:30:33 +11:00
|
|
|
|
2019-06-13 04:07:25 +10:00
|
|
|
/// Describes a fullscreen video mode of a monitor.
|
|
|
|
///
|
|
|
|
/// Can be acquired with:
|
|
|
|
/// - [`MonitorHandle::video_modes`][monitor_get].
|
|
|
|
///
|
|
|
|
/// [monitor_get]: ../monitor/struct.MonitorHandle.html#method.video_modes
|
2019-10-04 06:19:10 +10:00
|
|
|
#[derive(Clone, PartialEq, Eq, Hash)]
|
2019-06-13 04:07:25 +10:00
|
|
|
pub struct VideoMode {
|
2019-07-30 04:16:14 +10:00
|
|
|
pub(crate) video_mode: platform_impl::VideoMode,
|
|
|
|
}
|
|
|
|
|
2019-10-04 06:19:10 +10:00
|
|
|
impl std::fmt::Debug for VideoMode {
|
|
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
|
|
self.video_mode.fmt(f)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-07-30 04:16:14 +10:00
|
|
|
impl PartialOrd for VideoMode {
|
|
|
|
fn partial_cmp(&self, other: &VideoMode) -> Option<std::cmp::Ordering> {
|
|
|
|
Some(self.cmp(other))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Ord for VideoMode {
|
|
|
|
fn cmp(&self, other: &VideoMode) -> std::cmp::Ordering {
|
|
|
|
// TODO: we can impl `Ord` for `PhysicalSize` once we switch from `f32`
|
|
|
|
// to `u32` there
|
|
|
|
let size: (u32, u32) = self.size().into();
|
|
|
|
let other_size: (u32, u32) = other.size().into();
|
|
|
|
self.monitor().cmp(&other.monitor()).then(
|
|
|
|
size.cmp(&other_size)
|
|
|
|
.then(
|
|
|
|
self.refresh_rate()
|
|
|
|
.cmp(&other.refresh_rate())
|
|
|
|
.then(self.bit_depth().cmp(&other.bit_depth())),
|
|
|
|
)
|
|
|
|
.reverse(),
|
|
|
|
)
|
|
|
|
}
|
2019-06-13 04:07:25 +10:00
|
|
|
}
|
|
|
|
|
|
|
|
impl VideoMode {
|
|
|
|
/// Returns the resolution of this video mode.
|
2019-07-30 04:16:14 +10:00
|
|
|
#[inline]
|
2019-06-13 16:33:44 +10:00
|
|
|
pub fn size(&self) -> PhysicalSize {
|
2019-07-30 04:16:14 +10:00
|
|
|
self.video_mode.size()
|
2019-06-13 04:07:25 +10:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the bit depth of this video mode, as in how many bits you have
|
|
|
|
/// available per color. This is generally 24 bits or 32 bits on modern
|
|
|
|
/// systems, depending on whether the alpha channel is counted or not.
|
|
|
|
///
|
|
|
|
/// ## Platform-specific
|
|
|
|
///
|
|
|
|
/// - **Wayland:** Always returns 32.
|
|
|
|
/// - **iOS:** Always returns 32.
|
2019-07-30 04:16:14 +10:00
|
|
|
#[inline]
|
2019-06-13 04:07:25 +10:00
|
|
|
pub fn bit_depth(&self) -> u16 {
|
2019-07-30 04:16:14 +10:00
|
|
|
self.video_mode.bit_depth()
|
2019-06-13 04:07:25 +10:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the refresh rate of this video mode. **Note**: the returned
|
|
|
|
/// refresh rate is an integer approximation, and you shouldn't rely on this
|
|
|
|
/// value to be exact.
|
2019-07-30 04:16:14 +10:00
|
|
|
#[inline]
|
2019-06-13 04:07:25 +10:00
|
|
|
pub fn refresh_rate(&self) -> u16 {
|
2019-07-30 04:16:14 +10:00
|
|
|
self.video_mode.refresh_rate()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the monitor that this video mode is valid for. Each monitor has
|
|
|
|
/// a separate set of valid video modes.
|
|
|
|
#[inline]
|
|
|
|
pub fn monitor(&self) -> MonitorHandle {
|
|
|
|
self.video_mode.monitor()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl std::fmt::Display for VideoMode {
|
|
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
|
|
write!(
|
|
|
|
f,
|
|
|
|
"{}x{} @ {} Hz ({} bpp)",
|
|
|
|
self.size().width,
|
|
|
|
self.size().height,
|
|
|
|
self.refresh_rate(),
|
|
|
|
self.bit_depth()
|
|
|
|
)
|
2019-06-13 04:07:25 +10:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-02-06 02:30:33 +11:00
|
|
|
/// Handle to a monitor.
|
|
|
|
///
|
|
|
|
/// Allows you to retrieve information about a given monitor and can be used in [`Window`] creation.
|
|
|
|
///
|
|
|
|
/// [`Window`]: ../window/struct.Window.html
|
2019-07-30 04:16:14 +10:00
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
|
2019-02-06 02:30:33 +11:00
|
|
|
pub struct MonitorHandle {
|
2019-06-22 01:33:15 +10:00
|
|
|
pub(crate) inner: platform_impl::MonitorHandle,
|
2019-02-06 02:30:33 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
impl MonitorHandle {
|
|
|
|
/// Returns a human-readable name of the monitor.
|
|
|
|
///
|
|
|
|
/// Returns `None` if the monitor doesn't exist anymore.
|
2019-09-25 09:33:32 +10:00
|
|
|
///
|
|
|
|
/// ## Platform-specific
|
|
|
|
///
|
|
|
|
/// - **Web:** Always returns None
|
2019-02-06 02:30:33 +11:00
|
|
|
#[inline]
|
2019-05-30 11:29:54 +10:00
|
|
|
pub fn name(&self) -> Option<String> {
|
|
|
|
self.inner.name()
|
2019-02-06 02:30:33 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the monitor's resolution.
|
2019-09-25 09:33:32 +10:00
|
|
|
///
|
|
|
|
/// ## Platform-specific
|
|
|
|
///
|
|
|
|
/// - **Web:** Always returns (0,0)
|
2019-02-06 02:30:33 +11:00
|
|
|
#[inline]
|
2019-06-13 16:33:44 +10:00
|
|
|
pub fn size(&self) -> PhysicalSize {
|
|
|
|
self.inner.size()
|
2019-02-06 02:30:33 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the top-left corner position of the monitor relative to the larger full
|
|
|
|
/// screen area.
|
2019-09-25 09:33:32 +10:00
|
|
|
///
|
|
|
|
/// ## Platform-specific
|
|
|
|
///
|
|
|
|
/// - **Web:** Always returns (0,0)
|
2019-02-06 02:30:33 +11:00
|
|
|
#[inline]
|
2019-05-30 11:29:54 +10:00
|
|
|
pub fn position(&self) -> PhysicalPosition {
|
|
|
|
self.inner.position()
|
2019-02-06 02:30:33 +11:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the DPI factor that can be used to map logical pixels to physical pixels, and vice versa.
|
|
|
|
///
|
2019-06-26 23:35:54 +10:00
|
|
|
/// See the [`dpi`](../dpi/index.html) module for more information.
|
2019-02-06 02:30:33 +11:00
|
|
|
///
|
|
|
|
/// ## Platform-specific
|
|
|
|
///
|
|
|
|
/// - **X11:** Can be overridden using the `WINIT_HIDPI_FACTOR` environment variable.
|
|
|
|
/// - **Android:** Always returns 1.0.
|
2019-09-25 09:33:32 +10:00
|
|
|
/// - **Web:** Always returns 1.0
|
2019-02-06 02:30:33 +11:00
|
|
|
#[inline]
|
2019-05-30 11:29:54 +10:00
|
|
|
pub fn hidpi_factor(&self) -> f64 {
|
|
|
|
self.inner.hidpi_factor()
|
2019-02-06 02:30:33 +11:00
|
|
|
}
|
2019-06-13 04:07:25 +10:00
|
|
|
|
|
|
|
/// Returns all fullscreen video modes supported by this monitor.
|
2019-09-25 09:33:32 +10:00
|
|
|
///
|
|
|
|
/// ## Platform-specific
|
|
|
|
///
|
|
|
|
/// - **Web:** Always returns an empty iterator
|
2019-06-13 04:07:25 +10:00
|
|
|
#[inline]
|
|
|
|
pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
|
|
|
|
self.inner.video_modes()
|
|
|
|
}
|
2019-02-06 02:30:33 +11:00
|
|
|
}
|