Struct Rect

Source

pub struct Rect {
    pub x: f32,
    pub y: f32,
    pub w: f32,
    pub h: f32,
}

Expand description

A rectangle in logical pixels. The host’s scale_factor is applied at paint time, so layout, hit-testing, and Rect-shaped API arguments all speak the same un-scaled coordinate space.

Origin top-left, +y down.

Fields§

§x: f32

Left edge, in logical pixels.

§y: f32

Top edge, in logical pixels.

§w: f32

Width, in logical pixels.

§h: f32

Height, in logical pixels.

Implementations§

Source §

impl Rect

Source

pub const fn new(x: f32, y: f32, w: f32, h: f32) -> Self

Construct a rect from its left edge, top edge, width, and height.

Examples found in repository ?

examples/scrollbar.rs (line 100)

97fn main() -> std::io::Result<()> {
98    let mut root = fixture();
99
100    let viewport = Rect::new(0.0, 0.0, 960.0, 360.0);
101    let bundle = render_bundle(&mut root, viewport);
102
103    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");
104    let written = write_bundle(&bundle, &out_dir, "scrollbar")?;
105    for p in &written {
106        println!("wrote {}", p.display());
107    }
108
109    if !bundle.lint.findings.is_empty() {
110        eprintln!("\nlint findings ({}):", bundle.lint.findings.len());
111        eprint!("{}", bundle.lint.text());
112    }
113
114    Ok(())
115}

More examples

Hide additional examples

examples/settings.rs (line 69)

66fn main() -> std::io::Result<()> {
67    let mut root = settings();
68
69    let viewport = Rect::new(0.0, 0.0, 720.0, 760.0);
70    let bundle = render_bundle(&mut root, viewport);
71
72    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");
73    let written = write_bundle(&bundle, &out_dir, "settings")?;
74    for p in &written {
75        println!("wrote {}", p.display());
76    }
77
78    if !bundle.lint.findings.is_empty() {
79        eprintln!("\nlint findings ({}):", bundle.lint.findings.len());
80        eprint!("{}", bundle.lint.text());
81    }
82
83    Ok(())
84}

examples/modal.rs (line 57)

55fn main() -> std::io::Result<()> {
56    let mut root = modal_fixture();
57    let viewport = Rect::new(0.0, 0.0, 720.0, 560.0);
58    let bundle = render_bundle(&mut root, viewport);
59
60    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");
61    let written = write_bundle(&bundle, &out_dir, "modal")?;
62    for p in &written {
63        println!("wrote {}", p.display());
64    }
65
66    if !bundle.lint.findings.is_empty() {
67        eprintln!("\nlint findings ({}):", bundle.lint.findings.len());
68        eprint!("{}", bundle.lint.text());
69    }
70
71    Ok(())
72}

examples/custom_paint.rs (line 113)

111fn main() -> std::io::Result<()> {
112    let mut root = fixture();
113    let viewport = Rect::new(0.0, 0.0, 900.0, 360.0);
114    let bundle = render_bundle(&mut root, viewport);
115
116    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");
117    let written = write_bundle(&bundle, &out_dir, "custom_paint")?;
118    for p in &written {
119        println!("wrote {}", p.display());
120    }
121
122    if !bundle.lint.findings.is_empty() {
123        eprintln!("\nlint findings ({}):", bundle.lint.findings.len());
124        eprint!("{}", bundle.lint.text());
125    }
126
127    Ok(())
128}

examples/inline_runs.rs (line 53)

50fn main() -> std::io::Result<()> {
51    let mut root = fixture();
52
53    let viewport = Rect::new(0.0, 0.0, 640.0, 360.0);
54    let bundle = render_bundle(&mut root, viewport);
55
56    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");
57    let written = write_bundle(&bundle, &out_dir, "inline_runs")?;
58    for p in &written {
59        println!("wrote {}", p.display());
60    }
61
62    if !bundle.lint.findings.is_empty() {
63        eprintln!("\nlint findings ({}):", bundle.lint.findings.len());
64        eprint!("{}", bundle.lint.text());
65    }
66
67    Ok(())
68}

examples/custom_shader.rs (line 74)

71fn main() -> std::io::Result<()> {
72    let mut root = fixture();
73
74    let viewport = Rect::new(0.0, 0.0, 720.0, 360.0);
75    let bundle = render_bundle(&mut root, viewport);
76
77    let out_dir = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("out");
78    let written = write_bundle(&bundle, &out_dir, "custom_shader")?;
79    for p in &written {
80        println!("wrote {}", p.display());
81    }
82
83    if !bundle.lint.findings.is_empty() {
84        eprintln!("\nlint findings ({}):", bundle.lint.findings.len());
85        eprint!("{}", bundle.lint.text());
86    }
87
88    Ok(())
89}

Additional examples can be found in:

Source

pub fn right(self) -> f32

X coordinate of the right edge (x + w).

Source

pub fn bottom(self) -> f32

Y coordinate of the bottom edge (y + h).

Source

pub fn center_x(self) -> f32

X coordinate of the horizontal center.

Source

pub fn center_y(self) -> f32

Y coordinate of the vertical center.

Source

pub fn contains(self, x: f32, y: f32) -> bool

True when the point lies inside the rect. Left/top edges are inclusive; right/bottom edges are exclusive, so adjacent rects never both claim a shared-edge point.

Source

pub fn intersect(self, other: Rect) -> Option<Rect>

Overlapping region of the two rects, or None when they don’t overlap (touching edges count as no overlap).

Source

pub fn inset(self, p: Sides) -> Self

Shrink the rect inward by p on each side (e.g. to go from a node’s layout rect to its padded content rect). Width and height clamp at 0.0 rather than going negative.

Source