Struct Window 

pub struct Window { /* private fields */ }

A window

Implementations

impl Window

pub fn new(x: i32, y: i32, w: u32, h: u32, title: &str) -> Option<Self>

Create a new window

Examples found in repository

examples/rect_bench.rs (line 21)

fn main() {
    let mut window = Window::new(10, 10, 800, 600, "RECTANGLE BENCHMARK").unwrap();

    time!("set", { window.set(Color::rgb(255, 255, 255)) });

    time!("rect 400x400", {
        window.rect(0, 0, 400, 400, Color::rgb(0, 0, 255))
    });

    time!("rect 200x200", {
        window.rect(0, 0, 200, 200, Color::rgb(0, 255, 0))
    });

    time!("rect 100x100", {
        window.rect(0, 0, 100, 100, Color::rgb(255, 0, 0))
    });

    time!("sync", {
        window.sync();
    });

    'events: loop {
        for event in window.events() {
            #[allow(clippy::single_match)]
            match event.to_option() {
                EventOption::Quit(_quit_event) => break 'events,
                _ => (),
            }
        }
    }
}

examples/image_bench.rs (line 25)

fn main() {
    //let (width, height) = orbclient::get_display_size().unwrap();

    let mut window = Window::new(10, 10, 800, 600, "IMAGE BENCHMARK").unwrap();

    window.set(Color::rgb(255, 255, 255));

    //create image data : a green square
    let data = vec![Color::rgba(100, 200, 10, 20); 412500];
    let data2 = vec![Color::rgba(200, 100, 10, 20); 412500];
    let data3 = vec![Color::rgba(10, 100, 100, 20); 412500];
    let data4 = vec![Color::rgba(10, 100, 200, 20); 480000];

    //draw image benchmarking
    println!("Benchmarking implementations to draw an image on window:");

    time!("image_legacy", {
        for _i in 0..TIMES {
            window.image_legacy(15, 15, 750, 550, &data[..]);
        }
    });

    time!("image_fast", {
        for _i in 0..TIMES {
            window.image_fast(20, 20, 750, 550, &data2[..]);
        }
    });

    time!("image_opaque", {
        for _i in 0..TIMES {
            window.image_opaque(50, 50, 750, 550, &data3[..]);
        }
    });

    time!("image_over", {
        for _i in 0..TIMES {
            window.image_over(50, &data4[..360000]);
        }
    });

    println!("------------------------------------------------");

    window.sync();

    'events: loop {
        for event in window.events() {
            match event.to_option() {
                EventOption::Quit(_quit_event) => break 'events,
                EventOption::Mouse(evt) => println!(
                    "At position {:?} pixel color is : {:?}",
                    (evt.x, evt.y),
                    window.getpixel(evt.x, evt.y)
                ),
                event_option => println!("{:?}", event_option),
            }
        }
    }
}

examples/simple.rs (lines 8-14)

fn main() {
    let (width, height) = orbclient::get_display_size().unwrap();

    let mut window = Window::new(
        (width as i32) / 4,
        (height as i32) / 4,
        width / 2,
        height / 2,
        "TITLE",
    )
    .unwrap();

    let (win_w, win_h) = (width / 2, height / 2);

    // top left -> bottom rigth
    window.linear_gradient(
        0,
        0,
        win_w / 3,
        win_h,
        0,
        0,
        (win_w / 3) as i32,
        (win_h / 2) as i32,
        Color::rgb(128, 128, 128),
        Color::rgb(255, 255, 255),
    );
    // horizontal gradient
    window.linear_gradient(
        (win_w / 3) as i32,
        0,
        win_w / 3,
        win_h,
        (win_w / 3) as i32,
        0,
        (2 * win_w / 3) as i32,
        0,
        Color::rgb(128, 255, 255),
        Color::rgb(255, 255, 255),
    );
    // vertical gradient
    window.linear_gradient(
        (2 * win_w / 3) as i32,
        0,
        win_w / 3,
        win_h,
        (2 * win_w / 3) as i32,
        0,
        (2 * win_w / 3) as i32,
        win_h as i32,
        Color::rgb(0, 128, 0),
        Color::rgb(255, 255, 255),
    );
    window.arc(100, 100, -25, 1 << 0 | 1 << 2, Color::rgb(0, 0, 255));
    window.arc(100, 100, -25, 1 << 1 | 1 << 3, Color::rgb(0, 255, 255));
    window.arc(100, 100, -25, 1 << 4 | 1 << 6, Color::rgb(255, 0, 255));
    window.arc(100, 100, -25, 1 << 5 | 1 << 7, Color::rgb(255, 255, 0));
    window.circle(100, 100, 25, Color::rgb(0, 0, 0));
    window.circle(100, 101, -25, Color::rgb(0, 255, 0));
    window.circle(220, 220, -100, Color::rgba(128, 128, 128, 80));
    window.wu_circle(150, 220, 100, Color::rgba(255, 0, 0, 255));
    window.line(0, 0, 200, 200, Color::rgb(255, 0, 0));
    window.line(0, 200, 200, 0, Color::rgb(128, 255, 0));
    // vertical and horizontal line test
    window.line(100, 0, 100, 200, Color::rgb(0, 0, 255));
    window.line(0, 100, 200, 100, Color::rgb(255, 255, 0));
    window.wu_line(100, 220, 400, 250, Color::rgba(255, 0, 0, 255));
    window.line(100, 230, 400, 260, Color::rgba(255, 0, 0, 255));

    // path and bezier curve example draw a cloud
    let mut cloud_path = GraphicsPath::new();
    cloud_path.move_to(170, 80);
    cloud_path.bezier_curve_to(130, 100, 130, 150, 230, 150);
    cloud_path.bezier_curve_to(250, 180, 320, 180, 340, 150);
    cloud_path.bezier_curve_to(420, 150, 420, 120, 390, 100);
    cloud_path.bezier_curve_to(430, 40, 370, 30, 340, 50);
    cloud_path.bezier_curve_to(320, 5, 250, 20, 250, 50);
    cloud_path.bezier_curve_to(200, 5, 150, 20, 170, 80);
    window.draw_path_stroke(cloud_path, Color::rgb(0, 0, 255));

    // path and quadratic curve example draw a balloon
    let mut balloon_path = GraphicsPath::new();
    balloon_path.move_to(75, 25);
    balloon_path.quadratic_curve_to(25, 25, 25, 62);
    balloon_path.quadratic_curve_to(25, 100, 50, 100);
    balloon_path.quadratic_curve_to(50, 120, 30, 125);
    balloon_path.quadratic_curve_to(60, 120, 65, 100);
    balloon_path.quadratic_curve_to(125, 100, 125, 62);
    balloon_path.quadratic_curve_to(125, 25, 75, 25);
    window.draw_path_stroke(balloon_path, Color::rgb(0, 0, 255));

    window.char(200, 200, '═', Color::rgb(0, 0, 0));
    window.char(208, 200, '═', Color::rgb(0, 0, 0));

    // testing for non existent x,y position : does not panic but returns Color(0,0,0,0)
    let _non_existent_pixel = window.getpixel(width as i32 + 10, height as i32 + 10);

    // testing PartialEq for Color
    if Color::rgb(11, 2, 3) == Color::rgba(1, 2, 3, 100) {
        println!("Testing colors: they are the same!")
    } else {
        println!("Testing colors: they are NOT the same!")
    }

    //Draw a transparent rectangle over window content
    // default mode is Blend
    window.rect(250, 200, 80, 80, Color::rgba(100, 100, 100, 100));

    //Draw an opaque rectangle replacing window content
    window.mode().set(Mode::Overwrite); // set window drawing mode to Overwrite from now on
    window.rect(300, 220, 80, 80, Color::rgb(100, 100, 100));

    //Draw a hole in the window replacing alpha channel (Only in Orbital, not in SDL2)
    window.rect(300, 100, 80, 80, Color::rgba(10, 10, 10, 1));

    //Draw a transparent rectangle over window content
    window.mode().set(Mode::Blend); //set mode to Blend fron now on
    window.rect(200, 230, 80, 80, Color::rgba(100, 100, 100, 100));

    //Draw a blured box over window content
    window.box_blur(170, 100, 150, 150, 10);

    //Draw a shadow around a box
    window.box_shadow(170, 100, 150, 150, 0, 0, 20, Color::rgba(0, 0, 0, 255));

    window.sync();

    'events: loop {
        for event in window.events() {
            match event.to_option() {
                EventOption::Quit(_quit_event) => break 'events,
                EventOption::Mouse(evt) => println!(
                    "At position {:?} pixel color is : {:?}",
                    (evt.x, evt.y),
                    window.getpixel(evt.x, evt.y)
                ),
                event_option => println!("{:?}", event_option),
            }
        }
    }
}

pub fn new_flags( x: i32, y: i32, w: u32, h: u32, title: &str, flags: &[WindowFlag], ) -> Option<Self>

Create a new window with flags

pub fn event_sender(&self) -> EventSender

pub fn clipboard(&self) -> String

pub fn set_clipboard(&mut self, text: &str)

pub fn pop_drop_content(&self) -> Option<String>

Pops the content of the last drop event from the window.

pub fn sync_path(&mut self)

pub fn x(&self) -> i32

Get x

pub fn y(&self) -> i32

Get y

pub fn title(&self) -> String

Get title

pub fn is_async(&self) -> bool

Get async

pub fn set_async(&mut self, is_async: bool)

Set async

pub fn set_mouse_cursor(&mut self, visible: bool)

Set cursor visibility

pub fn set_mouse_grab(&mut self, grab: bool)

Set mouse grabbing

pub fn set_mouse_relative(&mut self, relative: bool)

Set mouse relative mode

pub fn set_pos(&mut self, x: i32, y: i32)

Set position

pub fn set_size(&mut self, width: u32, height: u32)

Set size

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

Set title

pub fn events(&mut self) -> EventIter

Blocking iterator over events

Examples found in repository

examples/rect_bench.rs (line 42)

fn main() {
    let mut window = Window::new(10, 10, 800, 600, "RECTANGLE BENCHMARK").unwrap();

    time!("set", { window.set(Color::rgb(255, 255, 255)) });

    time!("rect 400x400", {
        window.rect(0, 0, 400, 400, Color::rgb(0, 0, 255))
    });

    time!("rect 200x200", {
        window.rect(0, 0, 200, 200, Color::rgb(0, 255, 0))
    });

    time!("rect 100x100", {
        window.rect(0, 0, 100, 100, Color::rgb(255, 0, 0))
    });

    time!("sync", {
        window.sync();
    });

    'events: loop {
        for event in window.events() {
            #[allow(clippy::single_match)]
            match event.to_option() {
                EventOption::Quit(_quit_event) => break 'events,
                _ => (),
            }
        }
    }
}

examples/image_bench.rs (line 67)

fn main() {
    //let (width, height) = orbclient::get_display_size().unwrap();

    let mut window = Window::new(10, 10, 800, 600, "IMAGE BENCHMARK").unwrap();

    window.set(Color::rgb(255, 255, 255));

    //create image data : a green square
    let data = vec![Color::rgba(100, 200, 10, 20); 412500];
    let data2 = vec![Color::rgba(200, 100, 10, 20); 412500];
    let data3 = vec![Color::rgba(10, 100, 100, 20); 412500];
    let data4 = vec![Color::rgba(10, 100, 200, 20); 480000];

    //draw image benchmarking
    println!("Benchmarking implementations to draw an image on window:");

    time!("image_legacy", {
        for _i in 0..TIMES {
            window.image_legacy(15, 15, 750, 550, &data[..]);
        }
    });

    time!("image_fast", {
        for _i in 0..TIMES {
            window.image_fast(20, 20, 750, 550, &data2[..]);
        }
    });

    time!("image_opaque", {
        for _i in 0..TIMES {
            window.image_opaque(50, 50, 750, 550, &data3[..]);
        }
    });

    time!("image_over", {
        for _i in 0..TIMES {
            window.image_over(50, &data4[..360000]);
        }
    });

    println!("------------------------------------------------");

    window.sync();

    'events: loop {
        for event in window.events() {
            match event.to_option() {
                EventOption::Quit(_quit_event) => break 'events,
                EventOption::Mouse(evt) => println!(
                    "At position {:?} pixel color is : {:?}",
                    (evt.x, evt.y),
                    window.getpixel(evt.x, evt.y)
                ),
                event_option => println!("{:?}", event_option),
            }
        }
    }
}

examples/simple.rs (line 133)

fn main() {
    let (width, height) = orbclient::get_display_size().unwrap();

    let mut window = Window::new(
        (width as i32) / 4,
        (height as i32) / 4,
        width / 2,
        height / 2,
        "TITLE",
    )
    .unwrap();

    let (win_w, win_h) = (width / 2, height / 2);

    // top left -> bottom rigth
    window.linear_gradient(
        0,
        0,
        win_w / 3,
        win_h,
        0,
        0,
        (win_w / 3) as i32,
        (win_h / 2) as i32,
        Color::rgb(128, 128, 128),
        Color::rgb(255, 255, 255),
    );
    // horizontal gradient
    window.linear_gradient(
        (win_w / 3) as i32,
        0,
        win_w / 3,
        win_h,
        (win_w / 3) as i32,
        0,
        (2 * win_w / 3) as i32,
        0,
        Color::rgb(128, 255, 255),
        Color::rgb(255, 255, 255),
    );
    // vertical gradient
    window.linear_gradient(
        (2 * win_w / 3) as i32,
        0,
        win_w / 3,
        win_h,
        (2 * win_w / 3) as i32,
        0,
        (2 * win_w / 3) as i32,
        win_h as i32,
        Color::rgb(0, 128, 0),
        Color::rgb(255, 255, 255),
    );
    window.arc(100, 100, -25, 1 << 0 | 1 << 2, Color::rgb(0, 0, 255));
    window.arc(100, 100, -25, 1 << 1 | 1 << 3, Color::rgb(0, 255, 255));
    window.arc(100, 100, -25, 1 << 4 | 1 << 6, Color::rgb(255, 0, 255));
    window.arc(100, 100, -25, 1 << 5 | 1 << 7, Color::rgb(255, 255, 0));
    window.circle(100, 100, 25, Color::rgb(0, 0, 0));
    window.circle(100, 101, -25, Color::rgb(0, 255, 0));
    window.circle(220, 220, -100, Color::rgba(128, 128, 128, 80));
    window.wu_circle(150, 220, 100, Color::rgba(255, 0, 0, 255));
    window.line(0, 0, 200, 200, Color::rgb(255, 0, 0));
    window.line(0, 200, 200, 0, Color::rgb(128, 255, 0));
    // vertical and horizontal line test
    window.line(100, 0, 100, 200, Color::rgb(0, 0, 255));
    window.line(0, 100, 200, 100, Color::rgb(255, 255, 0));
    window.wu_line(100, 220, 400, 250, Color::rgba(255, 0, 0, 255));
    window.line(100, 230, 400, 260, Color::rgba(255, 0, 0, 255));

    // path and bezier curve example draw a cloud
    let mut cloud_path = GraphicsPath::new();
    cloud_path.move_to(170, 80);
    cloud_path.bezier_curve_to(130, 100, 130, 150, 230, 150);
    cloud_path.bezier_curve_to(250, 180, 320, 180, 340, 150);
    cloud_path.bezier_curve_to(420, 150, 420, 120, 390, 100);
    cloud_path.bezier_curve_to(430, 40, 370, 30, 340, 50);
    cloud_path.bezier_curve_to(320, 5, 250, 20, 250, 50);
    cloud_path.bezier_curve_to(200, 5, 150, 20, 170, 80);
    window.draw_path_stroke(cloud_path, Color::rgb(0, 0, 255));

    // path and quadratic curve example draw a balloon
    let mut balloon_path = GraphicsPath::new();
    balloon_path.move_to(75, 25);
    balloon_path.quadratic_curve_to(25, 25, 25, 62);
    balloon_path.quadratic_curve_to(25, 100, 50, 100);
    balloon_path.quadratic_curve_to(50, 120, 30, 125);
    balloon_path.quadratic_curve_to(60, 120, 65, 100);
    balloon_path.quadratic_curve_to(125, 100, 125, 62);
    balloon_path.quadratic_curve_to(125, 25, 75, 25);
    window.draw_path_stroke(balloon_path, Color::rgb(0, 0, 255));

    window.char(200, 200, '═', Color::rgb(0, 0, 0));
    window.char(208, 200, '═', Color::rgb(0, 0, 0));

    // testing for non existent x,y position : does not panic but returns Color(0,0,0,0)
    let _non_existent_pixel = window.getpixel(width as i32 + 10, height as i32 + 10);

    // testing PartialEq for Color
    if Color::rgb(11, 2, 3) == Color::rgba(1, 2, 3, 100) {
        println!("Testing colors: they are the same!")
    } else {
        println!("Testing colors: they are NOT the same!")
    }

    //Draw a transparent rectangle over window content
    // default mode is Blend
    window.rect(250, 200, 80, 80, Color::rgba(100, 100, 100, 100));

    //Draw an opaque rectangle replacing window content
    window.mode().set(Mode::Overwrite); // set window drawing mode to Overwrite from now on
    window.rect(300, 220, 80, 80, Color::rgb(100, 100, 100));

    //Draw a hole in the window replacing alpha channel (Only in Orbital, not in SDL2)
    window.rect(300, 100, 80, 80, Color::rgba(10, 10, 10, 1));

    //Draw a transparent rectangle over window content
    window.mode().set(Mode::Blend); //set mode to Blend fron now on
    window.rect(200, 230, 80, 80, Color::rgba(100, 100, 100, 100));

    //Draw a blured box over window content
    window.box_blur(170, 100, 150, 150, 10);

    //Draw a shadow around a box
    window.box_shadow(170, 100, 150, 150, 0, 0, 20, Color::rgba(0, 0, 0, 255));

    window.sync();

    'events: loop {
        for event in window.events() {
            match event.to_option() {
                EventOption::Quit(_quit_event) => break 'events,
                EventOption::Mouse(evt) => println!(
                    "At position {:?} pixel color is : {:?}",
                    (evt.x, evt.y),
                    window.getpixel(evt.x, evt.y)
                ),
                event_option => println!("{:?}", event_option),
            }
        }
    }
}

pub fn id(&self) -> u32

Returns the id

Trait Implementations

impl AsRawFd for Window

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl Drop for Window

fn drop(&mut self)

Executes the destructor for this type.

impl FromRawFd for Window

unsafe fn from_raw_fd(_fd: RawFd) -> Window

Constructs a new instance of Self from the given raw file descriptor.

impl IntoRawFd for Window

fn into_raw_fd(self) -> RawFd

Consumes this object, returning the raw underlying file descriptor.

impl Renderer for Window

fn width(&self) -> u32

Get width

fn height(&self) -> u32

Get height

fn data(&self) -> &[Color]

Access pixel buffer

fn data_mut(&mut self) -> &mut [Color]

Access pixel buffer mutably

fn sync(&mut self) -> bool

Flip the window buffer

fn mode(&self) -> &Cell<Mode>

Set/get mode

fn pixel(&mut self, x: i32, y: i32, color: Color)

Draw a pixel

fn arc(&mut self, x0: i32, y0: i32, radius: i32, parts: u8, color: Color)

Draw a piece of an arc. Negative radius will fill in the inside

fn circle(&mut self, x0: i32, y0: i32, radius: i32, color: Color)

Draw a circle. Negative radius will fill in the inside

fn line4points(&mut self, x0: i32, y0: i32, x: i32, y: i32, color: Color)

fn line(&mut self, argx1: i32, argy1: i32, argx2: i32, argy2: i32, color: Color)

Draw a line

fn lines(&mut self, points: &[[i32; 2]], color: Color)

fn draw_path_stroke(&mut self, graphicspath: GraphicsPath, color: Color)

Draw a path (GraphicsPath)

fn char(&mut self, x: i32, y: i32, c: char, color: Color)

Draw a character, using the loaded font

fn set(&mut self, color: Color)

Set entire window to a color

fn clear(&mut self)

Sets the whole window to black

fn rect(&mut self, x: i32, y: i32, w: u32, h: u32, color: Color)

fn box_blur(&mut self, x: i32, y: i32, w: u32, h: u32, r: i32)

fn box_shadow( &mut self, x: i32, y: i32, w: u32, h: u32, offset_x: i32, offset_y: i32, r: i32, color: Color, )

fn image(&mut self, start_x: i32, start_y: i32, w: u32, h: u32, data: &[Color])

Display an image

fn image_legacy( &mut self, start_x: i32, start_y: i32, w: u32, h: u32, data: &[Color], )

fn image_over(&mut self, start: i32, image_data: &[Color])

Display an image overwriting a portion of window starting at given line : very quick!!

fn image_opaque( &mut self, start_x: i32, start_y: i32, w: u32, h: u32, image_data: &[Color], )

Display an image using non transparent method

fn image_fast( &mut self, start_x: i32, start_y: i32, w: u32, h: u32, image_data: &[Color], )

fn linear_gradient( &mut self, rect_x: i32, rect_y: i32, rect_width: u32, rect_height: u32, start_x: i32, start_y: i32, end_x: i32, end_y: i32, start_color: Color, end_color: Color, )

Draw a linear gradient in a rectangular region

fn rounded_rect( &mut self, x: i32, y: i32, w: u32, h: u32, radius: u32, filled: bool, color: Color, )

Draw a rect with rounded corners

fn wu_line(&mut self, x0: i32, y0: i32, x1: i32, y1: i32, color: Color)

Draws antialiased line

fn wu_circle(&mut self, x0: i32, y0: i32, radius: i32, color: Color)

Draws antialiased circle

fn getpixel(&self, x: i32, y: i32) -> Color

Gets pixel color at x,y position