Struct Mlx

pub struct Mlx { /* private fields */ }

Api method holder.

Implementations

impl Mlx

pub fn new() -> Result<Self, MlxError>

Creates a new Mlx instance.

Calls the mlx_init C method under the hood.

Usage:

let mlx = Mlx::new().unwrap();

Examples found in repository

examples/example.rs (line 7)

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 new_window( &self, size_x: i32, size_y: i32, title: &str, ) -> Result<MlxWindow, MlxError>

Creates a new window instance.

Usage:

 let image = mlx.new_window(1920, 1080, "mlx-example").unwrap();

Examples found in repository

examples/example.rs (line 11)

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 clear_window(&self, window: &MlxWindow)

Clears the window with black.

pub fn destroy_window(&self, window: &MlxWindow)

Destroys the window. This function also drops the window object.

pub fn get_screen_size(&self) -> (i32, i32)

Get the actual screen size.

pub fn pixel_put(&self, window: &MlxWindow, x: i32, y: i32, color: i32)

Put a pixel on the screen

You should encode the color as RGB on the three last bytes of the int.

0x00|ff(R)|ff(G)|ff(B)

Usage:

 let x = 200;
 let y = 300;
 let color = 0x0000ff; // blue
 mlx.pixel_put(&window, x, y, color);

Examples found in repository

examples/example.rs (line 55)

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 string_put( &self, window: &MlxWindow, x: i32, y: i32, color: i32, s: &str, ) -> Result<(), MlxError>

Writes a string on the screen

Color is encoded in rgb as well. Usage:

 let x = 200;
 let y = 300;
 let color = 0xff0000; // red
 mlx.string_put(&window, x, y, color, "Hello World");

pub fn new_image(&self, width: i32, height: i32) -> Result<MlxImage, MlxError>

Creates a new image.

Examples found in repository

examples/example.rs (line 13)

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 xpm_to_image(&self, xpm_data: Vec<String>) -> Result<MlxImage, MlxError>

Creates a new image from xpm data.

Note that the minilibx does not use the standard Xpm library. You may not be able to read all types of xpm images.

It however handles transparency.

pub fn xpm_file_to_image(&self, filename: &str) -> Result<MlxImage, MlxError>

Creates a new image from an xpm file.

pub fn destroy_image(&self, image: &MlxImage)

Destroy the image. Also drops the image instance.

pub fn put_image_to_window( &self, window: &MlxWindow, image: &MlxImage, x: i32, y: i32, )

Draws an image to the window

Usage:

 let x = 200;
 let y = 200;
 mlx.put_image_to_window(&window, &image, x, y);

Examples found in repository

examples/example.rs (line 58)

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 get_color_value(&self, color: i32) -> u32

Transforms an RGB color parameter into a u32 value.

This returns a bits_per_pixel value of the rgb value.

You can use this to write into an image

pub fn do_key_autorepeaton(&self)

Enables key autorepeat when pressing a key

pub fn do_key_autorepeatoff(&self)

Disables key autorepeat when pressing a key

pub fn mouse_move(&self, window: &MlxWindow, x: i32, y: i32)

Moves the mouse cursor

pub fn mouse_show(&self, window: &MlxWindow)

Shows the mouse cursor

pub fn mouse_hide(&self, window: &MlxWindow)

Hides the mouse cursor

pub fn event_loop(&self)

Run the event loop.

This is running an infinite loop which launches hooks when receiving events.

Examples found in repository

examples/example.rs (line 65)

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

Trait Implementations

impl Clone for Mlx

fn clone(&self) -> Mlx

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Mlx