Skip to main content

gpui/
geometry.rs

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 anyhow::{Context as _, anyhow};
6use core::fmt::Debug;
7use derive_more::{Add, AddAssign, Div, DivAssign, Mul, Neg, Sub, SubAssign};
8use refineable::Refineable;
9use schemars::{JsonSchema, json_schema};
10use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
11use std::borrow::Cow;
12use std::ops::{AddAssign, Range};
13use std::{
14    cmp::{self, PartialOrd},
15    fmt::{self, Display},
16    hash::Hash,
17    ops::{Add, Div, Mul, MulAssign, Neg, Sub},
18};
19use taffy::prelude::{TaffyGridLine, TaffyGridSpan};
20
21use crate::{App, DisplayId};
22
23/// Axis in a 2D cartesian space.
24#[derive(Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
25pub enum Axis {
26    /// The y axis, or up and down
27    Vertical,
28    /// The x axis, or left and right
29    Horizontal,
30}
31
32impl Axis {
33    /// Swap this axis to the opposite axis.
34    pub fn invert(self) -> Self {
35        match self {
36            Axis::Vertical => Axis::Horizontal,
37            Axis::Horizontal => Axis::Vertical,
38        }
39    }
40}
41
42/// A trait for accessing the given unit along a certain axis.
43pub trait Along {
44    /// The unit associated with this type
45    type Unit;
46
47    /// Returns the unit along the given axis.
48    fn along(&self, axis: Axis) -> Self::Unit;
49
50    /// Applies the given function to the unit along the given axis and returns a new value.
51    fn apply_along(&self, axis: Axis, f: impl FnOnce(Self::Unit) -> Self::Unit) -> Self;
52}
53
54/// Describes a location in a 2D cartesian space.
55///
56/// It holds two public fields, `x` and `y`, which represent the coordinates in the space.
57/// The type `T` for the coordinates can be any type that implements `Default`, `Clone`, and `Debug`.
58///
59/// # Examples
60///
61/// ```
62/// # use gpui::Point;
63/// let point = Point { x: 10, y: 20 };
64/// println!("{:?}", point); // Outputs: Point { x: 10, y: 20 }
65/// ```
66#[derive(
67    Refineable,
68    Default,
69    Add,
70    AddAssign,
71    Sub,
72    SubAssign,
73    Copy,
74    Debug,
75    PartialEq,
76    Eq,
77    Serialize,
78    Deserialize,
79    JsonSchema,
80    Hash,
81    Neg,
82)]
83#[refineable(Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
84#[repr(C)]
85pub struct Point<T: Clone + Debug + Default + PartialEq> {
86    /// The x coordinate of the point.
87    pub x: T,
88    /// The y coordinate of the point.
89    pub y: T,
90}
91
92/// Constructs a new `Point<T>` with the given x and y coordinates.
93///
94/// # Arguments
95///
96/// * `x` - The x coordinate of the point.
97/// * `y` - The y coordinate of the point.
98///
99/// # Returns
100///
101/// Returns a `Point<T>` with the specified coordinates.
102///
103/// # Examples
104///
105/// ```
106/// use gpui::point;
107/// let p = point(10, 20);
108/// assert_eq!(p.x, 10);
109/// assert_eq!(p.y, 20);
110/// ```
111pub const fn point<T: Clone + Debug + Default + PartialEq>(x: T, y: T) -> Point<T> {
112    Point { x, y }
113}
114
115impl<T: Clone + Debug + Default + PartialEq> Point<T> {
116    /// Creates a new `Point` with the specified `x` and `y` coordinates.
117    ///
118    /// # Arguments
119    ///
120    /// * `x` - The horizontal coordinate of the point.
121    /// * `y` - The vertical coordinate of the point.
122    ///
123    /// # Examples
124    ///
125    /// ```
126    /// use gpui::Point;
127    /// let p = Point::new(10, 20);
128    /// assert_eq!(p.x, 10);
129    /// assert_eq!(p.y, 20);
130    /// ```
131    pub const fn new(x: T, y: T) -> Self {
132        Self { x, y }
133    }
134
135    /// Transforms the point to a `Point<U>` by applying the given function to both coordinates.
136    ///
137    /// This method allows for converting a `Point<T>` to a `Point<U>` by specifying a closure
138    /// that defines how to convert between the two types. The closure is applied to both the `x`
139    /// and `y` coordinates, resulting in a new point of the desired type.
140    ///
141    /// # Arguments
142    ///
143    /// * `f` - A closure that takes a value of type `T` and returns a value of type `U`.
144    ///
145    /// # Examples
146    ///
147    /// ```
148    /// # use gpui::Point;
149    /// let p = Point { x: 3, y: 4 };
150    /// let p_float = p.map(|coord| coord as f32);
151    /// assert_eq!(p_float, Point { x: 3.0, y: 4.0 });
152    /// ```
153    #[must_use]
154    pub fn map<U: Clone + Debug + Default + PartialEq>(&self, f: impl Fn(T) -> U) -> Point<U> {
155        Point {
156            x: f(self.x.clone()),
157            y: f(self.y.clone()),
158        }
159    }
160}
161
162impl<T: Clone + Debug + Default + PartialEq> Along for Point<T> {
163    type Unit = T;
164
165    fn along(&self, axis: Axis) -> T {
166        match axis {
167            Axis::Horizontal => self.x.clone(),
168            Axis::Vertical => self.y.clone(),
169        }
170    }
171
172    fn apply_along(&self, axis: Axis, f: impl FnOnce(T) -> T) -> Point<T> {
173        match axis {
174            Axis::Horizontal => Point {
175                x: f(self.x.clone()),
176                y: self.y.clone(),
177            },
178            Axis::Vertical => Point {
179                x: self.x.clone(),
180                y: f(self.y.clone()),
181            },
182        }
183    }
184}
185
186impl Point<Pixels> {
187    /// Scales the point by a given factor, which is typically derived from the resolution
188    /// of a target display to ensure proper sizing of UI elements.
189    ///
190    /// # Arguments
191    ///
192    /// * `factor` - The scaling factor to apply to both the x and y coordinates.
193    ///
194    /// # Examples
195    ///
196    /// ```
197    /// # use gpui::{Point, Pixels, ScaledPixels};
198    /// let p = Point { x: Pixels::from(10.0), y: Pixels::from(20.0) };
199    /// let scaled_p = p.scale(1.5);
200    /// assert_eq!(scaled_p, Point { x: ScaledPixels::from(15.0), y: ScaledPixels::from(30.0) });
201    /// ```
202    pub fn scale(&self, factor: f32) -> Point<ScaledPixels> {
203        Point {
204            x: self.x.scale(factor),
205            y: self.y.scale(factor),
206        }
207    }
208
209    /// Calculates the Euclidean distance from the origin (0, 0) to this point.
210    ///
211    /// # Examples
212    ///
213    /// ```
214    /// # use gpui::{Pixels, Point};
215    /// let p = Point { x: Pixels::from(3.0), y: Pixels::from(4.0) };
216    /// assert_eq!(p.magnitude(), 5.0);
217    /// ```
218    pub fn magnitude(&self) -> f64 {
219        ((self.x.0.powi(2) + self.y.0.powi(2)) as f64).sqrt()
220    }
221}
222
223impl<T> Point<T>
224where
225    T: Sub<T, Output = T> + Clone + Debug + Default + PartialEq,
226{
227    /// Get the position of this point, relative to the given origin
228    pub fn relative_to(&self, origin: &Point<T>) -> Point<T> {
229        point(
230            self.x.clone() - origin.x.clone(),
231            self.y.clone() - origin.y.clone(),
232        )
233    }
234}
235
236impl<T, Rhs> Mul<Rhs> for Point<T>
237where
238    T: Mul<Rhs, Output = T> + Clone + Debug + Default + PartialEq,
239    Rhs: Clone + Debug,
240{
241    type Output = Point<T>;
242
243    fn mul(self, rhs: Rhs) -> Self::Output {
244        Point {
245            x: self.x * rhs.clone(),
246            y: self.y * rhs,
247        }
248    }
249}
250
251impl<T, S> MulAssign<S> for Point<T>
252where
253    T: Mul<S, Output = T> + Clone + Debug + Default + PartialEq,
254    S: Clone,
255{
256    fn mul_assign(&mut self, rhs: S) {
257        self.x = self.x.clone() * rhs.clone();
258        self.y = self.y.clone() * rhs;
259    }
260}
261
262impl<T, S> Div<S> for Point<T>
263where
264    T: Div<S, Output = T> + Clone + Debug + Default + PartialEq,
265    S: Clone,
266{
267    type Output = Self;
268
269    fn div(self, rhs: S) -> Self::Output {
270        Self {
271            x: self.x / rhs.clone(),
272            y: self.y / rhs,
273        }
274    }
275}
276
277impl<T> Point<T>
278where
279    T: PartialOrd + Clone + Debug + Default + PartialEq,
280{
281    /// Returns a new point with the maximum values of each dimension from `self` and `other`.
282    ///
283    /// # Arguments
284    ///
285    /// * `other` - A reference to another `Point` to compare with `self`.
286    ///
287    /// # Examples
288    ///
289    /// ```
290    /// # use gpui::Point;
291    /// let p1 = Point { x: 3, y: 7 };
292    /// let p2 = Point { x: 5, y: 2 };
293    /// let max_point = p1.max(&p2);
294    /// assert_eq!(max_point, Point { x: 5, y: 7 });
295    /// ```
296    pub fn max(&self, other: &Self) -> Self {
297        Point {
298            x: if self.x > other.x {
299                self.x.clone()
300            } else {
301                other.x.clone()
302            },
303            y: if self.y > other.y {
304                self.y.clone()
305            } else {
306                other.y.clone()
307            },
308        }
309    }
310
311    /// Returns a new point with the minimum values of each dimension from `self` and `other`.
312    ///
313    /// # Arguments
314    ///
315    /// * `other` - A reference to another `Point` to compare with `self`.
316    ///
317    /// # Examples
318    ///
319    /// ```
320    /// # use gpui::Point;
321    /// let p1 = Point { x: 3, y: 7 };
322    /// let p2 = Point { x: 5, y: 2 };
323    /// let min_point = p1.min(&p2);
324    /// assert_eq!(min_point, Point { x: 3, y: 2 });
325    /// ```
326    pub fn min(&self, other: &Self) -> Self {
327        Point {
328            x: if self.x <= other.x {
329                self.x.clone()
330            } else {
331                other.x.clone()
332            },
333            y: if self.y <= other.y {
334                self.y.clone()
335            } else {
336                other.y.clone()
337            },
338        }
339    }
340
341    /// Clamps the point to a specified range.
342    ///
343    /// Given a minimum point and a maximum point, this method constrains the current point
344    /// such that its coordinates do not exceed the range defined by the minimum and maximum points.
345    /// If the current point's coordinates are less than the minimum, they are set to the minimum.
346    /// If they are greater than the maximum, they are set to the maximum.
347    ///
348    /// # Arguments
349    ///
350    /// * `min` - A reference to a `Point` representing the minimum allowable coordinates.
351    /// * `max` - A reference to a `Point` representing the maximum allowable coordinates.
352    ///
353    /// # Examples
354    ///
355    /// ```
356    /// # use gpui::Point;
357    /// let p = Point { x: 10, y: 20 };
358    /// let min = Point { x: 0, y: 5 };
359    /// let max = Point { x: 15, y: 25 };
360    /// let clamped_p = p.clamp(&min, &max);
361    /// assert_eq!(clamped_p, Point { x: 10, y: 20 });
362    ///
363    /// let p_out_of_bounds = Point { x: -5, y: 30 };
364    /// let clamped_p_out_of_bounds = p_out_of_bounds.clamp(&min, &max);
365    /// assert_eq!(clamped_p_out_of_bounds, Point { x: 0, y: 25 });
366    /// ```
367    pub fn clamp(&self, min: &Self, max: &Self) -> Self {
368        self.max(min).min(max)
369    }
370}
371
372impl<T: Clone + Debug + Default + PartialEq> Clone for Point<T> {
373    fn clone(&self) -> Self {
374        Self {
375            x: self.x.clone(),
376            y: self.y.clone(),
377        }
378    }
379}
380
381impl<T: Clone + Debug + Default + PartialEq + Display> Display for Point<T> {
382    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
383        write!(f, "({}, {})", self.x, self.y)
384    }
385}
386
387/// A structure representing a two-dimensional size with width and height in a given unit.
388///
389/// This struct is generic over the type `T`, which can be any type that implements `Clone`, `Default`, and `Debug`.
390/// It is commonly used to specify dimensions for elements in a UI, such as a window or element.
391#[derive(
392    Add, Clone, Copy, Default, Deserialize, Div, Hash, Neg, PartialEq, Refineable, Serialize, Sub,
393)]
394#[refineable(Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
395#[repr(C)]
396pub struct Size<T: Clone + Debug + Default + PartialEq> {
397    /// The width component of the size.
398    pub width: T,
399    /// The height component of the size.
400    pub height: T,
401}
402
403impl<T: Clone + Debug + Default + PartialEq> Size<T> {
404    /// Create a new Size, a synonym for [`size`]
405    pub fn new(width: T, height: T) -> Self {
406        size(width, height)
407    }
408}
409
410/// Constructs a new `Size<T>` with the provided width and height.
411///
412/// # Arguments
413///
414/// * `width` - The width component of the `Size`.
415/// * `height` - The height component of the `Size`.
416///
417/// # Examples
418///
419/// ```
420/// use gpui::size;
421/// let my_size = size(10, 20);
422/// assert_eq!(my_size.width, 10);
423/// assert_eq!(my_size.height, 20);
424/// ```
425pub const fn size<T>(width: T, height: T) -> Size<T>
426where
427    T: Clone + Debug + Default + PartialEq,
428{
429    Size { width, height }
430}
431
432impl<T> Size<T>
433where
434    T: Clone + Debug + Default + PartialEq,
435{
436    /// Applies a function to the width and height of the size, producing a new `Size<U>`.
437    ///
438    /// This method allows for converting a `Size<T>` to a `Size<U>` by specifying a closure
439    /// that defines how to convert between the two types. The closure is applied to both the `width`
440    /// and `height`, resulting in a new size of the desired type.
441    ///
442    /// # Arguments
443    ///
444    /// * `f` - A closure that takes a value of type `T` and returns a value of type `U`.
445    ///
446    /// # Examples
447    ///
448    /// ```
449    /// # use gpui::Size;
450    /// let my_size = Size { width: 10, height: 20 };
451    /// let my_new_size = my_size.map(|dimension| dimension as f32 * 1.5);
452    /// assert_eq!(my_new_size, Size { width: 15.0, height: 30.0 });
453    /// ```
454    pub fn map<U>(&self, f: impl Fn(T) -> U) -> Size<U>
455    where
456        U: Clone + Debug + Default + PartialEq,
457    {
458        Size {
459            width: f(self.width.clone()),
460            height: f(self.height.clone()),
461        }
462    }
463}
464
465impl<T> Size<T>
466where
467    T: Clone + Debug + Default + PartialEq + Half,
468{
469    /// Compute the center point of the size.g
470    pub fn center(&self) -> Point<T> {
471        Point {
472            x: self.width.half(),
473            y: self.height.half(),
474        }
475    }
476}
477
478impl Size<Pixels> {
479    /// Scales the size by a given factor.
480    ///
481    /// This method multiplies both the width and height by the provided scaling factor,
482    /// resulting in a new `Size<ScaledPixels>` that is proportionally larger or smaller
483    /// depending on the factor.
484    ///
485    /// # Arguments
486    ///
487    /// * `factor` - The scaling factor to apply to the width and height.
488    ///
489    /// # Examples
490    ///
491    /// ```
492    /// # use gpui::{Size, Pixels, ScaledPixels};
493    /// let size = Size { width: Pixels::from(100.0), height: Pixels::from(50.0) };
494    /// let scaled_size = size.scale(2.0);
495    /// assert_eq!(scaled_size, Size { width: ScaledPixels::from(200.0), height: ScaledPixels::from(100.0) });
496    /// ```
497    pub fn scale(&self, factor: f32) -> Size<ScaledPixels> {
498        Size {
499            width: self.width.scale(factor),
500            height: self.height.scale(factor),
501        }
502    }
503}
504
505impl<T> Along for Size<T>
506where
507    T: Clone + Debug + Default + PartialEq,
508{
509    type Unit = T;
510
511    fn along(&self, axis: Axis) -> T {
512        match axis {
513            Axis::Horizontal => self.width.clone(),
514            Axis::Vertical => self.height.clone(),
515        }
516    }
517
518    /// Returns the value of this size along the given axis.
519    fn apply_along(&self, axis: Axis, f: impl FnOnce(T) -> T) -> Self {
520        match axis {
521            Axis::Horizontal => Size {
522                width: f(self.width.clone()),
523                height: self.height.clone(),
524            },
525            Axis::Vertical => Size {
526                width: self.width.clone(),
527                height: f(self.height.clone()),
528            },
529        }
530    }
531}
532
533impl<T> Size<T>
534where
535    T: PartialOrd + Clone + Debug + Default + PartialEq,
536{
537    /// Returns a new `Size` with the maximum width and height from `self` and `other`.
538    ///
539    /// # Arguments
540    ///
541    /// * `other` - A reference to another `Size` to compare with `self`.
542    ///
543    /// # Examples
544    ///
545    /// ```
546    /// # use gpui::Size;
547    /// let size1 = Size { width: 30, height: 40 };
548    /// let size2 = Size { width: 50, height: 20 };
549    /// let max_size = size1.max(&size2);
550    /// assert_eq!(max_size, Size { width: 50, height: 40 });
551    /// ```
552    pub fn max(&self, other: &Self) -> Self {
553        Size {
554            width: if self.width >= other.width {
555                self.width.clone()
556            } else {
557                other.width.clone()
558            },
559            height: if self.height >= other.height {
560                self.height.clone()
561            } else {
562                other.height.clone()
563            },
564        }
565    }
566
567    /// Returns a new `Size` with the minimum width and height from `self` and `other`.
568    ///
569    /// # Arguments
570    ///
571    /// * `other` - A reference to another `Size` to compare with `self`.
572    ///
573    /// # Examples
574    ///
575    /// ```
576    /// # use gpui::Size;
577    /// let size1 = Size { width: 30, height: 40 };
578    /// let size2 = Size { width: 50, height: 20 };
579    /// let min_size = size1.min(&size2);
580    /// assert_eq!(min_size, Size { width: 30, height: 20 });
581    /// ```
582    pub fn min(&self, other: &Self) -> Self {
583        Size {
584            width: if self.width >= other.width {
585                other.width.clone()
586            } else {
587                self.width.clone()
588            },
589            height: if self.height >= other.height {
590                other.height.clone()
591            } else {
592                self.height.clone()
593            },
594        }
595    }
596}
597
598impl<T, Rhs> Mul<Rhs> for Size<T>
599where
600    T: Mul<Rhs, Output = Rhs> + Clone + Debug + Default + PartialEq,
601    Rhs: Clone + Debug + Default + PartialEq,
602{
603    type Output = Size<Rhs>;
604
605    fn mul(self, rhs: Rhs) -> Self::Output {
606        Size {
607            width: self.width * rhs.clone(),
608            height: self.height * rhs,
609        }
610    }
611}
612
613impl<T, S> MulAssign<S> for Size<T>
614where
615    T: Mul<S, Output = T> + Clone + Debug + Default + PartialEq,
616    S: Clone,
617{
618    fn mul_assign(&mut self, rhs: S) {
619        self.width = self.width.clone() * rhs.clone();
620        self.height = self.height.clone() * rhs;
621    }
622}
623
624impl<T> Eq for Size<T> where T: Eq + Clone + Debug + Default + PartialEq {}
625
626impl<T> Debug for Size<T>
627where
628    T: Clone + Debug + Default + PartialEq,
629{
630    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
631        write!(f, "Size {{ {:?} × {:?} }}", self.width, self.height)
632    }
633}
634
635impl<T: Clone + Debug + Default + PartialEq + Display> Display for Size<T> {
636    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
637        write!(f, "{} × {}", self.width, self.height)
638    }
639}
640
641impl<T: Clone + Debug + Default + PartialEq> From<Point<T>> for Size<T> {
642    fn from(point: Point<T>) -> Self {
643        Self {
644            width: point.x,
645            height: point.y,
646        }
647    }
648}
649
650impl From<Size<Pixels>> for Size<DefiniteLength> {
651    fn from(size: Size<Pixels>) -> Self {
652        Size {
653            width: size.width.into(),
654            height: size.height.into(),
655        }
656    }
657}
658
659impl From<Size<Pixels>> for Size<AbsoluteLength> {
660    fn from(size: Size<Pixels>) -> Self {
661        Size {
662            width: size.width.into(),
663            height: size.height.into(),
664        }
665    }
666}
667
668impl Size<Length> {
669    /// Returns a `Size` with both width and height set to fill the available space.
670    ///
671    /// This function creates a `Size` instance where both the width and height are set to `Length::Definite(DefiniteLength::Fraction(1.0))`,
672    /// which represents 100% of the available space in both dimensions.
673    ///
674    /// # Returns
675    ///
676    /// A `Size<Length>` that will fill the available space when used in a layout.
677    pub fn full() -> Self {
678        Self {
679            width: relative(1.).into(),
680            height: relative(1.).into(),
681        }
682    }
683}
684
685impl Size<Length> {
686    /// Returns a `Size` with both width and height set to `auto`, which allows the layout engine to determine the size.
687    ///
688    /// This function creates a `Size` instance where both the width and height are set to `Length::Auto`,
689    /// indicating that their size should be computed based on the layout context, such as the content size or
690    /// available space.
691    ///
692    /// # Returns
693    ///
694    /// A `Size<Length>` with width and height set to `Length::Auto`.
695    pub fn auto() -> Self {
696        Self {
697            width: Length::Auto,
698            height: Length::Auto,
699        }
700    }
701}
702
703/// Represents a rectangular area in a 2D space with an origin point and a size.
704///
705/// The `Bounds` struct is generic over a type `T` which represents the type of the coordinate system.
706/// The origin is represented as a `Point<T>` which defines the top left corner of the rectangle,
707/// and the size is represented as a `Size<T>` which defines the width and height of the rectangle.
708///
709/// # Examples
710///
711/// ```
712/// # use gpui::{Bounds, Point, Size};
713/// let origin = Point { x: 0, y: 0 };
714/// let size = Size { width: 10, height: 20 };
715/// let bounds = Bounds::new(origin, size);
716///
717/// assert_eq!(bounds.origin, origin);
718/// assert_eq!(bounds.size, size);
719/// ```
720#[derive(Refineable, Copy, Clone, Default, Debug, Eq, PartialEq, Serialize, Deserialize, Hash)]
721#[refineable(Debug)]
722#[repr(C)]
723pub struct Bounds<T: Clone + Debug + Default + PartialEq> {
724    /// The origin point of this area.
725    pub origin: Point<T>,
726    /// The size of the rectangle.
727    pub size: Size<T>,
728}
729
730/// Create a bounds with the given origin and size
731pub fn bounds<T: Clone + Debug + Default + PartialEq>(
732    origin: Point<T>,
733    size: Size<T>,
734) -> Bounds<T> {
735    Bounds { origin, size }
736}
737
738impl Bounds<Pixels> {
739    /// Generate a centered bounds for the given display or primary display if none is provided
740    pub fn centered(display_id: Option<DisplayId>, size: Size<Pixels>, cx: &App) -> Self {
741        let display = display_id
742            .and_then(|id| cx.find_display(id))
743            .or_else(|| cx.primary_display());
744
745        display
746            .map(|display| {
747                let visible_bounds = display.visible_bounds();
748                Bounds::centered_at(visible_bounds.center(), size.min(&visible_bounds.size))
749            })
750            .unwrap_or_else(|| Bounds {
751                origin: point(px(0.), px(0.)),
752                size,
753            })
754    }
755
756    /// Generate maximized bounds for the given display or primary display if none is provided
757    pub fn maximized(display_id: Option<DisplayId>, cx: &App) -> Self {
758        let display = display_id
759            .and_then(|id| cx.find_display(id))
760            .or_else(|| cx.primary_display());
761
762        display
763            .map(|display| display.bounds())
764            .unwrap_or_else(|| Bounds {
765                origin: point(px(0.), px(0.)),
766                size: size(px(1024.), px(768.)),
767            })
768    }
769}
770
771impl<T> Bounds<T>
772where
773    T: Clone + Debug + Default + PartialEq,
774{
775    /// Creates a new `Bounds` with the specified origin and size.
776    ///
777    /// # Arguments
778    ///
779    /// * `origin` - A `Point<T>` representing the origin of the bounds.
780    /// * `size` - A `Size<T>` representing the size of the bounds.
781    ///
782    /// # Returns
783    ///
784    /// Returns a `Bounds<T>` that has the given origin and size.
785    pub fn new(origin: Point<T>, size: Size<T>) -> Self {
786        Bounds { origin, size }
787    }
788}
789
790impl<T> Bounds<T>
791where
792    T: Sub<Output = T> + Clone + Debug + Default + PartialEq,
793{
794    /// Constructs a `Bounds` from two corner points: the top left and bottom right corners.
795    ///
796    /// This function calculates the origin and size of the `Bounds` based on the provided corner points.
797    /// The origin is set to the top left corner, and the size is determined by the difference between
798    /// the x and y coordinates of the bottom right and top left points.
799    ///
800    /// # Arguments
801    ///
802    /// * `top_left` - A `Point<T>` representing the top left corner of the rectangle.
803    /// * `bottom_right` - A `Point<T>` representing the bottom right corner of the rectangle.
804    ///
805    /// # Returns
806    ///
807    /// Returns a `Bounds<T>` that encompasses the area defined by the two corner points.
808    ///
809    /// # Examples
810    ///
811    /// ```
812    /// # use gpui::{Bounds, Point};
813    /// let top_left = Point { x: 0, y: 0 };
814    /// let bottom_right = Point { x: 10, y: 10 };
815    /// let bounds = Bounds::from_corners(top_left, bottom_right);
816    ///
817    /// assert_eq!(bounds.origin, top_left);
818    /// assert_eq!(bounds.size.width, 10);
819    /// assert_eq!(bounds.size.height, 10);
820    /// ```
821    pub fn from_corners(top_left: Point<T>, bottom_right: Point<T>) -> Self {
822        let origin = Point {
823            x: top_left.x.clone(),
824            y: top_left.y.clone(),
825        };
826        let size = Size {
827            width: bottom_right.x - top_left.x,
828            height: bottom_right.y - top_left.y,
829        };
830        Bounds { origin, size }
831    }
832}
833
834impl<T> Bounds<T>
835where
836    T: Sub<Output = T> + Half + Clone + Debug + Default + PartialEq,
837{
838    /// Constructs a `Bounds` from a corner point and size. The specified corner will be placed at
839    /// the specified origin.
840    pub fn from_anchor_and_size(corner: Anchor, origin: Point<T>, size: Size<T>) -> Bounds<T> {
841        let origin = match corner {
842            Anchor::TopLeft => origin,
843            Anchor::TopRight => Point {
844                x: origin.x - size.width.clone(),
845                y: origin.y,
846            },
847            Anchor::BottomLeft => Point {
848                x: origin.x,
849                y: origin.y - size.height.clone(),
850            },
851            Anchor::BottomRight => Point {
852                x: origin.x - size.width.clone(),
853                y: origin.y - size.height.clone(),
854            },
855            Anchor::TopCenter => Point {
856                x: origin.x - size.width.half(),
857                y: origin.y,
858            },
859            Anchor::BottomCenter => Point {
860                x: origin.x - size.width.half(),
861                y: origin.y - size.height.clone(),
862            },
863            Anchor::LeftCenter => Point {
864                x: origin.x,
865                y: origin.y - size.height.half(),
866            },
867            Anchor::RightCenter => Point {
868                x: origin.x - size.width.clone(),
869                y: origin.y - size.height.half(),
870            },
871        };
872
873        Bounds { origin, size }
874    }
875}
876
877impl<T> Bounds<T>
878where
879    T: Sub<T, Output = T> + Half + Clone + Debug + Default + PartialEq,
880{
881    /// Creates a new bounds centered at the given point.
882    pub fn centered_at(center: Point<T>, size: Size<T>) -> Self {
883        let origin = Point {
884            x: center.x - size.width.half(),
885            y: center.y - size.height.half(),
886        };
887        Self::new(origin, size)
888    }
889}
890
891impl<T> Bounds<T>
892where
893    T: Add<T, Output = T> + Half + Clone + Debug + Default + PartialEq,
894{
895    /// Returns the top center point of the bounds.
896    pub fn top_center(&self) -> Point<T> {
897        Point {
898            x: self.origin.x.clone() + self.size.width.half(),
899            y: self.origin.y.clone(),
900        }
901    }
902
903    /// Returns the bottom center point of the bounds.
904    pub fn bottom_center(&self) -> Point<T> {
905        Point {
906            x: self.origin.x.clone() + self.size.width.half(),
907            y: self.origin.y.clone() + self.size.height.clone(),
908        }
909    }
910
911    /// Returns the left center point of the bounds.
912    pub fn left_center(&self) -> Point<T> {
913        Point {
914            x: self.origin.x.clone(),
915            y: self.origin.y.clone() + self.size.height.half(),
916        }
917    }
918
919    /// Returns the right center point of the bounds.
920    pub fn right_center(&self) -> Point<T> {
921        Point {
922            x: self.origin.x.clone() + self.size.width.clone(),
923            y: self.origin.y.clone() + self.size.height.half(),
924        }
925    }
926}
927
928impl<T> Bounds<T>
929where
930    T: PartialOrd + Add<T, Output = T> + Clone + Debug + Default + PartialEq,
931{
932    /// Checks if this `Bounds` intersects with another `Bounds`.
933    ///
934    /// Two `Bounds` instances intersect if they overlap in the 2D space they occupy.
935    /// This method checks if there is any overlapping area between the two bounds.
936    ///
937    /// # Arguments
938    ///
939    /// * `other` - A reference to another `Bounds` to check for intersection with.
940    ///
941    /// # Returns
942    ///
943    /// Returns `true` if there is any intersection between the two bounds, `false` otherwise.
944    ///
945    /// # Examples
946    ///
947    /// ```
948    /// # use gpui::{Bounds, Point, Size};
949    /// let bounds1 = Bounds {
950    ///     origin: Point { x: 0, y: 0 },
951    ///     size: Size { width: 10, height: 10 },
952    /// };
953    /// let bounds2 = Bounds {
954    ///     origin: Point { x: 5, y: 5 },
955    ///     size: Size { width: 10, height: 10 },
956    /// };
957    /// let bounds3 = Bounds {
958    ///     origin: Point { x: 20, y: 20 },
959    ///     size: Size { width: 10, height: 10 },
960    /// };
961    ///
962    /// assert_eq!(bounds1.intersects(&bounds2), true); // Overlapping bounds
963    /// assert_eq!(bounds1.intersects(&bounds3), false); // Non-overlapping bounds
964    /// ```
965    pub fn intersects(&self, other: &Bounds<T>) -> bool {
966        let my_lower_right = self.bottom_right();
967        let their_lower_right = other.bottom_right();
968
969        self.origin.x < their_lower_right.x
970            && my_lower_right.x > other.origin.x
971            && self.origin.y < their_lower_right.y
972            && my_lower_right.y > other.origin.y
973    }
974}
975
976impl<T> Bounds<T>
977where
978    T: Add<T, Output = T> + Half + Clone + Debug + Default + PartialEq,
979{
980    /// Returns the center point of the bounds.
981    ///
982    /// Calculates the center by taking the origin's x and y coordinates and adding half the width and height
983    /// of the bounds, respectively. The center is represented as a `Point<T>` where `T` is the type of the
984    /// coordinate system.
985    ///
986    /// # Returns
987    ///
988    /// A `Point<T>` representing the center of the bounds.
989    ///
990    /// # Examples
991    ///
992    /// ```
993    /// # use gpui::{Bounds, Point, Size};
994    /// let bounds = Bounds {
995    ///     origin: Point { x: 0, y: 0 },
996    ///     size: Size { width: 10, height: 20 },
997    /// };
998    /// let center = bounds.center();
999    /// assert_eq!(center, Point { x: 5, y: 10 });
1000    /// ```
1001    pub fn center(&self) -> Point<T> {
1002        Point {
1003            x: self.origin.x.clone() + self.size.width.clone().half(),
1004            y: self.origin.y.clone() + self.size.height.clone().half(),
1005        }
1006    }
1007}
1008
1009impl<T> Bounds<T>
1010where
1011    T: Add<T, Output = T> + Clone + Debug + Default + PartialEq,
1012{
1013    /// Calculates the half perimeter of a rectangle defined by the bounds.
1014    ///
1015    /// The half perimeter is calculated as the sum of the width and the height of the rectangle.
1016    /// This method is generic over the type `T` which must implement the `Sub` trait to allow
1017    /// calculation of the width and height from the bounds' origin and size, as well as the `Add` trait
1018    /// to sum the width and height for the half perimeter.
1019    ///
1020    /// # Examples
1021    ///
1022    /// ```
1023    /// # use gpui::{Bounds, Point, Size};
1024    /// let bounds = Bounds {
1025    ///     origin: Point { x: 0, y: 0 },
1026    ///     size: Size { width: 10, height: 20 },
1027    /// };
1028    /// let half_perimeter = bounds.half_perimeter();
1029    /// assert_eq!(half_perimeter, 30);
1030    /// ```
1031    pub fn half_perimeter(&self) -> T {
1032        self.size.width.clone() + self.size.height.clone()
1033    }
1034}
1035
1036impl<T> Bounds<T>
1037where
1038    T: Add<T, Output = T> + Sub<Output = T> + Clone + Debug + Default + PartialEq,
1039{
1040    /// Dilates the bounds by a specified amount in all directions.
1041    ///
1042    /// This method expands the bounds by the given `amount`, increasing the size
1043    /// and adjusting the origin so that the bounds grow outwards equally in all directions.
1044    /// The resulting bounds will have its width and height increased by twice the `amount`
1045    /// (since it grows in both directions), and the origin will be moved by `-amount`
1046    /// in both the x and y directions.
1047    ///
1048    /// # Arguments
1049    ///
1050    /// * `amount` - The amount by which to dilate the bounds.
1051    ///
1052    /// # Examples
1053    ///
1054    /// ```
1055    /// # use gpui::{Bounds, Point, Size};
1056    /// let mut bounds = Bounds {
1057    ///     origin: Point { x: 10, y: 10 },
1058    ///     size: Size { width: 10, height: 10 },
1059    /// };
1060    /// let expanded_bounds = bounds.dilate(5);
1061    /// assert_eq!(expanded_bounds, Bounds {
1062    ///     origin: Point { x: 5, y: 5 },
1063    ///     size: Size { width: 20, height: 20 },
1064    /// });
1065    /// ```
1066    #[must_use]
1067    pub fn dilate(&self, amount: T) -> Bounds<T> {
1068        let double_amount = amount.clone() + amount.clone();
1069        Bounds {
1070            origin: self.origin.clone() - point(amount.clone(), amount),
1071            size: self.size.clone() + size(double_amount.clone(), double_amount),
1072        }
1073    }
1074
1075    /// Extends the bounds different amounts in each direction.
1076    #[must_use]
1077    pub fn extend(&self, amount: Edges<T>) -> Bounds<T> {
1078        Bounds {
1079            origin: self.origin.clone() - point(amount.left.clone(), amount.top.clone()),
1080            size: self.size.clone()
1081                + size(
1082                    amount.left.clone() + amount.right.clone(),
1083                    amount.top.clone() + amount.bottom,
1084                ),
1085        }
1086    }
1087}
1088
1089impl<T> Bounds<T>
1090where
1091    T: Add<T, Output = T>
1092        + Sub<T, Output = T>
1093        + Neg<Output = T>
1094        + Clone
1095        + Debug
1096        + Default
1097        + PartialEq,
1098{
1099    /// Inset the bounds by a specified amount. Equivalent to `dilate` with the amount negated.
1100    ///
1101    /// Note that this may panic if T does not support negative values.
1102    pub fn inset(&self, amount: T) -> Self {
1103        self.dilate(-amount)
1104    }
1105}
1106
1107impl<T: PartialOrd + Add<T, Output = T> + Sub<Output = T> + Clone + Debug + Default + PartialEq>
1108    Bounds<T>
1109{
1110    /// Calculates the intersection of two `Bounds` objects.
1111    ///
1112    /// This method computes the overlapping region of two `Bounds`. If the bounds do not intersect,
1113    /// the resulting `Bounds` will have a size with width and height of zero.
1114    ///
1115    /// # Arguments
1116    ///
1117    /// * `other` - A reference to another `Bounds` to intersect with.
1118    ///
1119    /// # Returns
1120    ///
1121    /// Returns a `Bounds` representing the intersection area. If there is no intersection,
1122    /// the returned `Bounds` will have a size with width and height of zero.
1123    ///
1124    /// # Examples
1125    ///
1126    /// ```
1127    /// # use gpui::{Bounds, Point, Size};
1128    /// let bounds1 = Bounds {
1129    ///     origin: Point { x: 0, y: 0 },
1130    ///     size: Size { width: 10, height: 10 },
1131    /// };
1132    /// let bounds2 = Bounds {
1133    ///     origin: Point { x: 5, y: 5 },
1134    ///     size: Size { width: 10, height: 10 },
1135    /// };
1136    /// let intersection = bounds1.intersect(&bounds2);
1137    ///
1138    /// assert_eq!(intersection, Bounds {
1139    ///     origin: Point { x: 5, y: 5 },
1140    ///     size: Size { width: 5, height: 5 },
1141    /// });
1142    /// ```
1143    pub fn intersect(&self, other: &Self) -> Self {
1144        let upper_left = self.origin.max(&other.origin);
1145        let bottom_right = self
1146            .bottom_right()
1147            .min(&other.bottom_right())
1148            .max(&upper_left);
1149        Self::from_corners(upper_left, bottom_right)
1150    }
1151
1152    /// Computes the union of two `Bounds`.
1153    ///
1154    /// This method calculates the smallest `Bounds` that contains both the current `Bounds` and the `other` `Bounds`.
1155    /// The resulting `Bounds` will have an origin that is the minimum of the origins of the two `Bounds`,
1156    /// and a size that encompasses the furthest extents of both `Bounds`.
1157    ///
1158    /// # Arguments
1159    ///
1160    /// * `other` - A reference to another `Bounds` to create a union with.
1161    ///
1162    /// # Returns
1163    ///
1164    /// Returns a `Bounds` representing the union of the two `Bounds`.
1165    ///
1166    /// # Examples
1167    ///
1168    /// ```
1169    /// # use gpui::{Bounds, Point, Size};
1170    /// let bounds1 = Bounds {
1171    ///     origin: Point { x: 0, y: 0 },
1172    ///     size: Size { width: 10, height: 10 },
1173    /// };
1174    /// let bounds2 = Bounds {
1175    ///     origin: Point { x: 5, y: 5 },
1176    ///     size: Size { width: 15, height: 15 },
1177    /// };
1178    /// let union_bounds = bounds1.union(&bounds2);
1179    ///
1180    /// assert_eq!(union_bounds, Bounds {
1181    ///     origin: Point { x: 0, y: 0 },
1182    ///     size: Size { width: 20, height: 20 },
1183    /// });
1184    /// ```
1185    pub fn union(&self, other: &Self) -> Self {
1186        let top_left = self.origin.min(&other.origin);
1187        let bottom_right = self.bottom_right().max(&other.bottom_right());
1188        Bounds::from_corners(top_left, bottom_right)
1189    }
1190}
1191
1192impl<T> Bounds<T>
1193where
1194    T: Add<T, Output = T> + Sub<T, Output = T> + Clone + Debug + Default + PartialEq,
1195{
1196    /// Computes the space available within outer bounds.
1197    pub fn space_within(&self, outer: &Self) -> Edges<T> {
1198        Edges {
1199            top: self.top() - outer.top(),
1200            right: outer.right() - self.right(),
1201            bottom: outer.bottom() - self.bottom(),
1202            left: self.left() - outer.left(),
1203        }
1204    }
1205}
1206
1207impl<T, Rhs> Mul<Rhs> for Bounds<T>
1208where
1209    T: Mul<Rhs, Output = Rhs> + Clone + Debug + Default + PartialEq,
1210    Point<T>: Mul<Rhs, Output = Point<Rhs>>,
1211    Rhs: Clone + Debug + Default + PartialEq,
1212{
1213    type Output = Bounds<Rhs>;
1214
1215    fn mul(self, rhs: Rhs) -> Self::Output {
1216        Bounds {
1217            origin: self.origin * rhs.clone(),
1218            size: self.size * rhs,
1219        }
1220    }
1221}
1222
1223impl<T, S> MulAssign<S> for Bounds<T>
1224where
1225    T: Mul<S, Output = T> + Clone + Debug + Default + PartialEq,
1226    S: Clone,
1227{
1228    fn mul_assign(&mut self, rhs: S) {
1229        self.origin *= rhs.clone();
1230        self.size *= rhs;
1231    }
1232}
1233
1234impl<T, S> Div<S> for Bounds<T>
1235where
1236    Size<T>: Div<S, Output = Size<T>>,
1237    T: Div<S, Output = T> + Clone + Debug + Default + PartialEq,
1238    S: Clone,
1239{
1240    type Output = Self;
1241
1242    fn div(self, rhs: S) -> Self {
1243        Self {
1244            origin: self.origin / rhs.clone(),
1245            size: self.size / rhs,
1246        }
1247    }
1248}
1249
1250impl<T> Add<Point<T>> for Bounds<T>
1251where
1252    T: Add<T, Output = T> + Clone + Debug + Default + PartialEq,
1253{
1254    type Output = Self;
1255
1256    fn add(self, rhs: Point<T>) -> Self {
1257        Self {
1258            origin: self.origin + rhs,
1259            size: self.size,
1260        }
1261    }
1262}
1263
1264impl<T> Sub<Point<T>> for Bounds<T>
1265where
1266    T: Sub<T, Output = T> + Clone + Debug + Default + PartialEq,
1267{
1268    type Output = Self;
1269
1270    fn sub(self, rhs: Point<T>) -> Self {
1271        Self {
1272            origin: self.origin - rhs,
1273            size: self.size,
1274        }
1275    }
1276}
1277
1278impl<T: Clone + Debug + Default + PartialEq> From<Size<T>> for Point<T> {
1279    fn from(size: Size<T>) -> Self {
1280        Self {
1281            x: size.width,
1282            y: size.height,
1283        }
1284    }
1285}
1286
1287impl<T> Bounds<T>
1288where
1289    T: Add<T, Output = T> + Clone + Debug + Default + PartialEq,
1290{
1291    /// Returns the top edge of the bounds.
1292    ///
1293    /// # Returns
1294    ///
1295    /// A value of type `T` representing the y-coordinate of the top edge of the bounds.
1296    pub fn top(&self) -> T {
1297        self.origin.y.clone()
1298    }
1299
1300    /// Returns the bottom edge of the bounds.
1301    ///
1302    /// # Returns
1303    ///
1304    /// A value of type `T` representing the y-coordinate of the bottom edge of the bounds.
1305    pub fn bottom(&self) -> T {
1306        self.origin.y.clone() + self.size.height.clone()
1307    }
1308
1309    /// Returns the left edge of the bounds.
1310    ///
1311    /// # Returns
1312    ///
1313    /// A value of type `T` representing the x-coordinate of the left edge of the bounds.
1314    pub fn left(&self) -> T {
1315        self.origin.x.clone()
1316    }
1317
1318    /// Returns the right edge of the bounds.
1319    ///
1320    /// # Returns
1321    ///
1322    /// A value of type `T` representing the x-coordinate of the right edge of the bounds.
1323    pub fn right(&self) -> T {
1324        self.origin.x.clone() + self.size.width.clone()
1325    }
1326
1327    /// Returns the top right corner point of the bounds.
1328    ///
1329    /// # Returns
1330    ///
1331    /// A `Point<T>` representing the top right corner of the bounds.
1332    ///
1333    /// # Examples
1334    ///
1335    /// ```
1336    /// # use gpui::{Bounds, Point, Size};
1337    /// let bounds = Bounds {
1338    ///     origin: Point { x: 0, y: 0 },
1339    ///     size: Size { width: 10, height: 20 },
1340    /// };
1341    /// let top_right = bounds.top_right();
1342    /// assert_eq!(top_right, Point { x: 10, y: 0 });
1343    /// ```
1344    pub fn top_right(&self) -> Point<T> {
1345        Point {
1346            x: self.origin.x.clone() + self.size.width.clone(),
1347            y: self.origin.y.clone(),
1348        }
1349    }
1350
1351    /// Returns the bottom right corner point of the bounds.
1352    ///
1353    /// # Returns
1354    ///
1355    /// A `Point<T>` representing the bottom right corner of the bounds.
1356    ///
1357    /// # Examples
1358    ///
1359    /// ```
1360    /// # use gpui::{Bounds, Point, Size};
1361    /// let bounds = Bounds {
1362    ///     origin: Point { x: 0, y: 0 },
1363    ///     size: Size { width: 10, height: 20 },
1364    /// };
1365    /// let bottom_right = bounds.bottom_right();
1366    /// assert_eq!(bottom_right, Point { x: 10, y: 20 });
1367    /// ```
1368    pub fn bottom_right(&self) -> Point<T> {
1369        Point {
1370            x: self.origin.x.clone() + self.size.width.clone(),
1371            y: self.origin.y.clone() + self.size.height.clone(),
1372        }
1373    }
1374
1375    /// Returns the bottom left corner point of the bounds.
1376    ///
1377    /// # Returns
1378    ///
1379    /// A `Point<T>` representing the bottom left corner of the bounds.
1380    ///
1381    /// # Examples
1382    ///
1383    /// ```
1384    /// # use gpui::{Bounds, Point, Size};
1385    /// let bounds = Bounds {
1386    ///     origin: Point { x: 0, y: 0 },
1387    ///     size: Size { width: 10, height: 20 },
1388    /// };
1389    /// let bottom_left = bounds.bottom_left();
1390    /// assert_eq!(bottom_left, Point { x: 0, y: 20 });
1391    /// ```
1392    pub fn bottom_left(&self) -> Point<T> {
1393        Point {
1394            x: self.origin.x.clone(),
1395            y: self.origin.y.clone() + self.size.height.clone(),
1396        }
1397    }
1398}
1399
1400impl<T> Bounds<T>
1401where
1402    T: Add<T, Output = T> + Half + Clone + Debug + Default + PartialEq,
1403{
1404    /// Returns the requested corner point of the bounds.
1405    ///
1406    /// # Returns
1407    ///
1408    /// A `Point<T>` representing the corner of the bounds requested by the parameter.
1409    ///
1410    /// # Examples
1411    ///
1412    /// ```
1413    /// use gpui::{Bounds, Anchor, Point, Size};
1414    /// let bounds = Bounds {
1415    ///     origin: Point { x: 0, y: 0 },
1416    ///     size: Size { width: 10, height: 20 },
1417    /// };
1418    /// let bottom_left = bounds.corner(Anchor::BottomLeft);
1419    /// assert_eq!(bottom_left, Point { x: 0, y: 20 });
1420    /// ```
1421    pub fn corner(&self, corner: Anchor) -> Point<T> {
1422        match corner {
1423            Anchor::TopLeft => self.origin.clone(),
1424            Anchor::TopRight => self.top_right(),
1425            Anchor::BottomLeft => self.bottom_left(),
1426            Anchor::BottomRight => self.bottom_right(),
1427            Anchor::TopCenter => self.top_center(),
1428            Anchor::BottomCenter => self.bottom_center(),
1429            Anchor::LeftCenter => self.left_center(),
1430            Anchor::RightCenter => self.right_center(),
1431        }
1432    }
1433}
1434
1435impl<T> Bounds<T>
1436where
1437    T: Add<T, Output = T> + PartialOrd + Clone + Debug + Default + PartialEq,
1438{
1439    /// Checks if the given point is within the bounds.
1440    ///
1441    /// This method determines whether a point lies inside the rectangle defined by the bounds,
1442    /// including the edges. The point is considered inside if its x-coordinate is greater than
1443    /// or equal to the left edge and less than or equal to the right edge, and its y-coordinate
1444    /// is greater than or equal to the top edge and less than or equal to the bottom edge of the bounds.
1445    ///
1446    /// # Arguments
1447    ///
1448    /// * `point` - A reference to a `Point<T>` that represents the point to check.
1449    ///
1450    /// # Returns
1451    ///
1452    /// Returns `true` if the point is within the bounds, `false` otherwise.
1453    ///
1454    /// # Examples
1455    ///
1456    /// ```
1457    /// # use gpui::{Point, Bounds, Size};
1458    /// let bounds = Bounds {
1459    ///     origin: Point { x: 0, y: 0 },
1460    ///     size: Size { width: 10, height: 10 },
1461    /// };
1462    /// let inside_point = Point { x: 5, y: 5 };
1463    /// let outside_point = Point { x: 15, y: 15 };
1464    ///
1465    /// assert!(bounds.contains(&inside_point));
1466    /// assert!(!bounds.contains(&outside_point));
1467    /// ```
1468    pub fn contains(&self, point: &Point<T>) -> bool {
1469        point.x >= self.origin.x
1470            && point.x < self.origin.x.clone() + self.size.width.clone()
1471            && point.y >= self.origin.y
1472            && point.y < self.origin.y.clone() + self.size.height.clone()
1473    }
1474
1475    /// Checks if this bounds is completely contained within another bounds.
1476    ///
1477    /// This method determines whether the current bounds is entirely enclosed by the given bounds.
1478    /// A bounds is considered to be contained within another if its origin (top-left corner) and
1479    /// its bottom-right corner are both contained within the other bounds.
1480    ///
1481    /// # Arguments
1482    ///
1483    /// * `other` - A reference to another `Bounds` that might contain this bounds.
1484    ///
1485    /// # Returns
1486    ///
1487    /// Returns `true` if this bounds is completely inside the other bounds, `false` otherwise.
1488    ///
1489    /// # Examples
1490    ///
1491    /// ```
1492    /// # use gpui::{Bounds, Point, Size};
1493    /// let outer_bounds = Bounds {
1494    ///     origin: Point { x: 0, y: 0 },
1495    ///     size: Size { width: 20, height: 20 },
1496    /// };
1497    /// let inner_bounds = Bounds {
1498    ///     origin: Point { x: 5, y: 5 },
1499    ///     size: Size { width: 10, height: 10 },
1500    /// };
1501    /// let overlapping_bounds = Bounds {
1502    ///     origin: Point { x: 15, y: 15 },
1503    ///     size: Size { width: 10, height: 10 },
1504    /// };
1505    ///
1506    /// assert!(inner_bounds.is_contained_within(&outer_bounds));
1507    /// assert!(!overlapping_bounds.is_contained_within(&outer_bounds));
1508    /// ```
1509    pub fn is_contained_within(&self, other: &Self) -> bool {
1510        other.contains(&self.origin) && other.contains(&self.bottom_right())
1511    }
1512
1513    /// Applies a function to the origin and size of the bounds, producing a new `Bounds<U>`.
1514    ///
1515    /// This method allows for converting a `Bounds<T>` to a `Bounds<U>` by specifying a closure
1516    /// that defines how to convert between the two types. The closure is applied to the `origin` and
1517    /// `size` fields, resulting in new bounds of the desired type.
1518    ///
1519    /// # Arguments
1520    ///
1521    /// * `f` - A closure that takes a value of type `T` and returns a value of type `U`.
1522    ///
1523    /// # Returns
1524    ///
1525    /// Returns a new `Bounds<U>` with the origin and size mapped by the provided function.
1526    ///
1527    /// # Examples
1528    ///
1529    /// ```
1530    /// # use gpui::{Bounds, Point, Size};
1531    /// let bounds = Bounds {
1532    ///     origin: Point { x: 10.0, y: 10.0 },
1533    ///     size: Size { width: 10.0, height: 20.0 },
1534    /// };
1535    /// let new_bounds = bounds.map(|value| value as f64 * 1.5);
1536    ///
1537    /// assert_eq!(new_bounds, Bounds {
1538    ///     origin: Point { x: 15.0, y: 15.0 },
1539    ///     size: Size { width: 15.0, height: 30.0 },
1540    /// });
1541    /// ```
1542    pub fn map<U>(&self, f: impl Fn(T) -> U) -> Bounds<U>
1543    where
1544        U: Clone + Debug + Default + PartialEq,
1545    {
1546        Bounds {
1547            origin: self.origin.map(&f),
1548            size: self.size.map(f),
1549        }
1550    }
1551
1552    /// Applies a function to the origin  of the bounds, producing a new `Bounds` with the new origin
1553    ///
1554    /// # Examples
1555    ///
1556    /// ```
1557    /// # use gpui::{Bounds, Point, Size};
1558    /// let bounds = Bounds {
1559    ///     origin: Point { x: 10.0, y: 10.0 },
1560    ///     size: Size { width: 10.0, height: 20.0 },
1561    /// };
1562    /// let new_bounds = bounds.map_origin(|value| value * 1.5);
1563    ///
1564    /// assert_eq!(new_bounds, Bounds {
1565    ///     origin: Point { x: 15.0, y: 15.0 },
1566    ///     size: Size { width: 10.0, height: 20.0 },
1567    /// });
1568    /// ```
1569    pub fn map_origin(self, f: impl Fn(T) -> T) -> Bounds<T> {
1570        Bounds {
1571            origin: self.origin.map(f),
1572            size: self.size,
1573        }
1574    }
1575
1576    /// Applies a function to the origin  of the bounds, producing a new `Bounds` with the new origin
1577    ///
1578    /// # Examples
1579    ///
1580    /// ```
1581    /// # use gpui::{Bounds, Point, Size};
1582    /// let bounds = Bounds {
1583    ///     origin: Point { x: 10.0, y: 10.0 },
1584    ///     size: Size { width: 10.0, height: 20.0 },
1585    /// };
1586    /// let new_bounds = bounds.map_size(|value| value * 1.5);
1587    ///
1588    /// assert_eq!(new_bounds, Bounds {
1589    ///     origin: Point { x: 10.0, y: 10.0 },
1590    ///     size: Size { width: 15.0, height: 30.0 },
1591    /// });
1592    /// ```
1593    pub fn map_size(self, f: impl Fn(T) -> T) -> Bounds<T> {
1594        Bounds {
1595            origin: self.origin,
1596            size: self.size.map(f),
1597        }
1598    }
1599}
1600
1601impl<T> Bounds<T>
1602where
1603    T: Add<T, Output = T> + Sub<T, Output = T> + PartialOrd + Clone + Debug + Default + PartialEq,
1604{
1605    /// Convert a point to the coordinate space defined by this Bounds
1606    pub fn localize(&self, point: &Point<T>) -> Option<Point<T>> {
1607        self.contains(point)
1608            .then(|| point.relative_to(&self.origin))
1609    }
1610}
1611
1612/// Checks if the bounds represent an empty area.
1613///
1614/// # Returns
1615///
1616/// Returns `true` if either the width or the height of the bounds is less than or equal to zero, indicating an empty area.
1617impl<T: PartialOrd + Clone + Debug + Default + PartialEq> Bounds<T> {
1618    /// Checks if the bounds represent an empty area.
1619    ///
1620    /// # Returns
1621    ///
1622    /// Returns `true` if either the width or the height of the bounds is less than or equal to zero, indicating an empty area.
1623    #[must_use]
1624    pub fn is_empty(&self) -> bool {
1625        self.size.width <= T::default() || self.size.height <= T::default()
1626    }
1627}
1628
1629impl<T: Clone + Debug + Default + PartialEq + Display + Add<T, Output = T>> Display for Bounds<T> {
1630    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1631        write!(
1632            f,
1633            "{} - {} (size {})",
1634            self.origin,
1635            self.bottom_right(),
1636            self.size
1637        )
1638    }
1639}
1640
1641impl Size<DevicePixels> {
1642    /// Converts the size from physical to logical pixels.
1643    pub fn to_pixels(self, scale_factor: f32) -> Size<Pixels> {
1644        size(
1645            px(self.width.0 as f32 / scale_factor),
1646            px(self.height.0 as f32 / scale_factor),
1647        )
1648    }
1649}
1650
1651impl Size<Pixels> {
1652    /// Converts the size from logical to physical pixels.
1653    pub fn to_device_pixels(self, scale_factor: f32) -> Size<DevicePixels> {
1654        size(
1655            DevicePixels((self.width.0 * scale_factor).round() as i32),
1656            DevicePixels((self.height.0 * scale_factor).round() as i32),
1657        )
1658    }
1659}
1660
1661impl Bounds<Pixels> {
1662    /// Scales the bounds by a given factor, typically used to adjust for display scaling.
1663    ///
1664    /// This method multiplies the origin and size of the bounds by the provided scaling factor,
1665    /// resulting in a new `Bounds<ScaledPixels>` that is proportionally larger or smaller
1666    /// depending on the scaling factor. This can be used to ensure that the bounds are properly
1667    /// scaled for different display densities.
1668    ///
1669    /// # Arguments
1670    ///
1671    /// * `factor` - The scaling factor to apply to the origin and size, typically the display's scaling factor.
1672    ///
1673    /// # Returns
1674    ///
1675    /// Returns a new `Bounds<ScaledPixels>` that represents the scaled bounds.
1676    ///
1677    /// # Examples
1678    ///
1679    /// ```
1680    /// # use gpui::{Bounds, Point, Size, Pixels, ScaledPixels, DevicePixels};
1681    /// let bounds = Bounds {
1682    ///     origin: Point { x: Pixels::from(10.0), y: Pixels::from(20.0) },
1683    ///     size: Size { width: Pixels::from(30.0), height: Pixels::from(40.0) },
1684    /// };
1685    /// let display_scale_factor = 2.0;
1686    /// let scaled_bounds = bounds.scale(display_scale_factor);
1687    /// assert_eq!(scaled_bounds, Bounds {
1688    ///     origin: Point {
1689    ///         x: ScaledPixels::from(20.0),
1690    ///         y: ScaledPixels::from(40.0),
1691    ///     },
1692    ///     size: Size {
1693    ///         width: ScaledPixels::from(60.0),
1694    ///         height: ScaledPixels::from(80.0)
1695    ///     },
1696    /// });
1697    /// ```
1698    pub fn scale(&self, factor: f32) -> Bounds<ScaledPixels> {
1699        Bounds {
1700            origin: self.origin.scale(factor),
1701            size: self.size.scale(factor),
1702        }
1703    }
1704
1705    /// Convert the bounds from logical pixels to physical pixels
1706    pub fn to_device_pixels(self, factor: f32) -> Bounds<DevicePixels> {
1707        Bounds {
1708            origin: point(
1709                DevicePixels((self.origin.x.0 * factor).round() as i32),
1710                DevicePixels((self.origin.y.0 * factor).round() as i32),
1711            ),
1712            size: self.size.to_device_pixels(factor),
1713        }
1714    }
1715}
1716
1717impl Bounds<DevicePixels> {
1718    /// Convert the bounds from physical pixels to logical pixels
1719    pub fn to_pixels(self, scale_factor: f32) -> Bounds<Pixels> {
1720        Bounds {
1721            origin: point(
1722                px(self.origin.x.0 as f32 / scale_factor),
1723                px(self.origin.y.0 as f32 / scale_factor),
1724            ),
1725            size: self.size.to_pixels(scale_factor),
1726        }
1727    }
1728}
1729
1730/// Represents the edges of a box in a 2D space, such as padding or margin.
1731///
1732/// Each field represents the size of the edge on one side of the box: `top`, `right`, `bottom`, and `left`.
1733///
1734/// # Examples
1735///
1736/// ```
1737/// # use gpui::Edges;
1738/// let edges = Edges {
1739///     top: 10.0,
1740///     right: 20.0,
1741///     bottom: 30.0,
1742///     left: 40.0,
1743/// };
1744///
1745/// assert_eq!(edges.top, 10.0);
1746/// assert_eq!(edges.right, 20.0);
1747/// assert_eq!(edges.bottom, 30.0);
1748/// assert_eq!(edges.left, 40.0);
1749/// ```
1750#[derive(Refineable, Clone, Default, Debug, Eq, PartialEq)]
1751#[refineable(Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
1752#[repr(C)]
1753pub struct Edges<T: Clone + Debug + Default + PartialEq> {
1754    /// The size of the top edge.
1755    pub top: T,
1756    /// The size of the right edge.
1757    pub right: T,
1758    /// The size of the bottom edge.
1759    pub bottom: T,
1760    /// The size of the left edge.
1761    pub left: T,
1762}
1763
1764impl<T> Add for Edges<T>
1765where
1766    T: Add<Output = T> + Clone + Debug + Default + PartialEq,
1767{
1768    type Output = Self;
1769
1770    fn add(self, rhs: Self) -> Self::Output {
1771        Self {
1772            top: self.top + rhs.top,
1773            right: self.right + rhs.right,
1774            bottom: self.bottom + rhs.bottom,
1775            left: self.left + rhs.left,
1776        }
1777    }
1778}
1779
1780impl<T> Mul for Edges<T>
1781where
1782    T: Mul<Output = T> + Clone + Debug + Default + PartialEq,
1783{
1784    type Output = Self;
1785
1786    fn mul(self, rhs: Self) -> Self::Output {
1787        Self {
1788            top: self.top * rhs.top,
1789            right: self.right * rhs.right,
1790            bottom: self.bottom * rhs.bottom,
1791            left: self.left * rhs.left,
1792        }
1793    }
1794}
1795
1796impl<T, S> MulAssign<S> for Edges<T>
1797where
1798    T: Mul<S, Output = T> + Clone + Debug + Default + PartialEq,
1799    S: Clone,
1800{
1801    fn mul_assign(&mut self, rhs: S) {
1802        self.top = self.top.clone() * rhs.clone();
1803        self.right = self.right.clone() * rhs.clone();
1804        self.bottom = self.bottom.clone() * rhs.clone();
1805        self.left = self.left.clone() * rhs;
1806    }
1807}
1808
1809impl<T: Clone + Debug + Default + PartialEq + Copy> Copy for Edges<T> {}
1810
1811impl<T: Clone + Debug + Default + PartialEq> Edges<T> {
1812    /// Constructs `Edges` where all sides are set to the same specified value.
1813    ///
1814    /// This function creates an `Edges` instance with the `top`, `right`, `bottom`, and `left` fields all initialized
1815    /// to the same value provided as an argument. This is useful when you want to have uniform edges around a box,
1816    /// such as padding or margin with the same size on all sides.
1817    ///
1818    /// # Arguments
1819    ///
1820    /// * `value` - The value to set for all four sides of the edges.
1821    ///
1822    /// # Returns
1823    ///
1824    /// An `Edges` instance with all sides set to the given value.
1825    ///
1826    /// # Examples
1827    ///
1828    /// ```
1829    /// # use gpui::Edges;
1830    /// let uniform_edges = Edges::all(10.0);
1831    /// assert_eq!(uniform_edges.top, 10.0);
1832    /// assert_eq!(uniform_edges.right, 10.0);
1833    /// assert_eq!(uniform_edges.bottom, 10.0);
1834    /// assert_eq!(uniform_edges.left, 10.0);
1835    /// ```
1836    pub fn all(value: T) -> Self {
1837        Self {
1838            top: value.clone(),
1839            right: value.clone(),
1840            bottom: value.clone(),
1841            left: value,
1842        }
1843    }
1844
1845    /// Applies a function to each field of the `Edges`, producing a new `Edges<U>`.
1846    ///
1847    /// This method allows for converting an `Edges<T>` to an `Edges<U>` by specifying a closure
1848    /// that defines how to convert between the two types. The closure is applied to each field
1849    /// (`top`, `right`, `bottom`, `left`), resulting in new edges of the desired type.
1850    ///
1851    /// # Arguments
1852    ///
1853    /// * `f` - A closure that takes a reference to a value of type `T` and returns a value of type `U`.
1854    ///
1855    /// # Returns
1856    ///
1857    /// Returns a new `Edges<U>` with each field mapped by the provided function.
1858    ///
1859    /// # Examples
1860    ///
1861    /// ```
1862    /// # use gpui::Edges;
1863    /// let edges = Edges { top: 10, right: 20, bottom: 30, left: 40 };
1864    /// let edges_float = edges.map(|&value| value as f32 * 1.1);
1865    /// assert_eq!(edges_float, Edges { top: 11.0, right: 22.0, bottom: 33.0, left: 44.0 });
1866    /// ```
1867    pub fn map<U>(&self, f: impl Fn(&T) -> U) -> Edges<U>
1868    where
1869        U: Clone + Debug + Default + PartialEq,
1870    {
1871        Edges {
1872            top: f(&self.top),
1873            right: f(&self.right),
1874            bottom: f(&self.bottom),
1875            left: f(&self.left),
1876        }
1877    }
1878
1879    /// Checks if any of the edges satisfy a given predicate.
1880    ///
1881    /// This method applies a predicate function to each field of the `Edges` and returns `true` if any field satisfies the predicate.
1882    ///
1883    /// # Arguments
1884    ///
1885    /// * `predicate` - A closure that takes a reference to a value of type `T` and returns a `bool`.
1886    ///
1887    /// # Returns
1888    ///
1889    /// Returns `true` if the predicate returns `true` for any of the edge values, `false` otherwise.
1890    ///
1891    /// # Examples
1892    ///
1893    /// ```
1894    /// # use gpui::Edges;
1895    /// let edges = Edges {
1896    ///     top: 10,
1897    ///     right: 0,
1898    ///     bottom: 5,
1899    ///     left: 0,
1900    /// };
1901    ///
1902    /// assert!(edges.any(|value| *value == 0));
1903    /// assert!(edges.any(|value| *value > 0));
1904    /// assert!(!edges.any(|value| *value > 10));
1905    /// ```
1906    pub fn any<F: Fn(&T) -> bool>(&self, predicate: F) -> bool {
1907        predicate(&self.top)
1908            || predicate(&self.right)
1909            || predicate(&self.bottom)
1910            || predicate(&self.left)
1911    }
1912}
1913
1914impl Edges<Length> {
1915    /// 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.
1916    ///
1917    /// 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.
1918    ///
1919    /// # Returns
1920    ///
1921    /// Returns an `Edges<Length>` with all edges set to `Length::Auto`.
1922    ///
1923    /// # Examples
1924    ///
1925    /// ```
1926    /// # use gpui::{Edges, Length};
1927    /// let auto_edges = Edges::auto();
1928    /// assert_eq!(auto_edges.top, Length::Auto);
1929    /// assert_eq!(auto_edges.right, Length::Auto);
1930    /// assert_eq!(auto_edges.bottom, Length::Auto);
1931    /// assert_eq!(auto_edges.left, Length::Auto);
1932    /// ```
1933    pub fn auto() -> Self {
1934        Self {
1935            top: Length::Auto,
1936            right: Length::Auto,
1937            bottom: Length::Auto,
1938            left: Length::Auto,
1939        }
1940    }
1941
1942    /// Sets the edges of the `Edges` struct to zero, which means no size or thickness.
1943    ///
1944    /// This is typically used when you want to specify that a box (like a padding or margin area)
1945    /// should have no edges, effectively making it non-existent or invisible in layout calculations.
1946    ///
1947    /// # Returns
1948    ///
1949    /// Returns an `Edges<Length>` with all edges set to zero length.
1950    ///
1951    /// # Examples
1952    ///
1953    /// ```
1954    /// # use gpui::{DefiniteLength, Edges, Length, Pixels};
1955    /// let no_edges = Edges::<Length>::zero();
1956    /// assert_eq!(no_edges.top, Length::Definite(DefiniteLength::from(Pixels::ZERO)));
1957    /// assert_eq!(no_edges.right, Length::Definite(DefiniteLength::from(Pixels::ZERO)));
1958    /// assert_eq!(no_edges.bottom, Length::Definite(DefiniteLength::from(Pixels::ZERO)));
1959    /// assert_eq!(no_edges.left, Length::Definite(DefiniteLength::from(Pixels::ZERO)));
1960    /// ```
1961    pub fn zero() -> Self {
1962        Self {
1963            top: px(0.).into(),
1964            right: px(0.).into(),
1965            bottom: px(0.).into(),
1966            left: px(0.).into(),
1967        }
1968    }
1969}
1970
1971impl Edges<DefiniteLength> {
1972    /// Sets the edges of the `Edges` struct to zero, which means no size or thickness.
1973    ///
1974    /// This is typically used when you want to specify that a box (like a padding or margin area)
1975    /// should have no edges, effectively making it non-existent or invisible in layout calculations.
1976    ///
1977    /// # Returns
1978    ///
1979    /// Returns an `Edges<DefiniteLength>` with all edges set to zero length.
1980    ///
1981    /// # Examples
1982    ///
1983    /// ```
1984    /// # use gpui::{px, DefiniteLength, Edges};
1985    /// let no_edges = Edges::<DefiniteLength>::zero();
1986    /// assert_eq!(no_edges.top, DefiniteLength::from(px(0.)));
1987    /// assert_eq!(no_edges.right, DefiniteLength::from(px(0.)));
1988    /// assert_eq!(no_edges.bottom, DefiniteLength::from(px(0.)));
1989    /// assert_eq!(no_edges.left, DefiniteLength::from(px(0.)));
1990    /// ```
1991    pub fn zero() -> Self {
1992        Self {
1993            top: px(0.).into(),
1994            right: px(0.).into(),
1995            bottom: px(0.).into(),
1996            left: px(0.).into(),
1997        }
1998    }
1999
2000    /// Converts the `DefiniteLength` to `Pixels` based on the parent size and the REM size.
2001    ///
2002    /// This method allows for a `DefiniteLength` value to be converted into pixels, taking into account
2003    /// the size of the parent element (for percentage-based lengths) and the size of a rem unit (for rem-based lengths).
2004    ///
2005    /// # Arguments
2006    ///
2007    /// * `parent_size` - `Size<AbsoluteLength>` representing the size of the parent element.
2008    /// * `rem_size` - `Pixels` representing the size of one REM unit.
2009    ///
2010    /// # Returns
2011    ///
2012    /// Returns an `Edges<Pixels>` representing the edges with lengths converted to pixels.
2013    ///
2014    /// # Examples
2015    ///
2016    /// ```
2017    /// # use gpui::{Edges, DefiniteLength, px, AbsoluteLength, rems, Size};
2018    /// let edges = Edges {
2019    ///     top: DefiniteLength::Absolute(AbsoluteLength::Pixels(px(10.0))),
2020    ///     right: DefiniteLength::Fraction(0.5),
2021    ///     bottom: DefiniteLength::Absolute(AbsoluteLength::Rems(rems(2.0))),
2022    ///     left: DefiniteLength::Fraction(0.25),
2023    /// };
2024    /// let parent_size = Size {
2025    ///     width: AbsoluteLength::Pixels(px(200.0)),
2026    ///     height: AbsoluteLength::Pixels(px(100.0)),
2027    /// };
2028    /// let rem_size = px(16.0);
2029    /// let edges_in_pixels = edges.to_pixels(parent_size, rem_size);
2030    ///
2031    /// assert_eq!(edges_in_pixels.top, px(10.0)); // Absolute length in pixels
2032    /// assert_eq!(edges_in_pixels.right, px(100.0)); // 50% of parent width
2033    /// assert_eq!(edges_in_pixels.bottom, px(32.0)); // 2 rems
2034    /// assert_eq!(edges_in_pixels.left, px(50.0)); // 25% of parent width
2035    /// ```
2036    pub fn to_pixels(self, parent_size: Size<AbsoluteLength>, rem_size: Pixels) -> Edges<Pixels> {
2037        Edges {
2038            top: self.top.to_pixels(parent_size.height, rem_size),
2039            right: self.right.to_pixels(parent_size.width, rem_size),
2040            bottom: self.bottom.to_pixels(parent_size.height, rem_size),
2041            left: self.left.to_pixels(parent_size.width, rem_size),
2042        }
2043    }
2044}
2045
2046impl Edges<AbsoluteLength> {
2047    /// Sets the edges of the `Edges` struct to zero, which means no size or thickness.
2048    ///
2049    /// This is typically used when you want to specify that a box (like a padding or margin area)
2050    /// should have no edges, effectively making it non-existent or invisible in layout calculations.
2051    ///
2052    /// # Returns
2053    ///
2054    /// Returns an `Edges<AbsoluteLength>` with all edges set to zero length.
2055    ///
2056    /// # Examples
2057    ///
2058    /// ```
2059    /// # use gpui::{AbsoluteLength, Edges, Pixels};
2060    /// let no_edges = Edges::<AbsoluteLength>::zero();
2061    /// assert_eq!(no_edges.top, AbsoluteLength::Pixels(Pixels::ZERO));
2062    /// assert_eq!(no_edges.right, AbsoluteLength::Pixels(Pixels::ZERO));
2063    /// assert_eq!(no_edges.bottom, AbsoluteLength::Pixels(Pixels::ZERO));
2064    /// assert_eq!(no_edges.left, AbsoluteLength::Pixels(Pixels::ZERO));
2065    /// ```
2066    pub fn zero() -> Self {
2067        Self {
2068            top: px(0.).into(),
2069            right: px(0.).into(),
2070            bottom: px(0.).into(),
2071            left: px(0.).into(),
2072        }
2073    }
2074
2075    /// Converts the `AbsoluteLength` to `Pixels` based on the `rem_size`.
2076    ///
2077    /// If the `AbsoluteLength` is already in pixels, it simply returns the corresponding `Pixels` value.
2078    /// If the `AbsoluteLength` is in rems, it multiplies the number of rems by the `rem_size` to convert it to pixels.
2079    ///
2080    /// # Arguments
2081    ///
2082    /// * `rem_size` - The size of one rem unit in pixels.
2083    ///
2084    /// # Returns
2085    ///
2086    /// Returns an `Edges<Pixels>` representing the edges with lengths converted to pixels.
2087    ///
2088    /// # Examples
2089    ///
2090    /// ```
2091    /// # use gpui::{Edges, AbsoluteLength, Pixels, px, rems};
2092    /// let edges = Edges {
2093    ///     top: AbsoluteLength::Pixels(px(10.0)),
2094    ///     right: AbsoluteLength::Rems(rems(1.0)),
2095    ///     bottom: AbsoluteLength::Pixels(px(20.0)),
2096    ///     left: AbsoluteLength::Rems(rems(2.0)),
2097    /// };
2098    /// let rem_size = px(16.0);
2099    /// let edges_in_pixels = edges.to_pixels(rem_size);
2100    ///
2101    /// assert_eq!(edges_in_pixels.top, px(10.0)); // Already in pixels
2102    /// assert_eq!(edges_in_pixels.right, px(16.0)); // 1 rem converted to pixels
2103    /// assert_eq!(edges_in_pixels.bottom, px(20.0)); // Already in pixels
2104    /// assert_eq!(edges_in_pixels.left, px(32.0)); // 2 rems converted to pixels
2105    /// ```
2106    pub fn to_pixels(self, rem_size: Pixels) -> Edges<Pixels> {
2107        Edges {
2108            top: self.top.to_pixels(rem_size),
2109            right: self.right.to_pixels(rem_size),
2110            bottom: self.bottom.to_pixels(rem_size),
2111            left: self.left.to_pixels(rem_size),
2112        }
2113    }
2114}
2115
2116impl Edges<Pixels> {
2117    /// Scales the `Edges<Pixels>` by a given factor, returning `Edges<ScaledPixels>`.
2118    ///
2119    /// This method is typically used for adjusting the edge sizes for different display densities or scaling factors.
2120    ///
2121    /// # Arguments
2122    ///
2123    /// * `factor` - The scaling factor to apply to each edge.
2124    ///
2125    /// # Returns
2126    ///
2127    /// Returns a new `Edges<ScaledPixels>` where each edge is the result of scaling the original edge by the given factor.
2128    ///
2129    /// # Examples
2130    ///
2131    /// ```
2132    /// # use gpui::{Edges, Pixels, ScaledPixels};
2133    /// let edges = Edges {
2134    ///     top: Pixels::from(10.0),
2135    ///     right: Pixels::from(20.0),
2136    ///     bottom: Pixels::from(30.0),
2137    ///     left: Pixels::from(40.0),
2138    /// };
2139    /// let scaled_edges = edges.scale(2.0);
2140    /// assert_eq!(scaled_edges.top, ScaledPixels::from(20.0));
2141    /// assert_eq!(scaled_edges.right, ScaledPixels::from(40.0));
2142    /// assert_eq!(scaled_edges.bottom, ScaledPixels::from(60.0));
2143    /// assert_eq!(scaled_edges.left, ScaledPixels::from(80.0));
2144    /// ```
2145    pub fn scale(&self, factor: f32) -> Edges<ScaledPixels> {
2146        Edges {
2147            top: self.top.scale(factor),
2148            right: self.right.scale(factor),
2149            bottom: self.bottom.scale(factor),
2150            left: self.left.scale(factor),
2151        }
2152    }
2153
2154    /// Returns the maximum value of any edge.
2155    ///
2156    /// # Returns
2157    ///
2158    /// The maximum `Pixels` value among all four edges.
2159    pub fn max(&self) -> Pixels {
2160        self.top.max(self.right).max(self.bottom).max(self.left)
2161    }
2162}
2163
2164impl From<f32> for Edges<Pixels> {
2165    fn from(val: f32) -> Self {
2166        let val: Pixels = val.into();
2167        val.into()
2168    }
2169}
2170
2171impl From<Pixels> for Edges<Pixels> {
2172    fn from(val: Pixels) -> Self {
2173        Edges {
2174            top: val,
2175            right: val,
2176            bottom: val,
2177            left: val,
2178        }
2179    }
2180}
2181
2182/// Identifies a reference point on a 2D box, used to anchor positioned elements.
2183#[derive(Clone, Copy, Debug, PartialEq, Eq)]
2184pub enum Anchor {
2185    /// The top left corner
2186    TopLeft,
2187    /// The top right corner
2188    TopRight,
2189    /// The bottom left corner
2190    BottomLeft,
2191    /// The bottom right corner
2192    BottomRight,
2193    /// The top center position
2194    TopCenter,
2195    /// The bottom center position
2196    BottomCenter,
2197    /// The left center position
2198    LeftCenter,
2199    /// The right center position
2200    RightCenter,
2201}
2202
2203impl Anchor {
2204    /// Returns the directly opposite corner.
2205    ///
2206    /// # Examples
2207    ///
2208    /// ```
2209    /// # use gpui::Anchor;
2210    /// assert_eq!(Anchor::TopLeft.opposite(), Anchor::BottomRight);
2211    /// ```
2212    #[must_use]
2213    pub fn opposite(self) -> Self {
2214        match self {
2215            Anchor::TopLeft => Anchor::BottomRight,
2216            Anchor::TopRight => Anchor::BottomLeft,
2217            Anchor::BottomLeft => Anchor::TopRight,
2218            Anchor::BottomRight => Anchor::TopLeft,
2219            Anchor::TopCenter => Anchor::BottomCenter,
2220            Anchor::BottomCenter => Anchor::TopCenter,
2221            Anchor::LeftCenter => Anchor::RightCenter,
2222            Anchor::RightCenter => Anchor::LeftCenter,
2223        }
2224    }
2225
2226    /// Returns the corner across from this corner, moving along the specified axis.
2227    ///
2228    /// # Examples
2229    ///
2230    /// ```
2231    /// # use gpui::{Axis, Anchor};
2232    /// let result = Anchor::TopLeft.other_side_along(Axis::Horizontal);
2233    /// assert_eq!(result, Anchor::TopRight);
2234    /// ```
2235    #[must_use]
2236    pub fn other_side_along(self, axis: Axis) -> Self {
2237        match axis {
2238            Axis::Vertical => match self {
2239                Anchor::TopLeft => Anchor::BottomLeft,
2240                Anchor::TopRight => Anchor::BottomRight,
2241                Anchor::BottomLeft => Anchor::TopLeft,
2242                Anchor::BottomRight => Anchor::TopRight,
2243                Anchor::TopCenter => Anchor::BottomCenter,
2244                Anchor::BottomCenter => Anchor::TopCenter,
2245                Anchor::LeftCenter => Anchor::LeftCenter,
2246                Anchor::RightCenter => Anchor::RightCenter,
2247            },
2248            Axis::Horizontal => match self {
2249                Anchor::TopLeft => Anchor::TopRight,
2250                Anchor::TopRight => Anchor::TopLeft,
2251                Anchor::BottomLeft => Anchor::BottomRight,
2252                Anchor::BottomRight => Anchor::BottomLeft,
2253                Anchor::TopCenter => Anchor::TopCenter,
2254                Anchor::BottomCenter => Anchor::BottomCenter,
2255                Anchor::LeftCenter => Anchor::RightCenter,
2256                Anchor::RightCenter => Anchor::LeftCenter,
2257            },
2258        }
2259    }
2260
2261    /// Returns true if at the center.
2262    #[inline]
2263    pub fn is_center(&self) -> bool {
2264        matches!(
2265            self,
2266            Self::TopCenter | Self::BottomCenter | Self::LeftCenter | Self::RightCenter
2267        )
2268    }
2269}
2270
2271/// Represents the corners of a box in a 2D space, such as border radius.
2272///
2273/// Each field represents the size of the corner on one side of the box: `top_left`, `top_right`, `bottom_right`, and `bottom_left`.
2274#[derive(Refineable, Clone, Default, Debug, Eq, PartialEq)]
2275#[refineable(Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
2276#[repr(C)]
2277pub struct Corners<T: Clone + Debug + Default + PartialEq> {
2278    /// The value associated with the top left corner.
2279    pub top_left: T,
2280    /// The value associated with the top right corner.
2281    pub top_right: T,
2282    /// The value associated with the bottom right corner.
2283    pub bottom_right: T,
2284    /// The value associated with the bottom left corner.
2285    pub bottom_left: T,
2286}
2287
2288impl<T> Corners<T>
2289where
2290    T: Add<T, Output = T> + Half + Clone + Debug + Default + PartialEq,
2291{
2292    /// Constructs `Corners` where all sides are set to the same specified value.
2293    ///
2294    /// This function creates a `Corners` instance with the `top_left`, `top_right`, `bottom_right`, and `bottom_left` fields all initialized
2295    /// to the same value provided as an argument. This is useful when you want to have uniform corners around a box,
2296    /// such as a uniform border radius on a rectangle.
2297    ///
2298    /// # Arguments
2299    ///
2300    /// * `value` - The value to set for all four corners.
2301    ///
2302    /// # Returns
2303    ///
2304    /// An `Corners` instance with all corners set to the given value.
2305    ///
2306    /// # Examples
2307    ///
2308    /// ```
2309    /// # use gpui::Corners;
2310    /// let uniform_corners = Corners::all(5.0);
2311    /// assert_eq!(uniform_corners.top_left, 5.0);
2312    /// assert_eq!(uniform_corners.top_right, 5.0);
2313    /// assert_eq!(uniform_corners.bottom_right, 5.0);
2314    /// assert_eq!(uniform_corners.bottom_left, 5.0);
2315    /// ```
2316    pub fn all(value: T) -> Self {
2317        Self {
2318            top_left: value.clone(),
2319            top_right: value.clone(),
2320            bottom_right: value.clone(),
2321            bottom_left: value,
2322        }
2323    }
2324
2325    /// Returns the requested corner value, supporting all eight corner positions.
2326    ///
2327    /// For the four basic corners (TopLeft, TopRight, BottomLeft, BottomRight),
2328    /// this returns the corresponding field value directly.
2329    ///
2330    /// For the center positions (TopCenter, BottomCenter, LeftCenter, RightCenter),
2331    /// this calculates the average of the two adjacent corners.
2332    ///
2333    /// # Returns
2334    ///
2335    /// A value of type `T` representing the corner requested by the parameter.
2336    ///
2337    /// # Examples
2338    ///
2339    /// Basic corner positions:
2340    ///
2341    /// ```
2342    /// # use gpui::{Anchor, Corners};
2343    /// let corners = Corners {
2344    ///     top_left: 10,
2345    ///     top_right: 20,
2346    ///     bottom_left: 30,
2347    ///     bottom_right: 40
2348    /// };
2349    /// assert_eq!(corners.corner(Anchor::TopLeft), 10);
2350    /// assert_eq!(corners.corner(Anchor::BottomRight), 40);
2351    /// ```
2352    ///
2353    /// Center positions (calculated as average of adjacent corners):
2354    ///
2355    /// ```
2356    /// # use gpui::{Anchor, Corners};
2357    /// let corners = Corners {
2358    ///     top_left: 10,
2359    ///     top_right: 20,
2360    ///     bottom_left: 30,
2361    ///     bottom_right: 40
2362    /// };
2363    /// assert_eq!(corners.corner(Anchor::TopCenter), 15);
2364    /// assert_eq!(corners.corner(Anchor::BottomCenter), 35);
2365    /// assert_eq!(corners.corner(Anchor::LeftCenter), 20);
2366    /// assert_eq!(corners.corner(Anchor::RightCenter), 30);
2367    /// ```
2368    #[must_use]
2369    pub fn corner(&self, corner: Anchor) -> T {
2370        match corner {
2371            Anchor::TopLeft => self.top_left.clone(),
2372            Anchor::TopRight => self.top_right.clone(),
2373            Anchor::BottomLeft => self.bottom_left.clone(),
2374            Anchor::BottomRight => self.bottom_right.clone(),
2375            Anchor::TopCenter => (self.top_left.clone() + self.top_right.clone()).half(),
2376            Anchor::BottomCenter => (self.bottom_left.clone() + self.bottom_right.clone()).half(),
2377            Anchor::LeftCenter => (self.top_left.clone() + self.bottom_left.clone()).half(),
2378            Anchor::RightCenter => (self.top_right.clone() + self.bottom_right.clone()).half(),
2379        }
2380    }
2381}
2382
2383impl Corners<AbsoluteLength> {
2384    /// Converts the `AbsoluteLength` to `Pixels` based on the provided rem size.
2385    ///
2386    /// # Arguments
2387    ///
2388    /// * `rem_size` - The size of one REM unit in pixels, used for conversion if the `AbsoluteLength` is in REMs.
2389    ///
2390    /// # Returns
2391    ///
2392    /// Returns a `Corners<Pixels>` instance with each corner's length converted to pixels.
2393    ///
2394    /// # Examples
2395    ///
2396    /// ```
2397    /// # use gpui::{Corners, AbsoluteLength, Pixels, Rems, Size};
2398    /// let corners = Corners {
2399    ///     top_left: AbsoluteLength::Pixels(Pixels::from(15.0)),
2400    ///     top_right: AbsoluteLength::Rems(Rems(1.0)),
2401    ///     bottom_right: AbsoluteLength::Pixels(Pixels::from(30.0)),
2402    ///     bottom_left: AbsoluteLength::Rems(Rems(2.0)),
2403    /// };
2404    /// let rem_size = Pixels::from(16.0);
2405    /// let corners_in_pixels = corners.to_pixels(rem_size);
2406    ///
2407    /// assert_eq!(corners_in_pixels.top_left, Pixels::from(15.0));
2408    /// assert_eq!(corners_in_pixels.top_right, Pixels::from(16.0)); // 1 rem converted to pixels
2409    /// assert_eq!(corners_in_pixels.bottom_right, Pixels::from(30.0));
2410    /// assert_eq!(corners_in_pixels.bottom_left, Pixels::from(32.0)); // 2 rems converted to pixels
2411    /// ```
2412    pub fn to_pixels(self, rem_size: Pixels) -> Corners<Pixels> {
2413        Corners {
2414            top_left: self.top_left.to_pixels(rem_size),
2415            top_right: self.top_right.to_pixels(rem_size),
2416            bottom_right: self.bottom_right.to_pixels(rem_size),
2417            bottom_left: self.bottom_left.to_pixels(rem_size),
2418        }
2419    }
2420}
2421
2422impl Corners<Pixels> {
2423    /// Scales the `Corners<Pixels>` by a given factor, returning `Corners<ScaledPixels>`.
2424    ///
2425    /// This method is typically used for adjusting the corner sizes for different display densities or scaling factors.
2426    ///
2427    /// # Arguments
2428    ///
2429    /// * `factor` - The scaling factor to apply to each corner.
2430    ///
2431    /// # Returns
2432    ///
2433    /// Returns a new `Corners<ScaledPixels>` where each corner is the result of scaling the original corner by the given factor.
2434    ///
2435    /// # Examples
2436    ///
2437    /// ```
2438    /// # use gpui::{Corners, Pixels, ScaledPixels};
2439    /// let corners = Corners {
2440    ///     top_left: Pixels::from(10.0),
2441    ///     top_right: Pixels::from(20.0),
2442    ///     bottom_right: Pixels::from(30.0),
2443    ///     bottom_left: Pixels::from(40.0),
2444    /// };
2445    /// let scaled_corners = corners.scale(2.0);
2446    /// assert_eq!(scaled_corners.top_left, ScaledPixels::from(20.0));
2447    /// assert_eq!(scaled_corners.top_right, ScaledPixels::from(40.0));
2448    /// assert_eq!(scaled_corners.bottom_right, ScaledPixels::from(60.0));
2449    /// assert_eq!(scaled_corners.bottom_left, ScaledPixels::from(80.0));
2450    /// ```
2451    #[must_use]
2452    pub fn scale(&self, factor: f32) -> Corners<ScaledPixels> {
2453        Corners {
2454            top_left: self.top_left.scale(factor),
2455            top_right: self.top_right.scale(factor),
2456            bottom_right: self.bottom_right.scale(factor),
2457            bottom_left: self.bottom_left.scale(factor),
2458        }
2459    }
2460
2461    /// Returns the maximum value of any corner.
2462    ///
2463    /// # Returns
2464    ///
2465    /// The maximum `Pixels` value among all four corners.
2466    #[must_use]
2467    pub fn max(&self) -> Pixels {
2468        self.top_left
2469            .max(self.top_right)
2470            .max(self.bottom_right)
2471            .max(self.bottom_left)
2472    }
2473}
2474
2475impl<T: Div<f32, Output = T> + Ord + Clone + Debug + Default + PartialEq> Corners<T> {
2476    /// Clamps corner radii to be less than or equal to half the shortest side of a quad.
2477    ///
2478    /// # Arguments
2479    ///
2480    /// * `size` - The size of the quad which limits the size of the corner radii.
2481    ///
2482    /// # Returns
2483    ///
2484    /// Anchor radii values clamped to fit.
2485    #[must_use]
2486    pub fn clamp_radii_for_quad_size(self, size: Size<T>) -> Corners<T> {
2487        let max = cmp::min(size.width, size.height) / 2.;
2488        Corners {
2489            top_left: cmp::min(self.top_left, max.clone()),
2490            top_right: cmp::min(self.top_right, max.clone()),
2491            bottom_right: cmp::min(self.bottom_right, max.clone()),
2492            bottom_left: cmp::min(self.bottom_left, max),
2493        }
2494    }
2495}
2496
2497impl<T: Clone + Debug + Default + PartialEq> Corners<T> {
2498    /// Applies a function to each field of the `Corners`, producing a new `Corners<U>`.
2499    ///
2500    /// This method allows for converting a `Corners<T>` to a `Corners<U>` by specifying a closure
2501    /// that defines how to convert between the two types. The closure is applied to each field
2502    /// (`top_left`, `top_right`, `bottom_right`, `bottom_left`), resulting in new corners of the desired type.
2503    ///
2504    /// # Arguments
2505    ///
2506    /// * `f` - A closure that takes a reference to a value of type `T` and returns a value of type `U`.
2507    ///
2508    /// # Returns
2509    ///
2510    /// Returns a new `Corners<U>` with each field mapped by the provided function.
2511    ///
2512    /// # Examples
2513    ///
2514    /// ```
2515    /// # use gpui::{Corners, Pixels, Rems};
2516    /// let corners = Corners {
2517    ///     top_left: Pixels::from(10.0),
2518    ///     top_right: Pixels::from(20.0),
2519    ///     bottom_right: Pixels::from(30.0),
2520    ///     bottom_left: Pixels::from(40.0),
2521    /// };
2522    /// let corners_in_rems = corners.map(|&px| Rems(f32::from(px) / 16.0));
2523    /// assert_eq!(corners_in_rems, Corners {
2524    ///     top_left: Rems(0.625),
2525    ///     top_right: Rems(1.25),
2526    ///     bottom_right: Rems(1.875),
2527    ///     bottom_left: Rems(2.5),
2528    /// });
2529    /// ```
2530    #[must_use]
2531    pub fn map<U>(&self, f: impl Fn(&T) -> U) -> Corners<U>
2532    where
2533        U: Clone + Debug + Default + PartialEq,
2534    {
2535        Corners {
2536            top_left: f(&self.top_left),
2537            top_right: f(&self.top_right),
2538            bottom_right: f(&self.bottom_right),
2539            bottom_left: f(&self.bottom_left),
2540        }
2541    }
2542}
2543
2544impl<T> Mul for Corners<T>
2545where
2546    T: Mul<Output = T> + Clone + Debug + Default + PartialEq,
2547{
2548    type Output = Self;
2549
2550    fn mul(self, rhs: Self) -> Self::Output {
2551        Self {
2552            top_left: self.top_left.clone() * rhs.top_left,
2553            top_right: self.top_right.clone() * rhs.top_right,
2554            bottom_right: self.bottom_right.clone() * rhs.bottom_right,
2555            bottom_left: self.bottom_left * rhs.bottom_left,
2556        }
2557    }
2558}
2559
2560impl<T, S> MulAssign<S> for Corners<T>
2561where
2562    T: Mul<S, Output = T> + Clone + Debug + Default + PartialEq,
2563    S: Clone,
2564{
2565    fn mul_assign(&mut self, rhs: S) {
2566        self.top_left = self.top_left.clone() * rhs.clone();
2567        self.top_right = self.top_right.clone() * rhs.clone();
2568        self.bottom_right = self.bottom_right.clone() * rhs.clone();
2569        self.bottom_left = self.bottom_left.clone() * rhs;
2570    }
2571}
2572
2573impl<T> Copy for Corners<T> where T: Copy + Clone + Debug + Default + PartialEq {}
2574
2575impl From<f32> for Corners<Pixels> {
2576    fn from(val: f32) -> Self {
2577        Corners {
2578            top_left: val.into(),
2579            top_right: val.into(),
2580            bottom_right: val.into(),
2581            bottom_left: val.into(),
2582        }
2583    }
2584}
2585
2586impl From<Pixels> for Corners<Pixels> {
2587    fn from(val: Pixels) -> Self {
2588        Corners {
2589            top_left: val,
2590            top_right: val,
2591            bottom_right: val,
2592            bottom_left: val,
2593        }
2594    }
2595}
2596
2597/// Represents an angle in Radians
2598#[derive(
2599    Clone,
2600    Copy,
2601    Default,
2602    Add,
2603    AddAssign,
2604    Sub,
2605    SubAssign,
2606    Neg,
2607    Div,
2608    DivAssign,
2609    PartialEq,
2610    Serialize,
2611    Deserialize,
2612    Debug,
2613)]
2614#[repr(transparent)]
2615pub struct Radians(pub f32);
2616
2617/// Create a `Radian` from a raw value
2618pub fn radians(value: f32) -> Radians {
2619    Radians(value)
2620}
2621
2622/// A type representing a percentage value.
2623#[derive(
2624    Clone,
2625    Copy,
2626    Default,
2627    Add,
2628    AddAssign,
2629    Sub,
2630    SubAssign,
2631    Neg,
2632    Div,
2633    DivAssign,
2634    PartialEq,
2635    Serialize,
2636    Deserialize,
2637    Debug,
2638)]
2639#[repr(transparent)]
2640pub struct Percentage(pub f32);
2641
2642/// Generate a `Radian` from a percentage of a full circle.
2643pub fn percentage(value: f32) -> Percentage {
2644    debug_assert!(
2645        (0.0..=1.0).contains(&value),
2646        "Percentage must be between 0 and 1"
2647    );
2648    Percentage(value)
2649}
2650
2651impl From<Percentage> for Radians {
2652    fn from(value: Percentage) -> Self {
2653        radians(value.0 * std::f32::consts::PI * 2.0)
2654    }
2655}
2656
2657/// Represents a length in pixels, the base unit of measurement in the UI framework.
2658///
2659/// `Pixels` is a value type that represents an absolute length in pixels, which is used
2660/// for specifying sizes, positions, and distances in the UI. It is the fundamental unit
2661/// of measurement for all visual elements and layout calculations.
2662///
2663/// The inner value is an `f32`, allowing for sub-pixel precision which can be useful for
2664/// anti-aliasing and animations. However, when applied to actual pixel grids, the value
2665/// is typically rounded to the nearest integer.
2666///
2667/// # Examples
2668///
2669/// ```
2670/// use gpui::{Pixels, ScaledPixels};
2671///
2672/// // Define a length of 10 pixels
2673/// let length = Pixels::from(10.0);
2674///
2675/// // Define a length and scale it by a factor of 2
2676/// let scaled_length = length.scale(2.0);
2677/// assert_eq!(scaled_length, ScaledPixels::from(20.0));
2678/// ```
2679#[derive(
2680    Clone,
2681    Copy,
2682    Default,
2683    Add,
2684    AddAssign,
2685    Sub,
2686    SubAssign,
2687    Neg,
2688    Div,
2689    DivAssign,
2690    PartialEq,
2691    Serialize,
2692    Deserialize,
2693    JsonSchema,
2694)]
2695#[repr(transparent)]
2696pub struct Pixels(pub(crate) f32);
2697
2698impl Div for Pixels {
2699    type Output = f32;
2700
2701    fn div(self, rhs: Self) -> Self::Output {
2702        self.0 / rhs.0
2703    }
2704}
2705
2706impl std::ops::DivAssign for Pixels {
2707    fn div_assign(&mut self, rhs: Self) {
2708        *self = Self(self.0 / rhs.0);
2709    }
2710}
2711
2712impl std::ops::RemAssign for Pixels {
2713    fn rem_assign(&mut self, rhs: Self) {
2714        self.0 %= rhs.0;
2715    }
2716}
2717
2718impl std::ops::Rem for Pixels {
2719    type Output = Self;
2720
2721    fn rem(self, rhs: Self) -> Self {
2722        Self(self.0 % rhs.0)
2723    }
2724}
2725
2726impl Mul<f32> for Pixels {
2727    type Output = Self;
2728
2729    fn mul(self, rhs: f32) -> Self {
2730        Self(self.0 * rhs)
2731    }
2732}
2733
2734impl Mul<Pixels> for f32 {
2735    type Output = Pixels;
2736
2737    fn mul(self, rhs: Pixels) -> Self::Output {
2738        rhs * self
2739    }
2740}
2741
2742impl Mul<usize> for Pixels {
2743    type Output = Self;
2744
2745    fn mul(self, rhs: usize) -> Self {
2746        self * (rhs as f32)
2747    }
2748}
2749
2750impl Mul<Pixels> for usize {
2751    type Output = Pixels;
2752
2753    fn mul(self, rhs: Pixels) -> Pixels {
2754        rhs * self
2755    }
2756}
2757
2758impl MulAssign<f32> for Pixels {
2759    fn mul_assign(&mut self, rhs: f32) {
2760        self.0 *= rhs;
2761    }
2762}
2763
2764impl Display for Pixels {
2765    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2766        write!(f, "{}px", self.0)
2767    }
2768}
2769
2770impl Debug for Pixels {
2771    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2772        Display::fmt(self, f)
2773    }
2774}
2775
2776impl std::iter::Sum for Pixels {
2777    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
2778        iter.fold(Self::ZERO, |a, b| a + b)
2779    }
2780}
2781
2782impl<'a> std::iter::Sum<&'a Pixels> for Pixels {
2783    fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self {
2784        iter.fold(Self::ZERO, |a, b| a + *b)
2785    }
2786}
2787
2788impl TryFrom<&'_ str> for Pixels {
2789    type Error = anyhow::Error;
2790
2791    fn try_from(value: &'_ str) -> Result<Self, Self::Error> {
2792        value
2793            .strip_suffix("px")
2794            .context("expected 'px' suffix")
2795            .and_then(|number| Ok(number.parse()?))
2796            .map(Self)
2797    }
2798}
2799
2800impl Pixels {
2801    /// Represents zero pixels.
2802    pub const ZERO: Pixels = Pixels(0.0);
2803    /// The maximum value that can be represented by `Pixels`.
2804    pub const MAX: Pixels = Pixels(f32::MAX);
2805    /// The minimum value that can be represented by `Pixels`.
2806    pub const MIN: Pixels = Pixels(f32::MIN);
2807
2808    /// Returns the raw `f32` value of this `Pixels`.
2809    pub fn as_f32(self) -> f32 {
2810        self.0
2811    }
2812
2813    /// Floors the `Pixels` value to the nearest whole number.
2814    ///
2815    /// # Returns
2816    ///
2817    /// Returns a new `Pixels` instance with the floored value.
2818    pub fn floor(&self) -> Self {
2819        Self(self.0.floor())
2820    }
2821
2822    /// Rounds the `Pixels` value to the nearest whole number.
2823    ///
2824    /// # Returns
2825    ///
2826    /// Returns a new `Pixels` instance with the rounded value.
2827    pub fn round(&self) -> Self {
2828        Self(self.0.round())
2829    }
2830
2831    /// Returns the ceiling of the `Pixels` value to the nearest whole number.
2832    ///
2833    /// # Returns
2834    ///
2835    /// Returns a new `Pixels` instance with the ceiling value.
2836    pub fn ceil(&self) -> Self {
2837        Self(self.0.ceil())
2838    }
2839
2840    /// Scales the `Pixels` value by a given factor, producing `ScaledPixels`.
2841    ///
2842    /// This method is used when adjusting pixel values for display scaling factors,
2843    /// such as high DPI (dots per inch) or Retina displays, where the pixel density is higher and
2844    /// thus requires scaling to maintain visual consistency and readability.
2845    ///
2846    /// The resulting `ScaledPixels` represent the scaled value which can be used for rendering
2847    /// calculations where display scaling is considered.
2848    #[must_use]
2849    pub fn scale(&self, factor: f32) -> ScaledPixels {
2850        ScaledPixels(self.0 * factor)
2851    }
2852
2853    /// Raises the `Pixels` value to a given power.
2854    ///
2855    /// # Arguments
2856    ///
2857    /// * `exponent` - The exponent to raise the `Pixels` value by.
2858    ///
2859    /// # Returns
2860    ///
2861    /// Returns a new `Pixels` instance with the value raised to the given exponent.
2862    pub fn pow(&self, exponent: f32) -> Self {
2863        Self(self.0.powf(exponent))
2864    }
2865
2866    /// Returns the absolute value of the `Pixels`.
2867    ///
2868    /// # Returns
2869    ///
2870    /// A new `Pixels` instance with the absolute value of the original `Pixels`.
2871    pub fn abs(&self) -> Self {
2872        Self(self.0.abs())
2873    }
2874
2875    /// Returns the sign of the `Pixels` value.
2876    ///
2877    /// # Returns
2878    ///
2879    /// Returns:
2880    /// * `1.0` if the value is positive
2881    /// * `-1.0` if the value is negative
2882    pub fn signum(&self) -> f32 {
2883        self.0.signum()
2884    }
2885
2886    /// Returns the f64 value of `Pixels`.
2887    ///
2888    /// # Returns
2889    ///
2890    /// A f64 value of the `Pixels`.
2891    pub fn to_f64(self) -> f64 {
2892        self.0 as f64
2893    }
2894}
2895
2896impl Eq for Pixels {}
2897
2898impl PartialOrd for Pixels {
2899    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
2900        Some(self.cmp(other))
2901    }
2902}
2903
2904impl Ord for Pixels {
2905    fn cmp(&self, other: &Self) -> cmp::Ordering {
2906        self.0.total_cmp(&other.0)
2907    }
2908}
2909
2910impl std::hash::Hash for Pixels {
2911    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
2912        self.0.to_bits().hash(state);
2913    }
2914}
2915
2916impl From<f64> for Pixels {
2917    fn from(pixels: f64) -> Self {
2918        Pixels(pixels as f32)
2919    }
2920}
2921
2922impl From<f32> for Pixels {
2923    fn from(pixels: f32) -> Self {
2924        Pixels(pixels)
2925    }
2926}
2927
2928impl From<Pixels> for f32 {
2929    fn from(pixels: Pixels) -> Self {
2930        pixels.0
2931    }
2932}
2933
2934impl From<&Pixels> for f32 {
2935    fn from(pixels: &Pixels) -> Self {
2936        pixels.0
2937    }
2938}
2939
2940impl From<Pixels> for f64 {
2941    fn from(pixels: Pixels) -> Self {
2942        pixels.0 as f64
2943    }
2944}
2945
2946impl From<Pixels> for u32 {
2947    fn from(pixels: Pixels) -> Self {
2948        pixels.0 as u32
2949    }
2950}
2951
2952impl From<&Pixels> for u32 {
2953    fn from(pixels: &Pixels) -> Self {
2954        pixels.0 as u32
2955    }
2956}
2957
2958impl From<u32> for Pixels {
2959    fn from(pixels: u32) -> Self {
2960        Pixels(pixels as f32)
2961    }
2962}
2963
2964impl From<Pixels> for usize {
2965    fn from(pixels: Pixels) -> Self {
2966        pixels.0 as usize
2967    }
2968}
2969
2970impl From<usize> for Pixels {
2971    fn from(pixels: usize) -> Self {
2972        Pixels(pixels as f32)
2973    }
2974}
2975
2976/// Represents physical pixels on the display.
2977///
2978/// `DevicePixels` is a unit of measurement that refers to the actual pixels on a device's screen.
2979/// This type is used when precise pixel manipulation is required, such as rendering graphics or
2980/// interfacing with hardware that operates on the pixel level. Unlike logical pixels that may be
2981/// affected by the device's scale factor, `DevicePixels` always correspond to real pixels on the
2982/// display.
2983#[derive(
2984    Add,
2985    AddAssign,
2986    Clone,
2987    Copy,
2988    Default,
2989    Div,
2990    Eq,
2991    Hash,
2992    Ord,
2993    PartialEq,
2994    PartialOrd,
2995    Sub,
2996    SubAssign,
2997    Serialize,
2998    Deserialize,
2999)]
3000#[repr(transparent)]
3001pub struct DevicePixels(pub i32);
3002
3003impl DevicePixels {
3004    /// Converts the `DevicePixels` value to the number of bytes needed to represent it in memory.
3005    ///
3006    /// This function is useful when working with graphical data that needs to be stored in a buffer,
3007    /// such as images or framebuffers, where each pixel may be represented by a specific number of bytes.
3008    ///
3009    /// # Arguments
3010    ///
3011    /// * `bytes_per_pixel` - The number of bytes used to represent a single pixel.
3012    ///
3013    /// # Returns
3014    ///
3015    /// The number of bytes required to represent the `DevicePixels` value in memory.
3016    ///
3017    /// # Examples
3018    ///
3019    /// ```
3020    /// # use gpui::DevicePixels;
3021    /// let pixels = DevicePixels(10); // 10 device pixels
3022    /// let bytes_per_pixel = 4; // Assume each pixel is represented by 4 bytes (e.g., RGBA)
3023    /// let total_bytes = pixels.to_bytes(bytes_per_pixel);
3024    /// assert_eq!(total_bytes, 40); // 10 pixels * 4 bytes/pixel = 40 bytes
3025    /// ```
3026    pub fn to_bytes(self, bytes_per_pixel: u8) -> u32 {
3027        self.0 as u32 * bytes_per_pixel as u32
3028    }
3029}
3030
3031impl fmt::Debug for DevicePixels {
3032    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3033        write!(f, "{} px (device)", self.0)
3034    }
3035}
3036
3037impl From<DevicePixels> for i32 {
3038    fn from(device_pixels: DevicePixels) -> Self {
3039        device_pixels.0
3040    }
3041}
3042
3043impl From<i32> for DevicePixels {
3044    fn from(device_pixels: i32) -> Self {
3045        DevicePixels(device_pixels)
3046    }
3047}
3048
3049impl From<u32> for DevicePixels {
3050    fn from(device_pixels: u32) -> Self {
3051        DevicePixels(device_pixels as i32)
3052    }
3053}
3054
3055impl From<DevicePixels> for u32 {
3056    fn from(device_pixels: DevicePixels) -> Self {
3057        device_pixels.0 as u32
3058    }
3059}
3060
3061impl From<DevicePixels> for u64 {
3062    fn from(device_pixels: DevicePixels) -> Self {
3063        device_pixels.0 as u64
3064    }
3065}
3066
3067impl From<u64> for DevicePixels {
3068    fn from(device_pixels: u64) -> Self {
3069        DevicePixels(device_pixels as i32)
3070    }
3071}
3072
3073impl From<DevicePixels> for usize {
3074    fn from(device_pixels: DevicePixels) -> Self {
3075        device_pixels.0 as usize
3076    }
3077}
3078
3079impl From<usize> for DevicePixels {
3080    fn from(device_pixels: usize) -> Self {
3081        DevicePixels(device_pixels as i32)
3082    }
3083}
3084
3085/// Represents scaled pixels that take into account the device's scale factor.
3086///
3087/// `ScaledPixels` are used to ensure that UI elements appear at the correct size on devices
3088/// with different pixel densities. When a device has a higher scale factor (such as Retina displays),
3089/// a single logical pixel may correspond to multiple physical pixels. By using `ScaledPixels`,
3090/// dimensions and positions can be specified in a way that scales appropriately across different
3091/// display resolutions.
3092#[derive(Clone, Copy, Default, Add, AddAssign, Sub, SubAssign, Div, DivAssign, PartialEq)]
3093#[repr(transparent)]
3094pub struct ScaledPixels(pub f32);
3095
3096impl ScaledPixels {
3097    /// Returns the raw `f32` value of this `ScaledPixels`.
3098    pub fn as_f32(self) -> f32 {
3099        self.0
3100    }
3101
3102    /// Floors the `ScaledPixels` value to the nearest whole number.
3103    ///
3104    /// # Returns
3105    ///
3106    /// Returns a new `ScaledPixels` instance with the floored value.
3107    pub fn floor(&self) -> Self {
3108        Self(self.0.floor())
3109    }
3110
3111    /// Rounds the `ScaledPixels` value to the nearest whole number.
3112    ///
3113    /// # Returns
3114    ///
3115    /// Returns a new `ScaledPixels` instance with the rounded value.
3116    pub fn round(&self) -> Self {
3117        Self(self.0.round())
3118    }
3119
3120    /// Ceils the `ScaledPixels` value to the nearest whole number.
3121    ///
3122    /// # Returns
3123    ///
3124    /// Returns a new `ScaledPixels` instance with the ceiled value.
3125    pub fn ceil(&self) -> Self {
3126        Self(self.0.ceil())
3127    }
3128}
3129
3130impl Eq for ScaledPixels {}
3131
3132impl PartialOrd for ScaledPixels {
3133    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
3134        Some(self.cmp(other))
3135    }
3136}
3137
3138impl Ord for ScaledPixels {
3139    fn cmp(&self, other: &Self) -> cmp::Ordering {
3140        self.0.total_cmp(&other.0)
3141    }
3142}
3143
3144impl Debug for ScaledPixels {
3145    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3146        write!(f, "{}px (scaled)", self.0)
3147    }
3148}
3149
3150impl From<ScaledPixels> for DevicePixels {
3151    fn from(scaled: ScaledPixels) -> Self {
3152        DevicePixels(scaled.0.ceil() as i32)
3153    }
3154}
3155
3156impl From<DevicePixels> for ScaledPixels {
3157    fn from(device: DevicePixels) -> Self {
3158        ScaledPixels(device.0 as f32)
3159    }
3160}
3161
3162impl From<ScaledPixels> for f64 {
3163    fn from(scaled_pixels: ScaledPixels) -> Self {
3164        scaled_pixels.0 as f64
3165    }
3166}
3167
3168impl From<ScaledPixels> for u32 {
3169    fn from(pixels: ScaledPixels) -> Self {
3170        pixels.0 as u32
3171    }
3172}
3173
3174impl From<f32> for ScaledPixels {
3175    fn from(pixels: f32) -> Self {
3176        Self(pixels)
3177    }
3178}
3179
3180impl Div for ScaledPixels {
3181    type Output = f32;
3182
3183    fn div(self, rhs: Self) -> Self::Output {
3184        self.0 / rhs.0
3185    }
3186}
3187
3188impl std::ops::DivAssign for ScaledPixels {
3189    fn div_assign(&mut self, rhs: Self) {
3190        *self = Self(self.0 / rhs.0);
3191    }
3192}
3193
3194impl std::ops::RemAssign for ScaledPixels {
3195    fn rem_assign(&mut self, rhs: Self) {
3196        self.0 %= rhs.0;
3197    }
3198}
3199
3200impl std::ops::Rem for ScaledPixels {
3201    type Output = Self;
3202
3203    fn rem(self, rhs: Self) -> Self {
3204        Self(self.0 % rhs.0)
3205    }
3206}
3207
3208impl Mul<f32> for ScaledPixels {
3209    type Output = Self;
3210
3211    fn mul(self, rhs: f32) -> Self {
3212        Self(self.0 * rhs)
3213    }
3214}
3215
3216impl Mul<ScaledPixels> for f32 {
3217    type Output = ScaledPixels;
3218
3219    fn mul(self, rhs: ScaledPixels) -> Self::Output {
3220        rhs * self
3221    }
3222}
3223
3224impl Mul<usize> for ScaledPixels {
3225    type Output = Self;
3226
3227    fn mul(self, rhs: usize) -> Self {
3228        self * (rhs as f32)
3229    }
3230}
3231
3232impl Mul<ScaledPixels> for usize {
3233    type Output = ScaledPixels;
3234
3235    fn mul(self, rhs: ScaledPixels) -> ScaledPixels {
3236        rhs * self
3237    }
3238}
3239
3240impl MulAssign<f32> for ScaledPixels {
3241    fn mul_assign(&mut self, rhs: f32) {
3242        self.0 *= rhs;
3243    }
3244}
3245
3246/// Represents a length in rems, a unit based on the font-size of the window, which can be assigned with [`Window::set_rem_size`][set_rem_size].
3247///
3248/// Rems are used for defining lengths that are scalable and consistent across different UI elements.
3249/// The value of `1rem` is typically equal to the font-size of the root element (often the `<html>` element in browsers),
3250/// making it a flexible unit that adapts to the user's text size preferences. In this framework, `rems` serve a similar
3251/// purpose, allowing for scalable and accessible design that can adjust to different display settings or user preferences.
3252///
3253/// For example, if the root element's font-size is `16px`, then `1rem` equals `16px`. A length of `2rems` would then be `32px`.
3254///
3255/// [set_rem_size]: crate::Window::set_rem_size
3256#[derive(Clone, Copy, Default, Add, Sub, Mul, Div, Neg, PartialEq)]
3257pub struct Rems(pub f32);
3258
3259impl Rems {
3260    /// A length of zero.
3261    pub const ZERO: Self = Self(0.0);
3262    /// Convert this Rem value to pixels.
3263    pub fn to_pixels(self, rem_size: Pixels) -> Pixels {
3264        self * rem_size
3265    }
3266    /// Convert from pixels to Rem
3267    pub fn from_pixels(length: Pixels, window: &gpui::Window) -> Self {
3268        Self(length / window.rem_size())
3269    }
3270}
3271
3272impl Mul<Pixels> for Rems {
3273    type Output = Pixels;
3274
3275    fn mul(self, other: Pixels) -> Pixels {
3276        Pixels(self.0 * other.0)
3277    }
3278}
3279
3280impl AddAssign<Rems> for Rems {
3281    fn add_assign(&mut self, rhs: Rems) {
3282        self.0 += rhs.0
3283    }
3284}
3285
3286impl Display for Rems {
3287    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3288        write!(f, "{}rem", self.0)
3289    }
3290}
3291
3292impl Debug for Rems {
3293    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3294        Display::fmt(self, f)
3295    }
3296}
3297
3298impl TryFrom<&'_ str> for Rems {
3299    type Error = anyhow::Error;
3300
3301    fn try_from(value: &'_ str) -> Result<Self, Self::Error> {
3302        value
3303            .strip_suffix("rem")
3304            .context("expected 'rem' suffix")
3305            .and_then(|number| Ok(number.parse()?))
3306            .map(Self)
3307    }
3308}
3309
3310/// Represents an absolute length in pixels or rems.
3311///
3312/// `AbsoluteLength` can be either a fixed number of pixels, which is an absolute measurement not
3313/// affected by the current font size, or a number of rems, which is relative to the font size of
3314/// the root element. It is used for specifying dimensions that are either independent of or
3315/// related to the typographic scale.
3316#[derive(Clone, Copy, Neg, PartialEq)]
3317pub enum AbsoluteLength {
3318    /// A length in pixels.
3319    Pixels(Pixels),
3320    /// A length in rems.
3321    Rems(Rems),
3322}
3323
3324impl AbsoluteLength {
3325    /// Checks if the absolute length is zero.
3326    pub fn is_zero(&self) -> bool {
3327        match self {
3328            AbsoluteLength::Pixels(px) => px.0 == 0.0,
3329            AbsoluteLength::Rems(rems) => rems.0 == 0.0,
3330        }
3331    }
3332}
3333
3334impl From<Pixels> for AbsoluteLength {
3335    fn from(pixels: Pixels) -> Self {
3336        AbsoluteLength::Pixels(pixels)
3337    }
3338}
3339
3340impl From<Rems> for AbsoluteLength {
3341    fn from(rems: Rems) -> Self {
3342        AbsoluteLength::Rems(rems)
3343    }
3344}
3345
3346impl AbsoluteLength {
3347    /// Converts an `AbsoluteLength` to `Pixels` based on a given `rem_size`.
3348    ///
3349    /// # Arguments
3350    ///
3351    /// * `rem_size` - The size of one rem in pixels.
3352    ///
3353    /// # Returns
3354    ///
3355    /// Returns the `AbsoluteLength` as `Pixels`.
3356    ///
3357    /// # Examples
3358    ///
3359    /// ```
3360    /// # use gpui::{AbsoluteLength, Pixels, Rems};
3361    /// let length_in_pixels = AbsoluteLength::Pixels(Pixels::from(42.0));
3362    /// let length_in_rems = AbsoluteLength::Rems(Rems(2.0));
3363    /// let rem_size = Pixels::from(16.0);
3364    ///
3365    /// assert_eq!(length_in_pixels.to_pixels(rem_size), Pixels::from(42.0));
3366    /// assert_eq!(length_in_rems.to_pixels(rem_size), Pixels::from(32.0));
3367    /// ```
3368    pub fn to_pixels(self, rem_size: Pixels) -> Pixels {
3369        match self {
3370            AbsoluteLength::Pixels(pixels) => pixels,
3371            AbsoluteLength::Rems(rems) => rems.to_pixels(rem_size),
3372        }
3373    }
3374
3375    /// Converts an `AbsoluteLength` to `Rems` based on a given `rem_size`.
3376    ///
3377    /// # Arguments
3378    ///
3379    /// * `rem_size` - The size of one rem in pixels.
3380    ///
3381    /// # Returns
3382    ///
3383    /// Returns the `AbsoluteLength` as `Pixels`.
3384    pub fn to_rems(self, rem_size: Pixels) -> Rems {
3385        match self {
3386            AbsoluteLength::Pixels(pixels) => Rems(pixels.0 / rem_size.0),
3387            AbsoluteLength::Rems(rems) => rems,
3388        }
3389    }
3390}
3391
3392impl Default for AbsoluteLength {
3393    fn default() -> Self {
3394        px(0.).into()
3395    }
3396}
3397
3398impl Display for AbsoluteLength {
3399    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3400        match self {
3401            Self::Pixels(pixels) => write!(f, "{pixels}"),
3402            Self::Rems(rems) => write!(f, "{rems}"),
3403        }
3404    }
3405}
3406
3407impl Debug for AbsoluteLength {
3408    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3409        Display::fmt(self, f)
3410    }
3411}
3412
3413const EXPECTED_ABSOLUTE_LENGTH: &str = "number with 'px' or 'rem' suffix";
3414
3415impl TryFrom<&'_ str> for AbsoluteLength {
3416    type Error = anyhow::Error;
3417
3418    fn try_from(value: &'_ str) -> Result<Self, Self::Error> {
3419        if let Ok(pixels) = value.try_into() {
3420            Ok(Self::Pixels(pixels))
3421        } else if let Ok(rems) = value.try_into() {
3422            Ok(Self::Rems(rems))
3423        } else {
3424            Err(anyhow!(
3425                "invalid AbsoluteLength '{value}', expected {EXPECTED_ABSOLUTE_LENGTH}"
3426            ))
3427        }
3428    }
3429}
3430
3431impl JsonSchema for AbsoluteLength {
3432    fn schema_name() -> Cow<'static, str> {
3433        "AbsoluteLength".into()
3434    }
3435
3436    fn json_schema(_generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
3437        json_schema!({
3438            "type": "string",
3439            "pattern": r"^-?\d+(\.\d+)?(px|rem)$"
3440        })
3441    }
3442}
3443
3444impl<'de> Deserialize<'de> for AbsoluteLength {
3445    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3446        struct StringVisitor;
3447
3448        impl de::Visitor<'_> for StringVisitor {
3449            type Value = AbsoluteLength;
3450
3451            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
3452                write!(f, "{EXPECTED_ABSOLUTE_LENGTH}")
3453            }
3454
3455            fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> {
3456                AbsoluteLength::try_from(value).map_err(E::custom)
3457            }
3458        }
3459
3460        deserializer.deserialize_str(StringVisitor)
3461    }
3462}
3463
3464impl Serialize for AbsoluteLength {
3465    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3466    where
3467        S: Serializer,
3468    {
3469        serializer.serialize_str(&format!("{self}"))
3470    }
3471}
3472
3473/// A non-auto length that can be defined in pixels, rems, or percent of parent.
3474///
3475/// This enum represents lengths that have a specific value, as opposed to lengths that are automatically
3476/// determined by the context. It includes absolute lengths in pixels or rems, and relative lengths as a
3477/// fraction of the parent's size.
3478#[derive(Clone, Copy, Neg, PartialEq)]
3479pub enum DefiniteLength {
3480    /// An absolute length specified in pixels or rems.
3481    Absolute(AbsoluteLength),
3482    /// A relative length specified as a fraction of the parent's size, between 0 and 1.
3483    Fraction(f32),
3484}
3485
3486impl DefiniteLength {
3487    /// Converts the `DefiniteLength` to `Pixels` based on a given `base_size` and `rem_size`.
3488    ///
3489    /// If the `DefiniteLength` is an absolute length, it will be directly converted to `Pixels`.
3490    /// If it is a fraction, the fraction will be multiplied by the `base_size` to get the length in pixels.
3491    ///
3492    /// # Arguments
3493    ///
3494    /// * `base_size` - The base size in `AbsoluteLength` to which the fraction will be applied.
3495    /// * `rem_size` - The size of one rem in pixels, used to convert rems to pixels.
3496    ///
3497    /// # Returns
3498    ///
3499    /// Returns the `DefiniteLength` as `Pixels`.
3500    ///
3501    /// # Examples
3502    ///
3503    /// ```
3504    /// # use gpui::{DefiniteLength, AbsoluteLength, Pixels, px, rems};
3505    /// let length_in_pixels = DefiniteLength::Absolute(AbsoluteLength::Pixels(px(42.0)));
3506    /// let length_in_rems = DefiniteLength::Absolute(AbsoluteLength::Rems(rems(2.0)));
3507    /// let length_as_fraction = DefiniteLength::Fraction(0.5);
3508    /// let base_size = AbsoluteLength::Pixels(px(100.0));
3509    /// let rem_size = px(16.0);
3510    ///
3511    /// assert_eq!(length_in_pixels.to_pixels(base_size, rem_size), Pixels::from(42.0));
3512    /// assert_eq!(length_in_rems.to_pixels(base_size, rem_size), Pixels::from(32.0));
3513    /// assert_eq!(length_as_fraction.to_pixels(base_size, rem_size), Pixels::from(50.0));
3514    /// ```
3515    pub fn to_pixels(self, base_size: AbsoluteLength, rem_size: Pixels) -> Pixels {
3516        match self {
3517            DefiniteLength::Absolute(size) => size.to_pixels(rem_size),
3518            DefiniteLength::Fraction(fraction) => match base_size {
3519                AbsoluteLength::Pixels(px) => px * fraction,
3520                AbsoluteLength::Rems(rems) => rems * rem_size * fraction,
3521            },
3522        }
3523    }
3524}
3525
3526impl Debug for DefiniteLength {
3527    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3528        Display::fmt(self, f)
3529    }
3530}
3531
3532impl Display for DefiniteLength {
3533    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3534        match self {
3535            DefiniteLength::Absolute(length) => write!(f, "{length}"),
3536            DefiniteLength::Fraction(fraction) => write!(f, "{}%", (fraction * 100.0) as i32),
3537        }
3538    }
3539}
3540
3541const EXPECTED_DEFINITE_LENGTH: &str = "expected number with 'px', 'rem', or '%' suffix";
3542
3543impl TryFrom<&'_ str> for DefiniteLength {
3544    type Error = anyhow::Error;
3545
3546    fn try_from(value: &'_ str) -> Result<Self, Self::Error> {
3547        if let Some(percentage) = value.strip_suffix('%') {
3548            let fraction: f32 = percentage.parse::<f32>().with_context(|| {
3549                format!("invalid DefiniteLength '{value}', expected {EXPECTED_DEFINITE_LENGTH}")
3550            })?;
3551            Ok(DefiniteLength::Fraction(fraction / 100.0))
3552        } else if let Ok(absolute_length) = value.try_into() {
3553            Ok(DefiniteLength::Absolute(absolute_length))
3554        } else {
3555            Err(anyhow!(
3556                "invalid DefiniteLength '{value}', expected {EXPECTED_DEFINITE_LENGTH}"
3557            ))
3558        }
3559    }
3560}
3561
3562impl JsonSchema for DefiniteLength {
3563    fn schema_name() -> Cow<'static, str> {
3564        "DefiniteLength".into()
3565    }
3566
3567    fn json_schema(_generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
3568        json_schema!({
3569            "type": "string",
3570            "pattern": r"^-?\d+(\.\d+)?(px|rem|%)$"
3571        })
3572    }
3573}
3574
3575impl<'de> Deserialize<'de> for DefiniteLength {
3576    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3577        struct StringVisitor;
3578
3579        impl de::Visitor<'_> for StringVisitor {
3580            type Value = DefiniteLength;
3581
3582            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
3583                write!(f, "{EXPECTED_DEFINITE_LENGTH}")
3584            }
3585
3586            fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> {
3587                DefiniteLength::try_from(value).map_err(E::custom)
3588            }
3589        }
3590
3591        deserializer.deserialize_str(StringVisitor)
3592    }
3593}
3594
3595impl Serialize for DefiniteLength {
3596    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3597    where
3598        S: Serializer,
3599    {
3600        serializer.serialize_str(&format!("{self}"))
3601    }
3602}
3603
3604impl From<Pixels> for DefiniteLength {
3605    fn from(pixels: Pixels) -> Self {
3606        Self::Absolute(pixels.into())
3607    }
3608}
3609
3610impl From<Rems> for DefiniteLength {
3611    fn from(rems: Rems) -> Self {
3612        Self::Absolute(rems.into())
3613    }
3614}
3615
3616impl From<AbsoluteLength> for DefiniteLength {
3617    fn from(length: AbsoluteLength) -> Self {
3618        Self::Absolute(length)
3619    }
3620}
3621
3622impl Default for DefiniteLength {
3623    fn default() -> Self {
3624        Self::Absolute(AbsoluteLength::default())
3625    }
3626}
3627
3628/// A length that can be defined in pixels, rems, percent of parent, or auto.
3629#[derive(Clone, Copy, PartialEq)]
3630pub enum Length {
3631    /// A definite length specified either in pixels, rems, or as a fraction of the parent's size.
3632    Definite(DefiniteLength),
3633    /// An automatic length that is determined by the context in which it is used.
3634    Auto,
3635}
3636
3637impl Debug for Length {
3638    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3639        Display::fmt(self, f)
3640    }
3641}
3642
3643impl Display for Length {
3644    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3645        match self {
3646            Length::Definite(definite_length) => write!(f, "{}", definite_length),
3647            Length::Auto => write!(f, "auto"),
3648        }
3649    }
3650}
3651
3652const EXPECTED_LENGTH: &str = "expected 'auto' or number with 'px', 'rem', or '%' suffix";
3653
3654impl TryFrom<&'_ str> for Length {
3655    type Error = anyhow::Error;
3656
3657    fn try_from(value: &'_ str) -> Result<Self, Self::Error> {
3658        if value == "auto" {
3659            Ok(Length::Auto)
3660        } else if let Ok(definite_length) = value.try_into() {
3661            Ok(Length::Definite(definite_length))
3662        } else {
3663            Err(anyhow!(
3664                "invalid Length '{value}', expected {EXPECTED_LENGTH}"
3665            ))
3666        }
3667    }
3668}
3669
3670impl JsonSchema for Length {
3671    fn schema_name() -> Cow<'static, str> {
3672        "Length".into()
3673    }
3674
3675    fn json_schema(_generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
3676        json_schema!({
3677            "type": "string",
3678            "pattern": r"^(auto|-?\d+(\.\d+)?(px|rem|%))$"
3679        })
3680    }
3681}
3682
3683impl<'de> Deserialize<'de> for Length {
3684    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3685        struct StringVisitor;
3686
3687        impl de::Visitor<'_> for StringVisitor {
3688            type Value = Length;
3689
3690            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
3691                write!(f, "{EXPECTED_LENGTH}")
3692            }
3693
3694            fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> {
3695                Length::try_from(value).map_err(E::custom)
3696            }
3697        }
3698
3699        deserializer.deserialize_str(StringVisitor)
3700    }
3701}
3702
3703impl Serialize for Length {
3704    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3705    where
3706        S: Serializer,
3707    {
3708        serializer.serialize_str(&format!("{self}"))
3709    }
3710}
3711
3712/// Constructs a `DefiniteLength` representing a relative fraction of a parent size.
3713///
3714/// This function creates a `DefiniteLength` that is a specified fraction of a parent's dimension.
3715/// The fraction should be a floating-point number between 0.0 and 1.0, where 1.0 represents 100% of the parent's size.
3716///
3717/// # Arguments
3718///
3719/// * `fraction` - The fraction of the parent's size, between 0.0 and 1.0.
3720///
3721/// # Returns
3722///
3723/// A `DefiniteLength` representing the relative length as a fraction of the parent's size.
3724pub const fn relative(fraction: f32) -> DefiniteLength {
3725    DefiniteLength::Fraction(fraction)
3726}
3727
3728/// Returns the Golden Ratio, i.e. `~(1.0 + sqrt(5.0)) / 2.0`.
3729pub const fn phi() -> DefiniteLength {
3730    relative(1.618_034)
3731}
3732
3733/// Constructs a `Rems` value representing a length in rems.
3734///
3735/// # Arguments
3736///
3737/// * `rems` - The number of rems for the length.
3738///
3739/// # Returns
3740///
3741/// A `Rems` representing the specified number of rems.
3742pub const fn rems(rems: f32) -> Rems {
3743    Rems(rems)
3744}
3745
3746/// Constructs a `Pixels` value representing a length in pixels.
3747///
3748/// # Arguments
3749///
3750/// * `pixels` - The number of pixels for the length.
3751///
3752/// # Returns
3753///
3754/// A `Pixels` representing the specified number of pixels.
3755pub const fn px(pixels: f32) -> Pixels {
3756    Pixels(pixels)
3757}
3758
3759/// Returns a `Length` representing an automatic length.
3760///
3761/// The `auto` length is often used in layout calculations where the length should be determined
3762/// by the layout context itself rather than being explicitly set. This is commonly used in CSS
3763/// for properties like `width`, `height`, `margin`, `padding`, etc., where `auto` can be used
3764/// to instruct the layout engine to calculate the size based on other factors like the size of the
3765/// container or the intrinsic size of the content.
3766///
3767/// # Returns
3768///
3769/// A `Length` variant set to `Auto`.
3770pub const fn auto() -> Length {
3771    Length::Auto
3772}
3773
3774impl From<Pixels> for Length {
3775    fn from(pixels: Pixels) -> Self {
3776        Self::Definite(pixels.into())
3777    }
3778}
3779
3780impl From<Rems> for Length {
3781    fn from(rems: Rems) -> Self {
3782        Self::Definite(rems.into())
3783    }
3784}
3785
3786impl From<DefiniteLength> for Length {
3787    fn from(length: DefiniteLength) -> Self {
3788        Self::Definite(length)
3789    }
3790}
3791
3792impl From<AbsoluteLength> for Length {
3793    fn from(length: AbsoluteLength) -> Self {
3794        Self::Definite(length.into())
3795    }
3796}
3797
3798impl Default for Length {
3799    fn default() -> Self {
3800        Self::Definite(DefiniteLength::default())
3801    }
3802}
3803
3804impl From<()> for Length {
3805    fn from(_: ()) -> Self {
3806        Self::Definite(DefiniteLength::default())
3807    }
3808}
3809
3810/// A location in a grid layout.
3811#[derive(Clone, PartialEq, Debug, Serialize, Deserialize, JsonSchema, Default)]
3812pub struct GridLocation {
3813    /// The rows this item uses within the grid.
3814    pub row: Range<GridPlacement>,
3815    /// The columns this item uses within the grid.
3816    pub column: Range<GridPlacement>,
3817}
3818
3819/// The placement of an item within a grid layout's column or row.
3820#[derive(Clone, Copy, PartialEq, Debug, Serialize, Deserialize, JsonSchema, Default)]
3821pub enum GridPlacement {
3822    /// The grid line index to place this item.
3823    Line(i16),
3824    /// The number of grid lines to span.
3825    Span(u16),
3826    /// Automatically determine the placement, equivalent to Span(1)
3827    #[default]
3828    Auto,
3829}
3830
3831impl From<GridPlacement> for taffy::GridPlacement {
3832    fn from(placement: GridPlacement) -> Self {
3833        match placement {
3834            GridPlacement::Line(index) => taffy::GridPlacement::from_line_index(index),
3835            GridPlacement::Span(span) => taffy::GridPlacement::from_span(span),
3836            GridPlacement::Auto => taffy::GridPlacement::Auto,
3837        }
3838    }
3839}
3840
3841/// Provides a trait for types that can calculate half of their value.
3842///
3843/// The `Half` trait is used for types that can be evenly divided, returning a new instance of the same type
3844/// representing half of the original value. This is commonly used for types that represent measurements or sizes,
3845/// such as lengths or pixels, where halving is a frequent operation during layout calculations or animations.
3846pub trait Half {
3847    /// Returns half of the current value.
3848    ///
3849    /// # Returns
3850    ///
3851    /// A new instance of the implementing type, representing half of the original value.
3852    fn half(&self) -> Self;
3853}
3854
3855impl Half for i32 {
3856    fn half(&self) -> Self {
3857        self / 2
3858    }
3859}
3860
3861impl Half for f32 {
3862    fn half(&self) -> Self {
3863        self / 2.
3864    }
3865}
3866
3867impl Half for DevicePixels {
3868    fn half(&self) -> Self {
3869        Self(self.0 / 2)
3870    }
3871}
3872
3873impl Half for ScaledPixels {
3874    fn half(&self) -> Self {
3875        Self(self.0 / 2.)
3876    }
3877}
3878
3879impl Half for Pixels {
3880    fn half(&self) -> Self {
3881        Self(self.0 / 2.)
3882    }
3883}
3884
3885impl Half for Rems {
3886    fn half(&self) -> Self {
3887        Self(self.0 / 2.)
3888    }
3889}
3890
3891/// A trait for checking if a value is zero.
3892///
3893/// This trait provides a method to determine if a value is considered to be zero.
3894/// It is implemented for various numeric and length-related types where the concept
3895/// of zero is applicable. This can be useful for comparisons, optimizations, or
3896/// determining if an operation has a neutral effect.
3897pub trait IsZero {
3898    /// Determines if the value is zero.
3899    ///
3900    /// # Returns
3901    ///
3902    /// Returns `true` if the value is zero, `false` otherwise.
3903    fn is_zero(&self) -> bool;
3904}
3905
3906impl IsZero for DevicePixels {
3907    fn is_zero(&self) -> bool {
3908        self.0 == 0
3909    }
3910}
3911
3912impl IsZero for ScaledPixels {
3913    fn is_zero(&self) -> bool {
3914        self.0 == 0.
3915    }
3916}
3917
3918impl IsZero for Pixels {
3919    fn is_zero(&self) -> bool {
3920        self.0 == 0.
3921    }
3922}
3923
3924impl IsZero for Rems {
3925    fn is_zero(&self) -> bool {
3926        self.0 == 0.
3927    }
3928}
3929
3930impl IsZero for AbsoluteLength {
3931    fn is_zero(&self) -> bool {
3932        match self {
3933            AbsoluteLength::Pixels(pixels) => pixels.is_zero(),
3934            AbsoluteLength::Rems(rems) => rems.is_zero(),
3935        }
3936    }
3937}
3938
3939impl IsZero for DefiniteLength {
3940    fn is_zero(&self) -> bool {
3941        match self {
3942            DefiniteLength::Absolute(length) => length.is_zero(),
3943            DefiniteLength::Fraction(fraction) => *fraction == 0.,
3944        }
3945    }
3946}
3947
3948impl IsZero for Length {
3949    fn is_zero(&self) -> bool {
3950        match self {
3951            Length::Definite(length) => length.is_zero(),
3952            Length::Auto => false,
3953        }
3954    }
3955}
3956
3957impl<T: IsZero + Clone + Debug + Default + PartialEq> IsZero for Point<T> {
3958    fn is_zero(&self) -> bool {
3959        self.x.is_zero() && self.y.is_zero()
3960    }
3961}
3962
3963impl<T> IsZero for Size<T>
3964where
3965    T: IsZero + Clone + Debug + Default + PartialEq,
3966{
3967    fn is_zero(&self) -> bool {
3968        self.width.is_zero() || self.height.is_zero()
3969    }
3970}
3971
3972impl<T: IsZero + Clone + Debug + Default + PartialEq> IsZero for Bounds<T> {
3973    fn is_zero(&self) -> bool {
3974        self.size.is_zero()
3975    }
3976}
3977
3978impl<T> IsZero for Corners<T>
3979where
3980    T: IsZero + Clone + Debug + Default + PartialEq,
3981{
3982    fn is_zero(&self) -> bool {
3983        self.top_left.is_zero()
3984            && self.top_right.is_zero()
3985            && self.bottom_right.is_zero()
3986            && self.bottom_left.is_zero()
3987    }
3988}
3989
3990#[cfg(test)]
3991mod tests {
3992    use super::*;
3993
3994    #[crate::test]
3995    fn test_centered_window_is_clamped_to_display(cx: &mut crate::TestAppContext) {
3996        cx.update(|cx| {
3997            let display = cx.primary_display().unwrap();
3998            let visible = display.visible_bounds();
3999            assert_eq!(
4000                Bounds::centered(
4001                    None,
4002                    size(visible.size.width * 2., visible.size.height * 2.),
4003                    cx
4004                ),
4005                visible
4006            );
4007            let small = visible.size / 2.;
4008            assert_eq!(
4009                Bounds::centered(Some(display.id()), small, cx),
4010                Bounds::centered_at(visible.center(), small)
4011            );
4012            assert_eq!(
4013                Bounds::centered(Some(DisplayId(u64::MAX)), small, cx),
4014                Bounds::centered_at(visible.center(), small)
4015            );
4016        });
4017    }
4018
4019    #[test]
4020    fn test_bounds_intersects() {
4021        let bounds1 = Bounds {
4022            origin: Point { x: 0.0, y: 0.0 },
4023            size: Size {
4024                width: 5.0,
4025                height: 5.0,
4026            },
4027        };
4028        let bounds2 = Bounds {
4029            origin: Point { x: 4.0, y: 4.0 },
4030            size: Size {
4031                width: 5.0,
4032                height: 5.0,
4033            },
4034        };
4035        let bounds3 = Bounds {
4036            origin: Point { x: 10.0, y: 10.0 },
4037            size: Size {
4038                width: 5.0,
4039                height: 5.0,
4040            },
4041        };
4042
4043        // Test Case 1: Intersecting bounds
4044        assert!(bounds1.intersects(&bounds2));
4045
4046        // Test Case 2: Non-Intersecting bounds
4047        assert!(!bounds1.intersects(&bounds3));
4048
4049        // Test Case 3: Bounds intersecting with themselves
4050        assert!(bounds1.intersects(&bounds1));
4051    }
4052}