pub struct Window(_);
Expand description
Window is used to open up a window. It’s possible to optionally display a 32-bit buffer when the widow is set as non-resizable.
Implementations
sourceimpl Window
impl Window
sourcepub fn new(
name: &str,
width: usize,
height: usize,
opts: WindowOptions
) -> Result<Window>
pub fn new(
name: &str,
width: usize,
height: usize,
opts: WindowOptions
) -> Result<Window>
Opens up a new window
Examples
Open up a window with default settings
let mut window = match Window::new("Test", 640, 400, WindowOptions::default()) {
Ok(win) => win,
Err(err) => {
println!("Unable to create window {}", err);
return;
}
};
Open up a window that is resizeable
let mut window = match Window::new("Test", 640, 400,
WindowOptions {
resize: true,
..WindowOptions::default()
}) {
Ok(win) => win,
Err(err) => {
println!("Unable to create window {}", err);
return;
}
};
sourcepub fn set_title(&mut self, title: &str)
pub fn set_title(&mut self, title: &str)
Allows you to set a new title of the window after creation
Examples
let mut window = match Window::new("Test", 640, 400, WindowOptions::default()).unwrap();
window.set_title("My New Title!");
sourcepub fn get_window_handle(&self) -> *mut c_void
pub fn get_window_handle(&self) -> *mut c_void
Returns the native handle for a window which is an opaque pointer/handle which dependens on the current operating system:
Windows HWND
MacOS NSWindow
X11 XWindow
sourcepub fn update_with_buffer(&mut self, buffer: &[u32]) -> Result<()>
pub fn update_with_buffer(&mut self, buffer: &[u32]) -> Result<()>
Updates the window with a 32-bit pixel buffer. Notice that the buffer needs to be at least the size of the created window
Examples
let mut buffer: Vec<u32> = vec![0; 640 * 400];
let mut window = match Window::new("Test", 640, 400, WindowOptions::default()).unwrap();
window.update_with_buffer(&buffer).unwrap();
sourcepub fn update(&mut self)
pub fn update(&mut self)
Updates the window (this is required to call in order to get keyboard/mouse input, etc)
Examples
let mut buffer: Vec<u32> = vec![0; 640 * 400];
let mut window = match Window::new("Test", 640, 400, WindowOptions::default()).unwrap();
window.update();
sourcepub fn is_open(&self) -> bool
pub fn is_open(&self) -> bool
Checks if the window is still open. A window can be closed by the user (by for example pressing the close button on the window) It’s up to the user to make sure that this is being checked and take action depending on the state.
Examples
while window.is_open() {
window.update(...)
}
sourcepub fn set_position(&mut self, x: isize, y: isize)
pub fn set_position(&mut self, x: isize, y: isize)
Sets the position of the window. This is useful if you have more than one window and want to align them up on the screen
Examples
// Moves the window to pixel position 20, 20 on the screen
window.set_position(20, 20);
sourcepub fn get_size(&self) -> (usize, usize)
pub fn get_size(&self) -> (usize, usize)
Returns the current size of the window
Examples
let size = window.get_size();
println!("width {} height {}", size.0, size.1);
sourcepub fn get_mouse_pos(&self, mode: MouseMode) -> Option<(f32, f32)>
pub fn get_mouse_pos(&self, mode: MouseMode) -> Option<(f32, f32)>
Get the current position of the mouse relative to the current window The coordinate system is as 0, 0 as the upper left corner
Examples
window.get_mouse_pos(MouseMode::Clamp).map(|mouse| {
println!("x {} y {}", mouse.0, mouse.1);
});
sourcepub fn get_unscaled_mouse_pos(&self, mode: MouseMode) -> Option<(f32, f32)>
pub fn get_unscaled_mouse_pos(&self, mode: MouseMode) -> Option<(f32, f32)>
Get the current position of the mouse relative to the current window The coordinate system is as 0, 0 as the upper left corner and ignores any scaling set to the window.
Examples
window.get_unscaled_mouse_pos(MouseMode::Clamp).map(|mouse| {
println!("x {} y {}", mouse.0, mouse.1);
});
sourcepub fn get_mouse_down(&self, button: MouseButton) -> bool
pub fn get_mouse_down(&self, button: MouseButton) -> bool
Check if a mouse button is down or not
Examples
let left_down = window.get_mouse_down(MouseButton::Left);
println!("is left down? {}", left_down)
sourcepub fn get_scroll_wheel(&self) -> Option<(f32, f32)>
pub fn get_scroll_wheel(&self) -> Option<(f32, f32)>
Get the current movement of the scroll wheel. Scroll wheel can mean different thing depending on the device attach. For example on Mac with trackpad “scroll wheel” means two finger swiping up/down (y axis) and to the sides (x-axis) When using a mouse this assumes the scroll wheel which often is only y direction.
Examples
window.get_scroll_wheel().map(|scroll| {
println!("scrolling - x {} y {}", scroll.0, scroll.1);
});
sourcepub fn set_cursor_style(&mut self, cursor: CursorStyle)
pub fn set_cursor_style(&mut self, cursor: CursorStyle)
Set a different cursor style. This can be used if you have resizing elements or something like that
Examples
window.set_cursor_style(CursorStyle::ResizeLeftRight);
sourcepub fn get_keys(&self) -> Option<Vec<Key>>
pub fn get_keys(&self) -> Option<Vec<Key>>
Get the current keys that are down.
Examples
window.get_keys().map(|keys| {
for t in keys {
match t {
Key::W => println!("holding w"),
Key::T => println!("holding t"),
_ => (),
}
}
});
sourcepub fn get_keys_pressed(&self, repeat: KeyRepeat) -> Option<Vec<Key>>
pub fn get_keys_pressed(&self, repeat: KeyRepeat) -> Option<Vec<Key>>
Get the current pressed keys. Repeat can be used to control if keys should be repeated if down or not.
Examples
window.get_keys_pressed(KeyRepeat::No).map(|keys| {
for t in keys {
match t {
Key::W => println!("pressed w"),
Key::T => println!("pressed t"),
_ => (),
}
}
});
sourcepub fn is_key_down(&self, key: Key) -> bool
pub fn is_key_down(&self, key: Key) -> bool
Check if a single key is down.
Examples
if window.is_key_down(Key::A) {
println!("Key A is down");
}
sourcepub fn is_key_pressed(&self, key: Key, repeat: KeyRepeat) -> bool
pub fn is_key_pressed(&self, key: Key, repeat: KeyRepeat) -> bool
Check if a single key is pressed. KeyRepeat will control if the key should be repeated or not while being pressed.
Examples
if window.is_key_pressed(KeyRepeat::No) {
println!("Key A is down");
}
sourcepub fn set_key_repeat_delay(&mut self, delay: f32)
pub fn set_key_repeat_delay(&mut self, delay: f32)
Sets the delay for when a key is being held before it starts being repeated the default value is 0.25 sec
Examples
window.set_key_repeat_delay(0.5) // 0.5 sec before repeat starts
sourcepub fn set_key_repeat_rate(&mut self, rate: f32)
pub fn set_key_repeat_rate(&mut self, rate: f32)
Sets the rate in between when the keys has passed the initial repeat_delay. The default value is 0.05 sec
Examples
window.set_key_repeat_rate(0.01) // 0.01 sec between keys
sourcepub fn set_input_callback(&mut self, callback: Box<dyn InputCallback>)
pub fn set_input_callback(&mut self, callback: Box<dyn InputCallback>)
Set input callback to recive callback on char input
This allows adding menus to your windows. As menus behaves a bit diffrently depending on Operating system here is how it works.
Windows:
Each window has their own menu and shortcuts are active depending on active window.
Mac:
As Mac uses one menu for the whole program the menu will change depending
on which window you have active.
Linux/BSD/etc:
Menus aren't supported as they depend on each WindowManager and is outside of the
scope for this library to support. Use [get_unix_menus] to get a structure
Remove a menu that has been added with [#add_menu]
Check if a menu item has been pressed