pub trait Window:
AsAny
+ Send
+ Sync {
Show 57 methods
// Required methods
fn id(&self) -> WindowId;
fn scale_factor(&self) -> f64;
fn request_redraw(&self);
fn pre_present_notify(&self);
fn reset_dead_keys(&self);
fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError>;
fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError>;
fn set_outer_position(&self, position: Position);
fn surface_size(&self) -> PhysicalSize<u32>;
fn request_surface_size(&self, size: Size) -> Option<PhysicalSize<u32>>;
fn outer_size(&self) -> PhysicalSize<u32>;
fn set_min_surface_size(&self, min_size: Option<Size>);
fn set_max_surface_size(&self, max_size: Option<Size>);
fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>>;
fn set_surface_resize_increments(&self, increments: Option<Size>);
fn set_title(&self, title: &str);
fn set_transparent(&self, transparent: bool);
fn set_blur(&self, blur: bool);
fn set_visible(&self, visible: bool);
fn is_visible(&self) -> Option<bool>;
fn set_resizable(&self, resizable: bool);
fn is_resizable(&self) -> bool;
fn set_enabled_buttons(&self, buttons: WindowButtons);
fn enabled_buttons(&self) -> WindowButtons;
fn set_minimized(&self, minimized: bool);
fn is_minimized(&self) -> Option<bool>;
fn set_maximized(&self, maximized: bool);
fn is_maximized(&self) -> bool;
fn set_fullscreen(&self, fullscreen: Option<Fullscreen>);
fn fullscreen(&self) -> Option<Fullscreen>;
fn set_decorations(&self, decorations: bool);
fn is_decorated(&self) -> bool;
fn set_window_level(&self, level: WindowLevel);
fn set_window_icon(&self, window_icon: Option<Icon>);
fn set_ime_cursor_area(&self, position: Position, size: Size);
fn set_ime_allowed(&self, allowed: bool);
fn set_ime_purpose(&self, purpose: ImePurpose);
fn focus_window(&self);
fn has_focus(&self) -> bool;
fn request_user_attention(&self, request_type: Option<UserAttentionType>);
fn set_theme(&self, theme: Option<Theme>);
fn theme(&self) -> Option<Theme>;
fn set_content_protected(&self, protected: bool);
fn title(&self) -> String;
fn set_cursor(&self, cursor: Cursor);
fn set_cursor_position(
&self,
position: Position,
) -> Result<(), RequestError>;
fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), RequestError>;
fn set_cursor_visible(&self, visible: bool);
fn drag_window(&self) -> Result<(), RequestError>;
fn drag_resize_window(
&self,
direction: ResizeDirection,
) -> Result<(), RequestError>;
fn show_window_menu(&self, position: Position);
fn set_cursor_hittest(&self, hittest: bool) -> Result<(), RequestError>;
fn current_monitor(&self) -> Option<MonitorHandle>;
fn available_monitors(&self) -> Box<dyn Iterator<Item = MonitorHandle>>;
fn primary_monitor(&self) -> Option<MonitorHandle>;
fn rwh_06_display_handle(&self) -> &dyn HasDisplayHandle;
fn rwh_06_window_handle(&self) -> &dyn HasWindowHandle;
}
Expand description
Represents a window.
The window is closed when dropped.
§Threading
This is Send + Sync
, meaning that it can be freely used from other
threads.
However, some platforms (macOS, Web and iOS) only allow user interface interactions on the main thread, so on those platforms, if you use the window from a thread other than the main, the code is scheduled to run on the main thread, and your thread may be blocked until that completes.
§Platform-specific
Web: The Window
, which is represented by a HTMLElementCanvas
, can
not be closed by dropping the Window
.
Required Methods§
sourcefn scale_factor(&self) -> f64
fn scale_factor(&self) -> f64
Returns the scale factor that can be used to map logical pixels to physical pixels, and vice versa.
Note that this value can change depending on user action (for example if the window is
moved to another screen); as such, tracking WindowEvent::ScaleFactorChanged
events is
the most robust way to track the DPI you need to use to draw.
This value may differ from MonitorHandle::scale_factor
.
See the dpi
crate for more information.
§Platform-specific
The scale factor is calculated differently on different platforms:
-
Windows: On Windows 8 and 10, per-monitor scaling is readily configured by users from the display settings. While users are free to select any option they want, they’re only given a selection of “nice” scale factors, i.e. 1.0, 1.25, 1.5… on Windows 7. The scale factor is global and changing it requires logging out. See this article for technical details.
-
macOS: Recent macOS versions allow the user to change the scaling factor for specific displays. When available, the user may pick a per-monitor scaling factor from a set of pre-defined settings. All “retina displays” have a scaling factor above 1.0 by default, but the specific value varies across devices.
-
X11: Many man-hours have been spent trying to figure out how to handle DPI in X11. Winit currently uses a three-pronged approach:
- Use the value in the
WINIT_X11_SCALE_FACTOR
environment variable if present. - If not present, use the value set in
Xft.dpi
in Xresources. - Otherwise, calculate the scale factor based on the millimeter monitor dimensions provided by XRandR.
If
WINIT_X11_SCALE_FACTOR
is set torandr
, it’ll ignore theXft.dpi
field and use the XRandR scaling method. Generally speaking, you should try to configure the standard system variables to do what you want before resorting toWINIT_X11_SCALE_FACTOR
. - Use the value in the
-
Wayland: The scale factor is suggested by the compositor for each window individually by using the wp-fractional-scale protocol if available. Falls back to integer-scale factors otherwise.
The monitor scale factor may differ from the window scale factor.
-
iOS: Scale factors are set by Apple to the value that best suits the device, and range from
1.0
to3.0
. See this article and this article for more information.This uses the underlying
UIView
’scontentScaleFactor
. -
Android: Scale factors are set by the manufacturer to the value that best suits the device, and range from
1.0
to4.0
. See this article for more information.This is currently unimplemented, and this function always returns 1.0.
-
Web: The scale factor is the ratio between CSS pixels and the physical device pixels. In other words, it is the value of
window.devicePixelRatio
. It is affected by both the screen scaling and the browser zoom level and can go below1.0
. -
Orbital: This is currently unimplemented, and this function always returns 1.0.
sourcefn request_redraw(&self)
fn request_redraw(&self)
Queues a WindowEvent::RedrawRequested
event to be emitted that aligns with the windowing
system drawing loop.
This is the strongly encouraged method of redrawing windows, as it can integrate with
OS-requested redraws (e.g. when a window gets resized). To improve the event delivery
consider using Window::pre_present_notify
as described in docs.
Applications should always aim to redraw whenever they receive a RedrawRequested
event.
There are no strong guarantees about when exactly a RedrawRequest
event will be emitted
with respect to other events, since the requirements can vary significantly between
windowing systems.
However as the event aligns with the windowing system drawing loop, it may not arrive in same or even next event loop iteration.
§Platform-specific
- Windows This API uses
RedrawWindow
to request aWM_PAINT
message andRedrawRequested
is emitted in sync with anyWM_PAINT
messages. - Wayland: The events are aligned with the frame callbacks when
Window::pre_present_notify
is used. - Web:
WindowEvent::RedrawRequested
will be aligned with therequestAnimationFrame
.
sourcefn pre_present_notify(&self)
fn pre_present_notify(&self)
Notify the windowing system before presenting to the window.
You should call this event after your drawing operations, but before you submit
the buffer to the display or commit your drawings. Doing so will help winit to properly
schedule and make assumptions about its internal state. For example, it could properly
throttle WindowEvent::RedrawRequested
.
§Example
This example illustrates how it looks with OpenGL, but it applies to other graphics APIs and software rendering.
// Do the actual drawing with OpenGL.
// Notify winit that we're about to submit buffer to the windowing system.
window.pre_present_notify();
// Submit buffer to the windowing system.
swap_buffers();
§Platform-specific
- Android / iOS / X11 / Web / Windows / macOS / Orbital: Unsupported.
- Wayland: Schedules a frame callback to throttle
WindowEvent::RedrawRequested
.
sourcefn reset_dead_keys(&self)
fn reset_dead_keys(&self)
Reset the dead key state of the keyboard.
This is useful when a dead key is bound to trigger an action. Then this function can be called to reset the dead key state so that follow-up text input won’t be affected by the dead key.
§Platform-specific
- Web, macOS: Does nothing
sourcefn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError>
fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError>
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 Window::outer_position
apply to this method.
§Platform-specific
- iOS: Returns the top left coordinates of the window’s safe area in the screen space coordinate system.
- Web: Returns the top-left coordinates relative to the viewport. Note: this returns
the same value as
Window::outer_position
. - Android / Wayland: Always returns
RequestError::NotSupported
.
sourcefn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError>
fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError>
Returns the position of the top-left hand corner of the window relative to the top-left hand corner of the desktop.
Note that the top-left hand corner of the desktop is not necessarily the same as 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.
§Platform-specific
- iOS: Returns the top left coordinates of the window in the screen space coordinate system.
- Web: Returns the top-left coordinates relative to the viewport.
- Android / Wayland: Always returns
RequestError::NotSupported
.
sourcefn set_outer_position(&self, position: Position)
fn set_outer_position(&self, position: Position)
Modifies the position of the window.
See Window::outer_position
for more information about the coordinates.
This automatically un-maximizes the window if it’s maximized.
// Specify the position in logical dimensions like this:
window.set_outer_position(LogicalPosition::new(400.0, 200.0).into());
// Or specify the position in physical dimensions like this:
window.set_outer_position(PhysicalPosition::new(400, 200).into());
§Platform-specific
- iOS: Sets the top left coordinates of the window in the screen space coordinate system.
- Web: Sets the top-left coordinates relative to the viewport. Doesn’t account for CSS
transform
. - Android / Wayland: Unsupported.
sourcefn surface_size(&self) -> PhysicalSize<u32>
fn surface_size(&self) -> PhysicalSize<u32>
Returns the size of the window’s render-able surface.
This is the dimensions you should pass to things like Wgpu or Glutin when configuring.
§Platform-specific
sourcefn request_surface_size(&self, size: Size) -> Option<PhysicalSize<u32>>
fn request_surface_size(&self, size: Size) -> Option<PhysicalSize<u32>>
Request the new size for the surface.
On platforms where the size is entirely controlled by the user the applied size will be returned immediately, resize event in such case may not be generated.
On platforms where resizing is disallowed by the windowing system, the current surface size is returned immediately, and the user one is ignored.
When None
is returned, it means that the request went to the display system,
and the actual size will be delivered later with the WindowEvent::SurfaceResized
.
See Window::surface_size
for more information about the values.
The request could automatically un-maximize the window if it’s maximized.
// Specify the size in logical dimensions like this:
let _ = window.request_surface_size(LogicalSize::new(400.0, 200.0).into());
// Or specify the size in physical dimensions like this:
let _ = window.request_surface_size(PhysicalSize::new(400, 200).into());
§Platform-specific
- Web: Sets the size of the canvas element. Doesn’t account for CSS
transform
.
sourcefn outer_size(&self) -> PhysicalSize<u32>
fn outer_size(&self) -> PhysicalSize<u32>
Returns the size of the entire window.
These dimensions include window decorations like the title bar and borders. If you don’t
want that (and you usually don’t), use Window::surface_size
instead.
§Platform-specific
- iOS: Returns the
PhysicalSize
of the window in screen space coordinates. - Web: Returns the size of the canvas element. Note: this returns the same value as
Window::surface_size
.
sourcefn set_min_surface_size(&self, min_size: Option<Size>)
fn set_min_surface_size(&self, min_size: Option<Size>)
Sets a minimum dimensions of the window’s surface.
// Specify the size in logical dimensions like this:
window.set_min_surface_size(Some(LogicalSize::new(400.0, 200.0).into()));
// Or specify the size in physical dimensions like this:
window.set_min_surface_size(Some(PhysicalSize::new(400, 200).into()));
§Platform-specific
- iOS / Android / Orbital: Unsupported.
sourcefn set_max_surface_size(&self, max_size: Option<Size>)
fn set_max_surface_size(&self, max_size: Option<Size>)
Sets a maximum dimensions of the window’s surface.
// Specify the size in logical dimensions like this:
window.set_max_surface_size(Some(LogicalSize::new(400.0, 200.0).into()));
// Or specify the size in physical dimensions like this:
window.set_max_surface_size(Some(PhysicalSize::new(400, 200).into()));
§Platform-specific
- iOS / Android / Orbital: Unsupported.
sourcefn surface_resize_increments(&self) -> Option<PhysicalSize<u32>>
fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>>
sourcefn set_surface_resize_increments(&self, increments: Option<Size>)
fn set_surface_resize_increments(&self, increments: Option<Size>)
Sets resize increments of the surface.
This is a niche constraint hint usually employed by terminal emulators and other such apps that need “blocky” resizes.
§Platform-specific
- macOS: Increments are converted to logical size and then macOS rounds them to whole numbers.
- Wayland: Not implemented.
- iOS / Android / Web / Orbital: Unsupported.
sourcefn set_transparent(&self, transparent: bool)
fn set_transparent(&self, transparent: bool)
Change the window transparency state.
This is just a hint that may not change anything about the window transparency, however doing a mismatch between the content of your window and this hint may result in visual artifacts.
The default value follows the WindowAttributes::with_transparent
.
§Platform-specific
- macOS: This will reset the window’s background color.
- Web / iOS / Android: Unsupported.
- X11: Can only be set while building the window, with
WindowAttributes::with_transparent
.
sourcefn set_blur(&self, blur: bool)
fn set_blur(&self, blur: bool)
Change the window blur state.
If true
, this will make the transparent window background blurry.
§Platform-specific
- Android / iOS / X11 / Web / Windows: Unsupported.
- Wayland: Only works with org_kde_kwin_blur_manager protocol.
sourcefn set_visible(&self, visible: bool)
fn set_visible(&self, visible: bool)
Modifies the window’s visibility.
If false
, this will hide the window. If true
, this will show the window.
§Platform-specific
- Android / Wayland / Web: Unsupported.
sourcefn is_visible(&self) -> Option<bool>
fn is_visible(&self) -> Option<bool>
Gets the window’s current visibility state.
None
means it couldn’t be determined, so it is not recommended to use this to drive your
rendering backend.
§Platform-specific
- X11: Not implemented.
- Wayland / iOS / Android / Web: Unsupported.
sourcefn set_resizable(&self, resizable: bool)
fn set_resizable(&self, resizable: bool)
Sets whether the window is resizable or not.
Note that making the window unresizable doesn’t exempt you from handling
WindowEvent::SurfaceResized
, as that event can still be triggered by DPI scaling,
entering fullscreen mode, etc. Also, the window could still be resized by calling
Window::request_surface_size
.
§Platform-specific
This only has an effect on desktop platforms.
- X11: Due to a bug in XFCE, this has no effect on Xfwm.
- iOS / Android / Web: Unsupported.
sourcefn is_resizable(&self) -> bool
fn is_resizable(&self) -> bool
Gets the window’s current resizable state.
§Platform-specific
- X11: Not implemented.
- iOS / Android / Web: Unsupported.
Sets the enabled window buttons.
§Platform-specific
- Wayland / X11 / Orbital: Not implemented.
- Web / iOS / Android: Unsupported.
Gets the enabled window buttons.
§Platform-specific
- Wayland / X11 / Orbital: Not implemented. Always returns
WindowButtons::all
. - Web / iOS / Android: Unsupported. Always returns
WindowButtons::all
.
sourcefn set_minimized(&self, minimized: bool)
fn set_minimized(&self, minimized: bool)
Sets the window to minimized or back
§Platform-specific
- iOS / Android / Web / Orbital: Unsupported.
- Wayland: Un-minimize is unsupported.
sourcefn is_minimized(&self) -> Option<bool>
fn is_minimized(&self) -> Option<bool>
sourcefn set_maximized(&self, maximized: bool)
fn set_maximized(&self, maximized: bool)
sourcefn is_maximized(&self) -> bool
fn is_maximized(&self) -> bool
sourcefn set_fullscreen(&self, fullscreen: Option<Fullscreen>)
fn set_fullscreen(&self, fullscreen: Option<Fullscreen>)
Sets the window to fullscreen or back.
§Platform-specific
-
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. SeeWindowExtMacOs::set_simple_fullscreen
if separate spaces are not preferred.The dock and the menu bar are disabled in exclusive fullscreen mode.
-
Wayland: Does not support exclusive fullscreen mode and will no-op a request.
-
Windows: Screen saver is disabled in fullscreen mode.
-
Android / Orbital: Unsupported.
-
Web: Passing a
MonitorHandle
orVideoModeHandle
that was not created with detailed monitor permissions or calling without a transient activation does nothing.
sourcefn fullscreen(&self) -> Option<Fullscreen>
fn fullscreen(&self) -> Option<Fullscreen>
Gets the window’s current fullscreen state.
§Platform-specific
- Android / Orbital: Will always return
None
. - Wayland: Can return
Borderless(None)
when there are no monitors. - Web: Can only return
None
orBorderless(None)
.
sourcefn set_decorations(&self, decorations: bool)
fn set_decorations(&self, decorations: bool)
Turn window decorations on or off.
Enable/disable window decorations provided by the server or Winit. By default this is enabled. Note that fullscreen windows and windows on mobile and Web platforms naturally do not have decorations.
§Platform-specific
- iOS / Android / Web: No effect.
sourcefn is_decorated(&self) -> bool
fn is_decorated(&self) -> bool
Gets the window’s current decorations state.
Returns true
when windows are decorated (server-side or by Winit).
Also returns true
when no decorations are required (mobile, Web).
§Platform-specific
- iOS / Android / Web: Always returns
true
.
sourcefn set_window_level(&self, level: WindowLevel)
fn set_window_level(&self, level: WindowLevel)
Change the window level.
This is just a hint to the OS, and the system could ignore it.
See WindowLevel
for details.
sourcefn set_window_icon(&self, window_icon: Option<Icon>)
fn set_window_icon(&self, window_icon: Option<Icon>)
Sets the window icon.
On Windows and X11, this is typically the small icon in the top-left corner of the titlebar.
§Platform-specific
-
iOS / Android / Web / Wayland / macOS / Orbital: Unsupported.
-
Windows: 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.
sourcefn set_ime_cursor_area(&self, position: Position, size: Size)
fn set_ime_cursor_area(&self, position: Position, size: Size)
Set the IME cursor editing area, where the position
is the top left corner of that area
and size
is the size of this area starting from the position. An example of such area
could be a input field in the UI or line in the editor.
The windowing system could place a candidate box close to that area, but try to not obscure the specified area, so the user input to it stays visible.
The candidate box is the window / popup / overlay that allows you to select the desired characters. The look of this box may differ between input devices, even on the same platform.
(Apple’s official term is “candidate window”, see their chinese and japanese guides).
§Example
// Specify the position in logical dimensions like this:
window.set_ime_cursor_area(
LogicalPosition::new(400.0, 200.0).into(),
LogicalSize::new(100, 100).into(),
);
// Or specify the position in physical dimensions like this:
window.set_ime_cursor_area(
PhysicalPosition::new(400, 200).into(),
PhysicalSize::new(100, 100).into(),
);
§Platform-specific
- X11: - area is not supported, only position.
- iOS / Android / Web / Orbital: Unsupported.
sourcefn set_ime_allowed(&self, allowed: bool)
fn set_ime_allowed(&self, allowed: bool)
Sets whether the window should get IME events
When IME is allowed, the window will receive Ime
events, and during the
preedit phase the window will NOT get KeyboardInput
events. The window
should allow IME while it is expecting text input.
When IME is not allowed, the window won’t receive Ime
events, and will
receive KeyboardInput
events for every keypress instead. Not allowing
IME is useful for games for example.
IME is not allowed by default.
§Platform-specific
- macOS: IME must be enabled to receive text-input where dead-key sequences are combined.
- iOS: This will show / hide the soft keyboard.
- Android / Web / Orbital: Unsupported.
- X11: Enabling IME will disable dead keys reporting during compose.
sourcefn set_ime_purpose(&self, purpose: ImePurpose)
fn set_ime_purpose(&self, purpose: ImePurpose)
Sets the IME purpose for the window using ImePurpose
.
§Platform-specific
- iOS / Android / Web / Windows / X11 / macOS / Orbital: Unsupported.
sourcefn focus_window(&self)
fn focus_window(&self)
Brings the window to the front and sets input focus. Has no effect if the window is already in focus, minimized, or not visible.
This method steals input focus from other applications. Do not use this method unless you are certain that’s what the user wants. Focus stealing can cause an extremely disruptive user experience.
§Platform-specific
- iOS / Android / Wayland / Orbital: Unsupported.
sourcefn has_focus(&self) -> bool
fn has_focus(&self) -> bool
Gets whether the window has keyboard focus.
This queries the same state information as WindowEvent::Focused
.
sourcefn request_user_attention(&self, request_type: Option<UserAttentionType>)
fn request_user_attention(&self, request_type: Option<UserAttentionType>)
Requests user attention to the window, this has no effect if the application
is already focused. How requesting for user attention manifests is platform dependent,
see UserAttentionType
for details.
Providing None
will unset the request for user attention. Unsetting the request for
user attention might not be done automatically by the WM when the window receives input.
§Platform-specific
- iOS / Android / Web / Orbital: Unsupported.
- macOS:
None
has no effect. - X11: Requests for user attention must be manually cleared.
- Wayland: Requires
xdg_activation_v1
protocol,None
has no effect.
sourcefn set_theme(&self, theme: Option<Theme>)
fn set_theme(&self, theme: Option<Theme>)
Set or override the window theme.
Specify None
to reset the theme to the system default.
§Platform-specific
- Wayland: Sets the theme for the client side decorations. Using
None
will use dbus to get the system preference. - X11: Sets
_GTK_THEME_VARIANT
hint todark
orlight
and ifNone
is used, it will default toTheme::Dark
. - iOS / Android / Web / Orbital: Unsupported.
sourcefn theme(&self) -> Option<Theme>
fn theme(&self) -> Option<Theme>
Returns the current window theme.
Returns None
if it cannot be determined on the current platform.
§Platform-specific
- iOS / Android / x11 / Orbital: Unsupported.
- Wayland: Only returns theme overrides.
sourcefn set_content_protected(&self, protected: bool)
fn set_content_protected(&self, protected: bool)
Prevents the window contents from being captured by other apps.
§Platform-specific
- macOS: if
false
,NSWindowSharingNone
is used but doesn’t completely prevent all apps from reading the window content, for instance, QuickTime. - iOS / Android / x11 / Wayland / Web / Orbital: Unsupported.
sourcefn title(&self) -> String
fn title(&self) -> String
Gets the current title of the window.
§Platform-specific
- iOS / Android / x11 / Wayland / Web: Unsupported. Always returns an empty string.
sourcefn set_cursor(&self, cursor: Cursor)
fn set_cursor(&self, cursor: Cursor)
Modifies the cursor icon of the window.
§Platform-specific
- iOS / Android / Orbital: Unsupported.
- Web: Custom cursors have to be loaded and decoded first, until then the previous cursor is shown.
sourcefn set_cursor_position(&self, position: Position) -> Result<(), RequestError>
fn set_cursor_position(&self, position: Position) -> Result<(), RequestError>
Changes the position of the cursor in window coordinates.
// Specify the position in logical dimensions like this:
window.set_cursor_position(LogicalPosition::new(400.0, 200.0).into());
// Or specify the position in physical dimensions like this:
window.set_cursor_position(PhysicalPosition::new(400, 200).into());
§Platform-specific
- Wayland: Cursor must be in
CursorGrabMode::Locked
. - iOS / Android / Web / Orbital: Always returns an
RequestError::NotSupported
.
sourcefn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), RequestError>
fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), RequestError>
sourcefn set_cursor_visible(&self, visible: bool)
fn set_cursor_visible(&self, visible: bool)
Modifies the cursor’s visibility.
If false
, this will hide the cursor. If true
, this will show the cursor.
§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.
- Wayland: 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 / Android: Unsupported.
sourcefn drag_window(&self) -> Result<(), RequestError>
fn drag_window(&self) -> Result<(), RequestError>
Moves the window with the left mouse button until the button is released.
There’s no guarantee that this will work unless the left mouse button was pressed immediately before this function is called.
§Platform-specific
- X11: Un-grabs the cursor.
- Wayland: Requires the cursor to be inside the window to be dragged.
- macOS: May prevent the button release event to be triggered.
- iOS / Android / Web: Always returns an
RequestError::NotSupported
.
sourcefn drag_resize_window(
&self,
direction: ResizeDirection,
) -> Result<(), RequestError>
fn drag_resize_window( &self, direction: ResizeDirection, ) -> Result<(), RequestError>
Resizes the window with the left mouse button until the button is released.
There’s no guarantee that this will work unless the left mouse button was pressed immediately before this function is called.
§Platform-specific
- macOS: Always returns an
RequestError::NotSupported
- iOS / Android / Web: Always returns an
RequestError::NotSupported
.
Show window menu at a specified position .
This is the context menu that is normally shown when interacting with the title bar. This is useful when implementing custom decorations.
§Platform-specific
Android / iOS / macOS / Orbital / Wayland / Web / X11: Unsupported.
sourcefn set_cursor_hittest(&self, hittest: bool) -> Result<(), RequestError>
fn set_cursor_hittest(&self, hittest: bool) -> Result<(), RequestError>
Modifies whether the window catches cursor events.
If true
, the window will catch the cursor events. If false
, events are passed through
the window such that any other window behind it receives them. By default hittest is
enabled.
§Platform-specific
- iOS / Android / Web / Orbital: Always returns an
RequestError::NotSupported
.
sourcefn current_monitor(&self) -> Option<MonitorHandle>
fn current_monitor(&self) -> Option<MonitorHandle>
Returns the monitor on which the window currently resides.
Returns None
if current monitor can’t be detected.
sourcefn available_monitors(&self) -> Box<dyn Iterator<Item = MonitorHandle>>
fn available_monitors(&self) -> Box<dyn Iterator<Item = MonitorHandle>>
Returns the list of all the monitors available on the system.
This is the same as ActiveEventLoop::available_monitors
, and is provided for
convenience.
§Platform-specific
Web: Only returns the current monitor without detailed monitor permissions.
sourcefn primary_monitor(&self) -> Option<MonitorHandle>
fn primary_monitor(&self) -> Option<MonitorHandle>
Returns the primary monitor of the system.
Returns None
if it can’t identify any monitor as a primary one.
This is the same as ActiveEventLoop::primary_monitor
, and is provided for convenience.
§Platform-specific
- Wayland: Always returns
None
. - Web: Always returns
None
without detailed monitor permissions.
sourcefn rwh_06_display_handle(&self) -> &dyn HasDisplayHandle
fn rwh_06_display_handle(&self) -> &dyn HasDisplayHandle
Get the raw-window-handle v0.6 display handle.
sourcefn rwh_06_window_handle(&self) -> &dyn HasWindowHandle
fn rwh_06_window_handle(&self) -> &dyn HasWindowHandle
Get the raw-window-handle v0.6 window handle.
Implementations§
source§impl dyn Window
impl dyn Window
sourcepub fn default_attributes() -> WindowAttributes
pub fn default_attributes() -> WindowAttributes
Create a new WindowAttributes
which allows modifying the window’s attributes before
creation.