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> Mul for Edges<T>
1765where
1766    T: Mul<Output = T> + Clone + Debug + Default + PartialEq,
1767{
1768    type Output = Self;
1769
1770    fn mul(self, rhs: Self) -> Self::Output {
1771        Self {
1772            top: self.top.clone() * rhs.top,
1773            right: self.right.clone() * rhs.right,
1774            bottom: self.bottom.clone() * rhs.bottom,
1775            left: self.left * rhs.left,
1776        }
1777    }
1778}
1779
1780impl<T, S> MulAssign<S> for Edges<T>
1781where
1782    T: Mul<S, Output = T> + Clone + Debug + Default + PartialEq,
1783    S: Clone,
1784{
1785    fn mul_assign(&mut self, rhs: S) {
1786        self.top = self.top.clone() * rhs.clone();
1787        self.right = self.right.clone() * rhs.clone();
1788        self.bottom = self.bottom.clone() * rhs.clone();
1789        self.left = self.left.clone() * rhs;
1790    }
1791}
1792
1793impl<T: Clone + Debug + Default + PartialEq + Copy> Copy for Edges<T> {}
1794
1795impl<T: Clone + Debug + Default + PartialEq> Edges<T> {
1796    /// Constructs `Edges` where all sides are set to the same specified value.
1797    ///
1798    /// This function creates an `Edges` instance with the `top`, `right`, `bottom`, and `left` fields all initialized
1799    /// to the same value provided as an argument. This is useful when you want to have uniform edges around a box,
1800    /// such as padding or margin with the same size on all sides.
1801    ///
1802    /// # Arguments
1803    ///
1804    /// * `value` - The value to set for all four sides of the edges.
1805    ///
1806    /// # Returns
1807    ///
1808    /// An `Edges` instance with all sides set to the given value.
1809    ///
1810    /// # Examples
1811    ///
1812    /// ```
1813    /// # use gpui::Edges;
1814    /// let uniform_edges = Edges::all(10.0);
1815    /// assert_eq!(uniform_edges.top, 10.0);
1816    /// assert_eq!(uniform_edges.right, 10.0);
1817    /// assert_eq!(uniform_edges.bottom, 10.0);
1818    /// assert_eq!(uniform_edges.left, 10.0);
1819    /// ```
1820    pub fn all(value: T) -> Self {
1821        Self {
1822            top: value.clone(),
1823            right: value.clone(),
1824            bottom: value.clone(),
1825            left: value,
1826        }
1827    }
1828
1829    /// Applies a function to each field of the `Edges`, producing a new `Edges<U>`.
1830    ///
1831    /// This method allows for converting an `Edges<T>` to an `Edges<U>` by specifying a closure
1832    /// that defines how to convert between the two types. The closure is applied to each field
1833    /// (`top`, `right`, `bottom`, `left`), resulting in new edges of the desired type.
1834    ///
1835    /// # Arguments
1836    ///
1837    /// * `f` - A closure that takes a reference to a value of type `T` and returns a value of type `U`.
1838    ///
1839    /// # Returns
1840    ///
1841    /// Returns a new `Edges<U>` with each field mapped by the provided function.
1842    ///
1843    /// # Examples
1844    ///
1845    /// ```
1846    /// # use gpui::Edges;
1847    /// let edges = Edges { top: 10, right: 20, bottom: 30, left: 40 };
1848    /// let edges_float = edges.map(|&value| value as f32 * 1.1);
1849    /// assert_eq!(edges_float, Edges { top: 11.0, right: 22.0, bottom: 33.0, left: 44.0 });
1850    /// ```
1851    pub fn map<U>(&self, f: impl Fn(&T) -> U) -> Edges<U>
1852    where
1853        U: Clone + Debug + Default + PartialEq,
1854    {
1855        Edges {
1856            top: f(&self.top),
1857            right: f(&self.right),
1858            bottom: f(&self.bottom),
1859            left: f(&self.left),
1860        }
1861    }
1862
1863    /// Checks if any of the edges satisfy a given predicate.
1864    ///
1865    /// This method applies a predicate function to each field of the `Edges` and returns `true` if any field satisfies the predicate.
1866    ///
1867    /// # Arguments
1868    ///
1869    /// * `predicate` - A closure that takes a reference to a value of type `T` and returns a `bool`.
1870    ///
1871    /// # Returns
1872    ///
1873    /// Returns `true` if the predicate returns `true` for any of the edge values, `false` otherwise.
1874    ///
1875    /// # Examples
1876    ///
1877    /// ```
1878    /// # use gpui::Edges;
1879    /// let edges = Edges {
1880    ///     top: 10,
1881    ///     right: 0,
1882    ///     bottom: 5,
1883    ///     left: 0,
1884    /// };
1885    ///
1886    /// assert!(edges.any(|value| *value == 0));
1887    /// assert!(edges.any(|value| *value > 0));
1888    /// assert!(!edges.any(|value| *value > 10));
1889    /// ```
1890    pub fn any<F: Fn(&T) -> bool>(&self, predicate: F) -> bool {
1891        predicate(&self.top)
1892            || predicate(&self.right)
1893            || predicate(&self.bottom)
1894            || predicate(&self.left)
1895    }
1896}
1897
1898impl Edges<Length> {
1899    /// 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.
1900    ///
1901    /// 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.
1902    ///
1903    /// # Returns
1904    ///
1905    /// Returns an `Edges<Length>` with all edges set to `Length::Auto`.
1906    ///
1907    /// # Examples
1908    ///
1909    /// ```
1910    /// # use gpui::{Edges, Length};
1911    /// let auto_edges = Edges::auto();
1912    /// assert_eq!(auto_edges.top, Length::Auto);
1913    /// assert_eq!(auto_edges.right, Length::Auto);
1914    /// assert_eq!(auto_edges.bottom, Length::Auto);
1915    /// assert_eq!(auto_edges.left, Length::Auto);
1916    /// ```
1917    pub fn auto() -> Self {
1918        Self {
1919            top: Length::Auto,
1920            right: Length::Auto,
1921            bottom: Length::Auto,
1922            left: Length::Auto,
1923        }
1924    }
1925
1926    /// Sets the edges of the `Edges` struct to zero, which means no size or thickness.
1927    ///
1928    /// This is typically used when you want to specify that a box (like a padding or margin area)
1929    /// should have no edges, effectively making it non-existent or invisible in layout calculations.
1930    ///
1931    /// # Returns
1932    ///
1933    /// Returns an `Edges<Length>` with all edges set to zero length.
1934    ///
1935    /// # Examples
1936    ///
1937    /// ```
1938    /// # use gpui::{DefiniteLength, Edges, Length, Pixels};
1939    /// let no_edges = Edges::<Length>::zero();
1940    /// assert_eq!(no_edges.top, Length::Definite(DefiniteLength::from(Pixels::ZERO)));
1941    /// assert_eq!(no_edges.right, Length::Definite(DefiniteLength::from(Pixels::ZERO)));
1942    /// assert_eq!(no_edges.bottom, Length::Definite(DefiniteLength::from(Pixels::ZERO)));
1943    /// assert_eq!(no_edges.left, Length::Definite(DefiniteLength::from(Pixels::ZERO)));
1944    /// ```
1945    pub fn zero() -> Self {
1946        Self {
1947            top: px(0.).into(),
1948            right: px(0.).into(),
1949            bottom: px(0.).into(),
1950            left: px(0.).into(),
1951        }
1952    }
1953}
1954
1955impl Edges<DefiniteLength> {
1956    /// Sets the edges of the `Edges` struct to zero, which means no size or thickness.
1957    ///
1958    /// This is typically used when you want to specify that a box (like a padding or margin area)
1959    /// should have no edges, effectively making it non-existent or invisible in layout calculations.
1960    ///
1961    /// # Returns
1962    ///
1963    /// Returns an `Edges<DefiniteLength>` with all edges set to zero length.
1964    ///
1965    /// # Examples
1966    ///
1967    /// ```
1968    /// # use gpui::{px, DefiniteLength, Edges};
1969    /// let no_edges = Edges::<DefiniteLength>::zero();
1970    /// assert_eq!(no_edges.top, DefiniteLength::from(px(0.)));
1971    /// assert_eq!(no_edges.right, DefiniteLength::from(px(0.)));
1972    /// assert_eq!(no_edges.bottom, DefiniteLength::from(px(0.)));
1973    /// assert_eq!(no_edges.left, DefiniteLength::from(px(0.)));
1974    /// ```
1975    pub fn zero() -> Self {
1976        Self {
1977            top: px(0.).into(),
1978            right: px(0.).into(),
1979            bottom: px(0.).into(),
1980            left: px(0.).into(),
1981        }
1982    }
1983
1984    /// Converts the `DefiniteLength` to `Pixels` based on the parent size and the REM size.
1985    ///
1986    /// This method allows for a `DefiniteLength` value to be converted into pixels, taking into account
1987    /// the size of the parent element (for percentage-based lengths) and the size of a rem unit (for rem-based lengths).
1988    ///
1989    /// # Arguments
1990    ///
1991    /// * `parent_size` - `Size<AbsoluteLength>` representing the size of the parent element.
1992    /// * `rem_size` - `Pixels` representing the size of one REM unit.
1993    ///
1994    /// # Returns
1995    ///
1996    /// Returns an `Edges<Pixels>` representing the edges with lengths converted to pixels.
1997    ///
1998    /// # Examples
1999    ///
2000    /// ```
2001    /// # use gpui::{Edges, DefiniteLength, px, AbsoluteLength, rems, Size};
2002    /// let edges = Edges {
2003    ///     top: DefiniteLength::Absolute(AbsoluteLength::Pixels(px(10.0))),
2004    ///     right: DefiniteLength::Fraction(0.5),
2005    ///     bottom: DefiniteLength::Absolute(AbsoluteLength::Rems(rems(2.0))),
2006    ///     left: DefiniteLength::Fraction(0.25),
2007    /// };
2008    /// let parent_size = Size {
2009    ///     width: AbsoluteLength::Pixels(px(200.0)),
2010    ///     height: AbsoluteLength::Pixels(px(100.0)),
2011    /// };
2012    /// let rem_size = px(16.0);
2013    /// let edges_in_pixels = edges.to_pixels(parent_size, rem_size);
2014    ///
2015    /// assert_eq!(edges_in_pixels.top, px(10.0)); // Absolute length in pixels
2016    /// assert_eq!(edges_in_pixels.right, px(100.0)); // 50% of parent width
2017    /// assert_eq!(edges_in_pixels.bottom, px(32.0)); // 2 rems
2018    /// assert_eq!(edges_in_pixels.left, px(50.0)); // 25% of parent width
2019    /// ```
2020    pub fn to_pixels(self, parent_size: Size<AbsoluteLength>, rem_size: Pixels) -> Edges<Pixels> {
2021        Edges {
2022            top: self.top.to_pixels(parent_size.height, rem_size),
2023            right: self.right.to_pixels(parent_size.width, rem_size),
2024            bottom: self.bottom.to_pixels(parent_size.height, rem_size),
2025            left: self.left.to_pixels(parent_size.width, rem_size),
2026        }
2027    }
2028}
2029
2030impl Edges<AbsoluteLength> {
2031    /// Sets the edges of the `Edges` struct to zero, which means no size or thickness.
2032    ///
2033    /// This is typically used when you want to specify that a box (like a padding or margin area)
2034    /// should have no edges, effectively making it non-existent or invisible in layout calculations.
2035    ///
2036    /// # Returns
2037    ///
2038    /// Returns an `Edges<AbsoluteLength>` with all edges set to zero length.
2039    ///
2040    /// # Examples
2041    ///
2042    /// ```
2043    /// # use gpui::{AbsoluteLength, Edges, Pixels};
2044    /// let no_edges = Edges::<AbsoluteLength>::zero();
2045    /// assert_eq!(no_edges.top, AbsoluteLength::Pixels(Pixels::ZERO));
2046    /// assert_eq!(no_edges.right, AbsoluteLength::Pixels(Pixels::ZERO));
2047    /// assert_eq!(no_edges.bottom, AbsoluteLength::Pixels(Pixels::ZERO));
2048    /// assert_eq!(no_edges.left, AbsoluteLength::Pixels(Pixels::ZERO));
2049    /// ```
2050    pub fn zero() -> Self {
2051        Self {
2052            top: px(0.).into(),
2053            right: px(0.).into(),
2054            bottom: px(0.).into(),
2055            left: px(0.).into(),
2056        }
2057    }
2058
2059    /// Converts the `AbsoluteLength` to `Pixels` based on the `rem_size`.
2060    ///
2061    /// If the `AbsoluteLength` is already in pixels, it simply returns the corresponding `Pixels` value.
2062    /// If the `AbsoluteLength` is in rems, it multiplies the number of rems by the `rem_size` to convert it to pixels.
2063    ///
2064    /// # Arguments
2065    ///
2066    /// * `rem_size` - The size of one rem unit in pixels.
2067    ///
2068    /// # Returns
2069    ///
2070    /// Returns an `Edges<Pixels>` representing the edges with lengths converted to pixels.
2071    ///
2072    /// # Examples
2073    ///
2074    /// ```
2075    /// # use gpui::{Edges, AbsoluteLength, Pixels, px, rems};
2076    /// let edges = Edges {
2077    ///     top: AbsoluteLength::Pixels(px(10.0)),
2078    ///     right: AbsoluteLength::Rems(rems(1.0)),
2079    ///     bottom: AbsoluteLength::Pixels(px(20.0)),
2080    ///     left: AbsoluteLength::Rems(rems(2.0)),
2081    /// };
2082    /// let rem_size = px(16.0);
2083    /// let edges_in_pixels = edges.to_pixels(rem_size);
2084    ///
2085    /// assert_eq!(edges_in_pixels.top, px(10.0)); // Already in pixels
2086    /// assert_eq!(edges_in_pixels.right, px(16.0)); // 1 rem converted to pixels
2087    /// assert_eq!(edges_in_pixels.bottom, px(20.0)); // Already in pixels
2088    /// assert_eq!(edges_in_pixels.left, px(32.0)); // 2 rems converted to pixels
2089    /// ```
2090    pub fn to_pixels(self, rem_size: Pixels) -> Edges<Pixels> {
2091        Edges {
2092            top: self.top.to_pixels(rem_size),
2093            right: self.right.to_pixels(rem_size),
2094            bottom: self.bottom.to_pixels(rem_size),
2095            left: self.left.to_pixels(rem_size),
2096        }
2097    }
2098}
2099
2100impl Edges<Pixels> {
2101    /// Scales the `Edges<Pixels>` by a given factor, returning `Edges<ScaledPixels>`.
2102    ///
2103    /// This method is typically used for adjusting the edge sizes for different display densities or scaling factors.
2104    ///
2105    /// # Arguments
2106    ///
2107    /// * `factor` - The scaling factor to apply to each edge.
2108    ///
2109    /// # Returns
2110    ///
2111    /// Returns a new `Edges<ScaledPixels>` where each edge is the result of scaling the original edge by the given factor.
2112    ///
2113    /// # Examples
2114    ///
2115    /// ```
2116    /// # use gpui::{Edges, Pixels, ScaledPixels};
2117    /// let edges = Edges {
2118    ///     top: Pixels::from(10.0),
2119    ///     right: Pixels::from(20.0),
2120    ///     bottom: Pixels::from(30.0),
2121    ///     left: Pixels::from(40.0),
2122    /// };
2123    /// let scaled_edges = edges.scale(2.0);
2124    /// assert_eq!(scaled_edges.top, ScaledPixels::from(20.0));
2125    /// assert_eq!(scaled_edges.right, ScaledPixels::from(40.0));
2126    /// assert_eq!(scaled_edges.bottom, ScaledPixels::from(60.0));
2127    /// assert_eq!(scaled_edges.left, ScaledPixels::from(80.0));
2128    /// ```
2129    pub fn scale(&self, factor: f32) -> Edges<ScaledPixels> {
2130        Edges {
2131            top: self.top.scale(factor),
2132            right: self.right.scale(factor),
2133            bottom: self.bottom.scale(factor),
2134            left: self.left.scale(factor),
2135        }
2136    }
2137
2138    /// Returns the maximum value of any edge.
2139    ///
2140    /// # Returns
2141    ///
2142    /// The maximum `Pixels` value among all four edges.
2143    pub fn max(&self) -> Pixels {
2144        self.top.max(self.right).max(self.bottom).max(self.left)
2145    }
2146}
2147
2148impl From<f32> for Edges<Pixels> {
2149    fn from(val: f32) -> Self {
2150        let val: Pixels = val.into();
2151        val.into()
2152    }
2153}
2154
2155impl From<Pixels> for Edges<Pixels> {
2156    fn from(val: Pixels) -> Self {
2157        Edges {
2158            top: val,
2159            right: val,
2160            bottom: val,
2161            left: val,
2162        }
2163    }
2164}
2165
2166/// Identifies a reference point on a 2D box, used to anchor positioned elements.
2167#[derive(Clone, Copy, Debug, PartialEq, Eq)]
2168pub enum Anchor {
2169    /// The top left corner
2170    TopLeft,
2171    /// The top right corner
2172    TopRight,
2173    /// The bottom left corner
2174    BottomLeft,
2175    /// The bottom right corner
2176    BottomRight,
2177    /// The top center position
2178    TopCenter,
2179    /// The bottom center position
2180    BottomCenter,
2181    /// The left center position
2182    LeftCenter,
2183    /// The right center position
2184    RightCenter,
2185}
2186
2187impl Anchor {
2188    /// Returns the directly opposite corner.
2189    ///
2190    /// # Examples
2191    ///
2192    /// ```
2193    /// # use gpui::Anchor;
2194    /// assert_eq!(Anchor::TopLeft.opposite(), Anchor::BottomRight);
2195    /// ```
2196    #[must_use]
2197    pub fn opposite(self) -> Self {
2198        match self {
2199            Anchor::TopLeft => Anchor::BottomRight,
2200            Anchor::TopRight => Anchor::BottomLeft,
2201            Anchor::BottomLeft => Anchor::TopRight,
2202            Anchor::BottomRight => Anchor::TopLeft,
2203            Anchor::TopCenter => Anchor::BottomCenter,
2204            Anchor::BottomCenter => Anchor::TopCenter,
2205            Anchor::LeftCenter => Anchor::RightCenter,
2206            Anchor::RightCenter => Anchor::LeftCenter,
2207        }
2208    }
2209
2210    /// Returns the corner across from this corner, moving along the specified axis.
2211    ///
2212    /// # Examples
2213    ///
2214    /// ```
2215    /// # use gpui::{Axis, Anchor};
2216    /// let result = Anchor::TopLeft.other_side_along(Axis::Horizontal);
2217    /// assert_eq!(result, Anchor::TopRight);
2218    /// ```
2219    #[must_use]
2220    pub fn other_side_along(self, axis: Axis) -> Self {
2221        match axis {
2222            Axis::Vertical => match self {
2223                Anchor::TopLeft => Anchor::BottomLeft,
2224                Anchor::TopRight => Anchor::BottomRight,
2225                Anchor::BottomLeft => Anchor::TopLeft,
2226                Anchor::BottomRight => Anchor::TopRight,
2227                Anchor::TopCenter => Anchor::BottomCenter,
2228                Anchor::BottomCenter => Anchor::TopCenter,
2229                Anchor::LeftCenter => Anchor::LeftCenter,
2230                Anchor::RightCenter => Anchor::RightCenter,
2231            },
2232            Axis::Horizontal => match self {
2233                Anchor::TopLeft => Anchor::TopRight,
2234                Anchor::TopRight => Anchor::TopLeft,
2235                Anchor::BottomLeft => Anchor::BottomRight,
2236                Anchor::BottomRight => Anchor::BottomLeft,
2237                Anchor::TopCenter => Anchor::TopCenter,
2238                Anchor::BottomCenter => Anchor::BottomCenter,
2239                Anchor::LeftCenter => Anchor::RightCenter,
2240                Anchor::RightCenter => Anchor::LeftCenter,
2241            },
2242        }
2243    }
2244
2245    /// Returns true if at the center.
2246    #[inline]
2247    pub fn is_center(&self) -> bool {
2248        matches!(
2249            self,
2250            Self::TopCenter | Self::BottomCenter | Self::LeftCenter | Self::RightCenter
2251        )
2252    }
2253}
2254
2255/// Represents the corners of a box in a 2D space, such as border radius.
2256///
2257/// Each field represents the size of the corner on one side of the box: `top_left`, `top_right`, `bottom_right`, and `bottom_left`.
2258#[derive(Refineable, Clone, Default, Debug, Eq, PartialEq)]
2259#[refineable(Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
2260#[repr(C)]
2261pub struct Corners<T: Clone + Debug + Default + PartialEq> {
2262    /// The value associated with the top left corner.
2263    pub top_left: T,
2264    /// The value associated with the top right corner.
2265    pub top_right: T,
2266    /// The value associated with the bottom right corner.
2267    pub bottom_right: T,
2268    /// The value associated with the bottom left corner.
2269    pub bottom_left: T,
2270}
2271
2272impl<T> Corners<T>
2273where
2274    T: Add<T, Output = T> + Half + Clone + Debug + Default + PartialEq,
2275{
2276    /// Constructs `Corners` where all sides are set to the same specified value.
2277    ///
2278    /// This function creates a `Corners` instance with the `top_left`, `top_right`, `bottom_right`, and `bottom_left` fields all initialized
2279    /// to the same value provided as an argument. This is useful when you want to have uniform corners around a box,
2280    /// such as a uniform border radius on a rectangle.
2281    ///
2282    /// # Arguments
2283    ///
2284    /// * `value` - The value to set for all four corners.
2285    ///
2286    /// # Returns
2287    ///
2288    /// An `Corners` instance with all corners set to the given value.
2289    ///
2290    /// # Examples
2291    ///
2292    /// ```
2293    /// # use gpui::Corners;
2294    /// let uniform_corners = Corners::all(5.0);
2295    /// assert_eq!(uniform_corners.top_left, 5.0);
2296    /// assert_eq!(uniform_corners.top_right, 5.0);
2297    /// assert_eq!(uniform_corners.bottom_right, 5.0);
2298    /// assert_eq!(uniform_corners.bottom_left, 5.0);
2299    /// ```
2300    pub fn all(value: T) -> Self {
2301        Self {
2302            top_left: value.clone(),
2303            top_right: value.clone(),
2304            bottom_right: value.clone(),
2305            bottom_left: value,
2306        }
2307    }
2308
2309    /// Returns the requested corner value, supporting all eight corner positions.
2310    ///
2311    /// For the four basic corners (TopLeft, TopRight, BottomLeft, BottomRight),
2312    /// this returns the corresponding field value directly.
2313    ///
2314    /// For the center positions (TopCenter, BottomCenter, LeftCenter, RightCenter),
2315    /// this calculates the average of the two adjacent corners.
2316    ///
2317    /// # Returns
2318    ///
2319    /// A value of type `T` representing the corner requested by the parameter.
2320    ///
2321    /// # Examples
2322    ///
2323    /// Basic corner positions:
2324    ///
2325    /// ```
2326    /// # use gpui::{Anchor, Corners};
2327    /// let corners = Corners {
2328    ///     top_left: 10,
2329    ///     top_right: 20,
2330    ///     bottom_left: 30,
2331    ///     bottom_right: 40
2332    /// };
2333    /// assert_eq!(corners.corner(Anchor::TopLeft), 10);
2334    /// assert_eq!(corners.corner(Anchor::BottomRight), 40);
2335    /// ```
2336    ///
2337    /// Center positions (calculated as average of adjacent corners):
2338    ///
2339    /// ```
2340    /// # use gpui::{Anchor, Corners};
2341    /// let corners = Corners {
2342    ///     top_left: 10,
2343    ///     top_right: 20,
2344    ///     bottom_left: 30,
2345    ///     bottom_right: 40
2346    /// };
2347    /// assert_eq!(corners.corner(Anchor::TopCenter), 15);
2348    /// assert_eq!(corners.corner(Anchor::BottomCenter), 35);
2349    /// assert_eq!(corners.corner(Anchor::LeftCenter), 20);
2350    /// assert_eq!(corners.corner(Anchor::RightCenter), 30);
2351    /// ```
2352    #[must_use]
2353    pub fn corner(&self, corner: Anchor) -> T {
2354        match corner {
2355            Anchor::TopLeft => self.top_left.clone(),
2356            Anchor::TopRight => self.top_right.clone(),
2357            Anchor::BottomLeft => self.bottom_left.clone(),
2358            Anchor::BottomRight => self.bottom_right.clone(),
2359            Anchor::TopCenter => (self.top_left.clone() + self.top_right.clone()).half(),
2360            Anchor::BottomCenter => (self.bottom_left.clone() + self.bottom_right.clone()).half(),
2361            Anchor::LeftCenter => (self.top_left.clone() + self.bottom_left.clone()).half(),
2362            Anchor::RightCenter => (self.top_right.clone() + self.bottom_right.clone()).half(),
2363        }
2364    }
2365}
2366
2367impl Corners<AbsoluteLength> {
2368    /// Converts the `AbsoluteLength` to `Pixels` based on the provided rem size.
2369    ///
2370    /// # Arguments
2371    ///
2372    /// * `rem_size` - The size of one REM unit in pixels, used for conversion if the `AbsoluteLength` is in REMs.
2373    ///
2374    /// # Returns
2375    ///
2376    /// Returns a `Corners<Pixels>` instance with each corner's length converted to pixels.
2377    ///
2378    /// # Examples
2379    ///
2380    /// ```
2381    /// # use gpui::{Corners, AbsoluteLength, Pixels, Rems, Size};
2382    /// let corners = Corners {
2383    ///     top_left: AbsoluteLength::Pixels(Pixels::from(15.0)),
2384    ///     top_right: AbsoluteLength::Rems(Rems(1.0)),
2385    ///     bottom_right: AbsoluteLength::Pixels(Pixels::from(30.0)),
2386    ///     bottom_left: AbsoluteLength::Rems(Rems(2.0)),
2387    /// };
2388    /// let rem_size = Pixels::from(16.0);
2389    /// let corners_in_pixels = corners.to_pixels(rem_size);
2390    ///
2391    /// assert_eq!(corners_in_pixels.top_left, Pixels::from(15.0));
2392    /// assert_eq!(corners_in_pixels.top_right, Pixels::from(16.0)); // 1 rem converted to pixels
2393    /// assert_eq!(corners_in_pixels.bottom_right, Pixels::from(30.0));
2394    /// assert_eq!(corners_in_pixels.bottom_left, Pixels::from(32.0)); // 2 rems converted to pixels
2395    /// ```
2396    pub fn to_pixels(self, rem_size: Pixels) -> Corners<Pixels> {
2397        Corners {
2398            top_left: self.top_left.to_pixels(rem_size),
2399            top_right: self.top_right.to_pixels(rem_size),
2400            bottom_right: self.bottom_right.to_pixels(rem_size),
2401            bottom_left: self.bottom_left.to_pixels(rem_size),
2402        }
2403    }
2404}
2405
2406impl Corners<Pixels> {
2407    /// Scales the `Corners<Pixels>` by a given factor, returning `Corners<ScaledPixels>`.
2408    ///
2409    /// This method is typically used for adjusting the corner sizes for different display densities or scaling factors.
2410    ///
2411    /// # Arguments
2412    ///
2413    /// * `factor` - The scaling factor to apply to each corner.
2414    ///
2415    /// # Returns
2416    ///
2417    /// Returns a new `Corners<ScaledPixels>` where each corner is the result of scaling the original corner by the given factor.
2418    ///
2419    /// # Examples
2420    ///
2421    /// ```
2422    /// # use gpui::{Corners, Pixels, ScaledPixels};
2423    /// let corners = Corners {
2424    ///     top_left: Pixels::from(10.0),
2425    ///     top_right: Pixels::from(20.0),
2426    ///     bottom_right: Pixels::from(30.0),
2427    ///     bottom_left: Pixels::from(40.0),
2428    /// };
2429    /// let scaled_corners = corners.scale(2.0);
2430    /// assert_eq!(scaled_corners.top_left, ScaledPixels::from(20.0));
2431    /// assert_eq!(scaled_corners.top_right, ScaledPixels::from(40.0));
2432    /// assert_eq!(scaled_corners.bottom_right, ScaledPixels::from(60.0));
2433    /// assert_eq!(scaled_corners.bottom_left, ScaledPixels::from(80.0));
2434    /// ```
2435    #[must_use]
2436    pub fn scale(&self, factor: f32) -> Corners<ScaledPixels> {
2437        Corners {
2438            top_left: self.top_left.scale(factor),
2439            top_right: self.top_right.scale(factor),
2440            bottom_right: self.bottom_right.scale(factor),
2441            bottom_left: self.bottom_left.scale(factor),
2442        }
2443    }
2444
2445    /// Returns the maximum value of any corner.
2446    ///
2447    /// # Returns
2448    ///
2449    /// The maximum `Pixels` value among all four corners.
2450    #[must_use]
2451    pub fn max(&self) -> Pixels {
2452        self.top_left
2453            .max(self.top_right)
2454            .max(self.bottom_right)
2455            .max(self.bottom_left)
2456    }
2457}
2458
2459impl<T: Div<f32, Output = T> + Ord + Clone + Debug + Default + PartialEq> Corners<T> {
2460    /// Clamps corner radii to be less than or equal to half the shortest side of a quad.
2461    ///
2462    /// # Arguments
2463    ///
2464    /// * `size` - The size of the quad which limits the size of the corner radii.
2465    ///
2466    /// # Returns
2467    ///
2468    /// Anchor radii values clamped to fit.
2469    #[must_use]
2470    pub fn clamp_radii_for_quad_size(self, size: Size<T>) -> Corners<T> {
2471        let max = cmp::min(size.width, size.height) / 2.;
2472        Corners {
2473            top_left: cmp::min(self.top_left, max.clone()),
2474            top_right: cmp::min(self.top_right, max.clone()),
2475            bottom_right: cmp::min(self.bottom_right, max.clone()),
2476            bottom_left: cmp::min(self.bottom_left, max),
2477        }
2478    }
2479}
2480
2481impl<T: Clone + Debug + Default + PartialEq> Corners<T> {
2482    /// Applies a function to each field of the `Corners`, producing a new `Corners<U>`.
2483    ///
2484    /// This method allows for converting a `Corners<T>` to a `Corners<U>` by specifying a closure
2485    /// that defines how to convert between the two types. The closure is applied to each field
2486    /// (`top_left`, `top_right`, `bottom_right`, `bottom_left`), resulting in new corners of the desired type.
2487    ///
2488    /// # Arguments
2489    ///
2490    /// * `f` - A closure that takes a reference to a value of type `T` and returns a value of type `U`.
2491    ///
2492    /// # Returns
2493    ///
2494    /// Returns a new `Corners<U>` with each field mapped by the provided function.
2495    ///
2496    /// # Examples
2497    ///
2498    /// ```
2499    /// # use gpui::{Corners, Pixels, Rems};
2500    /// let corners = Corners {
2501    ///     top_left: Pixels::from(10.0),
2502    ///     top_right: Pixels::from(20.0),
2503    ///     bottom_right: Pixels::from(30.0),
2504    ///     bottom_left: Pixels::from(40.0),
2505    /// };
2506    /// let corners_in_rems = corners.map(|&px| Rems(f32::from(px) / 16.0));
2507    /// assert_eq!(corners_in_rems, Corners {
2508    ///     top_left: Rems(0.625),
2509    ///     top_right: Rems(1.25),
2510    ///     bottom_right: Rems(1.875),
2511    ///     bottom_left: Rems(2.5),
2512    /// });
2513    /// ```
2514    #[must_use]
2515    pub fn map<U>(&self, f: impl Fn(&T) -> U) -> Corners<U>
2516    where
2517        U: Clone + Debug + Default + PartialEq,
2518    {
2519        Corners {
2520            top_left: f(&self.top_left),
2521            top_right: f(&self.top_right),
2522            bottom_right: f(&self.bottom_right),
2523            bottom_left: f(&self.bottom_left),
2524        }
2525    }
2526}
2527
2528impl<T> Mul for Corners<T>
2529where
2530    T: Mul<Output = T> + Clone + Debug + Default + PartialEq,
2531{
2532    type Output = Self;
2533
2534    fn mul(self, rhs: Self) -> Self::Output {
2535        Self {
2536            top_left: self.top_left.clone() * rhs.top_left,
2537            top_right: self.top_right.clone() * rhs.top_right,
2538            bottom_right: self.bottom_right.clone() * rhs.bottom_right,
2539            bottom_left: self.bottom_left * rhs.bottom_left,
2540        }
2541    }
2542}
2543
2544impl<T, S> MulAssign<S> for Corners<T>
2545where
2546    T: Mul<S, Output = T> + Clone + Debug + Default + PartialEq,
2547    S: Clone,
2548{
2549    fn mul_assign(&mut self, rhs: S) {
2550        self.top_left = self.top_left.clone() * rhs.clone();
2551        self.top_right = self.top_right.clone() * rhs.clone();
2552        self.bottom_right = self.bottom_right.clone() * rhs.clone();
2553        self.bottom_left = self.bottom_left.clone() * rhs;
2554    }
2555}
2556
2557impl<T> Copy for Corners<T> where T: Copy + Clone + Debug + Default + PartialEq {}
2558
2559impl From<f32> for Corners<Pixels> {
2560    fn from(val: f32) -> Self {
2561        Corners {
2562            top_left: val.into(),
2563            top_right: val.into(),
2564            bottom_right: val.into(),
2565            bottom_left: val.into(),
2566        }
2567    }
2568}
2569
2570impl From<Pixels> for Corners<Pixels> {
2571    fn from(val: Pixels) -> Self {
2572        Corners {
2573            top_left: val,
2574            top_right: val,
2575            bottom_right: val,
2576            bottom_left: val,
2577        }
2578    }
2579}
2580
2581/// Represents an angle in Radians
2582#[derive(
2583    Clone,
2584    Copy,
2585    Default,
2586    Add,
2587    AddAssign,
2588    Sub,
2589    SubAssign,
2590    Neg,
2591    Div,
2592    DivAssign,
2593    PartialEq,
2594    Serialize,
2595    Deserialize,
2596    Debug,
2597)]
2598#[repr(transparent)]
2599pub struct Radians(pub f32);
2600
2601/// Create a `Radian` from a raw value
2602pub fn radians(value: f32) -> Radians {
2603    Radians(value)
2604}
2605
2606/// A type representing a percentage value.
2607#[derive(
2608    Clone,
2609    Copy,
2610    Default,
2611    Add,
2612    AddAssign,
2613    Sub,
2614    SubAssign,
2615    Neg,
2616    Div,
2617    DivAssign,
2618    PartialEq,
2619    Serialize,
2620    Deserialize,
2621    Debug,
2622)]
2623#[repr(transparent)]
2624pub struct Percentage(pub f32);
2625
2626/// Generate a `Radian` from a percentage of a full circle.
2627pub fn percentage(value: f32) -> Percentage {
2628    debug_assert!(
2629        (0.0..=1.0).contains(&value),
2630        "Percentage must be between 0 and 1"
2631    );
2632    Percentage(value)
2633}
2634
2635impl From<Percentage> for Radians {
2636    fn from(value: Percentage) -> Self {
2637        radians(value.0 * std::f32::consts::PI * 2.0)
2638    }
2639}
2640
2641/// Represents a length in pixels, the base unit of measurement in the UI framework.
2642///
2643/// `Pixels` is a value type that represents an absolute length in pixels, which is used
2644/// for specifying sizes, positions, and distances in the UI. It is the fundamental unit
2645/// of measurement for all visual elements and layout calculations.
2646///
2647/// The inner value is an `f32`, allowing for sub-pixel precision which can be useful for
2648/// anti-aliasing and animations. However, when applied to actual pixel grids, the value
2649/// is typically rounded to the nearest integer.
2650///
2651/// # Examples
2652///
2653/// ```
2654/// use gpui::{Pixels, ScaledPixels};
2655///
2656/// // Define a length of 10 pixels
2657/// let length = Pixels::from(10.0);
2658///
2659/// // Define a length and scale it by a factor of 2
2660/// let scaled_length = length.scale(2.0);
2661/// assert_eq!(scaled_length, ScaledPixels::from(20.0));
2662/// ```
2663#[derive(
2664    Clone,
2665    Copy,
2666    Default,
2667    Add,
2668    AddAssign,
2669    Sub,
2670    SubAssign,
2671    Neg,
2672    Div,
2673    DivAssign,
2674    PartialEq,
2675    Serialize,
2676    Deserialize,
2677    JsonSchema,
2678)]
2679#[repr(transparent)]
2680pub struct Pixels(pub(crate) f32);
2681
2682impl Div for Pixels {
2683    type Output = f32;
2684
2685    fn div(self, rhs: Self) -> Self::Output {
2686        self.0 / rhs.0
2687    }
2688}
2689
2690impl std::ops::DivAssign for Pixels {
2691    fn div_assign(&mut self, rhs: Self) {
2692        *self = Self(self.0 / rhs.0);
2693    }
2694}
2695
2696impl std::ops::RemAssign for Pixels {
2697    fn rem_assign(&mut self, rhs: Self) {
2698        self.0 %= rhs.0;
2699    }
2700}
2701
2702impl std::ops::Rem for Pixels {
2703    type Output = Self;
2704
2705    fn rem(self, rhs: Self) -> Self {
2706        Self(self.0 % rhs.0)
2707    }
2708}
2709
2710impl Mul<f32> for Pixels {
2711    type Output = Self;
2712
2713    fn mul(self, rhs: f32) -> Self {
2714        Self(self.0 * rhs)
2715    }
2716}
2717
2718impl Mul<Pixels> for f32 {
2719    type Output = Pixels;
2720
2721    fn mul(self, rhs: Pixels) -> Self::Output {
2722        rhs * self
2723    }
2724}
2725
2726impl Mul<usize> for Pixels {
2727    type Output = Self;
2728
2729    fn mul(self, rhs: usize) -> Self {
2730        self * (rhs as f32)
2731    }
2732}
2733
2734impl Mul<Pixels> for usize {
2735    type Output = Pixels;
2736
2737    fn mul(self, rhs: Pixels) -> Pixels {
2738        rhs * self
2739    }
2740}
2741
2742impl MulAssign<f32> for Pixels {
2743    fn mul_assign(&mut self, rhs: f32) {
2744        self.0 *= rhs;
2745    }
2746}
2747
2748impl Display for Pixels {
2749    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2750        write!(f, "{}px", self.0)
2751    }
2752}
2753
2754impl Debug for Pixels {
2755    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2756        Display::fmt(self, f)
2757    }
2758}
2759
2760impl std::iter::Sum for Pixels {
2761    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
2762        iter.fold(Self::ZERO, |a, b| a + b)
2763    }
2764}
2765
2766impl<'a> std::iter::Sum<&'a Pixels> for Pixels {
2767    fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self {
2768        iter.fold(Self::ZERO, |a, b| a + *b)
2769    }
2770}
2771
2772impl TryFrom<&'_ str> for Pixels {
2773    type Error = anyhow::Error;
2774
2775    fn try_from(value: &'_ str) -> Result<Self, Self::Error> {
2776        value
2777            .strip_suffix("px")
2778            .context("expected 'px' suffix")
2779            .and_then(|number| Ok(number.parse()?))
2780            .map(Self)
2781    }
2782}
2783
2784impl Pixels {
2785    /// Represents zero pixels.
2786    pub const ZERO: Pixels = Pixels(0.0);
2787    /// The maximum value that can be represented by `Pixels`.
2788    pub const MAX: Pixels = Pixels(f32::MAX);
2789    /// The minimum value that can be represented by `Pixels`.
2790    pub const MIN: Pixels = Pixels(f32::MIN);
2791
2792    /// Returns the raw `f32` value of this `Pixels`.
2793    pub fn as_f32(self) -> f32 {
2794        self.0
2795    }
2796
2797    /// Floors the `Pixels` value to the nearest whole number.
2798    ///
2799    /// # Returns
2800    ///
2801    /// Returns a new `Pixels` instance with the floored value.
2802    pub fn floor(&self) -> Self {
2803        Self(self.0.floor())
2804    }
2805
2806    /// Rounds the `Pixels` value to the nearest whole number.
2807    ///
2808    /// # Returns
2809    ///
2810    /// Returns a new `Pixels` instance with the rounded value.
2811    pub fn round(&self) -> Self {
2812        Self(self.0.round())
2813    }
2814
2815    /// Returns the ceiling of the `Pixels` value to the nearest whole number.
2816    ///
2817    /// # Returns
2818    ///
2819    /// Returns a new `Pixels` instance with the ceiling value.
2820    pub fn ceil(&self) -> Self {
2821        Self(self.0.ceil())
2822    }
2823
2824    /// Scales the `Pixels` value by a given factor, producing `ScaledPixels`.
2825    ///
2826    /// This method is used when adjusting pixel values for display scaling factors,
2827    /// such as high DPI (dots per inch) or Retina displays, where the pixel density is higher and
2828    /// thus requires scaling to maintain visual consistency and readability.
2829    ///
2830    /// The resulting `ScaledPixels` represent the scaled value which can be used for rendering
2831    /// calculations where display scaling is considered.
2832    #[must_use]
2833    pub fn scale(&self, factor: f32) -> ScaledPixels {
2834        ScaledPixels(self.0 * factor)
2835    }
2836
2837    /// Raises the `Pixels` value to a given power.
2838    ///
2839    /// # Arguments
2840    ///
2841    /// * `exponent` - The exponent to raise the `Pixels` value by.
2842    ///
2843    /// # Returns
2844    ///
2845    /// Returns a new `Pixels` instance with the value raised to the given exponent.
2846    pub fn pow(&self, exponent: f32) -> Self {
2847        Self(self.0.powf(exponent))
2848    }
2849
2850    /// Returns the absolute value of the `Pixels`.
2851    ///
2852    /// # Returns
2853    ///
2854    /// A new `Pixels` instance with the absolute value of the original `Pixels`.
2855    pub fn abs(&self) -> Self {
2856        Self(self.0.abs())
2857    }
2858
2859    /// Returns the sign of the `Pixels` value.
2860    ///
2861    /// # Returns
2862    ///
2863    /// Returns:
2864    /// * `1.0` if the value is positive
2865    /// * `-1.0` if the value is negative
2866    pub fn signum(&self) -> f32 {
2867        self.0.signum()
2868    }
2869
2870    /// Returns the f64 value of `Pixels`.
2871    ///
2872    /// # Returns
2873    ///
2874    /// A f64 value of the `Pixels`.
2875    pub fn to_f64(self) -> f64 {
2876        self.0 as f64
2877    }
2878}
2879
2880impl Eq for Pixels {}
2881
2882impl PartialOrd for Pixels {
2883    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
2884        Some(self.cmp(other))
2885    }
2886}
2887
2888impl Ord for Pixels {
2889    fn cmp(&self, other: &Self) -> cmp::Ordering {
2890        self.0.total_cmp(&other.0)
2891    }
2892}
2893
2894impl std::hash::Hash for Pixels {
2895    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
2896        self.0.to_bits().hash(state);
2897    }
2898}
2899
2900impl From<f64> for Pixels {
2901    fn from(pixels: f64) -> Self {
2902        Pixels(pixels as f32)
2903    }
2904}
2905
2906impl From<f32> for Pixels {
2907    fn from(pixels: f32) -> Self {
2908        Pixels(pixels)
2909    }
2910}
2911
2912impl From<Pixels> for f32 {
2913    fn from(pixels: Pixels) -> Self {
2914        pixels.0
2915    }
2916}
2917
2918impl From<&Pixels> for f32 {
2919    fn from(pixels: &Pixels) -> Self {
2920        pixels.0
2921    }
2922}
2923
2924impl From<Pixels> for f64 {
2925    fn from(pixels: Pixels) -> Self {
2926        pixels.0 as f64
2927    }
2928}
2929
2930impl From<Pixels> for u32 {
2931    fn from(pixels: Pixels) -> Self {
2932        pixels.0 as u32
2933    }
2934}
2935
2936impl From<&Pixels> for u32 {
2937    fn from(pixels: &Pixels) -> Self {
2938        pixels.0 as u32
2939    }
2940}
2941
2942impl From<u32> for Pixels {
2943    fn from(pixels: u32) -> Self {
2944        Pixels(pixels as f32)
2945    }
2946}
2947
2948impl From<Pixels> for usize {
2949    fn from(pixels: Pixels) -> Self {
2950        pixels.0 as usize
2951    }
2952}
2953
2954impl From<usize> for Pixels {
2955    fn from(pixels: usize) -> Self {
2956        Pixels(pixels as f32)
2957    }
2958}
2959
2960/// Represents physical pixels on the display.
2961///
2962/// `DevicePixels` is a unit of measurement that refers to the actual pixels on a device's screen.
2963/// This type is used when precise pixel manipulation is required, such as rendering graphics or
2964/// interfacing with hardware that operates on the pixel level. Unlike logical pixels that may be
2965/// affected by the device's scale factor, `DevicePixels` always correspond to real pixels on the
2966/// display.
2967#[derive(
2968    Add,
2969    AddAssign,
2970    Clone,
2971    Copy,
2972    Default,
2973    Div,
2974    Eq,
2975    Hash,
2976    Ord,
2977    PartialEq,
2978    PartialOrd,
2979    Sub,
2980    SubAssign,
2981    Serialize,
2982    Deserialize,
2983)]
2984#[repr(transparent)]
2985pub struct DevicePixels(pub i32);
2986
2987impl DevicePixels {
2988    /// Converts the `DevicePixels` value to the number of bytes needed to represent it in memory.
2989    ///
2990    /// This function is useful when working with graphical data that needs to be stored in a buffer,
2991    /// such as images or framebuffers, where each pixel may be represented by a specific number of bytes.
2992    ///
2993    /// # Arguments
2994    ///
2995    /// * `bytes_per_pixel` - The number of bytes used to represent a single pixel.
2996    ///
2997    /// # Returns
2998    ///
2999    /// The number of bytes required to represent the `DevicePixels` value in memory.
3000    ///
3001    /// # Examples
3002    ///
3003    /// ```
3004    /// # use gpui::DevicePixels;
3005    /// let pixels = DevicePixels(10); // 10 device pixels
3006    /// let bytes_per_pixel = 4; // Assume each pixel is represented by 4 bytes (e.g., RGBA)
3007    /// let total_bytes = pixels.to_bytes(bytes_per_pixel);
3008    /// assert_eq!(total_bytes, 40); // 10 pixels * 4 bytes/pixel = 40 bytes
3009    /// ```
3010    pub fn to_bytes(self, bytes_per_pixel: u8) -> u32 {
3011        self.0 as u32 * bytes_per_pixel as u32
3012    }
3013}
3014
3015impl fmt::Debug for DevicePixels {
3016    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3017        write!(f, "{} px (device)", self.0)
3018    }
3019}
3020
3021impl From<DevicePixels> for i32 {
3022    fn from(device_pixels: DevicePixels) -> Self {
3023        device_pixels.0
3024    }
3025}
3026
3027impl From<i32> for DevicePixels {
3028    fn from(device_pixels: i32) -> Self {
3029        DevicePixels(device_pixels)
3030    }
3031}
3032
3033impl From<u32> for DevicePixels {
3034    fn from(device_pixels: u32) -> Self {
3035        DevicePixels(device_pixels as i32)
3036    }
3037}
3038
3039impl From<DevicePixels> for u32 {
3040    fn from(device_pixels: DevicePixels) -> Self {
3041        device_pixels.0 as u32
3042    }
3043}
3044
3045impl From<DevicePixels> for u64 {
3046    fn from(device_pixels: DevicePixels) -> Self {
3047        device_pixels.0 as u64
3048    }
3049}
3050
3051impl From<u64> for DevicePixels {
3052    fn from(device_pixels: u64) -> Self {
3053        DevicePixels(device_pixels as i32)
3054    }
3055}
3056
3057impl From<DevicePixels> for usize {
3058    fn from(device_pixels: DevicePixels) -> Self {
3059        device_pixels.0 as usize
3060    }
3061}
3062
3063impl From<usize> for DevicePixels {
3064    fn from(device_pixels: usize) -> Self {
3065        DevicePixels(device_pixels as i32)
3066    }
3067}
3068
3069/// Represents scaled pixels that take into account the device's scale factor.
3070///
3071/// `ScaledPixels` are used to ensure that UI elements appear at the correct size on devices
3072/// with different pixel densities. When a device has a higher scale factor (such as Retina displays),
3073/// a single logical pixel may correspond to multiple physical pixels. By using `ScaledPixels`,
3074/// dimensions and positions can be specified in a way that scales appropriately across different
3075/// display resolutions.
3076#[derive(Clone, Copy, Default, Add, AddAssign, Sub, SubAssign, Div, DivAssign, PartialEq)]
3077#[repr(transparent)]
3078pub struct ScaledPixels(pub f32);
3079
3080impl ScaledPixels {
3081    /// Returns the raw `f32` value of this `ScaledPixels`.
3082    pub fn as_f32(self) -> f32 {
3083        self.0
3084    }
3085
3086    /// Floors the `ScaledPixels` value to the nearest whole number.
3087    ///
3088    /// # Returns
3089    ///
3090    /// Returns a new `ScaledPixels` instance with the floored value.
3091    pub fn floor(&self) -> Self {
3092        Self(self.0.floor())
3093    }
3094
3095    /// Rounds the `ScaledPixels` value to the nearest whole number.
3096    ///
3097    /// # Returns
3098    ///
3099    /// Returns a new `ScaledPixels` instance with the rounded value.
3100    pub fn round(&self) -> Self {
3101        Self(self.0.round())
3102    }
3103
3104    /// Ceils the `ScaledPixels` value to the nearest whole number.
3105    ///
3106    /// # Returns
3107    ///
3108    /// Returns a new `ScaledPixels` instance with the ceiled value.
3109    pub fn ceil(&self) -> Self {
3110        Self(self.0.ceil())
3111    }
3112}
3113
3114impl Eq for ScaledPixels {}
3115
3116impl PartialOrd for ScaledPixels {
3117    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
3118        Some(self.cmp(other))
3119    }
3120}
3121
3122impl Ord for ScaledPixels {
3123    fn cmp(&self, other: &Self) -> cmp::Ordering {
3124        self.0.total_cmp(&other.0)
3125    }
3126}
3127
3128impl Debug for ScaledPixels {
3129    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3130        write!(f, "{}px (scaled)", self.0)
3131    }
3132}
3133
3134impl From<ScaledPixels> for DevicePixels {
3135    fn from(scaled: ScaledPixels) -> Self {
3136        DevicePixels(scaled.0.ceil() as i32)
3137    }
3138}
3139
3140impl From<DevicePixels> for ScaledPixels {
3141    fn from(device: DevicePixels) -> Self {
3142        ScaledPixels(device.0 as f32)
3143    }
3144}
3145
3146impl From<ScaledPixels> for f64 {
3147    fn from(scaled_pixels: ScaledPixels) -> Self {
3148        scaled_pixels.0 as f64
3149    }
3150}
3151
3152impl From<ScaledPixels> for u32 {
3153    fn from(pixels: ScaledPixels) -> Self {
3154        pixels.0 as u32
3155    }
3156}
3157
3158impl From<f32> for ScaledPixels {
3159    fn from(pixels: f32) -> Self {
3160        Self(pixels)
3161    }
3162}
3163
3164impl Div for ScaledPixels {
3165    type Output = f32;
3166
3167    fn div(self, rhs: Self) -> Self::Output {
3168        self.0 / rhs.0
3169    }
3170}
3171
3172impl std::ops::DivAssign for ScaledPixels {
3173    fn div_assign(&mut self, rhs: Self) {
3174        *self = Self(self.0 / rhs.0);
3175    }
3176}
3177
3178impl std::ops::RemAssign for ScaledPixels {
3179    fn rem_assign(&mut self, rhs: Self) {
3180        self.0 %= rhs.0;
3181    }
3182}
3183
3184impl std::ops::Rem for ScaledPixels {
3185    type Output = Self;
3186
3187    fn rem(self, rhs: Self) -> Self {
3188        Self(self.0 % rhs.0)
3189    }
3190}
3191
3192impl Mul<f32> for ScaledPixels {
3193    type Output = Self;
3194
3195    fn mul(self, rhs: f32) -> Self {
3196        Self(self.0 * rhs)
3197    }
3198}
3199
3200impl Mul<ScaledPixels> for f32 {
3201    type Output = ScaledPixels;
3202
3203    fn mul(self, rhs: ScaledPixels) -> Self::Output {
3204        rhs * self
3205    }
3206}
3207
3208impl Mul<usize> for ScaledPixels {
3209    type Output = Self;
3210
3211    fn mul(self, rhs: usize) -> Self {
3212        self * (rhs as f32)
3213    }
3214}
3215
3216impl Mul<ScaledPixels> for usize {
3217    type Output = ScaledPixels;
3218
3219    fn mul(self, rhs: ScaledPixels) -> ScaledPixels {
3220        rhs * self
3221    }
3222}
3223
3224impl MulAssign<f32> for ScaledPixels {
3225    fn mul_assign(&mut self, rhs: f32) {
3226        self.0 *= rhs;
3227    }
3228}
3229
3230/// 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].
3231///
3232/// Rems are used for defining lengths that are scalable and consistent across different UI elements.
3233/// The value of `1rem` is typically equal to the font-size of the root element (often the `<html>` element in browsers),
3234/// making it a flexible unit that adapts to the user's text size preferences. In this framework, `rems` serve a similar
3235/// purpose, allowing for scalable and accessible design that can adjust to different display settings or user preferences.
3236///
3237/// For example, if the root element's font-size is `16px`, then `1rem` equals `16px`. A length of `2rems` would then be `32px`.
3238///
3239/// [set_rem_size]: crate::Window::set_rem_size
3240#[derive(Clone, Copy, Default, Add, Sub, Mul, Div, Neg, PartialEq)]
3241pub struct Rems(pub f32);
3242
3243impl Rems {
3244    /// A length of zero.
3245    pub const ZERO: Self = Self(0.0);
3246    /// Convert this Rem value to pixels.
3247    pub fn to_pixels(self, rem_size: Pixels) -> Pixels {
3248        self * rem_size
3249    }
3250    /// Convert from pixels to Rem
3251    pub fn from_pixels(length: Pixels, window: &gpui::Window) -> Self {
3252        Self(length / window.rem_size())
3253    }
3254}
3255
3256impl Mul<Pixels> for Rems {
3257    type Output = Pixels;
3258
3259    fn mul(self, other: Pixels) -> Pixels {
3260        Pixels(self.0 * other.0)
3261    }
3262}
3263
3264impl AddAssign<Rems> for Rems {
3265    fn add_assign(&mut self, rhs: Rems) {
3266        self.0 += rhs.0
3267    }
3268}
3269
3270impl Display for Rems {
3271    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3272        write!(f, "{}rem", self.0)
3273    }
3274}
3275
3276impl Debug for Rems {
3277    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3278        Display::fmt(self, f)
3279    }
3280}
3281
3282impl TryFrom<&'_ str> for Rems {
3283    type Error = anyhow::Error;
3284
3285    fn try_from(value: &'_ str) -> Result<Self, Self::Error> {
3286        value
3287            .strip_suffix("rem")
3288            .context("expected 'rem' suffix")
3289            .and_then(|number| Ok(number.parse()?))
3290            .map(Self)
3291    }
3292}
3293
3294/// Represents an absolute length in pixels or rems.
3295///
3296/// `AbsoluteLength` can be either a fixed number of pixels, which is an absolute measurement not
3297/// affected by the current font size, or a number of rems, which is relative to the font size of
3298/// the root element. It is used for specifying dimensions that are either independent of or
3299/// related to the typographic scale.
3300#[derive(Clone, Copy, Neg, PartialEq)]
3301pub enum AbsoluteLength {
3302    /// A length in pixels.
3303    Pixels(Pixels),
3304    /// A length in rems.
3305    Rems(Rems),
3306}
3307
3308impl AbsoluteLength {
3309    /// Checks if the absolute length is zero.
3310    pub fn is_zero(&self) -> bool {
3311        match self {
3312            AbsoluteLength::Pixels(px) => px.0 == 0.0,
3313            AbsoluteLength::Rems(rems) => rems.0 == 0.0,
3314        }
3315    }
3316}
3317
3318impl From<Pixels> for AbsoluteLength {
3319    fn from(pixels: Pixels) -> Self {
3320        AbsoluteLength::Pixels(pixels)
3321    }
3322}
3323
3324impl From<Rems> for AbsoluteLength {
3325    fn from(rems: Rems) -> Self {
3326        AbsoluteLength::Rems(rems)
3327    }
3328}
3329
3330impl AbsoluteLength {
3331    /// Converts an `AbsoluteLength` to `Pixels` based on a given `rem_size`.
3332    ///
3333    /// # Arguments
3334    ///
3335    /// * `rem_size` - The size of one rem in pixels.
3336    ///
3337    /// # Returns
3338    ///
3339    /// Returns the `AbsoluteLength` as `Pixels`.
3340    ///
3341    /// # Examples
3342    ///
3343    /// ```
3344    /// # use gpui::{AbsoluteLength, Pixels, Rems};
3345    /// let length_in_pixels = AbsoluteLength::Pixels(Pixels::from(42.0));
3346    /// let length_in_rems = AbsoluteLength::Rems(Rems(2.0));
3347    /// let rem_size = Pixels::from(16.0);
3348    ///
3349    /// assert_eq!(length_in_pixels.to_pixels(rem_size), Pixels::from(42.0));
3350    /// assert_eq!(length_in_rems.to_pixels(rem_size), Pixels::from(32.0));
3351    /// ```
3352    pub fn to_pixels(self, rem_size: Pixels) -> Pixels {
3353        match self {
3354            AbsoluteLength::Pixels(pixels) => pixels,
3355            AbsoluteLength::Rems(rems) => rems.to_pixels(rem_size),
3356        }
3357    }
3358
3359    /// Converts an `AbsoluteLength` to `Rems` based on a given `rem_size`.
3360    ///
3361    /// # Arguments
3362    ///
3363    /// * `rem_size` - The size of one rem in pixels.
3364    ///
3365    /// # Returns
3366    ///
3367    /// Returns the `AbsoluteLength` as `Pixels`.
3368    pub fn to_rems(self, rem_size: Pixels) -> Rems {
3369        match self {
3370            AbsoluteLength::Pixels(pixels) => Rems(pixels.0 / rem_size.0),
3371            AbsoluteLength::Rems(rems) => rems,
3372        }
3373    }
3374}
3375
3376impl Default for AbsoluteLength {
3377    fn default() -> Self {
3378        px(0.).into()
3379    }
3380}
3381
3382impl Display for AbsoluteLength {
3383    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3384        match self {
3385            Self::Pixels(pixels) => write!(f, "{pixels}"),
3386            Self::Rems(rems) => write!(f, "{rems}"),
3387        }
3388    }
3389}
3390
3391impl Debug for AbsoluteLength {
3392    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3393        Display::fmt(self, f)
3394    }
3395}
3396
3397const EXPECTED_ABSOLUTE_LENGTH: &str = "number with 'px' or 'rem' suffix";
3398
3399impl TryFrom<&'_ str> for AbsoluteLength {
3400    type Error = anyhow::Error;
3401
3402    fn try_from(value: &'_ str) -> Result<Self, Self::Error> {
3403        if let Ok(pixels) = value.try_into() {
3404            Ok(Self::Pixels(pixels))
3405        } else if let Ok(rems) = value.try_into() {
3406            Ok(Self::Rems(rems))
3407        } else {
3408            Err(anyhow!(
3409                "invalid AbsoluteLength '{value}', expected {EXPECTED_ABSOLUTE_LENGTH}"
3410            ))
3411        }
3412    }
3413}
3414
3415impl JsonSchema for AbsoluteLength {
3416    fn schema_name() -> Cow<'static, str> {
3417        "AbsoluteLength".into()
3418    }
3419
3420    fn json_schema(_generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
3421        json_schema!({
3422            "type": "string",
3423            "pattern": r"^-?\d+(\.\d+)?(px|rem)$"
3424        })
3425    }
3426}
3427
3428impl<'de> Deserialize<'de> for AbsoluteLength {
3429    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3430        struct StringVisitor;
3431
3432        impl de::Visitor<'_> for StringVisitor {
3433            type Value = AbsoluteLength;
3434
3435            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
3436                write!(f, "{EXPECTED_ABSOLUTE_LENGTH}")
3437            }
3438
3439            fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> {
3440                AbsoluteLength::try_from(value).map_err(E::custom)
3441            }
3442        }
3443
3444        deserializer.deserialize_str(StringVisitor)
3445    }
3446}
3447
3448impl Serialize for AbsoluteLength {
3449    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3450    where
3451        S: Serializer,
3452    {
3453        serializer.serialize_str(&format!("{self}"))
3454    }
3455}
3456
3457/// A non-auto length that can be defined in pixels, rems, or percent of parent.
3458///
3459/// This enum represents lengths that have a specific value, as opposed to lengths that are automatically
3460/// determined by the context. It includes absolute lengths in pixels or rems, and relative lengths as a
3461/// fraction of the parent's size.
3462#[derive(Clone, Copy, Neg, PartialEq)]
3463pub enum DefiniteLength {
3464    /// An absolute length specified in pixels or rems.
3465    Absolute(AbsoluteLength),
3466    /// A relative length specified as a fraction of the parent's size, between 0 and 1.
3467    Fraction(f32),
3468}
3469
3470impl DefiniteLength {
3471    /// Converts the `DefiniteLength` to `Pixels` based on a given `base_size` and `rem_size`.
3472    ///
3473    /// If the `DefiniteLength` is an absolute length, it will be directly converted to `Pixels`.
3474    /// If it is a fraction, the fraction will be multiplied by the `base_size` to get the length in pixels.
3475    ///
3476    /// # Arguments
3477    ///
3478    /// * `base_size` - The base size in `AbsoluteLength` to which the fraction will be applied.
3479    /// * `rem_size` - The size of one rem in pixels, used to convert rems to pixels.
3480    ///
3481    /// # Returns
3482    ///
3483    /// Returns the `DefiniteLength` as `Pixels`.
3484    ///
3485    /// # Examples
3486    ///
3487    /// ```
3488    /// # use gpui::{DefiniteLength, AbsoluteLength, Pixels, px, rems};
3489    /// let length_in_pixels = DefiniteLength::Absolute(AbsoluteLength::Pixels(px(42.0)));
3490    /// let length_in_rems = DefiniteLength::Absolute(AbsoluteLength::Rems(rems(2.0)));
3491    /// let length_as_fraction = DefiniteLength::Fraction(0.5);
3492    /// let base_size = AbsoluteLength::Pixels(px(100.0));
3493    /// let rem_size = px(16.0);
3494    ///
3495    /// assert_eq!(length_in_pixels.to_pixels(base_size, rem_size), Pixels::from(42.0));
3496    /// assert_eq!(length_in_rems.to_pixels(base_size, rem_size), Pixels::from(32.0));
3497    /// assert_eq!(length_as_fraction.to_pixels(base_size, rem_size), Pixels::from(50.0));
3498    /// ```
3499    pub fn to_pixels(self, base_size: AbsoluteLength, rem_size: Pixels) -> Pixels {
3500        match self {
3501            DefiniteLength::Absolute(size) => size.to_pixels(rem_size),
3502            DefiniteLength::Fraction(fraction) => match base_size {
3503                AbsoluteLength::Pixels(px) => px * fraction,
3504                AbsoluteLength::Rems(rems) => rems * rem_size * fraction,
3505            },
3506        }
3507    }
3508}
3509
3510impl Debug for DefiniteLength {
3511    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3512        Display::fmt(self, f)
3513    }
3514}
3515
3516impl Display for DefiniteLength {
3517    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3518        match self {
3519            DefiniteLength::Absolute(length) => write!(f, "{length}"),
3520            DefiniteLength::Fraction(fraction) => write!(f, "{}%", (fraction * 100.0) as i32),
3521        }
3522    }
3523}
3524
3525const EXPECTED_DEFINITE_LENGTH: &str = "expected number with 'px', 'rem', or '%' suffix";
3526
3527impl TryFrom<&'_ str> for DefiniteLength {
3528    type Error = anyhow::Error;
3529
3530    fn try_from(value: &'_ str) -> Result<Self, Self::Error> {
3531        if let Some(percentage) = value.strip_suffix('%') {
3532            let fraction: f32 = percentage.parse::<f32>().with_context(|| {
3533                format!("invalid DefiniteLength '{value}', expected {EXPECTED_DEFINITE_LENGTH}")
3534            })?;
3535            Ok(DefiniteLength::Fraction(fraction / 100.0))
3536        } else if let Ok(absolute_length) = value.try_into() {
3537            Ok(DefiniteLength::Absolute(absolute_length))
3538        } else {
3539            Err(anyhow!(
3540                "invalid DefiniteLength '{value}', expected {EXPECTED_DEFINITE_LENGTH}"
3541            ))
3542        }
3543    }
3544}
3545
3546impl JsonSchema for DefiniteLength {
3547    fn schema_name() -> Cow<'static, str> {
3548        "DefiniteLength".into()
3549    }
3550
3551    fn json_schema(_generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
3552        json_schema!({
3553            "type": "string",
3554            "pattern": r"^-?\d+(\.\d+)?(px|rem|%)$"
3555        })
3556    }
3557}
3558
3559impl<'de> Deserialize<'de> for DefiniteLength {
3560    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3561        struct StringVisitor;
3562
3563        impl de::Visitor<'_> for StringVisitor {
3564            type Value = DefiniteLength;
3565
3566            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
3567                write!(f, "{EXPECTED_DEFINITE_LENGTH}")
3568            }
3569
3570            fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> {
3571                DefiniteLength::try_from(value).map_err(E::custom)
3572            }
3573        }
3574
3575        deserializer.deserialize_str(StringVisitor)
3576    }
3577}
3578
3579impl Serialize for DefiniteLength {
3580    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3581    where
3582        S: Serializer,
3583    {
3584        serializer.serialize_str(&format!("{self}"))
3585    }
3586}
3587
3588impl From<Pixels> for DefiniteLength {
3589    fn from(pixels: Pixels) -> Self {
3590        Self::Absolute(pixels.into())
3591    }
3592}
3593
3594impl From<Rems> for DefiniteLength {
3595    fn from(rems: Rems) -> Self {
3596        Self::Absolute(rems.into())
3597    }
3598}
3599
3600impl From<AbsoluteLength> for DefiniteLength {
3601    fn from(length: AbsoluteLength) -> Self {
3602        Self::Absolute(length)
3603    }
3604}
3605
3606impl Default for DefiniteLength {
3607    fn default() -> Self {
3608        Self::Absolute(AbsoluteLength::default())
3609    }
3610}
3611
3612/// A length that can be defined in pixels, rems, percent of parent, or auto.
3613#[derive(Clone, Copy, PartialEq)]
3614pub enum Length {
3615    /// A definite length specified either in pixels, rems, or as a fraction of the parent's size.
3616    Definite(DefiniteLength),
3617    /// An automatic length that is determined by the context in which it is used.
3618    Auto,
3619}
3620
3621impl Debug for Length {
3622    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3623        Display::fmt(self, f)
3624    }
3625}
3626
3627impl Display for Length {
3628    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3629        match self {
3630            Length::Definite(definite_length) => write!(f, "{}", definite_length),
3631            Length::Auto => write!(f, "auto"),
3632        }
3633    }
3634}
3635
3636const EXPECTED_LENGTH: &str = "expected 'auto' or number with 'px', 'rem', or '%' suffix";
3637
3638impl TryFrom<&'_ str> for Length {
3639    type Error = anyhow::Error;
3640
3641    fn try_from(value: &'_ str) -> Result<Self, Self::Error> {
3642        if value == "auto" {
3643            Ok(Length::Auto)
3644        } else if let Ok(definite_length) = value.try_into() {
3645            Ok(Length::Definite(definite_length))
3646        } else {
3647            Err(anyhow!(
3648                "invalid Length '{value}', expected {EXPECTED_LENGTH}"
3649            ))
3650        }
3651    }
3652}
3653
3654impl JsonSchema for Length {
3655    fn schema_name() -> Cow<'static, str> {
3656        "Length".into()
3657    }
3658
3659    fn json_schema(_generator: &mut schemars::SchemaGenerator) -> schemars::Schema {
3660        json_schema!({
3661            "type": "string",
3662            "pattern": r"^(auto|-?\d+(\.\d+)?(px|rem|%))$"
3663        })
3664    }
3665}
3666
3667impl<'de> Deserialize<'de> for Length {
3668    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3669        struct StringVisitor;
3670
3671        impl de::Visitor<'_> for StringVisitor {
3672            type Value = Length;
3673
3674            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
3675                write!(f, "{EXPECTED_LENGTH}")
3676            }
3677
3678            fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> {
3679                Length::try_from(value).map_err(E::custom)
3680            }
3681        }
3682
3683        deserializer.deserialize_str(StringVisitor)
3684    }
3685}
3686
3687impl Serialize for Length {
3688    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3689    where
3690        S: Serializer,
3691    {
3692        serializer.serialize_str(&format!("{self}"))
3693    }
3694}
3695
3696/// Constructs a `DefiniteLength` representing a relative fraction of a parent size.
3697///
3698/// This function creates a `DefiniteLength` that is a specified fraction of a parent's dimension.
3699/// The fraction should be a floating-point number between 0.0 and 1.0, where 1.0 represents 100% of the parent's size.
3700///
3701/// # Arguments
3702///
3703/// * `fraction` - The fraction of the parent's size, between 0.0 and 1.0.
3704///
3705/// # Returns
3706///
3707/// A `DefiniteLength` representing the relative length as a fraction of the parent's size.
3708pub const fn relative(fraction: f32) -> DefiniteLength {
3709    DefiniteLength::Fraction(fraction)
3710}
3711
3712/// Returns the Golden Ratio, i.e. `~(1.0 + sqrt(5.0)) / 2.0`.
3713pub const fn phi() -> DefiniteLength {
3714    relative(1.618_034)
3715}
3716
3717/// Constructs a `Rems` value representing a length in rems.
3718///
3719/// # Arguments
3720///
3721/// * `rems` - The number of rems for the length.
3722///
3723/// # Returns
3724///
3725/// A `Rems` representing the specified number of rems.
3726pub const fn rems(rems: f32) -> Rems {
3727    Rems(rems)
3728}
3729
3730/// Constructs a `Pixels` value representing a length in pixels.
3731///
3732/// # Arguments
3733///
3734/// * `pixels` - The number of pixels for the length.
3735///
3736/// # Returns
3737///
3738/// A `Pixels` representing the specified number of pixels.
3739pub const fn px(pixels: f32) -> Pixels {
3740    Pixels(pixels)
3741}
3742
3743/// Returns a `Length` representing an automatic length.
3744///
3745/// The `auto` length is often used in layout calculations where the length should be determined
3746/// by the layout context itself rather than being explicitly set. This is commonly used in CSS
3747/// for properties like `width`, `height`, `margin`, `padding`, etc., where `auto` can be used
3748/// to instruct the layout engine to calculate the size based on other factors like the size of the
3749/// container or the intrinsic size of the content.
3750///
3751/// # Returns
3752///
3753/// A `Length` variant set to `Auto`.
3754pub const fn auto() -> Length {
3755    Length::Auto
3756}
3757
3758impl From<Pixels> for Length {
3759    fn from(pixels: Pixels) -> Self {
3760        Self::Definite(pixels.into())
3761    }
3762}
3763
3764impl From<Rems> for Length {
3765    fn from(rems: Rems) -> Self {
3766        Self::Definite(rems.into())
3767    }
3768}
3769
3770impl From<DefiniteLength> for Length {
3771    fn from(length: DefiniteLength) -> Self {
3772        Self::Definite(length)
3773    }
3774}
3775
3776impl From<AbsoluteLength> for Length {
3777    fn from(length: AbsoluteLength) -> Self {
3778        Self::Definite(length.into())
3779    }
3780}
3781
3782impl Default for Length {
3783    fn default() -> Self {
3784        Self::Definite(DefiniteLength::default())
3785    }
3786}
3787
3788impl From<()> for Length {
3789    fn from(_: ()) -> Self {
3790        Self::Definite(DefiniteLength::default())
3791    }
3792}
3793
3794/// A location in a grid layout.
3795#[derive(Clone, PartialEq, Debug, Serialize, Deserialize, JsonSchema, Default)]
3796pub struct GridLocation {
3797    /// The rows this item uses within the grid.
3798    pub row: Range<GridPlacement>,
3799    /// The columns this item uses within the grid.
3800    pub column: Range<GridPlacement>,
3801}
3802
3803/// The placement of an item within a grid layout's column or row.
3804#[derive(Clone, Copy, PartialEq, Debug, Serialize, Deserialize, JsonSchema, Default)]
3805pub enum GridPlacement {
3806    /// The grid line index to place this item.
3807    Line(i16),
3808    /// The number of grid lines to span.
3809    Span(u16),
3810    /// Automatically determine the placement, equivalent to Span(1)
3811    #[default]
3812    Auto,
3813}
3814
3815impl From<GridPlacement> for taffy::GridPlacement {
3816    fn from(placement: GridPlacement) -> Self {
3817        match placement {
3818            GridPlacement::Line(index) => taffy::GridPlacement::from_line_index(index),
3819            GridPlacement::Span(span) => taffy::GridPlacement::from_span(span),
3820            GridPlacement::Auto => taffy::GridPlacement::Auto,
3821        }
3822    }
3823}
3824
3825/// Provides a trait for types that can calculate half of their value.
3826///
3827/// The `Half` trait is used for types that can be evenly divided, returning a new instance of the same type
3828/// representing half of the original value. This is commonly used for types that represent measurements or sizes,
3829/// such as lengths or pixels, where halving is a frequent operation during layout calculations or animations.
3830pub trait Half {
3831    /// Returns half of the current value.
3832    ///
3833    /// # Returns
3834    ///
3835    /// A new instance of the implementing type, representing half of the original value.
3836    fn half(&self) -> Self;
3837}
3838
3839impl Half for i32 {
3840    fn half(&self) -> Self {
3841        self / 2
3842    }
3843}
3844
3845impl Half for f32 {
3846    fn half(&self) -> Self {
3847        self / 2.
3848    }
3849}
3850
3851impl Half for DevicePixels {
3852    fn half(&self) -> Self {
3853        Self(self.0 / 2)
3854    }
3855}
3856
3857impl Half for ScaledPixels {
3858    fn half(&self) -> Self {
3859        Self(self.0 / 2.)
3860    }
3861}
3862
3863impl Half for Pixels {
3864    fn half(&self) -> Self {
3865        Self(self.0 / 2.)
3866    }
3867}
3868
3869impl Half for Rems {
3870    fn half(&self) -> Self {
3871        Self(self.0 / 2.)
3872    }
3873}
3874
3875/// A trait for checking if a value is zero.
3876///
3877/// This trait provides a method to determine if a value is considered to be zero.
3878/// It is implemented for various numeric and length-related types where the concept
3879/// of zero is applicable. This can be useful for comparisons, optimizations, or
3880/// determining if an operation has a neutral effect.
3881pub trait IsZero {
3882    /// Determines if the value is zero.
3883    ///
3884    /// # Returns
3885    ///
3886    /// Returns `true` if the value is zero, `false` otherwise.
3887    fn is_zero(&self) -> bool;
3888}
3889
3890impl IsZero for DevicePixels {
3891    fn is_zero(&self) -> bool {
3892        self.0 == 0
3893    }
3894}
3895
3896impl IsZero for ScaledPixels {
3897    fn is_zero(&self) -> bool {
3898        self.0 == 0.
3899    }
3900}
3901
3902impl IsZero for Pixels {
3903    fn is_zero(&self) -> bool {
3904        self.0 == 0.
3905    }
3906}
3907
3908impl IsZero for Rems {
3909    fn is_zero(&self) -> bool {
3910        self.0 == 0.
3911    }
3912}
3913
3914impl IsZero for AbsoluteLength {
3915    fn is_zero(&self) -> bool {
3916        match self {
3917            AbsoluteLength::Pixels(pixels) => pixels.is_zero(),
3918            AbsoluteLength::Rems(rems) => rems.is_zero(),
3919        }
3920    }
3921}
3922
3923impl IsZero for DefiniteLength {
3924    fn is_zero(&self) -> bool {
3925        match self {
3926            DefiniteLength::Absolute(length) => length.is_zero(),
3927            DefiniteLength::Fraction(fraction) => *fraction == 0.,
3928        }
3929    }
3930}
3931
3932impl IsZero for Length {
3933    fn is_zero(&self) -> bool {
3934        match self {
3935            Length::Definite(length) => length.is_zero(),
3936            Length::Auto => false,
3937        }
3938    }
3939}
3940
3941impl<T: IsZero + Clone + Debug + Default + PartialEq> IsZero for Point<T> {
3942    fn is_zero(&self) -> bool {
3943        self.x.is_zero() && self.y.is_zero()
3944    }
3945}
3946
3947impl<T> IsZero for Size<T>
3948where
3949    T: IsZero + Clone + Debug + Default + PartialEq,
3950{
3951    fn is_zero(&self) -> bool {
3952        self.width.is_zero() || self.height.is_zero()
3953    }
3954}
3955
3956impl<T: IsZero + Clone + Debug + Default + PartialEq> IsZero for Bounds<T> {
3957    fn is_zero(&self) -> bool {
3958        self.size.is_zero()
3959    }
3960}
3961
3962impl<T> IsZero for Corners<T>
3963where
3964    T: IsZero + Clone + Debug + Default + PartialEq,
3965{
3966    fn is_zero(&self) -> bool {
3967        self.top_left.is_zero()
3968            && self.top_right.is_zero()
3969            && self.bottom_right.is_zero()
3970            && self.bottom_left.is_zero()
3971    }
3972}
3973
3974#[cfg(test)]
3975mod tests {
3976    use super::*;
3977
3978    #[crate::test]
3979    fn test_centered_window_is_clamped_to_display(cx: &mut crate::TestAppContext) {
3980        cx.update(|cx| {
3981            let display = cx.primary_display().unwrap();
3982            let visible = display.visible_bounds();
3983            assert_eq!(
3984                Bounds::centered(
3985                    None,
3986                    size(visible.size.width * 2., visible.size.height * 2.),
3987                    cx
3988                ),
3989                visible
3990            );
3991            let small = visible.size / 2.;
3992            assert_eq!(
3993                Bounds::centered(Some(display.id()), small, cx),
3994                Bounds::centered_at(visible.center(), small)
3995            );
3996            assert_eq!(
3997                Bounds::centered(Some(DisplayId(u64::MAX)), small, cx),
3998                Bounds::centered_at(visible.center(), small)
3999            );
4000        });
4001    }
4002
4003    #[test]
4004    fn test_bounds_intersects() {
4005        let bounds1 = Bounds {
4006            origin: Point { x: 0.0, y: 0.0 },
4007            size: Size {
4008                width: 5.0,
4009                height: 5.0,
4010            },
4011        };
4012        let bounds2 = Bounds {
4013            origin: Point { x: 4.0, y: 4.0 },
4014            size: Size {
4015                width: 5.0,
4016                height: 5.0,
4017            },
4018        };
4019        let bounds3 = Bounds {
4020            origin: Point { x: 10.0, y: 10.0 },
4021            size: Size {
4022                width: 5.0,
4023                height: 5.0,
4024            },
4025        };
4026
4027        // Test Case 1: Intersecting bounds
4028        assert!(bounds1.intersects(&bounds2));
4029
4030        // Test Case 2: Non-Intersecting bounds
4031        assert!(!bounds1.intersects(&bounds3));
4032
4033        // Test Case 3: Bounds intersecting with themselves
4034        assert!(bounds1.intersects(&bounds1));
4035    }
4036}