Struct ScreenLayout

pub struct ScreenLayout {
    pub window_id: WindowId,
    pub monitor_scale: f64,
    pub monitor_bounds: Rect,
    pub window_content_bounds: Rect,
    pub window_bounds: Rect,
    pub view_origin_in_window: Option<Point>,
}

A ScreenLayout is a snapshot of the layout of a view within a window

Relates a realized View to the bounds of the window that contains it, and the window to the bounds of the monitor that contains it. All fields are in logical coordinates (if the OS scales physical coordinates for high DPI displays, the scaling is already applied).

Instances are a snapshot in time of the location of the view and window at the time of creation, and are not updated if view or window or monitor in use is.

Fields

window_id: WindowId

The window id

monitor_scale: f64

The scaling of the monitor, if any

monitor_bounds: Rect

The logical bounds of the monitor

window_content_bounds: Rect

The bounds of the view content within the monitor’s bounds

window_bounds: Rect

The bounds of the window within the monitor’s bounds

view_origin_in_window: Option<Point>

The origin of the view within the window, if this ScreenLayout was created from a View rather than a WindowId - needed for computing relative offsets from, e.g., the location of a mouse click within a View.

Implementations

impl ScreenLayout

pub fn to_physical_scale(&self) -> Self

Unscales this Screen to physical device coordinates, less any DPI scaling done by hardware.

pub fn window_frame_insets(&self) -> (f64, f64, f64, f64)

Get the insets required to transform the outer rectangle into the inner one in the form (left, top, right, bottom)

pub fn is_scaled(&self) -> bool

If true, this instance has scaling applied.

pub fn view_location_from_screen(&self, screen_point: Point) -> Point

Convert a screen position to a position within the view that created this one.

pub fn contains_frame_decoration_insets(&self) -> bool

Determine if this ScreenBounds has a different bounding rectangle for the content and frame bounds. Some X11 window managers (Openbox, for one) appear to support getting frame position separately from content position, but in fact report the same bounds for both.

pub fn screen_location_from_view( &self, relative_position: Option<Point>, target_size: Option<Size>, ) -> Point

Compute a position, in screen coordinates, relative to the view this layout was created from. If a target size is passed, the implementation will attempt to adjust the resulting point so that a rectangle of the required size fits entirely on-screen.

Trait Implementations

impl Clone for ScreenLayout

fn clone(&self) -> ScreenLayout

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ScreenLayout

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

Formats the value using the given formatter.

impl PartialEq for ScreenLayout

fn eq(&self, other: &ScreenLayout) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ScreenLayout

impl StructuralPartialEq for ScreenLayout