Struct fltk::app::Screen

pub struct Screen {
    pub n: i32,
}

An available screen

Unlike the standalone functions, it automatically checks the provided coordinates and screen numbers are currently valid and inside boundaries.

Fields

n: i32

The screen number

Implementations

impl Screen

pub fn all_screens() -> Vec<Screen>

Returns a vector containing all the Screens, ordered by screen number

Examples found in repository

examples/screens_info.rs (line 8)

fn main() {
    let screens = Screen::all_screens();
    println!("Number of detected screens = {}\n", screens.len());
    assert_eq![screens.len(), Screen::count() as usize];

    println!("Is scaling supported:");
    println!("- at all = {}", Screen::scaling_supported());
    println!("- separately = {}", Screen::scaling_supported_separately());

    let coord: Coord = [100, 100].into();
    let rect: Rect = [100, 100, 100, 100].into();

    // uncomment these lines to see out-of-boundaries errors:
    // let coord: Coord = [-100, 10_000].into();
    // let rect: Rect = [-100, 100, 10_000, 10_000].into();

    println!("\nScreen found:");
    println!("- at {coord:?} = {:?}", Screen::new_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::new_inside(rect));

    println!("\nWork area:");
    println!("- at {coord:?} = {:?}", Screen::work_area_at(coord));
    println!("- under the mouse = {:?}", Screen::work_area_mouse());

    println!("\nXYWH:");
    println!("- at {coord:?} = {:?}", Screen::xywh_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::xywh_inside(rect));
    println!("- under the mouse = {:?}", Screen::xywh_mouse());

    println!("\nFor each screen:");
    for s in screens {
        println!("+ {s:?}");
        println!("  - work area = {:?}:", s.work_area());
        println!("  - dpi = {:?}", s.dpi());
        println!("  - scale = {:?}", s.scale());
    }
}

pub fn new(number: i32) -> Result<Screen, FltkError>

Returns the Screen associated with the given screen number

Returns an error if the provided number is not a valid screen number.

pub fn new_at<C: Into<Coordinates<i32>> + Copy>(
    pos: C
) -> Result<Screen, FltkError>

Returns the Screen that contains the specified screen position

Returns an error if the provided coordinates are out of bounds.

Examples found in repository

examples/screens_info.rs (line 24)

fn main() {
    let screens = Screen::all_screens();
    println!("Number of detected screens = {}\n", screens.len());
    assert_eq![screens.len(), Screen::count() as usize];

    println!("Is scaling supported:");
    println!("- at all = {}", Screen::scaling_supported());
    println!("- separately = {}", Screen::scaling_supported_separately());

    let coord: Coord = [100, 100].into();
    let rect: Rect = [100, 100, 100, 100].into();

    // uncomment these lines to see out-of-boundaries errors:
    // let coord: Coord = [-100, 10_000].into();
    // let rect: Rect = [-100, 100, 10_000, 10_000].into();

    println!("\nScreen found:");
    println!("- at {coord:?} = {:?}", Screen::new_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::new_inside(rect));

    println!("\nWork area:");
    println!("- at {coord:?} = {:?}", Screen::work_area_at(coord));
    println!("- under the mouse = {:?}", Screen::work_area_mouse());

    println!("\nXYWH:");
    println!("- at {coord:?} = {:?}", Screen::xywh_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::xywh_inside(rect));
    println!("- under the mouse = {:?}", Screen::xywh_mouse());

    println!("\nFor each screen:");
    for s in screens {
        println!("+ {s:?}");
        println!("  - work area = {:?}:", s.work_area());
        println!("  - dpi = {:?}", s.dpi());
        println!("  - scale = {:?}", s.scale());
    }
}

pub fn new_inside<R: Into<Rect> + Copy>(rect: R) -> Result<Screen, FltkError>

Returns the Screen which intersects the most with the provided rectangle

Returns an error if any coordinates on the provided retangle are out of bounds.

Examples found in repository

examples/screens_info.rs (line 25)

fn main() {
    let screens = Screen::all_screens();
    println!("Number of detected screens = {}\n", screens.len());
    assert_eq![screens.len(), Screen::count() as usize];

    println!("Is scaling supported:");
    println!("- at all = {}", Screen::scaling_supported());
    println!("- separately = {}", Screen::scaling_supported_separately());

    let coord: Coord = [100, 100].into();
    let rect: Rect = [100, 100, 100, 100].into();

    // uncomment these lines to see out-of-boundaries errors:
    // let coord: Coord = [-100, 10_000].into();
    // let rect: Rect = [-100, 100, 10_000, 10_000].into();

    println!("\nScreen found:");
    println!("- at {coord:?} = {:?}", Screen::new_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::new_inside(rect));

    println!("\nWork area:");
    println!("- at {coord:?} = {:?}", Screen::work_area_at(coord));
    println!("- under the mouse = {:?}", Screen::work_area_mouse());

    println!("\nXYWH:");
    println!("- at {coord:?} = {:?}", Screen::xywh_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::xywh_inside(rect));
    println!("- under the mouse = {:?}", Screen::xywh_mouse());

    println!("\nFor each screen:");
    for s in screens {
        println!("+ {s:?}");
        println!("  - work area = {:?}:", s.work_area());
        println!("  - dpi = {:?}", s.dpi());
        println!("  - scale = {:?}", s.scale());
    }
}

pub fn scaling_supported() -> bool

Returns true if scaling factors are supported by this platform, wether shared by all screens, or each screen having its own value

Examples found in repository

examples/screens_info.rs (line 13)

fn main() {
    let screens = Screen::all_screens();
    println!("Number of detected screens = {}\n", screens.len());
    assert_eq![screens.len(), Screen::count() as usize];

    println!("Is scaling supported:");
    println!("- at all = {}", Screen::scaling_supported());
    println!("- separately = {}", Screen::scaling_supported_separately());

    let coord: Coord = [100, 100].into();
    let rect: Rect = [100, 100, 100, 100].into();

    // uncomment these lines to see out-of-boundaries errors:
    // let coord: Coord = [-100, 10_000].into();
    // let rect: Rect = [-100, 100, 10_000, 10_000].into();

    println!("\nScreen found:");
    println!("- at {coord:?} = {:?}", Screen::new_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::new_inside(rect));

    println!("\nWork area:");
    println!("- at {coord:?} = {:?}", Screen::work_area_at(coord));
    println!("- under the mouse = {:?}", Screen::work_area_mouse());

    println!("\nXYWH:");
    println!("- at {coord:?} = {:?}", Screen::xywh_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::xywh_inside(rect));
    println!("- under the mouse = {:?}", Screen::xywh_mouse());

    println!("\nFor each screen:");
    for s in screens {
        println!("+ {s:?}");
        println!("  - work area = {:?}:", s.work_area());
        println!("  - dpi = {:?}", s.dpi());
        println!("  - scale = {:?}", s.scale());
    }
}

pub fn scaling_supported_separately() -> bool

Returns true if each screen can have its own scaling factor value

Examples found in repository

examples/screens_info.rs (line 14)

fn main() {
    let screens = Screen::all_screens();
    println!("Number of detected screens = {}\n", screens.len());
    assert_eq![screens.len(), Screen::count() as usize];

    println!("Is scaling supported:");
    println!("- at all = {}", Screen::scaling_supported());
    println!("- separately = {}", Screen::scaling_supported_separately());

    let coord: Coord = [100, 100].into();
    let rect: Rect = [100, 100, 100, 100].into();

    // uncomment these lines to see out-of-boundaries errors:
    // let coord: Coord = [-100, 10_000].into();
    // let rect: Rect = [-100, 100, 10_000, 10_000].into();

    println!("\nScreen found:");
    println!("- at {coord:?} = {:?}", Screen::new_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::new_inside(rect));

    println!("\nWork area:");
    println!("- at {coord:?} = {:?}", Screen::work_area_at(coord));
    println!("- under the mouse = {:?}", Screen::work_area_mouse());

    println!("\nXYWH:");
    println!("- at {coord:?} = {:?}", Screen::xywh_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::xywh_inside(rect));
    println!("- under the mouse = {:?}", Screen::xywh_mouse());

    println!("\nFor each screen:");
    for s in screens {
        println!("+ {s:?}");
        println!("  - work area = {:?}:", s.work_area());
        println!("  - dpi = {:?}", s.dpi());
        println!("  - scale = {:?}", s.scale());
    }
}

pub fn count() -> i32

Returns the number of available screens

Examples found in repository

examples/screens_info.rs (line 10)

fn main() {
    let screens = Screen::all_screens();
    println!("Number of detected screens = {}\n", screens.len());
    assert_eq![screens.len(), Screen::count() as usize];

    println!("Is scaling supported:");
    println!("- at all = {}", Screen::scaling_supported());
    println!("- separately = {}", Screen::scaling_supported_separately());

    let coord: Coord = [100, 100].into();
    let rect: Rect = [100, 100, 100, 100].into();

    // uncomment these lines to see out-of-boundaries errors:
    // let coord: Coord = [-100, 10_000].into();
    // let rect: Rect = [-100, 100, 10_000, 10_000].into();

    println!("\nScreen found:");
    println!("- at {coord:?} = {:?}", Screen::new_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::new_inside(rect));

    println!("\nWork area:");
    println!("- at {coord:?} = {:?}", Screen::work_area_at(coord));
    println!("- under the mouse = {:?}", Screen::work_area_mouse());

    println!("\nXYWH:");
    println!("- at {coord:?} = {:?}", Screen::xywh_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::xywh_inside(rect));
    println!("- under the mouse = {:?}", Screen::xywh_mouse());

    println!("\nFor each screen:");
    for s in screens {
        println!("+ {s:?}");
        println!("  - work area = {:?}:", s.work_area());
        println!("  - dpi = {:?}", s.dpi());
        println!("  - scale = {:?}", s.scale());
    }
}

pub fn num_at<C: Into<Coordinates<i32>> + Copy>(
    pos: C
) -> Result<i32, FltkError>

Returns the screen number of the screen that contains the specified screen position coordinates

Returns an error if the provided coordinates are out of bounds.

pub fn work_area_at<C: Into<Coordinates<i32>> + Copy>(
    pos: C
) -> Result<Rect, FltkError>

Returns the bounding rectangle of the work area of the screen that contains the specified screen position coordinates

Returns an error if the provided coordinates are out of bounds.

Examples found in repository

examples/screens_info.rs (line 28)

fn main() {
    let screens = Screen::all_screens();
    println!("Number of detected screens = {}\n", screens.len());
    assert_eq![screens.len(), Screen::count() as usize];

    println!("Is scaling supported:");
    println!("- at all = {}", Screen::scaling_supported());
    println!("- separately = {}", Screen::scaling_supported_separately());

    let coord: Coord = [100, 100].into();
    let rect: Rect = [100, 100, 100, 100].into();

    // uncomment these lines to see out-of-boundaries errors:
    // let coord: Coord = [-100, 10_000].into();
    // let rect: Rect = [-100, 100, 10_000, 10_000].into();

    println!("\nScreen found:");
    println!("- at {coord:?} = {:?}", Screen::new_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::new_inside(rect));

    println!("\nWork area:");
    println!("- at {coord:?} = {:?}", Screen::work_area_at(coord));
    println!("- under the mouse = {:?}", Screen::work_area_mouse());

    println!("\nXYWH:");
    println!("- at {coord:?} = {:?}", Screen::xywh_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::xywh_inside(rect));
    println!("- under the mouse = {:?}", Screen::xywh_mouse());

    println!("\nFor each screen:");
    for s in screens {
        println!("+ {s:?}");
        println!("  - work area = {:?}:", s.work_area());
        println!("  - dpi = {:?}", s.dpi());
        println!("  - scale = {:?}", s.scale());
    }
}

pub fn work_area_mouse() -> Rect

Returns the bounding rectangle of the work area of the screen currently under the mouse pointer coordinates

Examples found in repository

examples/screens_info.rs (line 29)

fn main() {
    let screens = Screen::all_screens();
    println!("Number of detected screens = {}\n", screens.len());
    assert_eq![screens.len(), Screen::count() as usize];

    println!("Is scaling supported:");
    println!("- at all = {}", Screen::scaling_supported());
    println!("- separately = {}", Screen::scaling_supported_separately());

    let coord: Coord = [100, 100].into();
    let rect: Rect = [100, 100, 100, 100].into();

    // uncomment these lines to see out-of-boundaries errors:
    // let coord: Coord = [-100, 10_000].into();
    // let rect: Rect = [-100, 100, 10_000, 10_000].into();

    println!("\nScreen found:");
    println!("- at {coord:?} = {:?}", Screen::new_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::new_inside(rect));

    println!("\nWork area:");
    println!("- at {coord:?} = {:?}", Screen::work_area_at(coord));
    println!("- under the mouse = {:?}", Screen::work_area_mouse());

    println!("\nXYWH:");
    println!("- at {coord:?} = {:?}", Screen::xywh_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::xywh_inside(rect));
    println!("- under the mouse = {:?}", Screen::xywh_mouse());

    println!("\nFor each screen:");
    for s in screens {
        println!("+ {s:?}");
        println!("  - work area = {:?}:", s.work_area());
        println!("  - dpi = {:?}", s.dpi());
        println!("  - scale = {:?}", s.scale());
    }
}

pub fn work_area_num(number: i32) -> Result<Rect, FltkError>

Returns the bounding rectangle of the work area with the provided screen number

Returns an error if the provided number is not a valid screen number.

pub fn xywh_at<C: Into<Coordinates<i32>> + Copy>(
    pos: C
) -> Result<Rect, FltkError>

Returns the bounding rectangle of the screen that contains the specified screen position coordinates

Returns an error if the provided coordinates are out of bounds.

Examples found in repository

examples/screens_info.rs (line 32)

fn main() {
    let screens = Screen::all_screens();
    println!("Number of detected screens = {}\n", screens.len());
    assert_eq![screens.len(), Screen::count() as usize];

    println!("Is scaling supported:");
    println!("- at all = {}", Screen::scaling_supported());
    println!("- separately = {}", Screen::scaling_supported_separately());

    let coord: Coord = [100, 100].into();
    let rect: Rect = [100, 100, 100, 100].into();

    // uncomment these lines to see out-of-boundaries errors:
    // let coord: Coord = [-100, 10_000].into();
    // let rect: Rect = [-100, 100, 10_000, 10_000].into();

    println!("\nScreen found:");
    println!("- at {coord:?} = {:?}", Screen::new_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::new_inside(rect));

    println!("\nWork area:");
    println!("- at {coord:?} = {:?}", Screen::work_area_at(coord));
    println!("- under the mouse = {:?}", Screen::work_area_mouse());

    println!("\nXYWH:");
    println!("- at {coord:?} = {:?}", Screen::xywh_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::xywh_inside(rect));
    println!("- under the mouse = {:?}", Screen::xywh_mouse());

    println!("\nFor each screen:");
    for s in screens {
        println!("+ {s:?}");
        println!("  - work area = {:?}:", s.work_area());
        println!("  - dpi = {:?}", s.dpi());
        println!("  - scale = {:?}", s.scale());
    }
}

pub fn xywh_inside<R: Into<Rect> + Copy>(rect: R) -> Result<Rect, FltkError>

Returns the bounding rectangle of the screen that contains the specified screen position coordinates

Returns an error if the provided coordinates are out of bounds.

Examples found in repository

examples/screens_info.rs (line 33)

fn main() {
    let screens = Screen::all_screens();
    println!("Number of detected screens = {}\n", screens.len());
    assert_eq![screens.len(), Screen::count() as usize];

    println!("Is scaling supported:");
    println!("- at all = {}", Screen::scaling_supported());
    println!("- separately = {}", Screen::scaling_supported_separately());

    let coord: Coord = [100, 100].into();
    let rect: Rect = [100, 100, 100, 100].into();

    // uncomment these lines to see out-of-boundaries errors:
    // let coord: Coord = [-100, 10_000].into();
    // let rect: Rect = [-100, 100, 10_000, 10_000].into();

    println!("\nScreen found:");
    println!("- at {coord:?} = {:?}", Screen::new_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::new_inside(rect));

    println!("\nWork area:");
    println!("- at {coord:?} = {:?}", Screen::work_area_at(coord));
    println!("- under the mouse = {:?}", Screen::work_area_mouse());

    println!("\nXYWH:");
    println!("- at {coord:?} = {:?}", Screen::xywh_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::xywh_inside(rect));
    println!("- under the mouse = {:?}", Screen::xywh_mouse());

    println!("\nFor each screen:");
    for s in screens {
        println!("+ {s:?}");
        println!("  - work area = {:?}:", s.work_area());
        println!("  - dpi = {:?}", s.dpi());
        println!("  - scale = {:?}", s.scale());
    }
}

pub fn xywh_mouse() -> Rect

Gets the bounding rectangle of the screen currently under the mouse pointer coordinates

Examples found in repository

examples/screens_info.rs (line 34)

fn main() {
    let screens = Screen::all_screens();
    println!("Number of detected screens = {}\n", screens.len());
    assert_eq![screens.len(), Screen::count() as usize];

    println!("Is scaling supported:");
    println!("- at all = {}", Screen::scaling_supported());
    println!("- separately = {}", Screen::scaling_supported_separately());

    let coord: Coord = [100, 100].into();
    let rect: Rect = [100, 100, 100, 100].into();

    // uncomment these lines to see out-of-boundaries errors:
    // let coord: Coord = [-100, 10_000].into();
    // let rect: Rect = [-100, 100, 10_000, 10_000].into();

    println!("\nScreen found:");
    println!("- at {coord:?} = {:?}", Screen::new_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::new_inside(rect));

    println!("\nWork area:");
    println!("- at {coord:?} = {:?}", Screen::work_area_at(coord));
    println!("- under the mouse = {:?}", Screen::work_area_mouse());

    println!("\nXYWH:");
    println!("- at {coord:?} = {:?}", Screen::xywh_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::xywh_inside(rect));
    println!("- under the mouse = {:?}", Screen::xywh_mouse());

    println!("\nFor each screen:");
    for s in screens {
        println!("+ {s:?}");
        println!("  - work area = {:?}:", s.work_area());
        println!("  - dpi = {:?}", s.dpi());
        println!("  - scale = {:?}", s.scale());
    }
}

pub fn xywh_num(number: i32) -> Result<Rect, FltkError>

Returns the bounding rectangle of the screen with the provided screen number

Returns an error if the provided number is not a valid screen number.

pub fn keyboard_scaling(value: bool)

Controls the possibility to scale all windows by ctrl/+/-/0/ or cmd/+/-/0/

This function should be called before app::open_display runs. If it is not called, the default is to handle these keys for window scaling.

Pass a value of false to stop recognition of ctrl/+/-/0/ (or cmd/+/-/0/ under macOS) keys as window scaling.

pub fn is_valid(&self) -> bool

Returns true if the current screen’s number corresponds to a currently connected screen, or false otherwise.

pub fn dpi(&self) -> (f32, f32)

Returns the current screen (vertical, horizontal) resolution in dots-per-inch

Examples found in repository

examples/screens_info.rs (line 40)

fn main() {
    let screens = Screen::all_screens();
    println!("Number of detected screens = {}\n", screens.len());
    assert_eq![screens.len(), Screen::count() as usize];

    println!("Is scaling supported:");
    println!("- at all = {}", Screen::scaling_supported());
    println!("- separately = {}", Screen::scaling_supported_separately());

    let coord: Coord = [100, 100].into();
    let rect: Rect = [100, 100, 100, 100].into();

    // uncomment these lines to see out-of-boundaries errors:
    // let coord: Coord = [-100, 10_000].into();
    // let rect: Rect = [-100, 100, 10_000, 10_000].into();

    println!("\nScreen found:");
    println!("- at {coord:?} = {:?}", Screen::new_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::new_inside(rect));

    println!("\nWork area:");
    println!("- at {coord:?} = {:?}", Screen::work_area_at(coord));
    println!("- under the mouse = {:?}", Screen::work_area_mouse());

    println!("\nXYWH:");
    println!("- at {coord:?} = {:?}", Screen::xywh_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::xywh_inside(rect));
    println!("- under the mouse = {:?}", Screen::xywh_mouse());

    println!("\nFor each screen:");
    for s in screens {
        println!("+ {s:?}");
        println!("  - work area = {:?}:", s.work_area());
        println!("  - dpi = {:?}", s.dpi());
        println!("  - scale = {:?}", s.scale());
    }
}

pub fn set_scale(&self, factor: f32)

Sets the value of the GUI scaling factor for the current screen

pub fn scale(&self) -> f32

Returns the value of the GUI scaling factor for the current screen

Examples found in repository

examples/screens_info.rs (line 41)

fn main() {
    let screens = Screen::all_screens();
    println!("Number of detected screens = {}\n", screens.len());
    assert_eq![screens.len(), Screen::count() as usize];

    println!("Is scaling supported:");
    println!("- at all = {}", Screen::scaling_supported());
    println!("- separately = {}", Screen::scaling_supported_separately());

    let coord: Coord = [100, 100].into();
    let rect: Rect = [100, 100, 100, 100].into();

    // uncomment these lines to see out-of-boundaries errors:
    // let coord: Coord = [-100, 10_000].into();
    // let rect: Rect = [-100, 100, 10_000, 10_000].into();

    println!("\nScreen found:");
    println!("- at {coord:?} = {:?}", Screen::new_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::new_inside(rect));

    println!("\nWork area:");
    println!("- at {coord:?} = {:?}", Screen::work_area_at(coord));
    println!("- under the mouse = {:?}", Screen::work_area_mouse());

    println!("\nXYWH:");
    println!("- at {coord:?} = {:?}", Screen::xywh_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::xywh_inside(rect));
    println!("- under the mouse = {:?}", Screen::xywh_mouse());

    println!("\nFor each screen:");
    for s in screens {
        println!("+ {s:?}");
        println!("  - work area = {:?}:", s.work_area());
        println!("  - dpi = {:?}", s.dpi());
        println!("  - scale = {:?}", s.scale());
    }
}

pub fn work_area(&self) -> Rect

Returns the the work area of the current screen

Examples found in repository

examples/screens_info.rs (line 39)

fn main() {
    let screens = Screen::all_screens();
    println!("Number of detected screens = {}\n", screens.len());
    assert_eq![screens.len(), Screen::count() as usize];

    println!("Is scaling supported:");
    println!("- at all = {}", Screen::scaling_supported());
    println!("- separately = {}", Screen::scaling_supported_separately());

    let coord: Coord = [100, 100].into();
    let rect: Rect = [100, 100, 100, 100].into();

    // uncomment these lines to see out-of-boundaries errors:
    // let coord: Coord = [-100, 10_000].into();
    // let rect: Rect = [-100, 100, 10_000, 10_000].into();

    println!("\nScreen found:");
    println!("- at {coord:?} = {:?}", Screen::new_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::new_inside(rect));

    println!("\nWork area:");
    println!("- at {coord:?} = {:?}", Screen::work_area_at(coord));
    println!("- under the mouse = {:?}", Screen::work_area_mouse());

    println!("\nXYWH:");
    println!("- at {coord:?} = {:?}", Screen::xywh_at(coord));
    println!("- inside {rect:?} = {:?}", Screen::xywh_inside(rect));
    println!("- under the mouse = {:?}", Screen::xywh_mouse());

    println!("\nFor each screen:");
    for s in screens {
        println!("+ {s:?}");
        println!("  - work area = {:?}:", s.work_area());
        println!("  - dpi = {:?}", s.dpi());
        println!("  - scale = {:?}", s.scale());
    }
}

pub fn y(&self) -> i32

Returns the topmost y coordinate of the current screen’s work area

pub fn x(&self) -> i32

Returns the bottom-right x coordinate of the current screen’s work area

pub fn w(&self) -> i32

Returns the width in pixels of the current screen’s work area

pub fn h(&self) -> i32

Returns the height in pixels of the current screen’s work area

pub fn top_left(&self) -> Coordinates<i32>

Returns the top-left x,y coordinates of the current screen’s work area

pub fn bottom_right(&self) -> Coordinates<i32>

Returns the bottom-right x+w, y+h coordinates of the current screen’s work area

Trait Implementations

impl Clone for Screen

fn clone(&self) -> Screen

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Screen

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Copy for Screen