Struct Window 

pub struct Window { /* private fields */ }

Represents the “shell” of a Window.

You can set get and set many of the SDL_Window properties (i.e., border, size, PixelFormat, etc)

However, you cannot directly access the pixels of the Window. It needs to be converted to a Canvas to access the rendering functions.

Note: If a Window goes out of scope but it cloned its context, then the SDL_Window will not be destroyed until there are no more references to the WindowContext. This may happen when a TextureCreator<Window> outlives the Canvas<Window>

Implementations

impl Window

pub fn raw(&self) -> *mut SDL_Window

pub unsafe fn from_ll( subsystem: VideoSubsystem, raw: *mut SDL_Window, metal_view: SDL_MetalView, ) -> Window

pub const unsafe fn from_ref(context: Arc<WindowContext>) -> Window

Create a new Window without taking ownership of the WindowContext

pub fn subsystem(&self) -> &VideoSubsystem

pub fn into_canvas(self) -> WindowCanvas

Initializes a new `WindowCanvas’;

pub fn context(&self) -> Arc<WindowContext>

pub fn id(&self) -> u32

pub fn gl_create_context(&self) -> Result<GLContext, Error>

pub unsafe fn gl_get_current_context(&self) -> Option<GLContext>

pub fn gl_set_context_to_current(&self) -> Result<(), Error>

Set the window’s OpenGL context to the current context on the thread.

pub fn gl_make_current(&self, context: &GLContext) -> Result<(), Error>

pub fn gl_swap_window(&self)

pub fn vulkan_instance_extensions(&self) -> Result<Vec<String>, Error>

Get the names of the Vulkan instance extensions needed to create a surface with vulkan_create_surface.

pub fn vulkan_create_surface( &self, instance: VkInstance, ) -> Result<VkSurfaceKHR, Error>

Create a Vulkan rendering surface for a window.

The VkInstance must be created using a prior call to the vkCreateInstance function in the Vulkan library.

pub fn get_display(&self) -> Result<Display, Error>

pub fn set_display_mode<D>(&mut self, display_mode: D) -> Result<(), Error>

where D: Into<Option<DisplayMode>>,

pub fn display_mode(&self) -> Option<DisplayMode>

pub fn icc_profile(&self) -> Result<Vec<u8>, Error>

pub fn window_pixel_format(&self) -> PixelFormat

pub fn window_flags(&self) -> SDL_WindowFlags

pub fn has_input_focus(&self) -> bool

Does the window have input focus?

pub fn has_input_grabbed(&self) -> bool

Has the window grabbed input focus?

pub fn has_mouse_focus(&self) -> bool

Does the window have mouse focus?

pub fn is_maximized(&self) -> bool

Is the window maximized?

pub fn is_minimized(&self) -> bool

Is the window minimized?

pub fn set_title(&mut self, title: &str) -> Result<(), NulError>

pub fn title(&self) -> &str

pub fn set_icon<S: AsRef<SurfaceRef>>(&mut self, icon: S) -> bool

Use this function to set the icon for a window.

Example:

// requires "--features 'image'"
use sdl3::surface::Surface;

let window_icon = Surface::from_file("/path/to/icon.png")?;
window.set_icon(window_icon);

pub fn set_position(&mut self, x: WindowPos, y: WindowPos) -> bool

pub fn position(&self) -> (i32, i32)

pub fn border_size(&self) -> Result<(u16, u16, u16, u16), Error>

Use this function to get the size of a window’s borders (decorations) around the client area.

Remarks

This function is only supported on X11, otherwise an error is returned.

pub fn set_size( &mut self, width: u32, height: u32, ) -> Result<(), IntegerOrSdlError>

pub fn size(&self) -> (u32, u32)

pub fn display_scale(&self) -> f32

This is a combination of the window pixel density and the display content scale, and is the expected scale for displaying content in this window. For example, if a 3840x2160 window had a display scale of 2.0, the user expects the content to take twice as many pixels and be the same physical size as if it were being displayed in a 1920x1080 window with a display scale of 1.0.

Conceptually this value corresponds to the scale display setting, and is updated when that setting is changed, or the window moves to a display with a different scale setting.

pub fn sync(&self) -> bool

Block until any pending window state is finalized.

On asynchronous windowing systems, this acts as a synchronization barrier for pending window state. It will attempt to wait until any pending window state has been applied and is guaranteed to return within finite time. Note that for how long it can potentially block depends on the underlying window system, as window state changes may involve somewhat lengthy animations that must complete before the window is in its final requested state.

On windowing systems where changes are immediate, this does nothing.

Returns true on success or false if the operation timed out before the window was in the requested state.

This function should only be called on the main thread.

pub fn pixel_density(&self) -> f32

pub fn size_in_pixels(&self) -> (u32, u32)

pub fn set_minimum_size( &mut self, width: u32, height: u32, ) -> Result<(), IntegerOrSdlError>

pub fn minimum_size(&self) -> (u32, u32)

pub fn set_maximum_size( &mut self, width: u32, height: u32, ) -> Result<(), IntegerOrSdlError>

pub fn maximum_size(&self) -> (u32, u32)

pub fn set_bordered(&mut self, bordered: bool) -> bool

pub fn show(&mut self) -> bool

pub fn hide(&mut self) -> bool

pub fn raise(&mut self) -> bool

pub fn maximize(&mut self) -> bool

pub fn minimize(&mut self) -> bool

pub fn restore(&mut self) -> bool

pub fn fullscreen_state(&self) -> FullscreenType

pub fn set_fullscreen(&mut self, fullscreen: bool) -> Result<(), Error>

pub fn surface<'a>( &'a self, _e: &'a EventPump, ) -> Result<WindowSurfaceRef<'a>, Error>

Returns a WindowSurfaceRef, which can be used like a regular Surface. This is an alternative way to the Renderer (Canvas) way to modify pixels directly in the Window.

For this to happen, simply create a WindowSurfaceRef via this method, use the underlying Surface however you like, and when the changes of the Surface must be applied to the screen, call update_window if you intend to keep using the WindowSurfaceRef afterwards, or finish if you don’t intend to use it afterwards.

The Renderer way is of course much more flexible and recommended; even though you only want to support Software Rendering (which is what using Surface is), you can still create a Renderer which renders in a Software-based manner, so try to rely on a Renderer as much as possible !

pub fn set_keyboard_grab(&mut self, grabbed: bool) -> bool

pub fn set_mouse_grab(&mut self, grabbed: bool) -> bool

pub fn keyboard_grab(&self) -> bool

pub fn mouse_grab(&self) -> bool

pub fn set_mouse_rect<R>(&self, rect: R) -> Result<(), Error>

where R: Into<Option<Rect>>,

pub fn mouse_rect(&self) -> Option<Rect>

pub fn set_opacity(&mut self, opacity: f32) -> Result<(), Error>

Set the transparency of the window. The given value will be clamped internally between 0.0 (fully transparent), and 1.0 (fully opaque).

This method returns an error if opacity isn’t supported by the current platform.

pub fn opacity(&self) -> Result<f32, Error>

Returns the transparency of the window, as a value between 0.0 (fully transparent), and 1.0 (fully opaque).

If opacity isn’t supported by the current platform, this method returns Ok(1.0) instead of an error.

pub fn flash(&mut self, operation: FlashOperation) -> Result<(), Error>

Requests a window to demand attention from the user.

Trait Implementations

impl Clone for Window

fn clone(&self) -> Window

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl From<Window> for WindowCanvas

fn from(window: Window) -> WindowCanvas

Converts to this type from the input type.

impl From<WindowContext> for Window

fn from(context: WindowContext) -> Window

Converts to this type from the input type.

impl HasDisplayHandle for Window

fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError>

Get a handle to the display controller of the windowing system.

impl HasWindowHandle for Window

fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError>

Get a handle to the window.

impl RenderTarget for Window

type Context = WindowContext