[][src]Struct minifb::Window

pub struct Window(_);

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.


impl Window[src]

pub fn new(
    name: &str,
    width: usize,
    height: usize,
    opts: WindowOptions
) -> Result<Window>

Opens up a new window


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);

Open up a window that is resizeable

let mut window = Window::new("Test", 640, 400,
    WindowOptions {
       resize: true,
 .expect("Unable to open Window");

pub fn set_title(&mut self, title: &str)[src]

Allows you to set a new title of the window after creation


let mut window = Window::new("Test", 640, 400, WindowOptions::default()).unwrap();

window.set_title("My New Title!");

pub fn get_window_handle(&self) -> *mut c_void[src]

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

pub fn update_with_buffer(
    &mut self,
    buffer: &[u32],
    width: usize,
    height: usize
) -> Result<()>

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.


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();

pub fn update(&mut self)[src]

Updates the window (this is required to call in order to get keyboard/mouse input, etc)


let mut buffer: Vec<u32> = vec![0; 640 * 400];

let mut window = Window::new("Test", 640, 400, WindowOptions::default()).unwrap();


pub fn is_open(&self) -> bool[src]

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.


while window.is_open() {
    // Update window

pub fn set_position(&mut self, x: isize, y: isize)[src]

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


// Moves the window to pixel position 20, 20 on the screen
window.set_position(20, 20);

pub fn set_background_color(&mut self, red: usize, green: usize, blue: usize)[src]

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


// Set background color to bright red
window.set_background_color(255, 0, 0);

pub fn limit_update_rate(&mut self, time: Option<Duration>)[src]

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 {

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


// Make sure that at least 4 ms has passed since the last event poll

pub fn get_size(&self) -> (usize, usize)[src]

Returns the current size of the window


let size = window.get_size();
println!("width {} height {}", size.0, size.1);

pub fn get_mouse_pos(&self, mode: MouseMode) -> Option<(f32, f32)>[src]

Get the current position of the mouse relative to the current window The coordinate system is as 0, 0 as the upper left corner


window.get_mouse_pos(MouseMode::Clamp).map(|mouse| {
    println!("x {} y {}", mouse.0, mouse.1);

pub fn get_unscaled_mouse_pos(&self, mode: MouseMode) -> Option<(f32, f32)>[src]

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.


window.get_unscaled_mouse_pos(MouseMode::Clamp).map(|mouse| {
    println!("x {} y {}", mouse.0, mouse.1);

pub fn get_mouse_down(&self, button: MouseButton) -> bool[src]

Check if a mouse button is down or not


let left_down = window.get_mouse_down(MouseButton::Left);
println!("is left down? {}", left_down)

pub fn get_scroll_wheel(&self) -> Option<(f32, f32)>[src]

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.


window.get_scroll_wheel().map(|scroll| {
    println!("scrolling - x {} y {}", scroll.0, scroll.1);

pub fn set_cursor_style(&mut self, cursor: CursorStyle)[src]

Set a different cursor style. This can be used if you have resizing elements or something like that



pub fn get_keys(&self) -> Option<Vec<Key>>[src]

Get the current keys that are down.


window.get_keys().map(|keys| {
    for t in keys {
        match t {
            Key::W => println!("holding w"),
            Key::T => println!("holding t"),
            _ => (),

pub fn get_keys_pressed(&self, repeat: KeyRepeat) -> Option<Vec<Key>>[src]

Get the current pressed keys. Repeat can be used to control if keys should be repeated if down or not.


window.get_keys_pressed(KeyRepeat::No).map(|keys| {
    for t in keys {
        match t {
            Key::W => println!("pressed w"),
            Key::T => println!("pressed t"),
            _ => (),

pub fn is_key_down(&self, key: Key) -> bool[src]

Check if a single key is down.


if window.is_key_down(Key::A) {
    println!("Key A is down");

pub fn is_key_pressed(&self, key: Key, repeat: KeyRepeat) -> bool[src]

Check if a single key is pressed. KeyRepeat will control if the key should be repeated or not while being pressed.


if window.is_key_pressed(Key::A, KeyRepeat::No) {
    println!("Key A is down");

pub fn is_key_released(&self, key: Key) -> bool[src]

Check if a single key was released since last call to update.

pub fn set_key_repeat_delay(&mut self, delay: f32)[src]

Sets the delay for when a key is being held before it starts being repeated the default value is 0.25 sec


window.set_key_repeat_delay(0.5) // 0.5 sec before repeat starts

pub fn set_key_repeat_rate(&mut self, rate: f32)[src]

Sets the rate in between when the keys has passed the initial repeat_delay. The default value is 0.05 sec


window.set_key_repeat_rate(0.01) // 0.01 sec between keys

pub fn is_active(&mut self) -> bool[src]

Returns if this windows is the current active one

pub fn set_input_callback(&mut self, callback: Box<dyn InputCallback>)[src]

Set input callback to recive callback on char input

pub fn add_menu(&mut self, menu: &Menu) -> MenuHandle[src]

This allows adding menus to your windows. As menus behaves a bit diffrently depending on Operating system here is how it works.

  Each window has their own menu and shortcuts are active depending on active window.
  As Mac uses one menu for the whole program the menu will change depending
  on which window you have active.
  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

pub fn remove_menu(&mut self, handle: MenuHandle)[src]

Remove a menu that has been added with [#add_menu]

pub fn get_unix_menus(&self) -> Option<&Vec<UnixMenu>>[src]

pub fn is_menu_pressed(&mut self) -> Option<usize>[src]

Check if a menu item has been pressed

Trait Implementations

impl Debug for Window[src]

impl HasRawWindowHandle for Window[src]

Auto Trait Implementations

impl !RefUnwindSafe for Window

impl !Send for Window

impl !Sync for Window

impl Unpin for Window

impl !UnwindSafe for Window

Blanket Implementations

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

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

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

impl<T> Downcast for T where
    T: Any

impl<T> From<T> for T[src]

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

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

type Error = Infallible

The type returned in the event of a conversion error.

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.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>,