Trait Window

pub trait Window:
    AsAny
    + Send
    + Sync
    + Debug {
Show 60 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 surface_position(&self) -> PhysicalPosition<i32>;
    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 safe_area(&self) -> PhysicalInsets<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 request_ime_update(
        &self,
        request: ImeRequest,
    ) -> Result<(), ImeRequestError>;
    fn ime_capabilities(&self) -> Option<ImeCapabilities>;
    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;

    // Provided methods
    fn set_ime_cursor_area(&self, position: Position, size: Size) { ... }
    fn set_ime_allowed(&self, allowed: bool) { ... }
    fn set_ime_purpose(&self, purpose: ImePurpose) { ... }
}

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§

fn id(&self) -> WindowId

Returns an identifier unique to the window.

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 MonitorHandleProvider::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 to randr, it’ll ignore the Xft.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 to WINIT_X11_SCALE_FACTOR.
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 to 3.0. See this article and this article for more information.

This uses the underlying UIView’s contentScaleFactor.
Android: Scale factors are set by the manufacturer to the value that best suits the device, and range from 1.0 to 4.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 below 1.0.
Orbital: This is currently unimplemented, and this function always returns 1.0.

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 a WM_PAINT message and RedrawRequested is emitted in sync with any WM_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 the requestAnimationFrame.

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.

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

fn surface_position(&self) -> PhysicalPosition<i32>

The position of the top-left hand corner of the surface relative to the top-left hand corner of the window.

This, combined with outer_position, can be useful for calculating the position of the surface relative to the desktop.

This may also be useful for figuring out the size of the window’s decorations (such as buttons, title, etc.), but may also not correspond to that (e.g. if the title bar is made transparent on macOS, or your are drawing window decorations yourself).

This may be negative.

If the window does not have any decorations, and the surface is in the exact same position as the window itself, this simply returns (0, 0).

fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError>

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 primary monitor of the desktop.

The coordinates can be negative if the top-left hand corner of the window is outside of the visible screen region, or on another monitor than the primary.

§Platform-specific

Web: Returns the top-left coordinates relative to the viewport.
Android / Wayland: Always returns RequestError::NotSupported.

fn set_outer_position(&self, position: Position)

Sets the position of the window on the desktop.

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.

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 the surface for drawing. See WindowEvent::SurfaceResized for listening to changes to this field.

Note that to ensure that your content is not obscured by things such as notches or the title bar, you will likely want to only draw important content inside a specific area of the surface, see safe_area() for details.

§Platform-specific

Web: Returns the size of the canvas element. Doesn’t account for CSS transform.

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.

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

Web: Returns the size of the canvas element. Note: this returns the same value as Window::surface_size.

fn safe_area(&self) -> PhysicalInsets<u32>

The inset area of the surface that is unobstructed.

On some devices, especially mobile devices, the screen is not a perfect rectangle, and may have rounded corners, notches, bezels, and so on. When drawing your content, you usually want to draw your background and other such unimportant content on the entire surface, while you will want to restrict important content such as text, interactable or visual indicators to the part of the screen that is actually visible; for this, you use the safe area.

The safe area is a rectangle that is defined relative to the origin at the top-left corner of the surface, and the size extending downwards to the right. The area will not extend beyond the bounds of the surface.

Note that the safe area does not take occlusion from other windows into account; in a way, it is only a “hardware”-level occlusion.

If the entire content of the surface is visible, this returns (0, 0, 0, 0).

§Platform-specific

Android / Orbital / Wayland / Windows / X11: Unimplemented, returns (0, 0, 0, 0).

§Example

Convert safe area insets to a size and a position.

use dpi::{PhysicalPosition, PhysicalSize};

let surface_size = window.surface_size();
let insets = window.safe_area();

let origin = PhysicalPosition::new(insets.left, insets.top);
let size = PhysicalSize::new(
    surface_size.width - insets.left - insets.right,
    surface_size.height - insets.top - insets.bottom,
);

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.

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.

fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>>

Returns surface resize increments if any were set.

§Platform-specific

iOS / Android / Web / Wayland / Orbital: Always returns None.

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.

fn set_title(&self, title: &str)

Modifies the title of the window.

§Platform-specific

iOS / Android: Unsupported.

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.

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.

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.

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.

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.

fn is_resizable(&self) -> bool

Gets the window’s current resizable state.

§Platform-specific

X11: Not implemented.
iOS / Android / Web: Unsupported.

fn set_enabled_buttons(&self, buttons: WindowButtons)

Sets the enabled window buttons.

§Platform-specific

Wayland / X11 / Orbital: Not implemented.
Web / iOS / Android: Unsupported.

fn enabled_buttons(&self) -> WindowButtons

Gets the enabled window buttons.

§Platform-specific

Wayland / X11 / Orbital: Not implemented. Always returns WindowButtons::all.
Web / iOS / Android: Unsupported. Always returns WindowButtons::all.

fn set_minimized(&self, minimized: bool)

Minimize the window, or put it back from the minimized state.

§Platform-specific

iOS / Android / Web / Orbital: Unsupported.
Wayland: Un-minimize is unsupported.

fn is_minimized(&self) -> Option<bool>

Gets the window’s current minimized state.

None will be returned, if the minimized state couldn’t be determined.

§Note

You shouldn’t stop rendering for minimized windows, however you could lower the fps.

§Platform-specific

Wayland: always None.
iOS / Android / Web / Orbital: Unsupported.

fn set_maximized(&self, maximized: bool)

Sets the window to maximized or back.

§Platform-specific

iOS / Android / Web: Unsupported.

fn is_maximized(&self) -> bool

Gets the window’s current maximized state.

§Platform-specific

iOS / Android / Web: Unsupported.

fn set_fullscreen(&self, fullscreen: Option<Fullscreen>)

Set the window’s fullscreen state.

§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. See WindowExtMacOs::set_simple_fullscreen if separate spaces are not preferred.

The dock and the menu bar are disabled in exclusive fullscreen mode.
Orbital / Wayland: Does not support exclusive fullscreen mode and will no-op a request.
Windows: Screen saver is disabled in fullscreen mode.
Web: Passing a MonitorHandle or VideoMode that was not created with detailed monitor permissions or calling without a transient activation does nothing.

fn fullscreen(&self) -> Option<Fullscreen>

Gets the window’s current fullscreen state.

§Platform-specific

Android: Will always return None.
Orbital / Web: Can only return None or Borderless(None).
Wayland: Can return Borderless(None) when there are no monitors.

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.

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.

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.

fn set_window_icon(&self, window_icon: Option<Icon>)

Sets the window icon.

On Windows, Wayland and X11, this is typically the small icon in the top-left corner of the titlebar.

§Platform-specific

iOS / Android / Web / / 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.
Wayland: The compositor needs to implement xdg_toplevel_icon.

fn request_ime_update(&self, request: ImeRequest) -> Result<(), ImeRequestError>

Atomically apply request to IME.

For details consult ImeRequest and ImeCapabilities.

Input methods allows the user to compose text without using a keyboard. Requesting one may be beneficial for touch screen environments or ones where, for example, East Asian scripts may be entered.

If the focus within the application changes from one logical text input area to another, the application should inform the IME of the switch by disabling the IME and enabling it again in the other area.

IME is not enabled by default.

§Example

// Clear previous state by switching off IME
window.request_ime_update(ImeRequest::Disable).expect("Disable cannot fail");

let ime_caps = ImeCapabilities::new().with_cursor_area().with_hint_and_purpose();
let request_data = ImeRequestData::default()
                         .with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
                         .with_cursor_area(cursor_pos, cursor_size);
let enable_ime = ImeEnableRequest::new(ime_caps, request_data.clone()).unwrap();
window.request_ime_update(ImeRequest::Enable(enable_ime)).expect("Enabling may fail if IME is not supported");

// Update the current state
window
    .request_ime_update(ImeRequest::Update(request_data.clone()))
    .expect("will fail if it's not enabled or ime is not supported");

// Update the current state
window
    .request_ime_update(ImeRequest::Update(
       request_data.with_cursor_area(cursor_pos, cursor_size),
    ))
    .expect("Can fail - we didn't submit a cursor position initially");

// Switch off IME
window.request_ime_update(ImeRequest::Disable).expect("Disable cannot fail");

fn ime_capabilities(&self) -> Option<ImeCapabilities>

Return enabled by the client ImeCapabilities for this window.

When the IME is not yet enabled it’ll return None.

By default IME is disabled, thus will return None.

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.

fn has_focus(&self) -> bool

Gets whether the window has keyboard focus.

This queries the same state information as WindowEvent::Focused.

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.

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 to dark or light and if None is used, it will default to Theme::Dark.
iOS / Android / Web / Orbital: Unsupported.

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.

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.

fn title(&self) -> String

Gets the current title of the window.

§Platform-specific

iOS / Android / x11 / Wayland / Web: Unsupported. Always returns an empty string.

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.

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.

fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), RequestError>

Set grabbing mode on the cursor preventing it from leaving the window.

§Example

First try confining the cursor, and if that fails, try locking it instead.

window
    .set_cursor_grab(CursorGrabMode::Confined)
    .or_else(|_e| window.set_cursor_grab(CursorGrabMode::Locked))
    .unwrap();

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.

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.

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.

fn show_window_menu(&self, position: Position)

Show window menu at a specified position in surface coordinates.

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.

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.

fn current_monitor(&self) -> Option<MonitorHandle>

Returns the monitor on which the window currently resides.

Returns None if current monitor can’t be detected.

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.

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.

fn rwh_06_display_handle(&self) -> &dyn HasDisplayHandle

Get the raw-window-handle v0.6 display handle.

fn rwh_06_window_handle(&self) -> &dyn HasWindowHandle

Get the raw-window-handle v0.6 window handle.

Provided Methods§

fn set_ime_cursor_area(&self, position: Position, size: Size)

👎Deprecated: use Window::request_ime_update instead

Set the IME cursor editing area, where the position is the top left corner of that area in surface coordinates 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

iOS / Android / Web / Orbital: Unsupported.

fn set_ime_allowed(&self, allowed: bool)

👎Deprecated: use Window::request_ime_update instead

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 when 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 / Android: This will show / hide the soft keyboard.
Web / Orbital: Unsupported.
X11: Enabling IME will disable dead keys reporting during compose.