Struct minifb::Window [−] [src]

pub struct Window(_);

Methods

impl Window
[src]

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.

Examples

Open up a window and display a 32-bit RGB buffer (without error checking)

const WIDTH: usize = 640;
const HEIGHT: usize = 360;

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

let mut window = match Window::new("Test - Press ESC to exit", WIDTH, HEIGHT,
                                    WindowOptions::default()).unwrap()

while window.is_open() && !window.is_key_down(Key::Escape) {
    for i in buffer.iter_mut() {
        *i = 0; // write something interesting here
    }
    window.update_with_buffer(&buffer);
}

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

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

fn update_with_buffer(&mut self, buffer: &[u32])

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

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

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(...)
}

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

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

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)

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

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"),
            _ => (),
        }
    }
});

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"),
            _ => (),
        }
    }
});

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

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

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

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

fn is_active(&mut self) -> bool

Returns if this windows is the current active one

fn add_menu(&mut self, menu_name: &str, menu: &Vec<Menu>) -> Result<()>

This allows adding menus to your windows. As menus behaves a bit diffrently depending on Operating system here is how it works. See [Menu] for description on each field.

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.

fn update_menu(&mut self, menu_name: &str, menu: &Vec<Menu>) -> Result<()>

Updates an existing menu created with [add_menu]

fn remove_menu(&mut self, menu_name: &str) -> Result<()>

Remove a menu that has been added with [add_menu]

fn is_menu_pressed(&mut self) -> Option<usize>

Check if a menu item has been pressed