Struct MlxWindow

pub struct MlxWindow { /* private fields */ }

Hook api holder. Needed in most Mlx methods.

With hooks, you can provide closures that will run when an event occurs.

The mlx.event_loop method should run for these hooks to be executed.

Implementations

impl MlxWindow

pub fn mouse_hook<F, Args>(&self, cb: F, args: &'static Args)

where F: FnMut(i32, i32, i32, &'static Args) + 'static,

Hook running whenever a mouse event is received.

F should be a closure taking 4 arguments: the buttons, x, y and the data you provide as last argument of the mouse_hook call.

Usage:

let arg = (2, 3);
window.mouse_hook(|buttons, x, y, args| {
    println!("{} {}, {}, ({}, {})", buttons, x, y, args.0, args.1);
}, &arg);

pub fn key_hook<F, Args>(&self, cb: F, args: &'static Args)

where F: FnMut(i32, &'static Args) + 'static,

Hook running whenever a key event is received.

F should be a closure taking 2 arguments: the keycode and the data you provide as last argument of the mouse_hook call.

Usage:

let arg = (2, 3);
window.key_hook(|keycode, args| {
    println!("{}, ({}, {})", keycode, args.0, args.1);
}, &arg);

Examples found in repository

examples/example.rs (lines 41-62)

fn main() {
    let mlx = Mlx::new().unwrap();

    let width = 1080;
    let height = 720;
    let window = mlx.new_window(width, height, "Mlx example").unwrap();

    let image = match mlx.new_image(width, height) {
        Ok(img) => img,
        Err(e) => match e {
            MlxError::Any(s) => return println!("{}", s),
            _ => return,
        },
    };

    let _bytes_per_pixel = image.bits_per_pixel / 8;
    let offset = image.size_line / 2 + image.size_line * height / 2;
    for i in 1..100 {
        // we assume there are 32 bits per pixel here, because its just an example.
        // color encoding can go from 8 bits to 48 bits.
        let offset = offset + i * 4;
        match image.endian {
            Endian::Little => {
                image.write_to(offset + 2, 0xff); // R
                image.write_to(offset + 1, 0x0); // G
                image.write_to(offset, 0x0); // B
            }
            Endian::Big => {
                image.write_to(offset, 0xff); // R
                image.write_to(offset + 1, 0x0); // G
                image.write_to(offset + 2, 0x0); // B
            }
        }
    }

    window.key_hook(
        move |keycode, _| {
            // you can also check keycodes using the `xev` command
            println!("{}", keycode);

            // `q`
            if keycode == 113 {
                process::exit(0);
            // Enter
            } else if keycode == 97 {
                let x = width / 2;
                let y = height / 2;
                let color = 0xffffff;
                for i in 0..50 {
                    mlx.pixel_put(&window, x + i, y + i, color);
                }
            } else if keycode == 98 {
                mlx.put_image_to_window(&window, &image, 0, 0);
            }
        },
        &(),
    );

    // this will loop forever
    mlx.event_loop();
}

pub fn expose_hook<F, Args>(&self, cb: F, args: &'static Args)

where F: FnMut(&'static Args) + 'static,

Hook running whenever an ‘expose’ event is received.

F should be a closure taking the data you pass as an argument.

Usage:

let arg = (2, 3);
window.expose_hook(|args| {
    println!("({}, {})", args.0, args.1);
}, &arg);

The expose hook is running whenever the window or part of it should be redrawn.

pub fn loop_hook<F, Args>(&self, cb: F, args: &'static Args)

where F: FnMut(&'static Args) + 'static,

Hook running when no event occurs.

F should be a closure taking the data you pass as an argument.

Usage:

let arg = (2, 3);
window.loop_hook(|args| {
    println!("({}, {})", args.0, args.1);
}, &arg);

pub fn hook<F, Args>( &self, x_event: i32, x_mask: i32, cb: F, args: &'static Args, )

where F: FnMut(&'static Args) + 'static,

Hook running whenever the event you specify occurs.

F should be a closure taking the data you pass as an argument.

Usage:

let arg = (2, 3);
let x_event = 2; // keypress
let x_mask = 0; // no mask
window.hook(x_event, x_mask, |args| {
    println!("({}, {})", args.0, args.1);
}, &arg);

You can find informations on x events in /usr/include/X11/X.h around line 180 and x event masks around line 150.

Trait Implementations

impl Clone for MlxWindow

fn clone(&self) -> MlxWindow

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for MlxWindow