1//! The GPUI geometry module is a collection of types and traits that
2//! can be used to describe common units, concepts, and the relationships
3//! between them.
4
5use core::fmt::Debug;
6use derive_more::{Add, AddAssign, Div, DivAssign, Mul, Neg, Sub, SubAssign};
7use refineable::Refineable;
8use serde_derive::{Deserialize, Serialize};
9use std::{
10 cmp::{self, PartialOrd},
11 fmt,
12 hash::Hash,
13 ops::{Add, Div, Mul, MulAssign, Sub},
14};
15
16use crate::{AppContext, DisplayId};
17
18/// An axis along which a measurement can be made.
19#[derive(Copy, Clone, PartialEq, Eq, Debug)]
20pub enum Axis {
21 /// The y axis, or up and down
22 Vertical,
23 /// The x axis, or left and right
24 Horizontal,
25}
26
27impl Axis {
28 /// Swap this axis to the opposite axis.
29 pub fn invert(self) -> Self {
30 match self {
31 Axis::Vertical => Axis::Horizontal,
32 Axis::Horizontal => Axis::Vertical,
33 }
34 }
35}
36
37/// A trait for accessing the given unit along a certain axis.
38pub trait Along {
39 /// The unit associated with this type
40 type Unit;
41
42 /// Returns the unit along the given axis.
43 fn along(&self, axis: Axis) -> Self::Unit;
44
45 /// Applies the given function to the unit along the given axis and returns a new value.
46 fn apply_along(&self, axis: Axis, f: impl FnOnce(Self::Unit) -> Self::Unit) -> Self;
47}
48
49/// Describes a location in a 2D cartesian coordinate space.
50///
51/// It holds two public fields, `x` and `y`, which represent the coordinates in the space.
52/// The type `T` for the coordinates can be any type that implements `Default`, `Clone`, and `Debug`.
53///
54/// # Examples
55///
56/// ```
57/// # use zed::Point;
58/// let point = Point { x: 10, y: 20 };
59/// println!("{:?}", point); // Outputs: Point { x: 10, y: 20 }
60/// ```
61#[derive(Refineable, Default, Add, AddAssign, Sub, SubAssign, Copy, Debug, PartialEq, Eq, Hash)]
62#[refineable(Debug)]
63#[repr(C)]
64pub struct Point<T: Default + Clone + Debug> {
65 /// The x coordinate of the point.
66 pub x: T,
67 /// The y coordinate of the point.
68 pub y: T,
69}
70
71/// Constructs a new `Point<T>` with the given x and y coordinates.
72///
73/// # Arguments
74///
75/// * `x` - The x coordinate of the point.
76/// * `y` - The y coordinate of the point.
77///
78/// # Returns
79///
80/// Returns a `Point<T>` with the specified coordinates.
81///
82/// # Examples
83///
84/// ```
85/// # use zed::Point;
86/// let p = point(10, 20);
87/// assert_eq!(p.x, 10);
88/// assert_eq!(p.y, 20);
89/// ```
90pub const fn point<T: Clone + Debug + Default>(x: T, y: T) -> Point<T> {
91 Point { x, y }
92}
93
94impl<T: Clone + Debug + Default> Point<T> {
95 /// Creates a new `Point` with the specified `x` and `y` coordinates.
96 ///
97 /// # Arguments
98 ///
99 /// * `x` - The horizontal coordinate of the point.
100 /// * `y` - The vertical coordinate of the point.
101 ///
102 /// # Examples
103 ///
104 /// ```
105 /// let p = Point::new(10, 20);
106 /// assert_eq!(p.x, 10);
107 /// assert_eq!(p.y, 20);
108 /// ```
109 pub const fn new(x: T, y: T) -> Self {
110 Self { x, y }
111 }
112
113 /// Transforms the point to a `Point<U>` by applying the given function to both coordinates.
114 ///
115 /// This method allows for converting a `Point<T>` to a `Point<U>` by specifying a closure
116 /// that defines how to convert between the two types. The closure is applied to both the `x`
117 /// and `y` coordinates, resulting in a new point of the desired type.
118 ///
119 /// # Arguments
120 ///
121 /// * `f` - A closure that takes a value of type `T` and returns a value of type `U`.
122 ///
123 /// # Examples
124 ///
125 /// ```
126 /// # use zed::Point;
127 /// let p = Point { x: 3, y: 4 };
128 /// let p_float = p.map(|coord| coord as f32);
129 /// assert_eq!(p_float, Point { x: 3.0, y: 4.0 });
130 /// ```
131 pub fn map<U: Clone + Default + Debug>(&self, f: impl Fn(T) -> U) -> Point<U> {
132 Point {
133 x: f(self.x.clone()),
134 y: f(self.y.clone()),
135 }
136 }
137}
138
139impl<T: Clone + Debug + Default> Along for Point<T> {
140 type Unit = T;
141
142 fn along(&self, axis: Axis) -> T {
143 match axis {
144 Axis::Horizontal => self.x.clone(),
145 Axis::Vertical => self.y.clone(),
146 }
147 }
148
149 fn apply_along(&self, axis: Axis, f: impl FnOnce(T) -> T) -> Point<T> {
150 match axis {
151 Axis::Horizontal => Point {
152 x: f(self.x.clone()),
153 y: self.y.clone(),
154 },
155 Axis::Vertical => Point {
156 x: self.x.clone(),
157 y: f(self.y.clone()),
158 },
159 }
160 }
161}
162
163impl<T: Clone + Debug + Default + Negate> Negate for Point<T> {
164 fn negate(self) -> Self {
165 self.map(Negate::negate)
166 }
167}
168
169impl Point<Pixels> {
170 /// Scales the point by a given factor, which is typically derived from the resolution
171 /// of a target display to ensure proper sizing of UI elements.
172 ///
173 /// # Arguments
174 ///
175 /// * `factor` - The scaling factor to apply to both the x and y coordinates.
176 ///
177 /// # Examples
178 ///
179 /// ```
180 /// # use zed::{Point, Pixels, ScaledPixels};
181 /// let p = Point { x: Pixels(10.0), y: Pixels(20.0) };
182 /// let scaled_p = p.scale(1.5);
183 /// assert_eq!(scaled_p, Point { x: ScaledPixels(15.0), y: ScaledPixels(30.0) });
184 /// ```
185 pub fn scale(&self, factor: f32) -> Point<ScaledPixels> {
186 Point {
187 x: self.x.scale(factor),
188 y: self.y.scale(factor),
189 }
190 }
191
192 /// Calculates the Euclidean distance from the origin (0, 0) to this point.
193 ///
194 /// # Examples
195 ///
196 /// ```
197 /// # use zed::Point;
198 /// # use zed::Pixels;
199 /// let p = Point { x: Pixels(3.0), y: Pixels(4.0) };
200 /// assert_eq!(p.magnitude(), 5.0);
201 /// ```
202 pub fn magnitude(&self) -> f64 {
203 ((self.x.0.powi(2) + self.y.0.powi(2)) as f64).sqrt()
204 }
205}
206
207impl<T, Rhs> Mul<Rhs> for Point<T>
208where
209 T: Mul<Rhs, Output = T> + Clone + Default + Debug,
210 Rhs: Clone + Debug,
211{
212 type Output = Point<T>;
213
214 fn mul(self, rhs: Rhs) -> Self::Output {
215 Point {
216 x: self.x * rhs.clone(),
217 y: self.y * rhs,
218 }
219 }
220}
221
222impl<T, S> MulAssign<S> for Point<T>
223where
224 T: Clone + Mul<S, Output = T> + Default + Debug,
225 S: Clone,
226{
227 fn mul_assign(&mut self, rhs: S) {
228 self.x = self.x.clone() * rhs.clone();
229 self.y = self.y.clone() * rhs;
230 }
231}
232
233impl<T, S> Div<S> for Point<T>
234where
235 T: Div<S, Output = T> + Clone + Default + Debug,
236 S: Clone,
237{
238 type Output = Self;
239
240 fn div(self, rhs: S) -> Self::Output {
241 Self {
242 x: self.x / rhs.clone(),
243 y: self.y / rhs,
244 }
245 }
246}
247
248impl<T> Point<T>
249where
250 T: PartialOrd + Clone + Default + Debug,
251{
252 /// Returns a new point with the maximum values of each dimension from `self` and `other`.
253 ///
254 /// # Arguments
255 ///
256 /// * `other` - A reference to another `Point` to compare with `self`.
257 ///
258 /// # Examples
259 ///
260 /// ```
261 /// # use zed::Point;
262 /// let p1 = Point { x: 3, y: 7 };
263 /// let p2 = Point { x: 5, y: 2 };
264 /// let max_point = p1.max(&p2);
265 /// assert_eq!(max_point, Point { x: 5, y: 7 });
266 /// ```
267 pub fn max(&self, other: &Self) -> Self {
268 Point {
269 x: if self.x > other.x {
270 self.x.clone()
271 } else {
272 other.x.clone()
273 },
274 y: if self.y > other.y {
275 self.y.clone()
276 } else {
277 other.y.clone()
278 },
279 }
280 }
281
282 /// Returns a new point with the minimum values of each dimension from `self` and `other`.
283 ///
284 /// # Arguments
285 ///
286 /// * `other` - A reference to another `Point` to compare with `self`.
287 ///
288 /// # Examples
289 ///
290 /// ```
291 /// # use zed::Point;
292 /// let p1 = Point { x: 3, y: 7 };
293 /// let p2 = Point { x: 5, y: 2 };
294 /// let min_point = p1.min(&p2);
295 /// assert_eq!(min_point, Point { x: 3, y: 2 });
296 /// ```
297 pub fn min(&self, other: &Self) -> Self {
298 Point {
299 x: if self.x <= other.x {
300 self.x.clone()
301 } else {
302 other.x.clone()
303 },
304 y: if self.y <= other.y {
305 self.y.clone()
306 } else {
307 other.y.clone()
308 },
309 }
310 }
311
312 /// Clamps the point to a specified range.
313 ///
314 /// Given a minimum point and a maximum point, this method constrains the current point
315 /// such that its coordinates do not exceed the range defined by the minimum and maximum points.
316 /// If the current point's coordinates are less than the minimum, they are set to the minimum.
317 /// If they are greater than the maximum, they are set to the maximum.
318 ///
319 /// # Arguments
320 ///
321 /// * `min` - A reference to a `Point` representing the minimum allowable coordinates.
322 /// * `max` - A reference to a `Point` representing the maximum allowable coordinates.
323 ///
324 /// # Examples
325 ///
326 /// ```
327 /// # use zed::Point;
328 /// let p = Point { x: 10, y: 20 };
329 /// let min = Point { x: 0, y: 5 };
330 /// let max = Point { x: 15, y: 25 };
331 /// let clamped_p = p.clamp(&min, &max);
332 /// assert_eq!(clamped_p, Point { x: 10, y: 20 });
333 ///
334 /// let p_out_of_bounds = Point { x: -5, y: 30 };
335 /// let clamped_p_out_of_bounds = p_out_of_bounds.clamp(&min, &max);
336 /// assert_eq!(clamped_p_out_of_bounds, Point { x: 0, y: 25 });
337 /// ```
338 pub fn clamp(&self, min: &Self, max: &Self) -> Self {
339 self.max(min).min(max)
340 }
341}
342
343impl<T: Clone + Default + Debug> Clone for Point<T> {
344 fn clone(&self) -> Self {
345 Self {
346 x: self.x.clone(),
347 y: self.y.clone(),
348 }
349 }
350}
351
352/// A structure representing a two-dimensional size with width and height in a given unit.
353///
354/// This struct is generic over the type `T`, which can be any type that implements `Clone`, `Default`, and `Debug`.
355/// It is commonly used to specify dimensions for elements in a UI, such as a window or element.
356#[derive(Refineable, Default, Clone, Copy, PartialEq, Div, Hash, Serialize, Deserialize)]
357#[refineable(Debug)]
358#[repr(C)]
359pub struct Size<T: Clone + Default + Debug> {
360 /// The width component of the size.
361 pub width: T,
362 /// The height component of the size.
363 pub height: T,
364}
365
366/// Constructs a new `Size<T>` with the provided width and height.
367///
368/// # Arguments
369///
370/// * `width` - The width component of the `Size`.
371/// * `height` - The height component of the `Size`.
372///
373/// # Examples
374///
375/// ```
376/// # use zed::Size;
377/// let my_size = size(10, 20);
378/// assert_eq!(my_size.width, 10);
379/// assert_eq!(my_size.height, 20);
380/// ```
381pub const fn size<T>(width: T, height: T) -> Size<T>
382where
383 T: Clone + Default + Debug,
384{
385 Size { width, height }
386}
387
388impl<T> Size<T>
389where
390 T: Clone + Default + Debug,
391{
392 /// Applies a function to the width and height of the size, producing a new `Size<U>`.
393 ///
394 /// This method allows for converting a `Size<T>` to a `Size<U>` by specifying a closure
395 /// that defines how to convert between the two types. The closure is applied to both the `width`
396 /// and `height`, resulting in a new size of the desired type.
397 ///
398 /// # Arguments
399 ///
400 /// * `f` - A closure that takes a value of type `T` and returns a value of type `U`.
401 ///
402 /// # Examples
403 ///
404 /// ```
405 /// # use zed::Size;
406 /// let my_size = Size { width: 10, height: 20 };
407 /// let my_new_size = my_size.map(|dimension| dimension as f32 * 1.5);
408 /// assert_eq!(my_new_size, Size { width: 15.0, height: 30.0 });
409 /// ```
410 pub fn map<U>(&self, f: impl Fn(T) -> U) -> Size<U>
411 where
412 U: Clone + Default + Debug,
413 {
414 Size {
415 width: f(self.width.clone()),
416 height: f(self.height.clone()),
417 }
418 }
419}
420
421impl<T> Size<T>
422where
423 T: Clone + Default + Debug + Half,
424{
425 /// Compute the center point of the size.g
426 pub fn center(&self) -> Point<T> {
427 Point {
428 x: self.width.half(),
429 y: self.height.half(),
430 }
431 }
432}
433
434impl Size<Pixels> {
435 /// Scales the size by a given factor.
436 ///
437 /// This method multiplies both the width and height by the provided scaling factor,
438 /// resulting in a new `Size<ScaledPixels>` that is proportionally larger or smaller
439 /// depending on the factor.
440 ///
441 /// # Arguments
442 ///
443 /// * `factor` - The scaling factor to apply to the width and height.
444 ///
445 /// # Examples
446 ///
447 /// ```
448 /// # use zed::{Size, Pixels, ScaledPixels};
449 /// let size = Size { width: Pixels(100.0), height: Pixels(50.0) };
450 /// let scaled_size = size.scale(2.0);
451 /// assert_eq!(scaled_size, Size { width: ScaledPixels(200.0), height: ScaledPixels(100.0) });
452 /// ```
453 pub fn scale(&self, factor: f32) -> Size<ScaledPixels> {
454 Size {
455 width: self.width.scale(factor),
456 height: self.height.scale(factor),
457 }
458 }
459}
460
461impl<T> Along for Size<T>
462where
463 T: Clone + Default + Debug,
464{
465 type Unit = T;
466
467 fn along(&self, axis: Axis) -> T {
468 match axis {
469 Axis::Horizontal => self.width.clone(),
470 Axis::Vertical => self.height.clone(),
471 }
472 }
473
474 /// Returns the value of this size along the given axis.
475 fn apply_along(&self, axis: Axis, f: impl FnOnce(T) -> T) -> Self {
476 match axis {
477 Axis::Horizontal => Size {
478 width: f(self.width.clone()),
479 height: self.height.clone(),
480 },
481 Axis::Vertical => Size {
482 width: self.width.clone(),
483 height: f(self.height.clone()),
484 },
485 }
486 }
487}
488
489impl<T> Size<T>
490where
491 T: PartialOrd + Clone + Default + Debug,
492{
493 /// Returns a new `Size` with the maximum width and height from `self` and `other`.
494 ///
495 /// # Arguments
496 ///
497 /// * `other` - A reference to another `Size` to compare with `self`.
498 ///
499 /// # Examples
500 ///
501 /// ```
502 /// # use zed::Size;
503 /// let size1 = Size { width: 30, height: 40 };
504 /// let size2 = Size { width: 50, height: 20 };
505 /// let max_size = size1.max(&size2);
506 /// assert_eq!(max_size, Size { width: 50, height: 40 });
507 /// ```
508 pub fn max(&self, other: &Self) -> Self {
509 Size {
510 width: if self.width >= other.width {
511 self.width.clone()
512 } else {
513 other.width.clone()
514 },
515 height: if self.height >= other.height {
516 self.height.clone()
517 } else {
518 other.height.clone()
519 },
520 }
521 }
522 /// Returns a new `Size` with the minimum width and height from `self` and `other`.
523 ///
524 /// # Arguments
525 ///
526 /// * `other` - A reference to another `Size` to compare with `self`.
527 ///
528 /// # Examples
529 ///
530 /// ```
531 /// # use zed::Size;
532 /// let size1 = Size { width: 30, height: 40 };
533 /// let size2 = Size { width: 50, height: 20 };
534 /// let min_size = size1.min(&size2);
535 /// assert_eq!(min_size, Size { width: 30, height: 20 });
536 /// ```
537 pub fn min(&self, other: &Self) -> Self {
538 Size {
539 width: if self.width >= other.width {
540 other.width.clone()
541 } else {
542 self.width.clone()
543 },
544 height: if self.height >= other.height {
545 other.height.clone()
546 } else {
547 self.height.clone()
548 },
549 }
550 }
551}
552
553impl<T> Sub for Size<T>
554where
555 T: Sub<Output = T> + Clone + Default + Debug,
556{
557 type Output = Size<T>;
558
559 fn sub(self, rhs: Self) -> Self::Output {
560 Size {
561 width: self.width - rhs.width,
562 height: self.height - rhs.height,
563 }
564 }
565}
566
567impl<T> Add for Size<T>
568where
569 T: Add<Output = T> + Clone + Default + Debug,
570{
571 type Output = Size<T>;
572
573 fn add(self, rhs: Self) -> Self::Output {
574 Size {
575 width: self.width + rhs.width,
576 height: self.height + rhs.height,
577 }
578 }
579}
580
581impl<T, Rhs> Mul<Rhs> for Size<T>
582where
583 T: Mul<Rhs, Output = Rhs> + Clone + Default + Debug,
584 Rhs: Clone + Default + Debug,
585{
586 type Output = Size<Rhs>;
587
588 fn mul(self, rhs: Rhs) -> Self::Output {
589 Size {
590 width: self.width * rhs.clone(),
591 height: self.height * rhs,
592 }
593 }
594}
595
596impl<T, S> MulAssign<S> for Size<T>
597where
598 T: Mul<S, Output = T> + Clone + Default + Debug,
599 S: Clone,
600{
601 fn mul_assign(&mut self, rhs: S) {
602 self.width = self.width.clone() * rhs.clone();
603 self.height = self.height.clone() * rhs;
604 }
605}
606
607impl<T> Eq for Size<T> where T: Eq + Default + Debug + Clone {}
608
609impl<T> Debug for Size<T>
610where
611 T: Clone + Default + Debug,
612{
613 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
614 write!(f, "Size {{ {:?} × {:?} }}", self.width, self.height)
615 }
616}
617
618impl<T: Clone + Default + Debug> From<Point<T>> for Size<T> {
619 fn from(point: Point<T>) -> Self {
620 Self {
621 width: point.x,
622 height: point.y,
623 }
624 }
625}
626
627impl From<Size<Pixels>> for Size<DefiniteLength> {
628 fn from(size: Size<Pixels>) -> Self {
629 Size {
630 width: size.width.into(),
631 height: size.height.into(),
632 }
633 }
634}
635
636impl From<Size<Pixels>> for Size<AbsoluteLength> {
637 fn from(size: Size<Pixels>) -> Self {
638 Size {
639 width: size.width.into(),
640 height: size.height.into(),
641 }
642 }
643}
644
645impl Size<Length> {
646 /// Returns a `Size` with both width and height set to fill the available space.
647 ///
648 /// This function creates a `Size` instance where both the width and height are set to `Length::Definite(DefiniteLength::Fraction(1.0))`,
649 /// which represents 100% of the available space in both dimensions.
650 ///
651 /// # Returns
652 ///
653 /// A `Size<Length>` that will fill the available space when used in a layout.
654 pub fn full() -> Self {
655 Self {
656 width: relative(1.).into(),
657 height: relative(1.).into(),
658 }
659 }
660}
661
662impl Size<Length> {
663 /// Returns a `Size` with both width and height set to `auto`, which allows the layout engine to determine the size.
664 ///
665 /// This function creates a `Size` instance where both the width and height are set to `Length::Auto`,
666 /// indicating that their size should be computed based on the layout context, such as the content size or
667 /// available space.
668 ///
669 /// # Returns
670 ///
671 /// A `Size<Length>` with width and height set to `Length::Auto`.
672 pub fn auto() -> Self {
673 Self {
674 width: Length::Auto,
675 height: Length::Auto,
676 }
677 }
678}
679
680/// Represents a rectangular area in a 2D space with an origin point and a size.
681///
682/// The `Bounds` struct is generic over a type `T` which represents the type of the coordinate system.
683/// The origin is represented as a `Point<T>` which defines the upper-left corner of the rectangle,
684/// and the size is represented as a `Size<T>` which defines the width and height of the rectangle.
685///
686/// # Examples
687///
688/// ```
689/// # use zed::{Bounds, Point, Size};
690/// let origin = Point { x: 0, y: 0 };
691/// let size = Size { width: 10, height: 20 };
692/// let bounds = Bounds::new(origin, size);
693///
694/// assert_eq!(bounds.origin, origin);
695/// assert_eq!(bounds.size, size);
696/// ```
697#[derive(Refineable, Clone, Default, Debug, Eq, PartialEq, Hash)]
698#[refineable(Debug)]
699#[repr(C)]
700pub struct Bounds<T: Clone + Default + Debug> {
701 /// The origin point of this area.
702 pub origin: Point<T>,
703 /// The size of the rectangle.
704 pub size: Size<T>,
705}
706
707impl Bounds<Pixels> {
708 /// Generate a centered bounds for the given display or primary display if none is provided
709 pub fn centered(
710 display_id: Option<DisplayId>,
711 size: Size<Pixels>,
712 cx: &mut AppContext,
713 ) -> Self {
714 let display = display_id
715 .and_then(|id| cx.find_display(id))
716 .or_else(|| cx.primary_display());
717
718 display
719 .map(|display| {
720 let center = display.bounds().center();
721 Bounds {
722 origin: point(center.x - size.width / 2., center.y - size.height / 2.),
723 size,
724 }
725 })
726 .unwrap_or_else(|| Bounds {
727 origin: point(px(0.), px(0.)),
728 size,
729 })
730 }
731
732 /// Generate maximized bounds for the given display or primary display if none is provided
733 pub fn maximized(display_id: Option<DisplayId>, cx: &mut AppContext) -> Self {
734 let display = display_id
735 .and_then(|id| cx.find_display(id))
736 .or_else(|| cx.primary_display());
737
738 display
739 .map(|display| display.bounds())
740 .unwrap_or_else(|| Bounds {
741 origin: point(px(0.), px(0.)),
742 size: size(px(1024.), px(768.)),
743 })
744 }
745}
746
747impl<T> Bounds<T>
748where
749 T: Clone + Debug + Sub<Output = T> + Default,
750{
751 /// Constructs a `Bounds` from two corner points: the upper-left and lower-right corners.
752 ///
753 /// This function calculates the origin and size of the `Bounds` based on the provided corner points.
754 /// The origin is set to the upper-left corner, and the size is determined by the difference between
755 /// the x and y coordinates of the lower-right and upper-left points.
756 ///
757 /// # Arguments
758 ///
759 /// * `upper_left` - A `Point<T>` representing the upper-left corner of the rectangle.
760 /// * `lower_right` - A `Point<T>` representing the lower-right corner of the rectangle.
761 ///
762 /// # Returns
763 ///
764 /// Returns a `Bounds<T>` that encompasses the area defined by the two corner points.
765 ///
766 /// # Examples
767 ///
768 /// ```
769 /// # use zed::{Bounds, Point};
770 /// let upper_left = Point { x: 0, y: 0 };
771 /// let lower_right = Point { x: 10, y: 10 };
772 /// let bounds = Bounds::from_corners(upper_left, lower_right);
773 ///
774 /// assert_eq!(bounds.origin, upper_left);
775 /// assert_eq!(bounds.size.width, 10);
776 /// assert_eq!(bounds.size.height, 10);
777 /// ```
778 pub fn from_corners(upper_left: Point<T>, lower_right: Point<T>) -> Self {
779 let origin = Point {
780 x: upper_left.x.clone(),
781 y: upper_left.y.clone(),
782 };
783 let size = Size {
784 width: lower_right.x - upper_left.x,
785 height: lower_right.y - upper_left.y,
786 };
787 Bounds { origin, size }
788 }
789
790 /// Creates a new `Bounds` with the specified origin and size.
791 ///
792 /// # Arguments
793 ///
794 /// * `origin` - A `Point<T>` representing the origin of the bounds.
795 /// * `size` - A `Size<T>` representing the size of the bounds.
796 ///
797 /// # Returns
798 ///
799 /// Returns a `Bounds<T>` that has the given origin and size.
800 pub fn new(origin: Point<T>, size: Size<T>) -> Self {
801 Bounds { origin, size }
802 }
803}
804
805impl<T> Bounds<T>
806where
807 T: Clone + Debug + PartialOrd + Add<T, Output = T> + Sub<Output = T> + Default + Half,
808{
809 /// Checks if this `Bounds` intersects with another `Bounds`.
810 ///
811 /// Two `Bounds` instances intersect if they overlap in the 2D space they occupy.
812 /// This method checks if there is any overlapping area between the two bounds.
813 ///
814 /// # Arguments
815 ///
816 /// * `other` - A reference to another `Bounds` to check for intersection with.
817 ///
818 /// # Returns
819 ///
820 /// Returns `true` if there is any intersection between the two bounds, `false` otherwise.
821 ///
822 /// # Examples
823 ///
824 /// ```
825 /// # use zed::{Bounds, Point, Size};
826 /// let bounds1 = Bounds {
827 /// origin: Point { x: 0, y: 0 },
828 /// size: Size { width: 10, height: 10 },
829 /// };
830 /// let bounds2 = Bounds {
831 /// origin: Point { x: 5, y: 5 },
832 /// size: Size { width: 10, height: 10 },
833 /// };
834 /// let bounds3 = Bounds {
835 /// origin: Point { x: 20, y: 20 },
836 /// size: Size { width: 10, height: 10 },
837 /// };
838 ///
839 /// assert_eq!(bounds1.intersects(&bounds2), true); // Overlapping bounds
840 /// assert_eq!(bounds1.intersects(&bounds3), false); // Non-overlapping bounds
841 /// ```
842 pub fn intersects(&self, other: &Bounds<T>) -> bool {
843 let my_lower_right = self.lower_right();
844 let their_lower_right = other.lower_right();
845
846 self.origin.x < their_lower_right.x
847 && my_lower_right.x > other.origin.x
848 && self.origin.y < their_lower_right.y
849 && my_lower_right.y > other.origin.y
850 }
851
852 /// Dilates the bounds by a specified amount in all directions.
853 ///
854 /// This method expands the bounds by the given `amount`, increasing the size
855 /// and adjusting the origin so that the bounds grow outwards equally in all directions.
856 /// The resulting bounds will have its width and height increased by twice the `amount`
857 /// (since it grows in both directions), and the origin will be moved by `-amount`
858 /// in both the x and y directions.
859 ///
860 /// # Arguments
861 ///
862 /// * `amount` - The amount by which to dilate the bounds.
863 ///
864 /// # Examples
865 ///
866 /// ```
867 /// # use zed::{Bounds, Point, Size};
868 /// let mut bounds = Bounds {
869 /// origin: Point { x: 10, y: 10 },
870 /// size: Size { width: 10, height: 10 },
871 /// };
872 /// bounds.dilate(5);
873 /// assert_eq!(bounds, Bounds {
874 /// origin: Point { x: 5, y: 5 },
875 /// size: Size { width: 20, height: 20 },
876 /// });
877 /// ```
878 pub fn dilate(&mut self, amount: T) {
879 self.origin.x = self.origin.x.clone() - amount.clone();
880 self.origin.y = self.origin.y.clone() - amount.clone();
881 let double_amount = amount.clone() + amount;
882 self.size.width = self.size.width.clone() + double_amount.clone();
883 self.size.height = self.size.height.clone() + double_amount;
884 }
885
886 /// Returns the center point of the bounds.
887 ///
888 /// Calculates the center by taking the origin's x and y coordinates and adding half the width and height
889 /// of the bounds, respectively. The center is represented as a `Point<T>` where `T` is the type of the
890 /// coordinate system.
891 ///
892 /// # Returns
893 ///
894 /// A `Point<T>` representing the center of the bounds.
895 ///
896 /// # Examples
897 ///
898 /// ```
899 /// # use zed::{Bounds, Point, Size};
900 /// let bounds = Bounds {
901 /// origin: Point { x: 0, y: 0 },
902 /// size: Size { width: 10, height: 20 },
903 /// };
904 /// let center = bounds.center();
905 /// assert_eq!(center, Point { x: 5, y: 10 });
906 /// ```
907 pub fn center(&self) -> Point<T> {
908 Point {
909 x: self.origin.x.clone() + self.size.width.clone().half(),
910 y: self.origin.y.clone() + self.size.height.clone().half(),
911 }
912 }
913
914 /// Calculates the half perimeter of a rectangle defined by the bounds.
915 ///
916 /// The half perimeter is calculated as the sum of the width and the height of the rectangle.
917 /// This method is generic over the type `T` which must implement the `Sub` trait to allow
918 /// calculation of the width and height from the bounds' origin and size, as well as the `Add` trait
919 /// to sum the width and height for the half perimeter.
920 ///
921 /// # Examples
922 ///
923 /// ```
924 /// # use zed::{Bounds, Point, Size};
925 /// let bounds = Bounds {
926 /// origin: Point { x: 0, y: 0 },
927 /// size: Size { width: 10, height: 20 },
928 /// };
929 /// let half_perimeter = bounds.half_perimeter();
930 /// assert_eq!(half_perimeter, 30);
931 /// ```
932 pub fn half_perimeter(&self) -> T {
933 self.size.width.clone() + self.size.height.clone()
934 }
935}
936
937impl<T: Clone + Default + Debug + PartialOrd + Add<T, Output = T> + Sub<Output = T>> Bounds<T> {
938 /// Calculates the intersection of two `Bounds` objects.
939 ///
940 /// This method computes the overlapping region of two `Bounds`. If the bounds do not intersect,
941 /// the resulting `Bounds` will have a size with width and height of zero.
942 ///
943 /// # Arguments
944 ///
945 /// * `other` - A reference to another `Bounds` to intersect with.
946 ///
947 /// # Returns
948 ///
949 /// Returns a `Bounds` representing the intersection area. If there is no intersection,
950 /// the returned `Bounds` will have a size with width and height of zero.
951 ///
952 /// # Examples
953 ///
954 /// ```
955 /// # use zed::{Bounds, Point, Size};
956 /// let bounds1 = Bounds {
957 /// origin: Point { x: 0, y: 0 },
958 /// size: Size { width: 10, height: 10 },
959 /// };
960 /// let bounds2 = Bounds {
961 /// origin: Point { x: 5, y: 5 },
962 /// size: Size { width: 10, height: 10 },
963 /// };
964 /// let intersection = bounds1.intersect(&bounds2);
965 ///
966 /// assert_eq!(intersection, Bounds {
967 /// origin: Point { x: 5, y: 5 },
968 /// size: Size { width: 5, height: 5 },
969 /// });
970 /// ```
971 pub fn intersect(&self, other: &Self) -> Self {
972 let upper_left = self.origin.max(&other.origin);
973 let lower_right = self.lower_right().min(&other.lower_right());
974 Self::from_corners(upper_left, lower_right)
975 }
976
977 /// Computes the union of two `Bounds`.
978 ///
979 /// This method calculates the smallest `Bounds` that contains both the current `Bounds` and the `other` `Bounds`.
980 /// The resulting `Bounds` will have an origin that is the minimum of the origins of the two `Bounds`,
981 /// and a size that encompasses the furthest extents of both `Bounds`.
982 ///
983 /// # Arguments
984 ///
985 /// * `other` - A reference to another `Bounds` to create a union with.
986 ///
987 /// # Returns
988 ///
989 /// Returns a `Bounds` representing the union of the two `Bounds`.
990 ///
991 /// # Examples
992 ///
993 /// ```
994 /// # use zed::{Bounds, Point, Size};
995 /// let bounds1 = Bounds {
996 /// origin: Point { x: 0, y: 0 },
997 /// size: Size { width: 10, height: 10 },
998 /// };
999 /// let bounds2 = Bounds {
1000 /// origin: Point { x: 5, y: 5 },
1001 /// size: Size { width: 15, height: 15 },
1002 /// };
1003 /// let union_bounds = bounds1.union(&bounds2);
1004 ///
1005 /// assert_eq!(union_bounds, Bounds {
1006 /// origin: Point { x: 0, y: 0 },
1007 /// size: Size { width: 20, height: 20 },
1008 /// });
1009 /// ```
1010 pub fn union(&self, other: &Self) -> Self {
1011 let top_left = self.origin.min(&other.origin);
1012 let bottom_right = self.lower_right().max(&other.lower_right());
1013 Bounds::from_corners(top_left, bottom_right)
1014 }
1015}
1016
1017impl<T, Rhs> Mul<Rhs> for Bounds<T>
1018where
1019 T: Mul<Rhs, Output = Rhs> + Clone + Default + Debug,
1020 Point<T>: Mul<Rhs, Output = Point<Rhs>>,
1021 Rhs: Clone + Default + Debug,
1022{
1023 type Output = Bounds<Rhs>;
1024
1025 fn mul(self, rhs: Rhs) -> Self::Output {
1026 Bounds {
1027 origin: self.origin * rhs.clone(),
1028 size: self.size * rhs,
1029 }
1030 }
1031}
1032
1033impl<T, S> MulAssign<S> for Bounds<T>
1034where
1035 T: Mul<S, Output = T> + Clone + Default + Debug,
1036 S: Clone,
1037{
1038 fn mul_assign(&mut self, rhs: S) {
1039 self.origin *= rhs.clone();
1040 self.size *= rhs;
1041 }
1042}
1043
1044impl<T, S> Div<S> for Bounds<T>
1045where
1046 Size<T>: Div<S, Output = Size<T>>,
1047 T: Div<S, Output = T> + Default + Clone + Debug,
1048 S: Clone,
1049{
1050 type Output = Self;
1051
1052 fn div(self, rhs: S) -> Self {
1053 Self {
1054 origin: self.origin / rhs.clone(),
1055 size: self.size / rhs,
1056 }
1057 }
1058}
1059
1060impl<T> Bounds<T>
1061where
1062 T: Add<T, Output = T> + Clone + Default + Debug,
1063{
1064 /// Returns the top edge of the bounds.
1065 ///
1066 /// # Returns
1067 ///
1068 /// A value of type `T` representing the y-coordinate of the top edge of the bounds.
1069 pub fn top(&self) -> T {
1070 self.origin.y.clone()
1071 }
1072
1073 /// Returns the bottom edge of the bounds.
1074 ///
1075 /// # Returns
1076 ///
1077 /// A value of type `T` representing the y-coordinate of the bottom edge of the bounds.
1078 pub fn bottom(&self) -> T {
1079 self.origin.y.clone() + self.size.height.clone()
1080 }
1081
1082 /// Returns the left edge of the bounds.
1083 ///
1084 /// # Returns
1085 ///
1086 /// A value of type `T` representing the x-coordinate of the left edge of the bounds.
1087 pub fn left(&self) -> T {
1088 self.origin.x.clone()
1089 }
1090
1091 /// Returns the right edge of the bounds.
1092 ///
1093 /// # Returns
1094 ///
1095 /// A value of type `T` representing the x-coordinate of the right edge of the bounds.
1096 pub fn right(&self) -> T {
1097 self.origin.x.clone() + self.size.width.clone()
1098 }
1099
1100 /// Returns the upper-right corner point of the bounds.
1101 ///
1102 /// # Returns
1103 ///
1104 /// A `Point<T>` representing the upper-right corner of the bounds.
1105 ///
1106 /// # Examples
1107 ///
1108 /// ```
1109 /// # use zed::{Bounds, Point, Size};
1110 /// let bounds = Bounds {
1111 /// origin: Point { x: 0, y: 0 },
1112 /// size: Size { width: 10, height: 20 },
1113 /// };
1114 /// let upper_right = bounds.upper_right();
1115 /// assert_eq!(upper_right, Point { x: 10, y: 0 });
1116 /// ```
1117 pub fn upper_right(&self) -> Point<T> {
1118 Point {
1119 x: self.origin.x.clone() + self.size.width.clone(),
1120 y: self.origin.y.clone(),
1121 }
1122 }
1123
1124 /// Returns the lower-right corner point of the bounds.
1125 ///
1126 /// # Returns
1127 ///
1128 /// A `Point<T>` representing the lower-right corner of the bounds.
1129 ///
1130 /// # Examples
1131 ///
1132 /// ```
1133 /// # use zed::{Bounds, Point, Size};
1134 /// let bounds = Bounds {
1135 /// origin: Point { x: 0, y: 0 },
1136 /// size: Size { width: 10, height: 20 },
1137 /// };
1138 /// let lower_right = bounds.lower_right();
1139 /// assert_eq!(lower_right, Point { x: 10, y: 20 });
1140 /// ```
1141 pub fn lower_right(&self) -> Point<T> {
1142 Point {
1143 x: self.origin.x.clone() + self.size.width.clone(),
1144 y: self.origin.y.clone() + self.size.height.clone(),
1145 }
1146 }
1147
1148 /// Returns the lower-left corner point of the bounds.
1149 ///
1150 /// # Returns
1151 ///
1152 /// A `Point<T>` representing the lower-left corner of the bounds.
1153 ///
1154 /// # Examples
1155 ///
1156 /// ```
1157 /// # use zed::{Bounds, Point, Size};
1158 /// let bounds = Bounds {
1159 /// origin: Point { x: 0, y: 0 },
1160 /// size: Size { width: 10, height: 20 },
1161 /// };
1162 /// let lower_left = bounds.lower_left();
1163 /// assert_eq!(lower_left, Point { x: 0, y: 20 });
1164 /// ```
1165 pub fn lower_left(&self) -> Point<T> {
1166 Point {
1167 x: self.origin.x.clone(),
1168 y: self.origin.y.clone() + self.size.height.clone(),
1169 }
1170 }
1171}
1172
1173impl<T> Bounds<T>
1174where
1175 T: Add<T, Output = T> + PartialOrd + Clone + Default + Debug,
1176{
1177 /// Checks if the given point is within the bounds.
1178 ///
1179 /// This method determines whether a point lies inside the rectangle defined by the bounds,
1180 /// including the edges. The point is considered inside if its x-coordinate is greater than
1181 /// or equal to the left edge and less than or equal to the right edge, and its y-coordinate
1182 /// is greater than or equal to the top edge and less than or equal to the bottom edge of the bounds.
1183 ///
1184 /// # Arguments
1185 ///
1186 /// * `point` - A reference to a `Point<T>` that represents the point to check.
1187 ///
1188 /// # Returns
1189 ///
1190 /// Returns `true` if the point is within the bounds, `false` otherwise.
1191 ///
1192 /// # Examples
1193 ///
1194 /// ```
1195 /// # use zed::{Point, Bounds};
1196 /// let bounds = Bounds {
1197 /// origin: Point { x: 0, y: 0 },
1198 /// size: Size { width: 10, height: 10 },
1199 /// };
1200 /// let inside_point = Point { x: 5, y: 5 };
1201 /// let outside_point = Point { x: 15, y: 15 };
1202 ///
1203 /// assert!(bounds.contains_point(&inside_point));
1204 /// assert!(!bounds.contains_point(&outside_point));
1205 /// ```
1206 pub fn contains(&self, point: &Point<T>) -> bool {
1207 point.x >= self.origin.x
1208 && point.x <= self.origin.x.clone() + self.size.width.clone()
1209 && point.y >= self.origin.y
1210 && point.y <= self.origin.y.clone() + self.size.height.clone()
1211 }
1212
1213 /// Applies a function to the origin and size of the bounds, producing a new `Bounds<U>`.
1214 ///
1215 /// This method allows for converting a `Bounds<T>` to a `Bounds<U>` by specifying a closure
1216 /// that defines how to convert between the two types. The closure is applied to the `origin` and
1217 /// `size` fields, resulting in new bounds of the desired type.
1218 ///
1219 /// # Arguments
1220 ///
1221 /// * `f` - A closure that takes a value of type `T` and returns a value of type `U`.
1222 ///
1223 /// # Returns
1224 ///
1225 /// Returns a new `Bounds<U>` with the origin and size mapped by the provided function.
1226 ///
1227 /// # Examples
1228 ///
1229 /// ```
1230 /// # use zed::{Bounds, Point, Size};
1231 /// let bounds = Bounds {
1232 /// origin: Point { x: 10.0, y: 10.0 },
1233 /// size: Size { width: 10.0, height: 20.0 },
1234 /// };
1235 /// let new_bounds = bounds.map(|value| value as f64 * 1.5);
1236 ///
1237 /// assert_eq!(new_bounds, Bounds {
1238 /// origin: Point { x: 15.0, y: 15.0 },
1239 /// size: Size { width: 15.0, height: 30.0 },
1240 /// });
1241 /// ```
1242 pub fn map<U>(&self, f: impl Fn(T) -> U) -> Bounds<U>
1243 where
1244 U: Clone + Default + Debug,
1245 {
1246 Bounds {
1247 origin: self.origin.map(&f),
1248 size: self.size.map(f),
1249 }
1250 }
1251
1252 /// Applies a function to the origin of the bounds, producing a new `Bounds` with the new origin
1253 ///
1254 /// # Examples
1255 ///
1256 /// ```
1257 /// # use zed::{Bounds, Point, Size};
1258 /// let bounds = Bounds {
1259 /// origin: Point { x: 10.0, y: 10.0 },
1260 /// size: Size { width: 10.0, height: 20.0 },
1261 /// };
1262 /// let new_bounds = bounds.map_origin(|value| value * 1.5);
1263 ///
1264 /// assert_eq!(new_bounds, Bounds {
1265 /// origin: Point { x: 15.0, y: 15.0 },
1266 /// size: Size { width: 10.0, height: 20.0 },
1267 /// });
1268 /// ```
1269 pub fn map_origin(self, f: impl Fn(Point<T>) -> Point<T>) -> Bounds<T> {
1270 Bounds {
1271 origin: f(self.origin),
1272 size: self.size,
1273 }
1274 }
1275}
1276
1277/// Checks if the bounds represent an empty area.
1278///
1279/// # Returns
1280///
1281/// Returns `true` if either the width or the height of the bounds is less than or equal to zero, indicating an empty area.
1282impl<T: PartialOrd + Default + Debug + Clone> Bounds<T> {
1283 /// Checks if the bounds represent an empty area.
1284 ///
1285 /// # Returns
1286 ///
1287 /// Returns `true` if either the width or the height of the bounds is less than or equal to zero, indicating an empty area.
1288 pub fn is_empty(&self) -> bool {
1289 self.size.width <= T::default() || self.size.height <= T::default()
1290 }
1291}
1292
1293impl Size<DevicePixels> {
1294 /// Converts the size from physical to logical pixels.
1295 pub(crate) fn to_pixels(self, scale_factor: f32) -> Size<Pixels> {
1296 size(
1297 px(self.width.0 as f32 / scale_factor),
1298 px(self.height.0 as f32 / scale_factor),
1299 )
1300 }
1301}
1302
1303impl Size<Pixels> {
1304 /// Converts the size from physical to logical pixels.
1305 pub(crate) fn to_device_pixels(self, scale_factor: f32) -> Size<DevicePixels> {
1306 size(
1307 DevicePixels((self.width.0 * scale_factor) as i32),
1308 DevicePixels((self.height.0 * scale_factor) as i32),
1309 )
1310 }
1311}
1312
1313impl Bounds<Pixels> {
1314 /// Scales the bounds by a given factor, typically used to adjust for display scaling.
1315 ///
1316 /// This method multiplies the origin and size of the bounds by the provided scaling factor,
1317 /// resulting in a new `Bounds<ScaledPixels>` that is proportionally larger or smaller
1318 /// depending on the scaling factor. This can be used to ensure that the bounds are properly
1319 /// scaled for different display densities.
1320 ///
1321 /// # Arguments
1322 ///
1323 /// * `factor` - The scaling factor to apply to the origin and size, typically the display's scaling factor.
1324 ///
1325 /// # Returns
1326 ///
1327 /// Returns a new `Bounds<ScaledPixels>` that represents the scaled bounds.
1328 ///
1329 /// # Examples
1330 ///
1331 /// ```
1332 /// # use zed::{Bounds, Point, Size, Pixels};
1333 /// let bounds = Bounds {
1334 /// origin: Point { x: Pixels(10.0), y: Pixels(20.0) },
1335 /// size: Size { width: Pixels(30.0), height: Pixels(40.0) },
1336 /// };
1337 /// let display_scale_factor = 2.0;
1338 /// let scaled_bounds = bounds.scale(display_scale_factor);
1339 /// assert_eq!(scaled_bounds, Bounds {
1340 /// origin: Point { x: ScaledPixels(20.0), y: ScaledPixels(40.0) },
1341 /// size: Size { width: ScaledPixels(60.0), height: ScaledPixels(80.0) },
1342 /// });
1343 /// ```
1344 pub fn scale(&self, factor: f32) -> Bounds<ScaledPixels> {
1345 Bounds {
1346 origin: self.origin.scale(factor),
1347 size: self.size.scale(factor),
1348 }
1349 }
1350
1351 /// Convert the bounds from logical pixels to physical pixels
1352 pub fn to_device_pixels(&self, factor: f32) -> Bounds<DevicePixels> {
1353 Bounds {
1354 origin: point(
1355 DevicePixels((self.origin.x.0 * factor) as i32),
1356 DevicePixels((self.origin.y.0 * factor) as i32),
1357 ),
1358 size: self.size.to_device_pixels(factor),
1359 }
1360 }
1361}
1362
1363impl Bounds<DevicePixels> {
1364 /// Convert the bounds from physical pixels to logical pixels
1365 pub fn to_pixels(self, scale_factor: f32) -> Bounds<Pixels> {
1366 Bounds {
1367 origin: point(
1368 px(self.origin.x.0 as f32 / scale_factor),
1369 px(self.origin.y.0 as f32 / scale_factor),
1370 ),
1371 size: self.size.to_pixels(scale_factor),
1372 }
1373 }
1374}
1375
1376impl<T: Clone + Debug + Copy + Default> Copy for Bounds<T> {}
1377
1378/// Represents the edges of a box in a 2D space, such as padding or margin.
1379///
1380/// Each field represents the size of the edge on one side of the box: `top`, `right`, `bottom`, and `left`.
1381///
1382/// # Examples
1383///
1384/// ```
1385/// # use zed::Edges;
1386/// let edges = Edges {
1387/// top: 10.0,
1388/// right: 20.0,
1389/// bottom: 30.0,
1390/// left: 40.0,
1391/// };
1392///
1393/// assert_eq!(edges.top, 10.0);
1394/// assert_eq!(edges.right, 20.0);
1395/// assert_eq!(edges.bottom, 30.0);
1396/// assert_eq!(edges.left, 40.0);
1397/// ```
1398#[derive(Refineable, Clone, Default, Debug, Eq, PartialEq)]
1399#[refineable(Debug)]
1400#[repr(C)]
1401pub struct Edges<T: Clone + Default + Debug> {
1402 /// The size of the top edge.
1403 pub top: T,
1404 /// The size of the right edge.
1405 pub right: T,
1406 /// The size of the bottom edge.
1407 pub bottom: T,
1408 /// The size of the left edge.
1409 pub left: T,
1410}
1411
1412impl<T> Mul for Edges<T>
1413where
1414 T: Mul<Output = T> + Clone + Default + Debug,
1415{
1416 type Output = Self;
1417
1418 fn mul(self, rhs: Self) -> Self::Output {
1419 Self {
1420 top: self.top.clone() * rhs.top,
1421 right: self.right.clone() * rhs.right,
1422 bottom: self.bottom.clone() * rhs.bottom,
1423 left: self.left.clone() * rhs.left,
1424 }
1425 }
1426}
1427
1428impl<T, S> MulAssign<S> for Edges<T>
1429where
1430 T: Mul<S, Output = T> + Clone + Default + Debug,
1431 S: Clone,
1432{
1433 fn mul_assign(&mut self, rhs: S) {
1434 self.top = self.top.clone() * rhs.clone();
1435 self.right = self.right.clone() * rhs.clone();
1436 self.bottom = self.bottom.clone() * rhs.clone();
1437 self.left = self.left.clone() * rhs;
1438 }
1439}
1440
1441impl<T: Clone + Default + Debug + Copy> Copy for Edges<T> {}
1442
1443impl<T: Clone + Default + Debug> Edges<T> {
1444 /// Constructs `Edges` where all sides are set to the same specified value.
1445 ///
1446 /// This function creates an `Edges` instance with the `top`, `right`, `bottom`, and `left` fields all initialized
1447 /// to the same value provided as an argument. This is useful when you want to have uniform edges around a box,
1448 /// such as padding or margin with the same size on all sides.
1449 ///
1450 /// # Arguments
1451 ///
1452 /// * `value` - The value to set for all four sides of the edges.
1453 ///
1454 /// # Returns
1455 ///
1456 /// An `Edges` instance with all sides set to the given value.
1457 ///
1458 /// # Examples
1459 ///
1460 /// ```
1461 /// # use zed::Edges;
1462 /// let uniform_edges = Edges::all(10.0);
1463 /// assert_eq!(uniform_edges.top, 10.0);
1464 /// assert_eq!(uniform_edges.right, 10.0);
1465 /// assert_eq!(uniform_edges.bottom, 10.0);
1466 /// assert_eq!(uniform_edges.left, 10.0);
1467 /// ```
1468 pub fn all(value: T) -> Self {
1469 Self {
1470 top: value.clone(),
1471 right: value.clone(),
1472 bottom: value.clone(),
1473 left: value,
1474 }
1475 }
1476
1477 /// Applies a function to each field of the `Edges`, producing a new `Edges<U>`.
1478 ///
1479 /// This method allows for converting an `Edges<T>` to an `Edges<U>` by specifying a closure
1480 /// that defines how to convert between the two types. The closure is applied to each field
1481 /// (`top`, `right`, `bottom`, `left`), resulting in new edges of the desired type.
1482 ///
1483 /// # Arguments
1484 ///
1485 /// * `f` - A closure that takes a reference to a value of type `T` and returns a value of type `U`.
1486 ///
1487 /// # Returns
1488 ///
1489 /// Returns a new `Edges<U>` with each field mapped by the provided function.
1490 ///
1491 /// # Examples
1492 ///
1493 /// ```
1494 /// # use zed::Edges;
1495 /// let edges = Edges { top: 10, right: 20, bottom: 30, left: 40 };
1496 /// let edges_float = edges.map(|&value| value as f32 * 1.1);
1497 /// assert_eq!(edges_float, Edges { top: 11.0, right: 22.0, bottom: 33.0, left: 44.0 });
1498 /// ```
1499 pub fn map<U>(&self, f: impl Fn(&T) -> U) -> Edges<U>
1500 where
1501 U: Clone + Default + Debug,
1502 {
1503 Edges {
1504 top: f(&self.top),
1505 right: f(&self.right),
1506 bottom: f(&self.bottom),
1507 left: f(&self.left),
1508 }
1509 }
1510
1511 /// Checks if any of the edges satisfy a given predicate.
1512 ///
1513 /// This method applies a predicate function to each field of the `Edges` and returns `true` if any field satisfies the predicate.
1514 ///
1515 /// # Arguments
1516 ///
1517 /// * `predicate` - A closure that takes a reference to a value of type `T` and returns a `bool`.
1518 ///
1519 /// # Returns
1520 ///
1521 /// Returns `true` if the predicate returns `true` for any of the edge values, `false` otherwise.
1522 ///
1523 /// # Examples
1524 ///
1525 /// ```
1526 /// # use zed::Edges;
1527 /// let edges = Edges {
1528 /// top: 10,
1529 /// right: 0,
1530 /// bottom: 5,
1531 /// left: 0,
1532 /// };
1533 ///
1534 /// assert!(edges.any(|value| *value == 0));
1535 /// assert!(edges.any(|value| *value > 0));
1536 /// assert!(!edges.any(|value| *value > 10));
1537 /// ```
1538 pub fn any<F: Fn(&T) -> bool>(&self, predicate: F) -> bool {
1539 predicate(&self.top)
1540 || predicate(&self.right)
1541 || predicate(&self.bottom)
1542 || predicate(&self.left)
1543 }
1544}
1545
1546impl Edges<Length> {
1547 /// Sets the edges of the `Edges` struct to `auto`, which is a special value that allows the layout engine to automatically determine the size of the edges.
1548 ///
1549 /// This is typically used in layout contexts where the exact size of the edges is not important, or when the size should be calculated based on the content or container.
1550 ///
1551 /// # Returns
1552 ///
1553 /// Returns an `Edges<Length>` with all edges set to `Length::Auto`.
1554 ///
1555 /// # Examples
1556 ///
1557 /// ```
1558 /// # use zed::Edges;
1559 /// let auto_edges = Edges::auto();
1560 /// assert_eq!(auto_edges.top, Length::Auto);
1561 /// assert_eq!(auto_edges.right, Length::Auto);
1562 /// assert_eq!(auto_edges.bottom, Length::Auto);
1563 /// assert_eq!(auto_edges.left, Length::Auto);
1564 /// ```
1565 pub fn auto() -> Self {
1566 Self {
1567 top: Length::Auto,
1568 right: Length::Auto,
1569 bottom: Length::Auto,
1570 left: Length::Auto,
1571 }
1572 }
1573
1574 /// Sets the edges of the `Edges` struct to zero, which means no size or thickness.
1575 ///
1576 /// This is typically used when you want to specify that a box (like a padding or margin area)
1577 /// should have no edges, effectively making it non-existent or invisible in layout calculations.
1578 ///
1579 /// # Returns
1580 ///
1581 /// Returns an `Edges<Length>` with all edges set to zero length.
1582 ///
1583 /// # Examples
1584 ///
1585 /// ```
1586 /// # use zed::Edges;
1587 /// let no_edges = Edges::zero();
1588 /// assert_eq!(no_edges.top, Length::Definite(DefiniteLength::from(Pixels(0.))));
1589 /// assert_eq!(no_edges.right, Length::Definite(DefiniteLength::from(Pixels(0.))));
1590 /// assert_eq!(no_edges.bottom, Length::Definite(DefiniteLength::from(Pixels(0.))));
1591 /// assert_eq!(no_edges.left, Length::Definite(DefiniteLength::from(Pixels(0.))));
1592 /// ```
1593 pub fn zero() -> Self {
1594 Self {
1595 top: px(0.).into(),
1596 right: px(0.).into(),
1597 bottom: px(0.).into(),
1598 left: px(0.).into(),
1599 }
1600 }
1601}
1602
1603impl Edges<DefiniteLength> {
1604 /// Sets the edges of the `Edges` struct to zero, which means no size or thickness.
1605 ///
1606 /// This is typically used when you want to specify that a box (like a padding or margin area)
1607 /// should have no edges, effectively making it non-existent or invisible in layout calculations.
1608 ///
1609 /// # Returns
1610 ///
1611 /// Returns an `Edges<DefiniteLength>` with all edges set to zero length.
1612 ///
1613 /// # Examples
1614 ///
1615 /// ```
1616 /// # use zed::Edges;
1617 /// let no_edges = Edges::zero();
1618 /// assert_eq!(no_edges.top, DefiniteLength::from(zed::px(0.)));
1619 /// assert_eq!(no_edges.right, DefiniteLength::from(zed::px(0.)));
1620 /// assert_eq!(no_edges.bottom, DefiniteLength::from(zed::px(0.)));
1621 /// assert_eq!(no_edges.left, DefiniteLength::from(zed::px(0.)));
1622 /// ```
1623 pub fn zero() -> Self {
1624 Self {
1625 top: px(0.).into(),
1626 right: px(0.).into(),
1627 bottom: px(0.).into(),
1628 left: px(0.).into(),
1629 }
1630 }
1631
1632 /// Converts the `DefiniteLength` to `Pixels` based on the parent size and the REM size.
1633 ///
1634 /// This method allows for a `DefiniteLength` value to be converted into pixels, taking into account
1635 /// the size of the parent element (for percentage-based lengths) and the size of a rem unit (for rem-based lengths).
1636 ///
1637 /// # Arguments
1638 ///
1639 /// * `parent_size` - `Size<AbsoluteLength>` representing the size of the parent element.
1640 /// * `rem_size` - `Pixels` representing the size of one REM unit.
1641 ///
1642 /// # Returns
1643 ///
1644 /// Returns an `Edges<Pixels>` representing the edges with lengths converted to pixels.
1645 ///
1646 /// # Examples
1647 ///
1648 /// ```
1649 /// # use zed::{Edges, DefiniteLength, px, AbsoluteLength, Size};
1650 /// let edges = Edges {
1651 /// top: DefiniteLength::Absolute(AbsoluteLength::Pixels(px(10.0))),
1652 /// right: DefiniteLength::Fraction(0.5),
1653 /// bottom: DefiniteLength::Absolute(AbsoluteLength::Rems(rems(2.0))),
1654 /// left: DefiniteLength::Fraction(0.25),
1655 /// };
1656 /// let parent_size = Size {
1657 /// width: AbsoluteLength::Pixels(px(200.0)),
1658 /// height: AbsoluteLength::Pixels(px(100.0)),
1659 /// };
1660 /// let rem_size = px(16.0);
1661 /// let edges_in_pixels = edges.to_pixels(parent_size, rem_size);
1662 ///
1663 /// assert_eq!(edges_in_pixels.top, px(10.0)); // Absolute length in pixels
1664 /// assert_eq!(edges_in_pixels.right, px(100.0)); // 50% of parent width
1665 /// assert_eq!(edges_in_pixels.bottom, px(32.0)); // 2 rems
1666 /// assert_eq!(edges_in_pixels.left, px(50.0)); // 25% of parent width
1667 /// ```
1668 pub fn to_pixels(&self, parent_size: Size<AbsoluteLength>, rem_size: Pixels) -> Edges<Pixels> {
1669 Edges {
1670 top: self.top.to_pixels(parent_size.height, rem_size),
1671 right: self.right.to_pixels(parent_size.width, rem_size),
1672 bottom: self.bottom.to_pixels(parent_size.height, rem_size),
1673 left: self.left.to_pixels(parent_size.width, rem_size),
1674 }
1675 }
1676}
1677
1678impl Edges<AbsoluteLength> {
1679 /// Sets the edges of the `Edges` struct to zero, which means no size or thickness.
1680 ///
1681 /// This is typically used when you want to specify that a box (like a padding or margin area)
1682 /// should have no edges, effectively making it non-existent or invisible in layout calculations.
1683 ///
1684 /// # Returns
1685 ///
1686 /// Returns an `Edges<AbsoluteLength>` with all edges set to zero length.
1687 ///
1688 /// # Examples
1689 ///
1690 /// ```
1691 /// # use zed::Edges;
1692 /// let no_edges = Edges::zero();
1693 /// assert_eq!(no_edges.top, AbsoluteLength::Pixels(Pixels(0.0)));
1694 /// assert_eq!(no_edges.right, AbsoluteLength::Pixels(Pixels(0.0)));
1695 /// assert_eq!(no_edges.bottom, AbsoluteLength::Pixels(Pixels(0.0)));
1696 /// assert_eq!(no_edges.left, AbsoluteLength::Pixels(Pixels(0.0)));
1697 /// ```
1698 pub fn zero() -> Self {
1699 Self {
1700 top: px(0.).into(),
1701 right: px(0.).into(),
1702 bottom: px(0.).into(),
1703 left: px(0.).into(),
1704 }
1705 }
1706
1707 /// Converts the `AbsoluteLength` to `Pixels` based on the `rem_size`.
1708 ///
1709 /// If the `AbsoluteLength` is already in pixels, it simply returns the corresponding `Pixels` value.
1710 /// If the `AbsoluteLength` is in rems, it multiplies the number of rems by the `rem_size` to convert it to pixels.
1711 ///
1712 /// # Arguments
1713 ///
1714 /// * `rem_size` - The size of one rem unit in pixels.
1715 ///
1716 /// # Returns
1717 ///
1718 /// Returns an `Edges<Pixels>` representing the edges with lengths converted to pixels.
1719 ///
1720 /// # Examples
1721 ///
1722 /// ```
1723 /// # use zed::{Edges, AbsoluteLength, Pixels, px};
1724 /// let edges = Edges {
1725 /// top: AbsoluteLength::Pixels(px(10.0)),
1726 /// right: AbsoluteLength::Rems(rems(1.0)),
1727 /// bottom: AbsoluteLength::Pixels(px(20.0)),
1728 /// left: AbsoluteLength::Rems(rems(2.0)),
1729 /// };
1730 /// let rem_size = px(16.0);
1731 /// let edges_in_pixels = edges.to_pixels(rem_size);
1732 ///
1733 /// assert_eq!(edges_in_pixels.top, px(10.0)); // Already in pixels
1734 /// assert_eq!(edges_in_pixels.right, px(16.0)); // 1 rem converted to pixels
1735 /// assert_eq!(edges_in_pixels.bottom, px(20.0)); // Already in pixels
1736 /// assert_eq!(edges_in_pixels.left, px(32.0)); // 2 rems converted to pixels
1737 /// ```
1738 pub fn to_pixels(&self, rem_size: Pixels) -> Edges<Pixels> {
1739 Edges {
1740 top: self.top.to_pixels(rem_size),
1741 right: self.right.to_pixels(rem_size),
1742 bottom: self.bottom.to_pixels(rem_size),
1743 left: self.left.to_pixels(rem_size),
1744 }
1745 }
1746}
1747
1748impl Edges<Pixels> {
1749 /// Scales the `Edges<Pixels>` by a given factor, returning `Edges<ScaledPixels>`.
1750 ///
1751 /// This method is typically used for adjusting the edge sizes for different display densities or scaling factors.
1752 ///
1753 /// # Arguments
1754 ///
1755 /// * `factor` - The scaling factor to apply to each edge.
1756 ///
1757 /// # Returns
1758 ///
1759 /// Returns a new `Edges<ScaledPixels>` where each edge is the result of scaling the original edge by the given factor.
1760 ///
1761 /// # Examples
1762 ///
1763 /// ```
1764 /// # use zed::{Edges, Pixels};
1765 /// let edges = Edges {
1766 /// top: Pixels(10.0),
1767 /// right: Pixels(20.0),
1768 /// bottom: Pixels(30.0),
1769 /// left: Pixels(40.0),
1770 /// };
1771 /// let scaled_edges = edges.scale(2.0);
1772 /// assert_eq!(scaled_edges.top, ScaledPixels(20.0));
1773 /// assert_eq!(scaled_edges.right, ScaledPixels(40.0));
1774 /// assert_eq!(scaled_edges.bottom, ScaledPixels(60.0));
1775 /// assert_eq!(scaled_edges.left, ScaledPixels(80.0));
1776 /// ```
1777 pub fn scale(&self, factor: f32) -> Edges<ScaledPixels> {
1778 Edges {
1779 top: self.top.scale(factor),
1780 right: self.right.scale(factor),
1781 bottom: self.bottom.scale(factor),
1782 left: self.left.scale(factor),
1783 }
1784 }
1785
1786 /// Returns the maximum value of any edge.
1787 ///
1788 /// # Returns
1789 ///
1790 /// The maximum `Pixels` value among all four edges.
1791 pub fn max(&self) -> Pixels {
1792 self.top.max(self.right).max(self.bottom).max(self.left)
1793 }
1794}
1795
1796impl From<f32> for Edges<Pixels> {
1797 fn from(val: f32) -> Self {
1798 Edges {
1799 top: val.into(),
1800 right: val.into(),
1801 bottom: val.into(),
1802 left: val.into(),
1803 }
1804 }
1805}
1806
1807/// Represents the corners of a box in a 2D space, such as border radius.
1808///
1809/// Each field represents the size of the corner on one side of the box: `top_left`, `top_right`, `bottom_right`, and `bottom_left`.
1810#[derive(Refineable, Clone, Default, Debug, Eq, PartialEq)]
1811#[refineable(Debug)]
1812#[repr(C)]
1813pub struct Corners<T: Clone + Default + Debug> {
1814 /// The value associated with the top left corner.
1815 pub top_left: T,
1816 /// The value associated with the top right corner.
1817 pub top_right: T,
1818 /// The value associated with the bottom right corner.
1819 pub bottom_right: T,
1820 /// The value associated with the bottom left corner.
1821 pub bottom_left: T,
1822}
1823
1824impl<T> Corners<T>
1825where
1826 T: Clone + Default + Debug,
1827{
1828 /// Constructs `Corners` where all sides are set to the same specified value.
1829 ///
1830 /// This function creates a `Corners` instance with the `top_left`, `top_right`, `bottom_right`, and `bottom_left` fields all initialized
1831 /// to the same value provided as an argument. This is useful when you want to have uniform corners around a box,
1832 /// such as a uniform border radius on a rectangle.
1833 ///
1834 /// # Arguments
1835 ///
1836 /// * `value` - The value to set for all four corners.
1837 ///
1838 /// # Returns
1839 ///
1840 /// An `Corners` instance with all corners set to the given value.
1841 ///
1842 /// # Examples
1843 ///
1844 /// ```
1845 /// # use zed::Corners;
1846 /// let uniform_corners = Corners::all(5.0);
1847 /// assert_eq!(uniform_corners.top_left, 5.0);
1848 /// assert_eq!(uniform_corners.top_right, 5.0);
1849 /// assert_eq!(uniform_corners.bottom_right, 5.0);
1850 /// assert_eq!(uniform_corners.bottom_left, 5.0);
1851 /// ```
1852 pub fn all(value: T) -> Self {
1853 Self {
1854 top_left: value.clone(),
1855 top_right: value.clone(),
1856 bottom_right: value.clone(),
1857 bottom_left: value,
1858 }
1859 }
1860}
1861
1862impl Corners<AbsoluteLength> {
1863 /// Converts the `AbsoluteLength` to `Pixels` based on the provided size and rem size, ensuring the resulting
1864 /// `Pixels` do not exceed half of the maximum of the provided size's width and height.
1865 ///
1866 /// This method is particularly useful when dealing with corner radii, where the radius in pixels should not
1867 /// exceed half the size of the box it applies to, to avoid the corners overlapping.
1868 ///
1869 /// # Arguments
1870 ///
1871 /// * `size` - The `Size<Pixels>` against which the maximum allowable radius is determined.
1872 /// * `rem_size` - The size of one REM unit in pixels, used for conversion if the `AbsoluteLength` is in REMs.
1873 ///
1874 /// # Returns
1875 ///
1876 /// Returns a `Corners<Pixels>` instance with each corner's length converted to pixels and clamped to the
1877 /// maximum allowable radius based on the provided size.
1878 ///
1879 /// # Examples
1880 ///
1881 /// ```
1882 /// # use zed::{Corners, AbsoluteLength, Pixels, Size};
1883 /// let corners = Corners {
1884 /// top_left: AbsoluteLength::Pixels(Pixels(15.0)),
1885 /// top_right: AbsoluteLength::Rems(Rems(1.0)),
1886 /// bottom_right: AbsoluteLength::Pixels(Pixels(20.0)),
1887 /// bottom_left: AbsoluteLength::Rems(Rems(2.0)),
1888 /// };
1889 /// let size = Size { width: Pixels(100.0), height: Pixels(50.0) };
1890 /// let rem_size = Pixels(16.0);
1891 /// let corners_in_pixels = corners.to_pixels(size, rem_size);
1892 ///
1893 /// // The resulting corners should not exceed half the size of the smallest dimension (50.0 / 2.0 = 25.0).
1894 /// assert_eq!(corners_in_pixels.top_left, Pixels(15.0));
1895 /// assert_eq!(corners_in_pixels.top_right, Pixels(16.0)); // 1 rem converted to pixels
1896 /// assert_eq!(corners_in_pixels.bottom_right, Pixels(20.0).min(Pixels(25.0))); // Clamped to 25.0
1897 /// assert_eq!(corners_in_pixels.bottom_left, Pixels(32.0).min(Pixels(25.0))); // 2 rems converted to pixels and clamped
1898 /// ```
1899 pub fn to_pixels(&self, size: Size<Pixels>, rem_size: Pixels) -> Corners<Pixels> {
1900 let max = size.width.max(size.height) / 2.;
1901 Corners {
1902 top_left: self.top_left.to_pixels(rem_size).min(max),
1903 top_right: self.top_right.to_pixels(rem_size).min(max),
1904 bottom_right: self.bottom_right.to_pixels(rem_size).min(max),
1905 bottom_left: self.bottom_left.to_pixels(rem_size).min(max),
1906 }
1907 }
1908}
1909
1910impl Corners<Pixels> {
1911 /// Scales the `Corners<Pixels>` by a given factor, returning `Corners<ScaledPixels>`.
1912 ///
1913 /// This method is typically used for adjusting the corner sizes for different display densities or scaling factors.
1914 ///
1915 /// # Arguments
1916 ///
1917 /// * `factor` - The scaling factor to apply to each corner.
1918 ///
1919 /// # Returns
1920 ///
1921 /// Returns a new `Corners<ScaledPixels>` where each corner is the result of scaling the original corner by the given factor.
1922 ///
1923 /// # Examples
1924 ///
1925 /// ```
1926 /// # use zed::{Corners, Pixels};
1927 /// let corners = Corners {
1928 /// top_left: Pixels(10.0),
1929 /// top_right: Pixels(20.0),
1930 /// bottom_right: Pixels(30.0),
1931 /// bottom_left: Pixels(40.0),
1932 /// };
1933 /// let scaled_corners = corners.scale(2.0);
1934 /// assert_eq!(scaled_corners.top_left, ScaledPixels(20.0));
1935 /// assert_eq!(scaled_corners.top_right, ScaledPixels(40.0));
1936 /// assert_eq!(scaled_corners.bottom_right, ScaledPixels(60.0));
1937 /// assert_eq!(scaled_corners.bottom_left, ScaledPixels(80.0));
1938 /// ```
1939 pub fn scale(&self, factor: f32) -> Corners<ScaledPixels> {
1940 Corners {
1941 top_left: self.top_left.scale(factor),
1942 top_right: self.top_right.scale(factor),
1943 bottom_right: self.bottom_right.scale(factor),
1944 bottom_left: self.bottom_left.scale(factor),
1945 }
1946 }
1947
1948 /// Returns the maximum value of any corner.
1949 ///
1950 /// # Returns
1951 ///
1952 /// The maximum `Pixels` value among all four corners.
1953 pub fn max(&self) -> Pixels {
1954 self.top_left
1955 .max(self.top_right)
1956 .max(self.bottom_right)
1957 .max(self.bottom_left)
1958 }
1959}
1960
1961impl<T: Clone + Default + Debug> Corners<T> {
1962 /// Applies a function to each field of the `Corners`, producing a new `Corners<U>`.
1963 ///
1964 /// This method allows for converting a `Corners<T>` to a `Corners<U>` by specifying a closure
1965 /// that defines how to convert between the two types. The closure is applied to each field
1966 /// (`top_left`, `top_right`, `bottom_right`, `bottom_left`), resulting in new corners of the desired type.
1967 ///
1968 /// # Arguments
1969 ///
1970 /// * `f` - A closure that takes a reference to a value of type `T` and returns a value of type `U`.
1971 ///
1972 /// # Returns
1973 ///
1974 /// Returns a new `Corners<U>` with each field mapped by the provided function.
1975 ///
1976 /// # Examples
1977 ///
1978 /// ```
1979 /// # use zed::{Corners, Pixels};
1980 /// let corners = Corners {
1981 /// top_left: Pixels(10.0),
1982 /// top_right: Pixels(20.0),
1983 /// bottom_right: Pixels(30.0),
1984 /// bottom_left: Pixels(40.0),
1985 /// };
1986 /// let corners_in_rems = corners.map(|&px| Rems(px.0 / 16.0));
1987 /// assert_eq!(corners_in_rems, Corners {
1988 /// top_left: Rems(0.625),
1989 /// top_right: Rems(1.25),
1990 /// bottom_right: Rems(1.875),
1991 /// bottom_left: Rems(2.5),
1992 /// });
1993 /// ```
1994 pub fn map<U>(&self, f: impl Fn(&T) -> U) -> Corners<U>
1995 where
1996 U: Clone + Default + Debug,
1997 {
1998 Corners {
1999 top_left: f(&self.top_left),
2000 top_right: f(&self.top_right),
2001 bottom_right: f(&self.bottom_right),
2002 bottom_left: f(&self.bottom_left),
2003 }
2004 }
2005}
2006
2007impl<T> Mul for Corners<T>
2008where
2009 T: Mul<Output = T> + Clone + Default + Debug,
2010{
2011 type Output = Self;
2012
2013 fn mul(self, rhs: Self) -> Self::Output {
2014 Self {
2015 top_left: self.top_left.clone() * rhs.top_left,
2016 top_right: self.top_right.clone() * rhs.top_right,
2017 bottom_right: self.bottom_right.clone() * rhs.bottom_right,
2018 bottom_left: self.bottom_left.clone() * rhs.bottom_left,
2019 }
2020 }
2021}
2022
2023impl<T, S> MulAssign<S> for Corners<T>
2024where
2025 T: Mul<S, Output = T> + Clone + Default + Debug,
2026 S: Clone,
2027{
2028 fn mul_assign(&mut self, rhs: S) {
2029 self.top_left = self.top_left.clone() * rhs.clone();
2030 self.top_right = self.top_right.clone() * rhs.clone();
2031 self.bottom_right = self.bottom_right.clone() * rhs.clone();
2032 self.bottom_left = self.bottom_left.clone() * rhs;
2033 }
2034}
2035
2036impl<T> Copy for Corners<T> where T: Copy + Clone + Default + Debug {}
2037
2038impl From<f32> for Corners<Pixels> {
2039 fn from(val: f32) -> Self {
2040 Corners {
2041 top_left: val.into(),
2042 top_right: val.into(),
2043 bottom_right: val.into(),
2044 bottom_left: val.into(),
2045 }
2046 }
2047}
2048
2049impl From<Pixels> for Corners<Pixels> {
2050 fn from(val: Pixels) -> Self {
2051 Corners {
2052 top_left: val,
2053 top_right: val,
2054 bottom_right: val,
2055 bottom_left: val,
2056 }
2057 }
2058}
2059
2060/// Represents an angle in Radians
2061#[derive(
2062 Clone,
2063 Copy,
2064 Default,
2065 Add,
2066 AddAssign,
2067 Sub,
2068 SubAssign,
2069 Neg,
2070 Div,
2071 DivAssign,
2072 PartialEq,
2073 Serialize,
2074 Deserialize,
2075 Debug,
2076)]
2077#[repr(transparent)]
2078pub struct Radians(pub f32);
2079
2080/// Create a `Radian` from a raw value
2081pub fn radians(value: f32) -> Radians {
2082 Radians(value)
2083}
2084
2085/// A type representing a percentage value.
2086#[derive(
2087 Clone,
2088 Copy,
2089 Default,
2090 Add,
2091 AddAssign,
2092 Sub,
2093 SubAssign,
2094 Neg,
2095 Div,
2096 DivAssign,
2097 PartialEq,
2098 Serialize,
2099 Deserialize,
2100 Debug,
2101)]
2102#[repr(transparent)]
2103pub struct Percentage(pub f32);
2104
2105/// Generate a `Radian` from a percentage of a full circle.
2106pub fn percentage(value: f32) -> Percentage {
2107 debug_assert!(
2108 value >= 0.0 && value <= 1.0,
2109 "Percentage must be between 0 and 1"
2110 );
2111 Percentage(value)
2112}
2113
2114impl From<Percentage> for Radians {
2115 fn from(value: Percentage) -> Self {
2116 radians(value.0 * std::f32::consts::PI * 2.0)
2117 }
2118}
2119
2120/// Represents a length in pixels, the base unit of measurement in the UI framework.
2121///
2122/// `Pixels` is a value type that represents an absolute length in pixels, which is used
2123/// for specifying sizes, positions, and distances in the UI. It is the fundamental unit
2124/// of measurement for all visual elements and layout calculations.
2125///
2126/// The inner value is an `f32`, allowing for sub-pixel precision which can be useful for
2127/// anti-aliasing and animations. However, when applied to actual pixel grids, the value
2128/// is typically rounded to the nearest integer.
2129///
2130/// # Examples
2131///
2132/// ```
2133/// use zed::Pixels;
2134///
2135/// // Define a length of 10 pixels
2136/// let length = Pixels(10.0);
2137///
2138/// // Define a length and scale it by a factor of 2
2139/// let scaled_length = length.scale(2.0);
2140/// assert_eq!(scaled_length, Pixels(20.0));
2141/// ```
2142#[derive(
2143 Clone,
2144 Copy,
2145 Default,
2146 Add,
2147 AddAssign,
2148 Sub,
2149 SubAssign,
2150 Neg,
2151 Div,
2152 DivAssign,
2153 PartialEq,
2154 Serialize,
2155 Deserialize,
2156)]
2157#[repr(transparent)]
2158pub struct Pixels(pub f32);
2159
2160impl std::fmt::Display for Pixels {
2161 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2162 f.write_fmt(format_args!("{}px", self.0))
2163 }
2164}
2165
2166impl std::ops::Div for Pixels {
2167 type Output = f32;
2168
2169 fn div(self, rhs: Self) -> Self::Output {
2170 self.0 / rhs.0
2171 }
2172}
2173
2174impl std::ops::DivAssign for Pixels {
2175 fn div_assign(&mut self, rhs: Self) {
2176 *self = Self(self.0 / rhs.0);
2177 }
2178}
2179
2180impl std::ops::RemAssign for Pixels {
2181 fn rem_assign(&mut self, rhs: Self) {
2182 self.0 %= rhs.0;
2183 }
2184}
2185
2186impl std::ops::Rem for Pixels {
2187 type Output = Self;
2188
2189 fn rem(self, rhs: Self) -> Self {
2190 Self(self.0 % rhs.0)
2191 }
2192}
2193
2194impl Mul<f32> for Pixels {
2195 type Output = Pixels;
2196
2197 fn mul(self, other: f32) -> Pixels {
2198 Pixels(self.0 * other)
2199 }
2200}
2201
2202impl Mul<usize> for Pixels {
2203 type Output = Pixels;
2204
2205 fn mul(self, other: usize) -> Pixels {
2206 Pixels(self.0 * other as f32)
2207 }
2208}
2209
2210impl Mul<Pixels> for f32 {
2211 type Output = Pixels;
2212
2213 fn mul(self, rhs: Pixels) -> Self::Output {
2214 Pixels(self * rhs.0)
2215 }
2216}
2217
2218impl MulAssign<f32> for Pixels {
2219 fn mul_assign(&mut self, other: f32) {
2220 self.0 *= other;
2221 }
2222}
2223
2224impl Pixels {
2225 /// Represents zero pixels.
2226 pub const ZERO: Pixels = Pixels(0.0);
2227 /// The maximum value that can be represented by `Pixels`.
2228 pub const MAX: Pixels = Pixels(f32::MAX);
2229
2230 /// Floors the `Pixels` value to the nearest whole number.
2231 ///
2232 /// # Returns
2233 ///
2234 /// Returns a new `Pixels` instance with the floored value.
2235 pub fn floor(&self) -> Self {
2236 Self(self.0.floor())
2237 }
2238
2239 /// Rounds the `Pixels` value to the nearest whole number.
2240 ///
2241 /// # Returns
2242 ///
2243 /// Returns a new `Pixels` instance with the rounded value.
2244 pub fn round(&self) -> Self {
2245 Self(self.0.round())
2246 }
2247
2248 /// Returns the ceiling of the `Pixels` value to the nearest whole number.
2249 ///
2250 /// # Returns
2251 ///
2252 /// Returns a new `Pixels` instance with the ceiling value.
2253 pub fn ceil(&self) -> Self {
2254 Self(self.0.ceil())
2255 }
2256
2257 /// Scales the `Pixels` value by a given factor, producing `ScaledPixels`.
2258 ///
2259 /// This method is used when adjusting pixel values for display scaling factors,
2260 /// such as high DPI (dots per inch) or Retina displays, where the pixel density is higher and
2261 /// thus requires scaling to maintain visual consistency and readability.
2262 ///
2263 /// The resulting `ScaledPixels` represent the scaled value which can be used for rendering
2264 /// calculations where display scaling is considered.
2265 pub fn scale(&self, factor: f32) -> ScaledPixels {
2266 ScaledPixels(self.0 * factor)
2267 }
2268
2269 /// Raises the `Pixels` value to a given power.
2270 ///
2271 /// # Arguments
2272 ///
2273 /// * `exponent` - The exponent to raise the `Pixels` value by.
2274 ///
2275 /// # Returns
2276 ///
2277 /// Returns a new `Pixels` instance with the value raised to the given exponent.
2278 pub fn pow(&self, exponent: f32) -> Self {
2279 Self(self.0.powf(exponent))
2280 }
2281
2282 /// Returns the absolute value of the `Pixels`.
2283 ///
2284 /// # Returns
2285 ///
2286 /// A new `Pixels` instance with the absolute value of the original `Pixels`.
2287 pub fn abs(&self) -> Self {
2288 Self(self.0.abs())
2289 }
2290}
2291
2292impl Mul<Pixels> for Pixels {
2293 type Output = Pixels;
2294
2295 fn mul(self, rhs: Pixels) -> Self::Output {
2296 Pixels(self.0 * rhs.0)
2297 }
2298}
2299
2300impl Eq for Pixels {}
2301
2302impl PartialOrd for Pixels {
2303 fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
2304 Some(self.cmp(other))
2305 }
2306}
2307
2308impl Ord for Pixels {
2309 fn cmp(&self, other: &Self) -> cmp::Ordering {
2310 self.0.total_cmp(&other.0)
2311 }
2312}
2313
2314impl std::hash::Hash for Pixels {
2315 fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
2316 self.0.to_bits().hash(state);
2317 }
2318}
2319
2320impl From<f64> for Pixels {
2321 fn from(pixels: f64) -> Self {
2322 Pixels(pixels as f32)
2323 }
2324}
2325
2326impl From<f32> for Pixels {
2327 fn from(pixels: f32) -> Self {
2328 Pixels(pixels)
2329 }
2330}
2331
2332impl Debug for Pixels {
2333 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2334 write!(f, "{} px", self.0)
2335 }
2336}
2337
2338impl From<Pixels> for f32 {
2339 fn from(pixels: Pixels) -> Self {
2340 pixels.0
2341 }
2342}
2343
2344impl From<&Pixels> for f32 {
2345 fn from(pixels: &Pixels) -> Self {
2346 pixels.0
2347 }
2348}
2349
2350impl From<Pixels> for f64 {
2351 fn from(pixels: Pixels) -> Self {
2352 pixels.0 as f64
2353 }
2354}
2355
2356impl From<Pixels> for u32 {
2357 fn from(pixels: Pixels) -> Self {
2358 pixels.0 as u32
2359 }
2360}
2361
2362impl From<u32> for Pixels {
2363 fn from(pixels: u32) -> Self {
2364 Pixels(pixels as f32)
2365 }
2366}
2367
2368impl From<Pixels> for usize {
2369 fn from(pixels: Pixels) -> Self {
2370 pixels.0 as usize
2371 }
2372}
2373
2374impl From<usize> for Pixels {
2375 fn from(pixels: usize) -> Self {
2376 Pixels(pixels as f32)
2377 }
2378}
2379
2380/// Represents physical pixels on the display.
2381///
2382/// `DevicePixels` is a unit of measurement that refers to the actual pixels on a device's screen.
2383/// This type is used when precise pixel manipulation is required, such as rendering graphics or
2384/// interfacing with hardware that operates on the pixel level. Unlike logical pixels that may be
2385/// affected by the device's scale factor, `DevicePixels` always correspond to real pixels on the
2386/// display.
2387#[derive(
2388 Add, AddAssign, Clone, Copy, Default, Div, Eq, Hash, Ord, PartialEq, PartialOrd, Sub, SubAssign,
2389)]
2390#[repr(transparent)]
2391pub struct DevicePixels(pub(crate) i32);
2392
2393impl DevicePixels {
2394 /// Converts the `DevicePixels` value to the number of bytes needed to represent it in memory.
2395 ///
2396 /// This function is useful when working with graphical data that needs to be stored in a buffer,
2397 /// such as images or framebuffers, where each pixel may be represented by a specific number of bytes.
2398 ///
2399 /// # Arguments
2400 ///
2401 /// * `bytes_per_pixel` - The number of bytes used to represent a single pixel.
2402 ///
2403 /// # Returns
2404 ///
2405 /// The number of bytes required to represent the `DevicePixels` value in memory.
2406 ///
2407 /// # Examples
2408 ///
2409 /// ```
2410 /// # use zed::DevicePixels;
2411 /// let pixels = DevicePixels(10); // 10 device pixels
2412 /// let bytes_per_pixel = 4; // Assume each pixel is represented by 4 bytes (e.g., RGBA)
2413 /// let total_bytes = pixels.to_bytes(bytes_per_pixel);
2414 /// assert_eq!(total_bytes, 40); // 10 pixels * 4 bytes/pixel = 40 bytes
2415 /// ```
2416 pub fn to_bytes(&self, bytes_per_pixel: u8) -> u32 {
2417 self.0 as u32 * bytes_per_pixel as u32
2418 }
2419}
2420
2421impl fmt::Debug for DevicePixels {
2422 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2423 write!(f, "{} px (device)", self.0)
2424 }
2425}
2426
2427impl From<DevicePixels> for i32 {
2428 fn from(device_pixels: DevicePixels) -> Self {
2429 device_pixels.0
2430 }
2431}
2432
2433impl From<i32> for DevicePixels {
2434 fn from(device_pixels: i32) -> Self {
2435 DevicePixels(device_pixels)
2436 }
2437}
2438
2439impl From<u32> for DevicePixels {
2440 fn from(device_pixels: u32) -> Self {
2441 DevicePixels(device_pixels as i32)
2442 }
2443}
2444
2445impl From<DevicePixels> for u32 {
2446 fn from(device_pixels: DevicePixels) -> Self {
2447 device_pixels.0 as u32
2448 }
2449}
2450
2451impl From<DevicePixels> for u64 {
2452 fn from(device_pixels: DevicePixels) -> Self {
2453 device_pixels.0 as u64
2454 }
2455}
2456
2457impl From<u64> for DevicePixels {
2458 fn from(device_pixels: u64) -> Self {
2459 DevicePixels(device_pixels as i32)
2460 }
2461}
2462
2463impl From<DevicePixels> for usize {
2464 fn from(device_pixels: DevicePixels) -> Self {
2465 device_pixels.0 as usize
2466 }
2467}
2468
2469impl From<usize> for DevicePixels {
2470 fn from(device_pixels: usize) -> Self {
2471 DevicePixels(device_pixels as i32)
2472 }
2473}
2474
2475/// Represents scaled pixels that take into account the device's scale factor.
2476///
2477/// `ScaledPixels` are used to ensure that UI elements appear at the correct size on devices
2478/// with different pixel densities. When a device has a higher scale factor (such as Retina displays),
2479/// a single logical pixel may correspond to multiple physical pixels. By using `ScaledPixels`,
2480/// dimensions and positions can be specified in a way that scales appropriately across different
2481/// display resolutions.
2482#[derive(Clone, Copy, Default, Add, AddAssign, Sub, SubAssign, Div, PartialEq, PartialOrd)]
2483#[repr(transparent)]
2484pub struct ScaledPixels(pub(crate) f32);
2485
2486impl ScaledPixels {
2487 /// Floors the `ScaledPixels` value to the nearest whole number.
2488 ///
2489 /// # Returns
2490 ///
2491 /// Returns a new `ScaledPixels` instance with the floored value.
2492 pub fn floor(&self) -> Self {
2493 Self(self.0.floor())
2494 }
2495
2496 /// Rounds the `ScaledPixels` value to the nearest whole number.
2497 ///
2498 /// # Returns
2499 ///
2500 /// Returns a new `ScaledPixels` instance with the rounded value.
2501 pub fn ceil(&self) -> Self {
2502 Self(self.0.ceil())
2503 }
2504}
2505
2506impl Eq for ScaledPixels {}
2507
2508impl Debug for ScaledPixels {
2509 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2510 write!(f, "{} px (scaled)", self.0)
2511 }
2512}
2513
2514impl From<ScaledPixels> for DevicePixels {
2515 fn from(scaled: ScaledPixels) -> Self {
2516 DevicePixels(scaled.0.ceil() as i32)
2517 }
2518}
2519
2520impl From<DevicePixels> for ScaledPixels {
2521 fn from(device: DevicePixels) -> Self {
2522 ScaledPixels(device.0 as f32)
2523 }
2524}
2525
2526impl From<ScaledPixels> for f64 {
2527 fn from(scaled_pixels: ScaledPixels) -> Self {
2528 scaled_pixels.0 as f64
2529 }
2530}
2531
2532/// Represents a length in rems, a unit based on the font-size of the window, which can be assigned with [`WindowContext::set_rem_size`][set_rem_size].
2533///
2534/// Rems are used for defining lengths that are scalable and consistent across different UI elements.
2535/// The value of `1rem` is typically equal to the font-size of the root element (often the `<html>` element in browsers),
2536/// making it a flexible unit that adapts to the user's text size preferences. In this framework, `rems` serve a similar
2537/// purpose, allowing for scalable and accessible design that can adjust to different display settings or user preferences.
2538///
2539/// For example, if the root element's font-size is `16px`, then `1rem` equals `16px`. A length of `2rems` would then be `32px`.
2540///
2541/// [set_rem_size]: crate::WindowContext::set_rem_size
2542#[derive(Clone, Copy, Default, Add, Sub, Mul, Div, Neg, PartialEq)]
2543pub struct Rems(pub f32);
2544
2545impl Rems {
2546 /// Convert this Rem value to pixels.
2547 pub fn to_pixels(&self, rem_size: Pixels) -> Pixels {
2548 *self * rem_size
2549 }
2550}
2551
2552impl Mul<Pixels> for Rems {
2553 type Output = Pixels;
2554
2555 fn mul(self, other: Pixels) -> Pixels {
2556 Pixels(self.0 * other.0)
2557 }
2558}
2559
2560impl Debug for Rems {
2561 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2562 write!(f, "{} rem", self.0)
2563 }
2564}
2565
2566/// Represents an absolute length in pixels or rems.
2567///
2568/// `AbsoluteLength` can be either a fixed number of pixels, which is an absolute measurement not
2569/// affected by the current font size, or a number of rems, which is relative to the font size of
2570/// the root element. It is used for specifying dimensions that are either independent of or
2571/// related to the typographic scale.
2572#[derive(Clone, Copy, Debug, Neg, PartialEq)]
2573pub enum AbsoluteLength {
2574 /// A length in pixels.
2575 Pixels(Pixels),
2576 /// A length in rems.
2577 Rems(Rems),
2578}
2579
2580impl AbsoluteLength {
2581 /// Checks if the absolute length is zero.
2582 pub fn is_zero(&self) -> bool {
2583 match self {
2584 AbsoluteLength::Pixels(px) => px.0 == 0.0,
2585 AbsoluteLength::Rems(rems) => rems.0 == 0.0,
2586 }
2587 }
2588}
2589
2590impl From<Pixels> for AbsoluteLength {
2591 fn from(pixels: Pixels) -> Self {
2592 AbsoluteLength::Pixels(pixels)
2593 }
2594}
2595
2596impl From<Rems> for AbsoluteLength {
2597 fn from(rems: Rems) -> Self {
2598 AbsoluteLength::Rems(rems)
2599 }
2600}
2601
2602impl AbsoluteLength {
2603 /// Converts an `AbsoluteLength` to `Pixels` based on a given `rem_size`.
2604 ///
2605 /// # Arguments
2606 ///
2607 /// * `rem_size` - The size of one rem in pixels.
2608 ///
2609 /// # Returns
2610 ///
2611 /// Returns the `AbsoluteLength` as `Pixels`.
2612 ///
2613 /// # Examples
2614 ///
2615 /// ```
2616 /// # use zed::{AbsoluteLength, Pixels};
2617 /// let length_in_pixels = AbsoluteLength::Pixels(Pixels(42.0));
2618 /// let length_in_rems = AbsoluteLength::Rems(Rems(2.0));
2619 /// let rem_size = Pixels(16.0);
2620 ///
2621 /// assert_eq!(length_in_pixels.to_pixels(rem_size), Pixels(42.0));
2622 /// assert_eq!(length_in_rems.to_pixels(rem_size), Pixels(32.0));
2623 /// ```
2624 pub fn to_pixels(&self, rem_size: Pixels) -> Pixels {
2625 match self {
2626 AbsoluteLength::Pixels(pixels) => *pixels,
2627 AbsoluteLength::Rems(rems) => rems.to_pixels(rem_size),
2628 }
2629 }
2630}
2631
2632impl Default for AbsoluteLength {
2633 fn default() -> Self {
2634 px(0.).into()
2635 }
2636}
2637
2638/// A non-auto length that can be defined in pixels, rems, or percent of parent.
2639///
2640/// This enum represents lengths that have a specific value, as opposed to lengths that are automatically
2641/// determined by the context. It includes absolute lengths in pixels or rems, and relative lengths as a
2642/// fraction of the parent's size.
2643#[derive(Clone, Copy, Neg, PartialEq)]
2644pub enum DefiniteLength {
2645 /// An absolute length specified in pixels or rems.
2646 Absolute(AbsoluteLength),
2647 /// A relative length specified as a fraction of the parent's size, between 0 and 1.
2648 Fraction(f32),
2649}
2650
2651impl DefiniteLength {
2652 /// Converts the `DefiniteLength` to `Pixels` based on a given `base_size` and `rem_size`.
2653 ///
2654 /// If the `DefiniteLength` is an absolute length, it will be directly converted to `Pixels`.
2655 /// If it is a fraction, the fraction will be multiplied by the `base_size` to get the length in pixels.
2656 ///
2657 /// # Arguments
2658 ///
2659 /// * `base_size` - The base size in `AbsoluteLength` to which the fraction will be applied.
2660 /// * `rem_size` - The size of one rem in pixels, used to convert rems to pixels.
2661 ///
2662 /// # Returns
2663 ///
2664 /// Returns the `DefiniteLength` as `Pixels`.
2665 ///
2666 /// # Examples
2667 ///
2668 /// ```
2669 /// # use zed::{DefiniteLength, AbsoluteLength, Pixels, px, rems};
2670 /// let length_in_pixels = DefiniteLength::Absolute(AbsoluteLength::Pixels(px(42.0)));
2671 /// let length_in_rems = DefiniteLength::Absolute(AbsoluteLength::Rems(rems(2.0)));
2672 /// let length_as_fraction = DefiniteLength::Fraction(0.5);
2673 /// let base_size = AbsoluteLength::Pixels(px(100.0));
2674 /// let rem_size = px(16.0);
2675 ///
2676 /// assert_eq!(length_in_pixels.to_pixels(base_size, rem_size), Pixels(42.0));
2677 /// assert_eq!(length_in_rems.to_pixels(base_size, rem_size), Pixels(32.0));
2678 /// assert_eq!(length_as_fraction.to_pixels(base_size, rem_size), Pixels(50.0));
2679 /// ```
2680 pub fn to_pixels(&self, base_size: AbsoluteLength, rem_size: Pixels) -> Pixels {
2681 match self {
2682 DefiniteLength::Absolute(size) => size.to_pixels(rem_size),
2683 DefiniteLength::Fraction(fraction) => match base_size {
2684 AbsoluteLength::Pixels(px) => px * *fraction,
2685 AbsoluteLength::Rems(rems) => rems * rem_size * *fraction,
2686 },
2687 }
2688 }
2689}
2690
2691impl Debug for DefiniteLength {
2692 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2693 match self {
2694 DefiniteLength::Absolute(length) => Debug::fmt(length, f),
2695 DefiniteLength::Fraction(fract) => write!(f, "{}%", (fract * 100.0) as i32),
2696 }
2697 }
2698}
2699
2700impl From<Pixels> for DefiniteLength {
2701 fn from(pixels: Pixels) -> Self {
2702 Self::Absolute(pixels.into())
2703 }
2704}
2705
2706impl From<Rems> for DefiniteLength {
2707 fn from(rems: Rems) -> Self {
2708 Self::Absolute(rems.into())
2709 }
2710}
2711
2712impl From<AbsoluteLength> for DefiniteLength {
2713 fn from(length: AbsoluteLength) -> Self {
2714 Self::Absolute(length)
2715 }
2716}
2717
2718impl Default for DefiniteLength {
2719 fn default() -> Self {
2720 Self::Absolute(AbsoluteLength::default())
2721 }
2722}
2723
2724/// A length that can be defined in pixels, rems, percent of parent, or auto.
2725#[derive(Clone, Copy)]
2726pub enum Length {
2727 /// A definite length specified either in pixels, rems, or as a fraction of the parent's size.
2728 Definite(DefiniteLength),
2729 /// An automatic length that is determined by the context in which it is used.
2730 Auto,
2731}
2732
2733impl Debug for Length {
2734 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2735 match self {
2736 Length::Definite(definite_length) => write!(f, "{:?}", definite_length),
2737 Length::Auto => write!(f, "auto"),
2738 }
2739 }
2740}
2741
2742/// Constructs a `DefiniteLength` representing a relative fraction of a parent size.
2743///
2744/// This function creates a `DefiniteLength` that is a specified fraction of a parent's dimension.
2745/// The fraction should be a floating-point number between 0.0 and 1.0, where 1.0 represents 100% of the parent's size.
2746///
2747/// # Arguments
2748///
2749/// * `fraction` - The fraction of the parent's size, between 0.0 and 1.0.
2750///
2751/// # Returns
2752///
2753/// A `DefiniteLength` representing the relative length as a fraction of the parent's size.
2754pub fn relative(fraction: f32) -> DefiniteLength {
2755 DefiniteLength::Fraction(fraction)
2756}
2757
2758/// Returns the Golden Ratio, i.e. `~(1.0 + sqrt(5.0)) / 2.0`.
2759pub fn phi() -> DefiniteLength {
2760 relative(1.618_034)
2761}
2762
2763/// Constructs a `Rems` value representing a length in rems.
2764///
2765/// # Arguments
2766///
2767/// * `rems` - The number of rems for the length.
2768///
2769/// # Returns
2770///
2771/// A `Rems` representing the specified number of rems.
2772pub fn rems(rems: f32) -> Rems {
2773 Rems(rems)
2774}
2775
2776/// Constructs a `Pixels` value representing a length in pixels.
2777///
2778/// # Arguments
2779///
2780/// * `pixels` - The number of pixels for the length.
2781///
2782/// # Returns
2783///
2784/// A `Pixels` representing the specified number of pixels.
2785pub const fn px(pixels: f32) -> Pixels {
2786 Pixels(pixels)
2787}
2788
2789/// Returns a `Length` representing an automatic length.
2790///
2791/// The `auto` length is often used in layout calculations where the length should be determined
2792/// by the layout context itself rather than being explicitly set. This is commonly used in CSS
2793/// for properties like `width`, `height`, `margin`, `padding`, etc., where `auto` can be used
2794/// to instruct the layout engine to calculate the size based on other factors like the size of the
2795/// container or the intrinsic size of the content.
2796///
2797/// # Returns
2798///
2799/// A `Length` variant set to `Auto`.
2800pub fn auto() -> Length {
2801 Length::Auto
2802}
2803
2804impl From<Pixels> for Length {
2805 fn from(pixels: Pixels) -> Self {
2806 Self::Definite(pixels.into())
2807 }
2808}
2809
2810impl From<Rems> for Length {
2811 fn from(rems: Rems) -> Self {
2812 Self::Definite(rems.into())
2813 }
2814}
2815
2816impl From<DefiniteLength> for Length {
2817 fn from(length: DefiniteLength) -> Self {
2818 Self::Definite(length)
2819 }
2820}
2821
2822impl From<AbsoluteLength> for Length {
2823 fn from(length: AbsoluteLength) -> Self {
2824 Self::Definite(length.into())
2825 }
2826}
2827
2828impl Default for Length {
2829 fn default() -> Self {
2830 Self::Definite(DefiniteLength::default())
2831 }
2832}
2833
2834impl From<()> for Length {
2835 fn from(_: ()) -> Self {
2836 Self::Definite(DefiniteLength::default())
2837 }
2838}
2839
2840/// Provides a trait for types that can calculate half of their value.
2841///
2842/// The `Half` trait is used for types that can be evenly divided, returning a new instance of the same type
2843/// representing half of the original value. This is commonly used for types that represent measurements or sizes,
2844/// such as lengths or pixels, where halving is a frequent operation during layout calculations or animations.
2845pub trait Half {
2846 /// Returns half of the current value.
2847 ///
2848 /// # Returns
2849 ///
2850 /// A new instance of the implementing type, representing half of the original value.
2851 fn half(&self) -> Self;
2852}
2853
2854impl Half for i32 {
2855 fn half(&self) -> Self {
2856 self / 2
2857 }
2858}
2859
2860impl Half for f32 {
2861 fn half(&self) -> Self {
2862 self / 2.
2863 }
2864}
2865
2866impl Half for DevicePixels {
2867 fn half(&self) -> Self {
2868 Self(self.0 / 2)
2869 }
2870}
2871
2872impl Half for ScaledPixels {
2873 fn half(&self) -> Self {
2874 Self(self.0 / 2.)
2875 }
2876}
2877
2878impl Half for Pixels {
2879 fn half(&self) -> Self {
2880 Self(self.0 / 2.)
2881 }
2882}
2883
2884impl Half for Rems {
2885 fn half(&self) -> Self {
2886 Self(self.0 / 2.)
2887 }
2888}
2889
2890/// Provides a trait for types that can negate their values.
2891pub trait Negate {
2892 /// Returns the negation of the given value
2893 fn negate(self) -> Self;
2894}
2895
2896impl Negate for i32 {
2897 fn negate(self) -> Self {
2898 -self
2899 }
2900}
2901
2902impl Negate for f32 {
2903 fn negate(self) -> Self {
2904 -self
2905 }
2906}
2907
2908impl Negate for DevicePixels {
2909 fn negate(self) -> Self {
2910 Self(-self.0)
2911 }
2912}
2913
2914impl Negate for ScaledPixels {
2915 fn negate(self) -> Self {
2916 Self(-self.0)
2917 }
2918}
2919
2920impl Negate for Pixels {
2921 fn negate(self) -> Self {
2922 Self(-self.0)
2923 }
2924}
2925
2926impl Negate for Rems {
2927 fn negate(self) -> Self {
2928 Self(-self.0)
2929 }
2930}
2931
2932/// A trait for checking if a value is zero.
2933///
2934/// This trait provides a method to determine if a value is considered to be zero.
2935/// It is implemented for various numeric and length-related types where the concept
2936/// of zero is applicable. This can be useful for comparisons, optimizations, or
2937/// determining if an operation has a neutral effect.
2938pub trait IsZero {
2939 /// Determines if the value is zero.
2940 ///
2941 /// # Returns
2942 ///
2943 /// Returns `true` if the value is zero, `false` otherwise.
2944 fn is_zero(&self) -> bool;
2945}
2946
2947impl IsZero for DevicePixels {
2948 fn is_zero(&self) -> bool {
2949 self.0 == 0
2950 }
2951}
2952
2953impl IsZero for ScaledPixels {
2954 fn is_zero(&self) -> bool {
2955 self.0 == 0.
2956 }
2957}
2958
2959impl IsZero for Pixels {
2960 fn is_zero(&self) -> bool {
2961 self.0 == 0.
2962 }
2963}
2964
2965impl IsZero for Rems {
2966 fn is_zero(&self) -> bool {
2967 self.0 == 0.
2968 }
2969}
2970
2971impl IsZero for AbsoluteLength {
2972 fn is_zero(&self) -> bool {
2973 match self {
2974 AbsoluteLength::Pixels(pixels) => pixels.is_zero(),
2975 AbsoluteLength::Rems(rems) => rems.is_zero(),
2976 }
2977 }
2978}
2979
2980impl IsZero for DefiniteLength {
2981 fn is_zero(&self) -> bool {
2982 match self {
2983 DefiniteLength::Absolute(length) => length.is_zero(),
2984 DefiniteLength::Fraction(fraction) => *fraction == 0.,
2985 }
2986 }
2987}
2988
2989impl IsZero for Length {
2990 fn is_zero(&self) -> bool {
2991 match self {
2992 Length::Definite(length) => length.is_zero(),
2993 Length::Auto => false,
2994 }
2995 }
2996}
2997
2998impl<T: IsZero + Debug + Clone + Default> IsZero for Point<T> {
2999 fn is_zero(&self) -> bool {
3000 self.x.is_zero() && self.y.is_zero()
3001 }
3002}
3003
3004impl<T> IsZero for Size<T>
3005where
3006 T: IsZero + Default + Debug + Clone,
3007{
3008 fn is_zero(&self) -> bool {
3009 self.width.is_zero() || self.height.is_zero()
3010 }
3011}
3012
3013impl<T: IsZero + Debug + Clone + Default> IsZero for Bounds<T> {
3014 fn is_zero(&self) -> bool {
3015 self.size.is_zero()
3016 }
3017}
3018
3019impl<T> IsZero for Corners<T>
3020where
3021 T: IsZero + Clone + Default + Debug,
3022{
3023 fn is_zero(&self) -> bool {
3024 self.top_left.is_zero()
3025 && self.top_right.is_zero()
3026 && self.bottom_right.is_zero()
3027 && self.bottom_left.is_zero()
3028 }
3029}
3030
3031#[cfg(test)]
3032mod tests {
3033 use super::*;
3034
3035 #[test]
3036 fn test_bounds_intersects() {
3037 let bounds1 = Bounds {
3038 origin: Point { x: 0.0, y: 0.0 },
3039 size: Size {
3040 width: 5.0,
3041 height: 5.0,
3042 },
3043 };
3044 let bounds2 = Bounds {
3045 origin: Point { x: 4.0, y: 4.0 },
3046 size: Size {
3047 width: 5.0,
3048 height: 5.0,
3049 },
3050 };
3051 let bounds3 = Bounds {
3052 origin: Point { x: 10.0, y: 10.0 },
3053 size: Size {
3054 width: 5.0,
3055 height: 5.0,
3056 },
3057 };
3058
3059 // Test Case 1: Intersecting bounds
3060 assert_eq!(bounds1.intersects(&bounds2), true);
3061
3062 // Test Case 2: Non-Intersecting bounds
3063 assert_eq!(bounds1.intersects(&bounds3), false);
3064
3065 // Test Case 3: Bounds intersecting with themselves
3066 assert_eq!(bounds1.intersects(&bounds1), true);
3067 }
3068}