Struct winit::window::WindowAttributes

source · 
pub struct WindowAttributes {
Show 20 fields
    pub inner_size: Option<Size>,
    pub min_inner_size: Option<Size>,
    pub max_inner_size: Option<Size>,
    pub position: Option<Position>,
    pub resizable: bool,
    pub enabled_buttons: WindowButtons,
    pub title: String,
    pub maximized: bool,
    pub visible: bool,
    pub transparent: bool,
    pub blur: bool,
    pub decorations: bool,
    pub window_icon: Option<Icon>,
    pub preferred_theme: Option<Theme>,
    pub resize_increments: Option<Size>,
    pub content_protected: bool,
    pub window_level: WindowLevel,
    pub active: bool,
    pub cursor: Cursor,
    pub fullscreen: Option<Fullscreen>,
    /* private fields */

}
Expand description

Attributes used when creating a window.

Fields§

§inner_size: Option<Size>§min_inner_size: Option<Size>§max_inner_size: Option<Size>§position: Option<Position>§resizable: bool§enabled_buttons: WindowButtons§title: String§maximized: bool§visible: bool§transparent: bool§blur: bool§decorations: bool§window_icon: Option<Icon>§preferred_theme: Option<Theme>§resize_increments: Option<Size>§content_protected: bool§window_level: WindowLevel§active: bool§cursor: Cursor§fullscreen: Option<Fullscreen>

Implementations§

source§

impl WindowAttributes

source

pub fn new() -> Self

👎Deprecated: use Window::default_attributes instead

Initializes new attributes with default values.

source§

impl WindowAttributes

source

pub fn parent_window(&self) -> Option<&RawWindowHandle>

Available on crate feature rwh_06 only.

Get the parent window stored on the attributes.

source

pub fn with_inner_size<S: Into<Size>>(self, size: S) -> Self

Requests the window to be of specific dimensions.

If this is not set, some platform-specific dimensions will be used.

See Window::request_inner_size for details.

Examples found in repository?
examples/x11_embed.rs (line 24)
21
22
23
24
25
26
27
28

        fn resumed(&mut self, event_loop: &ActiveEventLoop) {
            let window_attributes = Window::default_attributes()
                .with_title("An embedded window!")
                .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
                .with_embed_parent_window(self.parent_window_id);

            self.window = Some(event_loop.create_window(window_attributes).unwrap());
        }
More examples
Hide additional examples
examples/run_on_demand.rs (line 34)
31
32
33
34
35
36
37
38

        fn resumed(&mut self, event_loop: &ActiveEventLoop) {
            let window_attributes = Window::default_attributes()
                .with_title("Fantastic window number one!")
                .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0));
            let window = event_loop.create_window(window_attributes).unwrap();
            self.window_id = Some(window.id());
            self.window = Some(window);
        }
examples/child_window.rs (line 19)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

fn main() -> Result<(), impl std::error::Error> {
    use std::collections::HashMap;

    use winit::dpi::{LogicalPosition, LogicalSize, Position};
    use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
    use winit::event_loop::{ActiveEventLoop, EventLoop};
    use winit::raw_window_handle::HasRawWindowHandle;
    use winit::window::Window;

    #[path = "util/fill.rs"]
    mod fill;

    fn spawn_child_window(parent: &Window, event_loop: &ActiveEventLoop) -> Window {
        let parent = parent.raw_window_handle().unwrap();
        let mut window_attributes = Window::default_attributes()
            .with_title("child window")
            .with_inner_size(LogicalSize::new(200.0f32, 200.0f32))
            .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
            .with_visible(true);
        // `with_parent_window` is unsafe. Parent window must be a valid window.
        window_attributes = unsafe { window_attributes.with_parent_window(Some(parent)) };

        event_loop.create_window(window_attributes).unwrap()
    }

    let mut windows = HashMap::new();

    let event_loop: EventLoop<()> = EventLoop::new().unwrap();
    let mut parent_window_id = None;

    event_loop.run(move |event: Event<()>, event_loop| {
        match event {
            Event::Resumed => {
                let attributes = Window::default_attributes()
                    .with_title("parent window")
                    .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
                    .with_inner_size(LogicalSize::new(640.0f32, 480.0f32));
                let window = event_loop.create_window(attributes).unwrap();

                parent_window_id = Some(window.id());

                println!("Parent window id: {parent_window_id:?})");
                windows.insert(window.id(), window);
            },
            Event::WindowEvent { window_id, event } => match event {
                WindowEvent::CloseRequested => {
                    windows.clear();
                    event_loop.exit();
                },
                WindowEvent::CursorEntered { device_id: _ } => {
                    // On x11, println when the cursor entered in a window even if the child window
                    // is created by some key inputs.
                    // the child windows are always placed at (0, 0) with size (200, 200) in the
                    // parent window, so we also can see this log when we move
                    // the cursor around (200, 200) in parent window.
                    println!("cursor entered in the window {window_id:?}");
                },
                WindowEvent::KeyboardInput {
                    event: KeyEvent { state: ElementState::Pressed, .. },
                    ..
                } => {
                    let parent_window = windows.get(&parent_window_id.unwrap()).unwrap();
                    let child_window = spawn_child_window(parent_window, event_loop);
                    let child_id = child_window.id();
                    println!("Child window created with id: {child_id:?}");
                    windows.insert(child_id, child_window);
                },
                WindowEvent::RedrawRequested => {
                    if let Some(window) = windows.get(&window_id) {
                        fill::fill_window(window);
                    }
                },
                _ => (),
            },
            _ => (),
        }
    })
}
source

pub fn with_min_inner_size<S: Into<Size>>(self, min_size: S) -> Self

Sets the minimum dimensions a window can have.

If this is not set, the window will have no minimum dimensions (aside from reserved).

See Window::set_min_inner_size for details.

source

pub fn with_max_inner_size<S: Into<Size>>(self, max_size: S) -> Self

Sets the maximum dimensions a window can have.

If this is not set, the window will have no maximum or will be set to the primary monitor’s dimensions by the platform.

See Window::set_max_inner_size for details.

source

pub fn with_position<P: Into<Position>>(self, position: P) -> Self

Sets a desired initial position for the window.

If this is not set, some platform-specific position will be chosen.

See Window::set_outer_position for details.

§Platform-specific
  • macOS: The top left corner position of the window content, the window’s “inner” position. The window title bar will be placed above it. The window will be positioned such that it fits on screen, maintaining set inner_size if any. If you need to precisely position the top left corner of the whole window you have to use Window::set_outer_position after creating the window.
  • Windows: The top left corner position of the window title bar, the window’s “outer” position. There may be a small gap between this position and the window due to the specifics of the Window Manager.
  • X11: The top left corner of the window, the window’s “outer” position.
  • Others: Ignored.
Examples found in repository?
examples/child_window.rs (line 20)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

fn main() -> Result<(), impl std::error::Error> {
    use std::collections::HashMap;

    use winit::dpi::{LogicalPosition, LogicalSize, Position};
    use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
    use winit::event_loop::{ActiveEventLoop, EventLoop};
    use winit::raw_window_handle::HasRawWindowHandle;
    use winit::window::Window;

    #[path = "util/fill.rs"]
    mod fill;

    fn spawn_child_window(parent: &Window, event_loop: &ActiveEventLoop) -> Window {
        let parent = parent.raw_window_handle().unwrap();
        let mut window_attributes = Window::default_attributes()
            .with_title("child window")
            .with_inner_size(LogicalSize::new(200.0f32, 200.0f32))
            .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
            .with_visible(true);
        // `with_parent_window` is unsafe. Parent window must be a valid window.
        window_attributes = unsafe { window_attributes.with_parent_window(Some(parent)) };

        event_loop.create_window(window_attributes).unwrap()
    }

    let mut windows = HashMap::new();

    let event_loop: EventLoop<()> = EventLoop::new().unwrap();
    let mut parent_window_id = None;

    event_loop.run(move |event: Event<()>, event_loop| {
        match event {
            Event::Resumed => {
                let attributes = Window::default_attributes()
                    .with_title("parent window")
                    .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
                    .with_inner_size(LogicalSize::new(640.0f32, 480.0f32));
                let window = event_loop.create_window(attributes).unwrap();

                parent_window_id = Some(window.id());

                println!("Parent window id: {parent_window_id:?})");
                windows.insert(window.id(), window);
            },
            Event::WindowEvent { window_id, event } => match event {
                WindowEvent::CloseRequested => {
                    windows.clear();
                    event_loop.exit();
                },
                WindowEvent::CursorEntered { device_id: _ } => {
                    // On x11, println when the cursor entered in a window even if the child window
                    // is created by some key inputs.
                    // the child windows are always placed at (0, 0) with size (200, 200) in the
                    // parent window, so we also can see this log when we move
                    // the cursor around (200, 200) in parent window.
                    println!("cursor entered in the window {window_id:?}");
                },
                WindowEvent::KeyboardInput {
                    event: KeyEvent { state: ElementState::Pressed, .. },
                    ..
                } => {
                    let parent_window = windows.get(&parent_window_id.unwrap()).unwrap();
                    let child_window = spawn_child_window(parent_window, event_loop);
                    let child_id = child_window.id();
                    println!("Child window created with id: {child_id:?}");
                    windows.insert(child_id, child_window);
                },
                WindowEvent::RedrawRequested => {
                    if let Some(window) = windows.get(&window_id) {
                        fill::fill_window(window);
                    }
                },
                _ => (),
            },
            _ => (),
        }
    })
}
source

pub fn with_resizable(self, resizable: bool) -> Self

Sets whether the window is resizable or not.

The default is true.

See Window::set_resizable for details.

source

pub fn with_enabled_buttons(self, buttons: WindowButtons) -> Self

Sets the enabled window buttons.

The default is WindowButtons::all

See Window::set_enabled_buttons for details.

source

pub fn with_title<T: Into<String>>(self, title: T) -> Self

Sets the initial title of the window in the title bar.

The default is "winit window".

See Window::set_title for details.

Examples found in repository?
examples/pump_events.rs (line 26)
25
26
27
28

        fn resumed(&mut self, event_loop: &ActiveEventLoop) {
            let window_attributes = Window::default_attributes().with_title("A fantastic window!");
            self.window = Some(event_loop.create_window(window_attributes).unwrap());
        }
More examples
Hide additional examples
examples/control_flow.rs (lines 71-73)
70
71
72
73
74
75

    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        let window_attributes = Window::default_attributes().with_title(
            "Press 1, 2, 3 to change control flow mode. Press R to toggle redraw requests.",
        );
        self.window = Some(event_loop.create_window(window_attributes).unwrap());
    }
examples/x11_embed.rs (line 23)
21
22
23
24
25
26
27
28

        fn resumed(&mut self, event_loop: &ActiveEventLoop) {
            let window_attributes = Window::default_attributes()
                .with_title("An embedded window!")
                .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
                .with_embed_parent_window(self.parent_window_id);

            self.window = Some(event_loop.create_window(window_attributes).unwrap());
        }
examples/run_on_demand.rs (line 33)
31
32
33
34
35
36
37
38

        fn resumed(&mut self, event_loop: &ActiveEventLoop) {
            let window_attributes = Window::default_attributes()
                .with_title("Fantastic window number one!")
                .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0));
            let window = event_loop.create_window(window_attributes).unwrap();
            self.window_id = Some(window.id());
            self.window = Some(window);
        }
examples/child_window.rs (line 18)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

fn main() -> Result<(), impl std::error::Error> {
    use std::collections::HashMap;

    use winit::dpi::{LogicalPosition, LogicalSize, Position};
    use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
    use winit::event_loop::{ActiveEventLoop, EventLoop};
    use winit::raw_window_handle::HasRawWindowHandle;
    use winit::window::Window;

    #[path = "util/fill.rs"]
    mod fill;

    fn spawn_child_window(parent: &Window, event_loop: &ActiveEventLoop) -> Window {
        let parent = parent.raw_window_handle().unwrap();
        let mut window_attributes = Window::default_attributes()
            .with_title("child window")
            .with_inner_size(LogicalSize::new(200.0f32, 200.0f32))
            .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
            .with_visible(true);
        // `with_parent_window` is unsafe. Parent window must be a valid window.
        window_attributes = unsafe { window_attributes.with_parent_window(Some(parent)) };

        event_loop.create_window(window_attributes).unwrap()
    }

    let mut windows = HashMap::new();

    let event_loop: EventLoop<()> = EventLoop::new().unwrap();
    let mut parent_window_id = None;

    event_loop.run(move |event: Event<()>, event_loop| {
        match event {
            Event::Resumed => {
                let attributes = Window::default_attributes()
                    .with_title("parent window")
                    .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
                    .with_inner_size(LogicalSize::new(640.0f32, 480.0f32));
                let window = event_loop.create_window(attributes).unwrap();

                parent_window_id = Some(window.id());

                println!("Parent window id: {parent_window_id:?})");
                windows.insert(window.id(), window);
            },
            Event::WindowEvent { window_id, event } => match event {
                WindowEvent::CloseRequested => {
                    windows.clear();
                    event_loop.exit();
                },
                WindowEvent::CursorEntered { device_id: _ } => {
                    // On x11, println when the cursor entered in a window even if the child window
                    // is created by some key inputs.
                    // the child windows are always placed at (0, 0) with size (200, 200) in the
                    // parent window, so we also can see this log when we move
                    // the cursor around (200, 200) in parent window.
                    println!("cursor entered in the window {window_id:?}");
                },
                WindowEvent::KeyboardInput {
                    event: KeyEvent { state: ElementState::Pressed, .. },
                    ..
                } => {
                    let parent_window = windows.get(&parent_window_id.unwrap()).unwrap();
                    let child_window = spawn_child_window(parent_window, event_loop);
                    let child_id = child_window.id();
                    println!("Child window created with id: {child_id:?}");
                    windows.insert(child_id, child_window);
                },
                WindowEvent::RedrawRequested => {
                    if let Some(window) = windows.get(&window_id) {
                        fill::fill_window(window);
                    }
                },
                _ => (),
            },
            _ => (),
        }
    })
}
examples/window.rs (line 132)
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

    fn create_window(
        &mut self,
        event_loop: &ActiveEventLoop,
        _tab_id: Option<String>,
    ) -> Result<WindowId, Box<dyn Error>> {
        // TODO read-out activation token.

        #[allow(unused_mut)]
        let mut window_attributes = Window::default_attributes()
            .with_title("Winit window")
            .with_transparent(true)
            .with_window_icon(Some(self.icon.clone()));

        #[cfg(any(x11_platform, wayland_platform))]
        if let Some(token) = event_loop.read_token_from_env() {
            startup_notify::reset_activation_token_env();
            info!("Using token {:?} to activate a window", token);
            window_attributes = window_attributes.with_activation_token(token);
        }

        #[cfg(macos_platform)]
        if let Some(tab_id) = _tab_id {
            window_attributes = window_attributes.with_tabbing_identifier(&tab_id);
        }

        #[cfg(web_platform)]
        {
            use winit::platform::web::WindowAttributesExtWebSys;
            window_attributes = window_attributes.with_append(true);
        }

        let window = event_loop.create_window(window_attributes)?;

        #[cfg(ios_platform)]
        {
            use winit::platform::ios::WindowExtIOS;
            window.recognize_doubletap_gesture(true);
            window.recognize_pinch_gesture(true);
            window.recognize_rotation_gesture(true);
            window.recognize_pan_gesture(true, 2, 2);
        }

        let window_state = WindowState::new(self, window)?;
        let window_id = window_state.window.id();
        info!("Created new window with id={window_id:?}");
        self.windows.insert(window_id, window_state);
        Ok(window_id)
    }
source

pub fn with_fullscreen(self, fullscreen: Option<Fullscreen>) -> Self

Sets whether the window should be put into fullscreen upon creation.

The default is None.

See Window::set_fullscreen for details.

source

pub fn with_maximized(self, maximized: bool) -> Self

Request that the window is maximized upon creation.

The default is false.

See Window::set_maximized for details.

source

pub fn with_visible(self, visible: bool) -> Self

Sets whether the window will be initially visible or hidden.

The default is to show the window.

See Window::set_visible for details.

Examples found in repository?
examples/child_window.rs (line 21)
15
16
17
18
19
20
21
22
23
24
25
26

    fn spawn_child_window(parent: &Window, event_loop: &ActiveEventLoop) -> Window {
        let parent = parent.raw_window_handle().unwrap();
        let mut window_attributes = Window::default_attributes()
            .with_title("child window")
            .with_inner_size(LogicalSize::new(200.0f32, 200.0f32))
            .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
            .with_visible(true);
        // `with_parent_window` is unsafe. Parent window must be a valid window.
        window_attributes = unsafe { window_attributes.with_parent_window(Some(parent)) };

        event_loop.create_window(window_attributes).unwrap()
    }
source

pub fn with_transparent(self, transparent: bool) -> Self

Sets whether the background of the window should be transparent.

If this is true, writing colors with alpha values different than 1.0 will produce a transparent window. On some platforms this is more of a hint for the system and you’d still have the alpha buffer. To control it see Window::set_transparent.

The default is false.

Examples found in repository?
examples/window.rs (line 133)
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

    fn create_window(
        &mut self,
        event_loop: &ActiveEventLoop,
        _tab_id: Option<String>,
    ) -> Result<WindowId, Box<dyn Error>> {
        // TODO read-out activation token.

        #[allow(unused_mut)]
        let mut window_attributes = Window::default_attributes()
            .with_title("Winit window")
            .with_transparent(true)
            .with_window_icon(Some(self.icon.clone()));

        #[cfg(any(x11_platform, wayland_platform))]
        if let Some(token) = event_loop.read_token_from_env() {
            startup_notify::reset_activation_token_env();
            info!("Using token {:?} to activate a window", token);
            window_attributes = window_attributes.with_activation_token(token);
        }

        #[cfg(macos_platform)]
        if let Some(tab_id) = _tab_id {
            window_attributes = window_attributes.with_tabbing_identifier(&tab_id);
        }

        #[cfg(web_platform)]
        {
            use winit::platform::web::WindowAttributesExtWebSys;
            window_attributes = window_attributes.with_append(true);
        }

        let window = event_loop.create_window(window_attributes)?;

        #[cfg(ios_platform)]
        {
            use winit::platform::ios::WindowExtIOS;
            window.recognize_doubletap_gesture(true);
            window.recognize_pinch_gesture(true);
            window.recognize_rotation_gesture(true);
            window.recognize_pan_gesture(true, 2, 2);
        }

        let window_state = WindowState::new(self, window)?;
        let window_id = window_state.window.id();
        info!("Created new window with id={window_id:?}");
        self.windows.insert(window_id, window_state);
        Ok(window_id)
    }
source

pub fn with_blur(self, blur: bool) -> Self

Sets whether the background of the window should be blurred by the system.

The default is false.

See Window::set_blur for details.

source

pub fn transparent(&self) -> bool

Get whether the window will support transparency.

source

pub fn with_decorations(self, decorations: bool) -> Self

Sets whether the window should have a border, a title bar, etc.

The default is true.

See Window::set_decorations for details.

source

pub fn with_window_level(self, level: WindowLevel) -> Self

Sets the window level.

This is just a hint to the OS, and the system could ignore it.

The default is WindowLevel::Normal.

See WindowLevel for details.

source

pub fn with_window_icon(self, window_icon: Option<Icon>) -> Self

Sets the window icon.

The default is None.

See Window::set_window_icon for details.

Examples found in repository?
examples/window.rs (line 134)
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

    fn create_window(
        &mut self,
        event_loop: &ActiveEventLoop,
        _tab_id: Option<String>,
    ) -> Result<WindowId, Box<dyn Error>> {
        // TODO read-out activation token.

        #[allow(unused_mut)]
        let mut window_attributes = Window::default_attributes()
            .with_title("Winit window")
            .with_transparent(true)
            .with_window_icon(Some(self.icon.clone()));

        #[cfg(any(x11_platform, wayland_platform))]
        if let Some(token) = event_loop.read_token_from_env() {
            startup_notify::reset_activation_token_env();
            info!("Using token {:?} to activate a window", token);
            window_attributes = window_attributes.with_activation_token(token);
        }

        #[cfg(macos_platform)]
        if let Some(tab_id) = _tab_id {
            window_attributes = window_attributes.with_tabbing_identifier(&tab_id);
        }

        #[cfg(web_platform)]
        {
            use winit::platform::web::WindowAttributesExtWebSys;
            window_attributes = window_attributes.with_append(true);
        }

        let window = event_loop.create_window(window_attributes)?;

        #[cfg(ios_platform)]
        {
            use winit::platform::ios::WindowExtIOS;
            window.recognize_doubletap_gesture(true);
            window.recognize_pinch_gesture(true);
            window.recognize_rotation_gesture(true);
            window.recognize_pan_gesture(true, 2, 2);
        }

        let window_state = WindowState::new(self, window)?;
        let window_id = window_state.window.id();
        info!("Created new window with id={window_id:?}");
        self.windows.insert(window_id, window_state);
        Ok(window_id)
    }
source

pub fn with_theme(self, theme: Option<Theme>) -> Self

Sets a specific theme for the window.

If None is provided, the window will use the system theme.

The default is None.

§Platform-specific
  • macOS: This is an app-wide setting.
  • Wayland: This controls only CSD. When using None it’ll try to use dbus to get the system preference. When explicit theme is used, this will avoid dbus all together.
  • x11: Build window with _GTK_THEME_VARIANT hint set to dark or light.
  • iOS / Android / Web / x11 / Orbital: Ignored.
source

pub fn with_resize_increments<S: Into<Size>>(self, resize_increments: S) -> Self

Build window with resize increments hint.

The default is None.

See Window::set_resize_increments for details.

source

pub fn with_content_protected(self, protected: bool) -> Self

Prevents the window contents from being captured by other apps.

The default is false.

§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 / Web / x11 / Orbital: Ignored.
source

pub fn with_active(self, active: bool) -> Self

Whether the window will be initially focused or not.

The window should be assumed as not focused by default following by the WindowEvent::Focused.

§Platform-specific:

Android / iOS / X11 / Wayland / Orbital: Unsupported.

source

pub fn with_cursor(self, cursor: impl Into<Cursor>) -> Self

Modifies the cursor icon of the window.

The default is CursorIcon::Default.

See Window::set_cursor() for more details.

source

pub unsafe fn with_parent_window( self, parent_window: Option<RawWindowHandle> ) -> Self

Available on crate feature rwh_06 only.

Build window with parent window.

The default is None.

§Safety

parent_window must be a valid window handle.

§Platform-specific
Examples found in repository?
examples/child_window.rs (line 23)
15
16
17
18
19
20
21
22
23
24
25
26

    fn spawn_child_window(parent: &Window, event_loop: &ActiveEventLoop) -> Window {
        let parent = parent.raw_window_handle().unwrap();
        let mut window_attributes = Window::default_attributes()
            .with_title("child window")
            .with_inner_size(LogicalSize::new(200.0f32, 200.0f32))
            .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
            .with_visible(true);
        // `with_parent_window` is unsafe. Parent window must be a valid window.
        window_attributes = unsafe { window_attributes.with_parent_window(Some(parent)) };

        event_loop.create_window(window_attributes).unwrap()
    }

Trait Implementations§

source§

impl Clone for WindowAttributes

source§

fn clone(&self) -> WindowAttributes

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for WindowAttributes

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for WindowAttributes

source§

fn default() -> WindowAttributes

Returns the “default value” for a type. Read more
source§

impl WindowAttributesExtIOS for WindowAttributes

Available on ios_platform only.
source§

fn with_scale_factor(self, scale_factor: f64) -> Self

Sets the contentScaleFactor of the underlying UIWindow to scale_factor. Read more
source§

fn with_valid_orientations(self, valid_orientations: ValidOrientations) -> Self

Sets the valid orientations for the Window. Read more
source§

fn with_prefers_home_indicator_hidden(self, hidden: bool) -> Self

Sets whether the Window prefers the home indicator hidden. Read more
source§

fn with_preferred_screen_edges_deferring_system_gestures( self, edges: ScreenEdge ) -> Self

Sets the screen edges for which the system gestures will take a lower priority than the application’s touch handling. Read more
source§

fn with_prefers_status_bar_hidden(self, hidden: bool) -> Self

Sets whether the Window prefers the status bar hidden. Read more
source§

fn with_preferred_status_bar_style( self, status_bar_style: StatusBarStyle ) -> Self

Sets the style of the Window’s status bar. Read more
source§

impl WindowAttributesExtMacOS for WindowAttributes

Available on macos_platform only.
source§

fn with_movable_by_window_background( self, movable_by_window_background: bool ) -> Self

Enables click-and-drag behavior for the entire window, not just the titlebar.
source§

fn with_titlebar_transparent(self, titlebar_transparent: bool) -> Self

Makes the titlebar transparent and allows the content to appear behind it.
source§

fn with_titlebar_hidden(self, titlebar_hidden: bool) -> Self

Hides the window titlebar.
source§

fn with_titlebar_buttons_hidden(self, titlebar_buttons_hidden: bool) -> Self

Hides the window titlebar buttons.
source§

fn with_title_hidden(self, title_hidden: bool) -> Self

Hides the window title.
source§

fn with_fullsize_content_view(self, fullsize_content_view: bool) -> Self

Makes the window content appear behind the titlebar.
source§

fn with_disallow_hidpi(self, disallow_hidpi: bool) -> Self

source§

fn with_has_shadow(self, has_shadow: bool) -> Self

source§

fn with_accepts_first_mouse(self, accepts_first_mouse: bool) -> Self

Window accepts click-through mouse events.
source§

fn with_tabbing_identifier(self, tabbing_identifier: &str) -> Self

Defines the window tabbing identifier. Read more
source§

fn with_option_as_alt(self, option_as_alt: OptionAsAlt) -> Self

Set how the Option keys are interpreted. Read more
source§

impl WindowAttributesExtStartupNotify for WindowAttributes

Available on x11_platform or wayland_platform only.
source§

fn with_activation_token(self, token: ActivationToken) -> Self

Use this ActivationToken during window creation. Read more
source§

impl WindowAttributesExtWayland for WindowAttributes

Available on wayland_platform only.
source§

fn with_name( self, general: impl Into<String>, instance: impl Into<String> ) -> Self

Build window with the given name. Read more
source§

impl WindowAttributesExtWebSys for WindowAttributes

Available on web_platform only.
source§

fn with_canvas(self, canvas: Option<HtmlCanvasElement>) -> Self

Pass an HtmlCanvasElement to be used for this Window. If None, WindowAttributes::default() will create one. Read more
source§

fn with_prevent_default(self, prevent_default: bool) -> Self

Sets whether event.preventDefault() should be called on events on the canvas that have side effects. Read more
source§

fn with_focusable(self, focusable: bool) -> Self

Whether the canvas should be focusable using the tab key. This is necessary to capture canvas keyboard events. Read more
source§

fn with_append(self, append: bool) -> Self

On window creation, append the canvas element to the web page if it isn’t already. Read more
source§

impl WindowAttributesExtWindows for WindowAttributes

Available on windows_platform only.
source§

fn with_owner_window(self, parent: HWND) -> Self

Set an owner to the window to be created. Can be used to create a dialog box, for example. This only works when WindowAttributes::with_parent_window isn’t called or set to None. Can be used in combination with WindowExtWindows::set_enable(false) on the owner window to create a modal dialog box. Read more
source§

fn with_menu(self, menu: HMENU) -> Self

Sets a menu on the window to be created. Read more
source§

fn with_taskbar_icon(self, taskbar_icon: Option<Icon>) -> Self

This sets ICON_BIG. A good ceiling here is 256x256.
source§

fn with_no_redirection_bitmap(self, flag: bool) -> Self

This sets WS_EX_NOREDIRECTIONBITMAP.
source§

fn with_drag_and_drop(self, flag: bool) -> Self

Enables or disables drag and drop support (enabled by default). Will interfere with other crates that use multi-threaded COM API (CoInitializeEx with COINIT_MULTITHREADED instead of COINIT_APARTMENTTHREADED) on the same thread. Note that winit may still attempt to initialize COM API regardless of this option. Currently only fullscreen mode does that, but there may be more in the future. If you need COM API with COINIT_MULTITHREADED you must initialize it before calling any winit functions. See https://docs.microsoft.com/en-us/windows/win32/api/objbase/nf-objbase-coinitialize#remarks for more information.
source§

fn with_skip_taskbar(self, skip: bool) -> Self

Whether show or hide the window icon in the taskbar.
source§

fn with_class_name<S: Into<String>>(self, class_name: S) -> Self

Customize the window class name.
source§

fn with_undecorated_shadow(self, shadow: bool) -> Self

Shows or hides the background drop shadow for undecorated windows. Read more
source§

fn with_system_backdrop(self, backdrop_type: BackdropType) -> Self

Sets system-drawn backdrop type. Read more
source§

fn with_clip_children(self, flag: bool) -> Self

This sets or removes WS_CLIPCHILDREN style.
source§

fn with_border_color(self, color: Option<Color>) -> Self

Sets the color of the window border. Read more
source§

fn with_title_background_color(self, color: Option<Color>) -> Self

Sets the background color of the title bar. Read more
source§

fn with_title_text_color(self, color: Color) -> Self

Sets the color of the window title. Read more
source§

fn with_corner_preference(self, corners: CornerPreference) -> Self

Sets the preferred style of the window corners. Read more
source§

impl WindowAttributesExtX11 for WindowAttributes

Available on x11_platform only.
source§

fn with_x11_visual(self, visual_id: XVisualID) -> Self

Create this window with a specific X11 visual.
source§

fn with_x11_screen(self, screen_id: i32) -> Self

source§

fn with_name( self, general: impl Into<String>, instance: impl Into<String> ) -> Self

Build window with the given general and instance names. Read more
source§

fn with_override_redirect(self, override_redirect: bool) -> Self

Build window with override-redirect flag; defaults to false.
source§

fn with_x11_window_type(self, x11_window_types: Vec<WindowType>) -> Self

Build window with _NET_WM_WINDOW_TYPE hints; defaults to Normal.
source§

fn with_base_size<S: Into<Size>>(self, base_size: S) -> Self

Build window with base size hint. Read more
source§

fn with_embed_parent_window(self, parent_window_id: XWindow) -> Self

Embed this window into another parent window. Read more
source§

impl WindowAttributesExtAndroid for WindowAttributes

Available on android_platform only.

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> Downcast for T
where T: Any,

source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
source§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
source§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

source§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more