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