Struct minifb::Window [−][src]
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
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 = Window::new("Test", 640, 400,
WindowOptions {
resize: true,
..WindowOptions::default()
})
.expect("Unable to open Window");
Allows you to set a new title of the window after creation
Examples
let mut window = Window::new("Test", 640, 400, WindowOptions::default()).unwrap();
window.set_title("My New Title!");
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
Updates the window with a 32-bit pixel buffer. The encoding for each pixel is 0RGB
:
The upper 8-bits are ignored, the next 8-bits are for the red channel, the next 8-bits
afterwards for the green channel, and the lower 8-bits for the blue channel.
Notice that the buffer needs to be at least the size of the created window.
Examples
fn from_u8_rgb(r: u8, g: u8, b: u8) -> u32 {
let (r, g, b) = (r as u32, g as u32, b as u32);
(r << 16) | (g << 8) | b
}
let window_width = 600;
let window_height = 400;
let buffer_width = 600;
let buffer_height = 400;
let azure_blue = from_u8_rgb(0, 127, 255);
let mut buffer: Vec<u32> = vec![azure_blue; buffer_width * buffer_height];
let mut window = Window::new("Test", window_width, window_height, WindowOptions::default()).unwrap();
window.update_with_buffer(&buffer, buffer_width, buffer_height).unwrap();
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 = Window::new("Test", 640, 400, WindowOptions::default()).unwrap();
window.update();
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() {
// Update window
}
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);
Makes the window the topmost window and makes it stay always on top. This is useful if you want the window to float above all over windows
Examples
// Makes the window always on top
window.topmost(true);
Sets the background color that is used with update_with_buffer. In some cases there will be a blank area around the buffer depending on the ScaleMode that has been set. This color will be used in the in that area. The function takes 3 parameters in (red, green, blue) and each value is in the range of 0-255 where 255 is the brightest value
Examples
// Set background color to bright red
window.set_background_color(255, 0, 0);
Changes whether or not the cursor image should be shown or if the cursor image should be invisible inside the window When creating a new window the default is ‘false’
Limits the update rate of polling for new events in order to reduce CPU usage. The problem of having a tight loop that does something like this
loop {
window.update();
}
Is that lots of CPU time will be spent calling system functions to check for new events in a tight loop making the CPU time go up.
Using limit_update_rate
minifb will check how much time has passed since the last time and if it’s less than the selected time it will sleep for the remainder of it.
This means that if more time has spent than the set time (external code taking longer) minifb will not do any waiting at all so there is no loss in CPU performance with this feature.
By default it’s set to 4 milliseconds. Setting this value to None and no waiting will be done
Examples
// Make sure that at least 4 ms has passed since the last event poll
window.limit_update_rate(Some(std::time::Duration::from_millis(4)));
Returns the current size of the window
Examples
let size = window.get_size();
println!("width {} height {}", size.0, size.1);
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);
});
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);
});
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)
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);
});
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);
Get the current keys that are down.
Examples
window.get_keys().iter().for_each(|key|
match key {
Key::W => println!("holding w"),
Key::T => println!("holding t"),
_ => (),
}
);
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).iter().for_each(|key|
match key {
Key::W => println!("pressed w"),
Key::T => println!("pressed t"),
_ => (),
}
);
Get the current released keys.
Examples
window.get_keys_released().iter().for_each(|key|
match key {
Key::W => println!("released w"),
Key::T => println!("released t"),
_ => (),
}
);
Check if a single key is down.
Examples
if window.is_key_down(Key::A) {
println!("Key A is down");
}
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(Key::A, KeyRepeat::No) {
println!("Key A is down");
}
Check if a single key was released since last call to update.
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
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
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_posix_menus] to get a structure
Remove a menu that has been added with [#add_menu]
get_unix_menus
will be removed in 1.0.0, use get_posix_menus
instead
Check if a menu item has been pressed
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for Window
impl !UnwindSafe for Window
Blanket Implementations
Mutably borrows from an owned value. Read more
impl<T> Downcast for T where
T: Any,
impl<T> Downcast for T where
T: 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
. Read more
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Convert Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read more
Convert &Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read more
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
pub 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. Read more