2019-02-06 02:30:33 +11:00
//! The `Window` struct and associated types.
2019-05-30 11:29:54 +10:00
use std ::fmt ;
2019-02-06 02:30:33 +11:00
2019-06-22 01:33:15 +10:00
use crate ::{
dpi ::{ LogicalPosition , LogicalSize } ,
error ::{ ExternalError , NotSupportedError , OsError } ,
event_loop ::EventLoopWindowTarget ,
2019-07-30 04:16:14 +10:00
monitor ::{ AvailableMonitorsIter , MonitorHandle , VideoMode } ,
2019-06-22 01:33:15 +10:00
platform_impl ,
} ;
2019-02-06 02:30:33 +11:00
2019-06-18 04:27:00 +10:00
pub use crate ::icon ::* ;
2019-02-06 02:30:33 +11:00
/// Represents a window.
///
/// # Example
///
/// ```no_run
2019-06-22 01:33:15 +10:00
/// use winit::{
/// event::{Event, WindowEvent},
/// event_loop::{ControlFlow, EventLoop},
/// window::Window,
/// };
2019-02-06 02:30:33 +11:00
///
/// let mut event_loop = EventLoop::new();
/// let window = Window::new(&event_loop).unwrap();
///
/// event_loop.run(move |event, _, control_flow| {
/// match event {
2019-06-22 01:33:15 +10:00
/// Event::WindowEvent {
/// event: WindowEvent::CloseRequested,
/// ..
/// } => *control_flow = ControlFlow::Exit,
2019-02-06 02:30:33 +11:00
/// _ => *control_flow = ControlFlow::Wait,
/// }
/// });
/// ```
pub struct Window {
pub ( crate ) window : platform_impl ::Window ,
}
impl fmt ::Debug for Window {
2019-06-18 04:27:00 +10:00
fn fmt ( & self , fmtr : & mut fmt ::Formatter < '_ > ) -> fmt ::Result {
2019-02-06 02:30:33 +11:00
fmtr . pad ( " Window { .. } " )
}
}
2019-07-30 04:16:14 +10:00
impl Drop for Window {
fn drop ( & mut self ) {
// If the window is in exclusive fullscreen, we must restore the desktop
// video mode (generally this would be done on application exit, but
// closing the window doesn't necessarily always mean application exit,
// such as when there are multiple windows)
if let Some ( Fullscreen ::Exclusive ( _ ) ) = self . fullscreen ( ) {
self . set_fullscreen ( None ) ;
}
}
}
2019-02-06 02:30:33 +11:00
/// Identifier of a window. Unique for each window.
///
/// Can be obtained with `window.id()`.
///
/// Whenever you receive an event specific to a window, this event contains a `WindowId` which you
/// can then compare to the ids of your windows.
#[ derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash) ]
pub struct WindowId ( pub ( crate ) platform_impl ::WindowId ) ;
impl WindowId {
/// Returns a dummy `WindowId`, useful for unit testing. The only guarantee made about the return
/// value of this function is that it will always be equal to itself and to future values returned
/// by this function. No other guarantees are made. This may be equal to a real `WindowId`.
///
/// **Passing this into a winit function will result in undefined behavior.**
pub unsafe fn dummy ( ) -> Self {
WindowId ( platform_impl ::WindowId ::dummy ( ) )
}
}
/// Object that allows you to build windows.
#[ derive(Clone) ]
pub struct WindowBuilder {
/// The attributes to use to create the window.
pub window : WindowAttributes ,
2019-06-29 05:32:27 +10:00
// Platform-specific configuration.
2019-02-06 02:30:33 +11:00
pub ( crate ) platform_specific : platform_impl ::PlatformSpecificWindowBuilderAttributes ,
}
impl fmt ::Debug for WindowBuilder {
2019-06-18 04:27:00 +10:00
fn fmt ( & self , fmtr : & mut fmt ::Formatter < '_ > ) -> fmt ::Result {
2019-02-06 02:30:33 +11:00
fmtr . debug_struct ( " WindowBuilder " )
. field ( " window " , & self . window )
. finish ( )
}
}
/// Attributes to use when creating a window.
#[ derive(Debug, Clone) ]
pub struct WindowAttributes {
/// The dimensions of the window. If this is `None`, some platform-specific dimensions will be
/// used.
///
/// The default is `None`.
2019-05-30 11:29:54 +10:00
pub inner_size : Option < LogicalSize > ,
2019-02-06 02:30:33 +11:00
/// The minimum dimensions a window can be, If this is `None`, the window will have no minimum dimensions (aside from reserved).
///
/// The default is `None`.
2019-05-30 11:29:54 +10:00
pub min_inner_size : Option < LogicalSize > ,
2015-02-16 19:29:37 +11:00
2019-02-06 02:30:33 +11:00
/// The maximum dimensions a window can be, If this is `None`, the maximum will have no maximum or will be set to the primary monitor's dimensions by the platform.
///
/// The default is `None`.
2019-05-30 11:29:54 +10:00
pub max_inner_size : Option < LogicalSize > ,
2019-02-06 02:30:33 +11:00
/// Whether the window is resizable or not.
///
/// The default is `true`.
pub resizable : bool ,
/// Whether the window should be set as fullscreen upon creation.
///
/// The default is `None`.
2019-07-30 04:16:14 +10:00
pub fullscreen : Option < Fullscreen > ,
2019-02-06 02:30:33 +11:00
/// The title of the window in the title bar.
///
/// The default is `"winit window"`.
pub title : String ,
/// Whether the window should be maximized upon creation.
///
/// The default is `false`.
pub maximized : bool ,
/// Whether the window should be immediately visible upon creation.
///
/// The default is `true`.
pub visible : bool ,
/// Whether the the window should be transparent. If this is true, writing colors
/// with alpha values different than `1.0` will produce a transparent window.
///
/// The default is `false`.
pub transparent : bool ,
/// Whether the window should have borders and bars.
///
/// The default is `true`.
pub decorations : bool ,
/// Whether the window should always be on top of other windows.
///
/// The default is `false`.
pub always_on_top : bool ,
/// The window icon.
///
/// The default is `None`.
pub window_icon : Option < Icon > ,
}
impl Default for WindowAttributes {
#[ inline ]
fn default ( ) -> WindowAttributes {
WindowAttributes {
2019-05-30 11:29:54 +10:00
inner_size : None ,
min_inner_size : None ,
max_inner_size : None ,
2019-02-06 02:30:33 +11:00
resizable : true ,
title : " winit window " . to_owned ( ) ,
maximized : false ,
fullscreen : None ,
visible : true ,
transparent : false ,
decorations : true ,
always_on_top : false ,
window_icon : None ,
}
}
}
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 ]
2019-05-30 11:29:54 +10:00
pub fn with_inner_size ( mut self , size : LogicalSize ) -> WindowBuilder {
self . window . inner_size = 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 ]
2019-05-30 11:29:54 +10:00
pub fn with_min_inner_size ( mut self , min_size : LogicalSize ) -> WindowBuilder {
self . window . min_inner_size = Some ( min_size ) ;
2015-11-09 20:42:54 +11:00
self
}
/// Sets a maximum dimension size for the window
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn with_max_inner_size ( mut self , max_size : LogicalSize ) -> WindowBuilder {
self . window . max_inner_size = 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
}
2019-07-30 04:16:14 +10:00
/// Sets the window fullscreen state. None means a normal window, Some(Fullscreen)
2017-09-07 18:33:46 +10:00
/// means a fullscreen window on that specific monitor
2019-07-29 19:18:23 +10:00
///
/// ## Platform-specific
///
/// - **Windows:** Screen saver is disabled in fullscreen mode.
2015-09-21 22:42:05 +10:00
#[ inline ]
2019-07-30 04:16:14 +10:00
pub fn with_fullscreen ( mut self , monitor : Option < Fullscreen > ) -> WindowBuilder {
2017-09-07 18:33:46 +10:00
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 ]
2019-06-13 03:34:09 +10:00
pub fn with_visible ( 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 ]
2019-06-13 03:34:09 +10:00
pub fn with_transparent ( 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
}
2015-02-16 19:29:37 +11:00
/// Builds the window.
///
2019-06-22 09:35:08 +10:00
/// Possible causes of error include denied permission, incompatible system, and lack of memory.
2018-06-15 09:42:18 +10:00
#[ inline ]
2019-06-22 01:33:15 +10:00
pub fn build < T : 'static > (
2019-07-07 03:28:50 +10:00
self ,
2019-06-22 01:33:15 +10:00
window_target : & EventLoopWindowTarget < T > ,
) -> Result < Window , OsError > {
platform_impl ::Window ::new ( & window_target . p , self . window , self . platform_specific )
. map ( | window | Window { window } )
2015-02-16 19:29:37 +11:00
}
}
2019-05-30 11:29:54 +10:00
/// Base Window functions.
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
///
2019-02-06 02:30:33 +11:00
/// This function is equivalent to `WindowBuilder::new().build(event_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 ]
2019-05-30 11:29:54 +10:00
pub fn new < T : 'static > ( event_loop : & EventLoopWindowTarget < T > ) -> Result < Window , OsError > {
2015-02-16 19:29:37 +11:00
let builder = WindowBuilder ::new ( ) ;
2019-02-06 02:30:33 +11:00
builder . build ( event_loop )
2015-02-16 19:29:37 +11:00
}
2019-05-30 11:29:54 +10:00
/// Returns an identifier unique to the window.
2015-02-16 19:29:37 +11:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn id ( & self ) -> WindowId {
WindowId ( self . window . id ( ) )
2015-02-16 19:29:37 +11:00
}
2019-05-30 11:29:54 +10:00
/// Returns the DPI factor that can be used to map logical pixels to physical pixels, and vice versa.
2015-02-16 19:29:37 +11:00
///
2019-06-26 23:35:54 +10:00
/// See the [`dpi`](../dpi/index.html) module for more information.
2015-02-16 19:29:37 +11:00
///
2019-05-30 11:29:54 +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.
2015-02-16 19:29:37 +11:00
///
/// ## Platform-specific
///
2019-05-30 11:29:54 +10:00
/// - **X11:** This respects Xft.dpi, and can be overridden using the `WINIT_HIDPI_FACTOR` environment variable.
/// - **Android:** Always returns 1.0.
/// - **iOS:** Can only be called on the main thread. Returns the underlying `UIView`'s
/// [`contentScaleFactor`].
///
/// [`contentScaleFactor`]: https://developer.apple.com/documentation/uikit/uiview/1622657-contentscalefactor?language=objc
2015-02-16 19:29:37 +11:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn hidpi_factor ( & self ) -> f64 {
self . window . hidpi_factor ( )
2015-02-16 19:29:37 +11:00
}
2019-02-06 02:30:33 +11:00
/// Emits a `WindowEvent::RedrawRequested` event in the associated event loop after all OS
/// events have been processed by the event loop.
///
2019-06-18 08:22:01 +10:00
/// This is the **strongly encouraged** method of redrawing windows, as it can integrate with
2019-02-06 02:30:33 +11:00
/// OS-requested redraws (e.g. when a window gets resized).
///
/// This function can cause `RedrawRequested` events to be emitted after `Event::EventsCleared`
/// but before `Event::NewEvents` if called in the following circumstances:
/// * While processing `EventsCleared`.
/// * While processing a `RedrawRequested` event that was sent during `EventsCleared` or any
/// directly subsequent `RedrawRequested` event.
2019-05-26 11:10:41 +10:00
///
/// ## Platform-specific
///
/// - **iOS:** Can only be called on the main thread.
2019-05-30 11:29:54 +10:00
#[ inline ]
2019-02-06 02:30:33 +11:00
pub fn request_redraw ( & self ) {
self . window . request_redraw ( )
}
2019-05-30 11:29:54 +10:00
}
/// Position and size functions.
impl Window {
/// 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 `outer_position` apply to this method.
///
/// ## Platform-specific
///
/// - **iOS:** Can only be called on the main thread. Returns the top left coordinates of the
/// window's [safe area] in the screen space coordinate system.
///
/// [safe area]: https://developer.apple.com/documentation/uikit/uiview/2891103-safeareainsets?language=objc
#[ inline ]
pub fn inner_position ( & self ) -> Result < LogicalPosition , NotSupportedError > {
self . window . inner_position ( )
}
2019-02-06 02:30:33 +11:00
2015-02-16 19:29:37 +11:00
/// 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.
///
2019-05-26 11:10:41 +10:00
/// ## Platform-specific
///
/// - **iOS:** Can only be called on the main thread. Returns the top left coordinates of the
/// window in the screen space coordinate system.
2015-02-16 19:29:37 +11:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn outer_position ( & self ) -> Result < LogicalPosition , NotSupportedError > {
self . window . outer_position ( )
2018-04-17 11:40:30 +10:00
}
2015-02-16 19:29:37 +11:00
/// Modifies the position of the window.
///
2019-05-30 11:29:54 +10:00
/// See `outer_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.
2019-05-26 11:10:41 +10:00
///
/// ## Platform-specific
///
/// - **iOS:** Can only be called on the main thread. Sets the top left coordinates of the
/// window in the screen space coordinate system.
2015-02-16 19:29:37 +11:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn set_outer_position ( & self , position : LogicalPosition ) {
self . window . set_outer_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
///
2019-05-26 11:10:41 +10:00
/// ## Platform-specific
///
/// - **iOS:** Can only be called on the main thread. Returns the `LogicalSize` of the window's
/// [safe area] in screen space coordinates.
///
2019-05-30 11:29:54 +10:00
/// [safe area]: https://developer.apple.com/documentation/uikit/uiview/2891103-safeareainsets?language=objc
2015-02-16 19:29:37 +11:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn inner_size ( & self ) -> LogicalSize {
self . window . inner_size ( )
2015-02-16 19:29:37 +11:00
}
/// Modifies the inner size of the window.
///
2019-05-30 11:29:54 +10:00
/// See `inner_size` for more information about the values.
2019-05-26 11:10:41 +10:00
///
/// ## Platform-specific
///
/// - **iOS:** Unimplemented. Currently this panics, as it's not clear what `set_inner_size`
/// would mean for iOS.
2015-02-16 19:29:37 +11:00
#[ 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
}
2019-05-30 11:29:54 +10:00
/// Returns the logical size of the entire window.
///
/// These dimensions include the title bar and borders. If you don't want that (and you usually don't),
/// use `inner_size` instead.
2019-05-26 11:10:41 +10:00
///
/// ## Platform-specific
///
2019-05-30 11:29:54 +10:00
/// - **iOS:** Can only be called on the main thread. Returns the `LogicalSize` of the window in
/// screen space coordinates.
2018-03-23 20:35:35 +11:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn outer_size ( & self ) -> LogicalSize {
self . window . outer_size ( )
2018-03-23 20:35:35 +11:00
}
2019-05-30 11:29:54 +10:00
/// Sets a minimum dimension size for the window.
2019-05-26 11:10:41 +10:00
///
/// ## Platform-specific
///
/// - **iOS:** Has no effect.
2018-03-23 20:35:35 +11:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn set_min_inner_size ( & self , dimensions : Option < LogicalSize > ) {
self . window . set_min_inner_size ( dimensions )
2018-03-23 20:35:35 +11:00
}
2019-05-30 11:29:54 +10:00
/// Sets a maximum dimension size for the window.
2019-05-26 11:10:41 +10:00
///
/// ## Platform-specific
///
/// - **iOS:** Has no effect.
2018-06-12 08:47:50 +10:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn set_max_inner_size ( & self , dimensions : Option < LogicalSize > ) {
self . window . set_max_inner_size ( dimensions )
2018-06-12 08:47:50 +10:00
}
2019-05-30 11:29:54 +10:00
}
2018-06-12 08:47:50 +10:00
2019-05-30 11:29:54 +10:00
/// Misc. attribute functions.
impl Window {
/// Modifies the title of the window.
2018-07-17 00:44:29 +10:00
///
2018-06-15 09:42:18 +10:00
/// ## Platform-specific
///
2019-05-30 11:29:54 +10:00
/// - Has no effect on iOS.
2015-02-21 07:32:40 +11:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn set_title ( & self , title : & str ) {
self . window . set_title ( title )
2015-02-21 07:32:40 +11:00
}
2019-05-30 11:29:54 +10:00
/// Modifies the window's visibility.
2019-05-26 11:10:41 +10:00
///
2019-05-30 11:29:54 +10:00
/// If `false`, this will hide the window. If `true`, this will show the window.
2019-05-26 11:10:41 +10:00
/// ## Platform-specific
///
/// - **Android:** Has no effect.
2019-05-30 11:29:54 +10:00
/// - **iOS:** Can only be called on the main thread.
2018-06-15 09:42:18 +10:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn set_visible ( & self , visible : bool ) {
self . window . set_visible ( visible )
2015-02-16 19:29:37 +11:00
}
2019-05-30 11:29:54 +10:00
/// Sets whether the window is resizable or not.
2019-05-26 11:10:41 +10:00
///
2019-05-30 11:29:54 +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.
2015-03-27 03:04:01 +11:00
///
2018-06-19 02:32:18 +10:00
/// ## Platform-specific
///
2019-05-30 11:29:54 +10:00
/// This only has an effect on desktop platforms.
///
/// Due to a bug in XFCE, this has no effect on Xfwm.
2018-06-19 02:32:18 +10:00
///
/// ## Platform-specific
///
2019-05-26 11:10:41 +10:00
/// - **iOS:** Has no effect.
2015-09-21 22:42:05 +10:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn set_resizable ( & self , resizable : bool ) {
self . window . set_resizable ( resizable )
2015-01-25 22:06:50 +11:00
}
2017-01-29 01:05:36 +11:00
2019-05-26 11:10:41 +10:00
/// Sets the window to maximized or back.
///
/// ## Platform-specific
2019-05-30 11:29:54 +10:00
///
2019-05-26 11:10:41 +10:00
/// - **iOS:** Has no effect.
2017-08-28 09:19:26 +10:00
#[ inline ]
pub fn set_maximized ( & self , maximized : bool ) {
self . window . set_maximized ( maximized )
}
2019-05-26 11:10:41 +10:00
/// Sets the window to fullscreen or back.
///
/// ## Platform-specific
2019-05-30 11:29:54 +10:00
///
2019-07-30 04:16:14 +10:00
/// - **macOS:** `Fullscreen::Exclusive` provides true exclusive mode with a
/// video mode change. *Caveat!* macOS doesn't provide task switching (or
/// spaces!) while in exclusive fullscreen mode. This mode should be used
/// when a video mode change is desired, but for a better user experience,
/// borderless fullscreen might be preferred.
///
/// `Fullscreen::Borderless` provides a borderless fullscreen window on a
/// separate space. This is the idiomatic way for fullscreen games to work
/// on macOS. See [`WindowExtMacOs::set_simple_fullscreen`][simple] if
/// separate spaces are not preferred.
///
/// The dock and the menu bar are always disabled in fullscreen mode.
2019-05-26 11:10:41 +10:00
/// - **iOS:** Can only be called on the main thread.
2019-07-30 04:16:14 +10:00
/// - **Wayland:** Does not support exclusive fullscreen mode.
2019-07-29 19:18:23 +10:00
/// - **Windows:** Screen saver is disabled in fullscreen mode.
2019-07-30 04:16:14 +10:00
///
/// [simple]:
/// ../platform/macos/trait.WindowExtMacOS.html#tymethod.set_simple_fullscreen
2017-08-28 09:22:26 +10:00
#[ inline ]
2019-07-30 04:16:14 +10:00
pub fn set_fullscreen ( & self , fullscreen : Option < Fullscreen > ) {
self . window . set_fullscreen ( fullscreen )
2017-09-07 18:33:46 +10:00
}
2019-04-26 03:09:32 +10:00
/// Gets the window's current fullscreen state.
2019-05-26 11:10:41 +10:00
///
/// ## Platform-specific
2019-05-30 11:29:54 +10:00
///
2019-05-26 11:10:41 +10:00
/// - **iOS:** Can only be called on the main thread.
2019-04-26 03:09:32 +10:00
#[ inline ]
2019-07-30 04:16:14 +10:00
pub fn fullscreen ( & self ) -> Option < Fullscreen > {
2019-05-30 11:29:54 +10:00
self . window . fullscreen ( )
2019-04-26 03:09:32 +10:00
}
2017-12-22 23:50:46 +11:00
/// Turn window decorations on or off.
2019-05-26 11:10:41 +10:00
///
/// ## Platform-specific
2019-05-30 11:29:54 +10:00
///
2019-08-09 09:10:54 +10:00
/// - **iOS:** Has no effect.
2017-12-22 23:50:46 +11:00
#[ 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.
2019-05-26 11:10:41 +10:00
///
/// ## Platform-specific
2019-05-30 11:29:54 +10:00
///
2019-05-26 11:10:41 +10:00
/// - **iOS:** Has no effect.
2018-05-21 00:24:05 +10:00
#[ 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.
2019-05-26 11:10:41 +10:00
///
/// ## Platform-specific
///
/// **iOS:** Has no effect.
2018-05-18 11:28:30 +10:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn set_ime_position ( & self , position : LogicalPosition ) {
self . window . set_ime_position ( position )
2018-05-18 11:28:30 +10:00
}
2019-05-30 11:29:54 +10:00
}
2018-05-18 11:28:30 +10:00
2019-05-30 11:29:54 +10:00
/// Cursor functions.
impl Window {
/// Modifies the cursor icon of the window.
2019-05-26 11:10:41 +10:00
///
/// ## Platform-specific
///
2019-05-30 11:29:54 +10:00
/// - **iOS:** Has no effect.
/// - **Android:** Has no effect.
2018-06-15 09:42:18 +10:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn set_cursor_icon ( & self , cursor : CursorIcon ) {
self . window . set_cursor_icon ( cursor ) ;
2017-08-28 09:22:26 +10:00
}
2019-05-30 11:29:54 +10:00
/// Changes the position of the cursor in window coordinates.
2019-05-26 11:10:41 +10:00
///
/// ## Platform-specific
///
2019-05-30 11:29:54 +10:00
/// - **iOS:** Always returns an `Err`.
2018-06-17 00:14:12 +10:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn set_cursor_position ( & self , position : LogicalPosition ) -> Result < ( ) , ExternalError > {
self . window . set_cursor_position ( position )
2018-06-17 00:14:12 +10:00
}
2019-05-30 11:29:54 +10:00
/// Grabs the cursor, preventing it from leaving the window.
2019-05-26 11:10:41 +10:00
///
/// ## Platform-specific
///
2019-05-30 11:29:54 +10:00
/// - **macOS:** This presently merely locks the cursor in a fixed location, which looks visually
/// awkward.
/// - **Android:** Has no effect.
/// - **iOS:** Always returns an Err.
2018-06-17 00:14:12 +10:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn set_cursor_grab ( & self , grab : bool ) -> Result < ( ) , ExternalError > {
self . window . set_cursor_grab ( grab )
2018-06-17 00:14:12 +10:00
}
2019-06-02 10:06:41 +10:00
/// Modifies the cursor's visibility.
///
/// If `false`, this will hide the cursor. If `true`, this will show the cursor.
2019-05-30 11:29:54 +10:00
///
/// ## Platform-specific
///
/// - **Windows:** The cursor is only hidden within the confines of the window.
/// - **X11:** The cursor is only hidden within the confines of the window.
/// - **macOS:** The cursor is hidden as long as the window has input focus, even if the cursor is
/// outside of the window.
/// - **iOS:** Has no effect.
/// - **Android:** Has no effect.
2017-01-29 01:05:36 +11:00
#[ inline ]
2019-05-30 11:29:54 +10:00
pub fn set_cursor_visible ( & self , visible : bool ) {
self . window . set_cursor_visible ( visible )
2017-01-29 01:05:36 +11:00
}
2015-02-16 19:29:37 +11:00
}
2019-05-30 11:29:54 +10:00
/// Monitor info functions.
impl Window {
/// Returns the monitor on which the window currently resides
///
/// ## Platform-specific
///
/// **iOS:** Can only be called on the main thread.
#[ inline ]
pub fn current_monitor ( & self ) -> MonitorHandle {
self . window . current_monitor ( )
2015-03-16 23:50:23 +11:00
}
2015-02-16 19:29:37 +11:00
2019-05-30 11:29:54 +10:00
/// Returns the list of all the monitors available on the system.
///
/// This is the same as `EventLoop::available_monitors`, and is provided for convenience.
///
/// ## Platform-specific
///
/// **iOS:** Can only be called on the main thread.
#[ inline ]
pub fn available_monitors ( & self ) -> AvailableMonitorsIter {
let data = self . window . available_monitors ( ) ;
2019-06-22 01:33:15 +10:00
AvailableMonitorsIter {
data : data . into_iter ( ) ,
}
2015-03-17 07:52:58 +11:00
}
2019-05-30 11:29:54 +10:00
/// Returns the primary monitor of the system.
///
/// This is the same as `EventLoop::primary_monitor`, and is provided for convenience.
///
/// ## Platform-specific
///
/// **iOS:** Can only be called on the main thread.
#[ inline ]
pub fn primary_monitor ( & self ) -> MonitorHandle {
2019-06-22 01:33:15 +10:00
MonitorHandle {
inner : self . window . primary_monitor ( ) ,
}
2015-02-16 19:29:37 +11:00
}
2019-02-06 02:30:33 +11:00
}
2017-09-07 18:33:46 +10:00
2019-08-14 21:57:16 +10:00
unsafe impl raw_window_handle ::HasRawWindowHandle for Window {
fn raw_window_handle ( & self ) -> raw_window_handle ::RawWindowHandle {
self . window . raw_window_handle ( )
}
}
2019-02-06 02:30:33 +11:00
/// Describes the appearance of the mouse cursor.
#[ derive(Debug, Copy, Clone, PartialEq, Eq, Hash) ]
#[ cfg_attr(feature = " serde " , derive(Serialize, Deserialize)) ]
2019-05-30 11:29:54 +10:00
pub enum CursorIcon {
2019-02-06 02:30:33 +11:00
/// The platform-dependent default cursor.
Default ,
/// A simple crosshair.
Crosshair ,
/// A hand (often used to indicate links in web browsers).
Hand ,
/// Self explanatory.
Arrow ,
/// Indicates something is to be moved.
Move ,
/// Indicates text that may be selected or edited.
Text ,
/// Program busy indicator.
Wait ,
/// Help indicator (often rendered as a "?")
Help ,
/// Progress indicator. Shows that processing is being done. But in contrast
/// with "Wait" the user may still interact with the program. Often rendered
/// as a spinning beach ball, or an arrow with a watch or hourglass.
Progress ,
/// Cursor showing that something cannot be done.
NotAllowed ,
ContextMenu ,
Cell ,
VerticalText ,
Alias ,
Copy ,
NoDrop ,
Grab ,
Grabbing ,
AllScroll ,
ZoomIn ,
ZoomOut ,
/// Indicate that some edge is to be moved. For example, the 'SeResize' cursor
/// is used when the movement starts from the south-east corner of the box.
EResize ,
NResize ,
NeResize ,
NwResize ,
SResize ,
SeResize ,
SwResize ,
WResize ,
EwResize ,
NsResize ,
NeswResize ,
NwseResize ,
ColResize ,
RowResize ,
}
2017-10-17 22:56:38 +11:00
2019-05-30 11:29:54 +10:00
impl Default for CursorIcon {
2019-02-06 02:30:33 +11:00
fn default ( ) -> Self {
2019-05-30 11:29:54 +10:00
CursorIcon ::Default
2017-10-17 22:56:38 +11:00
}
2015-02-16 19:29:37 +11:00
}
2019-07-30 04:16:14 +10:00
#[ derive(Clone, Debug, PartialEq) ]
pub enum Fullscreen {
Exclusive ( VideoMode ) ,
Borderless ( MonitorHandle ) ,
}