Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Make all geometry types Default to support movement-based refinement

Browse source
This commit is contained in:
Nathan Sobo 2023-10-13 12:41:00 -06:00
parent fedb787b4f
commit 297b6b282c
4 changed files with 170 additions and 83 deletions
Download patch file Download diff file Expand all files Collapse all files

188
crates/gpui3/src/geometry.rs
View file

@ -2,28 +2,29 @@ use core::fmt::Debug;
use derive_more::{Add, AddAssign, Div, Mul, Neg, Sub, SubAssign}; use derive_more::{Add, AddAssign, Div, Mul, Neg, Sub, SubAssign};
use refineable::Refineable; use refineable::Refineable;
use std::{ use std::{
cmp, fmt, cmp::{self, PartialOrd},
fmt,
ops::{Add, AddAssign, Div, Mul, MulAssign, Sub, SubAssign}, ops::{Add, AddAssign, Div, Mul, MulAssign, Sub, SubAssign},
}; };
#[derive(Refineable, Default, Add, AddAssign, Sub, SubAssign, Copy, Debug, PartialEq, Eq, Hash)] #[derive(Refineable, Default, Add, AddAssign, Sub, SubAssign, Copy, Debug, PartialEq, Eq, Hash)]
#[refineable(debug)] #[refineable(debug)]
#[repr(C)] #[repr(C)]
pub struct Point<T: Clone + Debug> { pub struct Point<T: Default + Clone + Debug> {
pub x: T, pub x: T,
pub y: T, pub y: T,
} }
pub fn point<T: Clone + Debug>(x: T, y: T) -> Point<T> { pub fn point<T: Clone + Debug + Default>(x: T, y: T) -> Point<T> {
Point { x, y } Point { x, y }
} }
impl<T: Clone + Debug> Point<T> { impl<T: Clone + Debug + Default> Point<T> {
pub fn new(x: T, y: T) -> Self { pub fn new(x: T, y: T) -> Self {
Self { x, y } Self { x, y }
} }
pub fn map<U: Clone + Debug, F: Fn(T) -> U>(&self, f: F) -> Point<U> { pub fn map<U: Clone + Default + Debug>(&self, f: impl Fn(T) -> U) -> Point<U> {
Point { Point {
x: f(self.x.clone()), x: f(self.x.clone()),
y: f(self.y.clone()), y: f(self.y.clone()),
@ -42,7 +43,7 @@ impl Point<Pixels> {
impl<T, Rhs> Mul<Rhs> for Point<T> impl<T, Rhs> Mul<Rhs> for Point<T>
where where
T: Mul<Rhs, Output = T> + Clone + Debug, T: Mul<Rhs, Output = T> + Clone + Default + Debug,
Rhs: Clone + Debug, Rhs: Clone + Debug,
{ {
type Output = Point<T>; type Output = Point<T>;
@ -55,28 +56,42 @@ where
} }
} }
impl<T: Clone + Debug + Mul<S, Output = T>, S: Clone> MulAssign<S> for Point<T> { impl<T, S> MulAssign<S> for Point<T>
where
T: Clone + Mul<S, Output = T> + Default + Debug,
S: Clone,
{
fn mul_assign(&mut self, rhs: S) { fn mul_assign(&mut self, rhs: S) {
self.x = self.x.clone() * rhs.clone(); self.x = self.x.clone() * rhs.clone();
self.y = self.y.clone() * rhs; self.y = self.y.clone() * rhs;
} }
} }
impl<T: Clone + Debug + Sub<Output = T>> SubAssign<Size<T>> for Point<T> { impl<T> SubAssign<Size<T>> for Point<T>
where
T: Sub<Output = T> + Clone + Debug + Default,
{
fn sub_assign(&mut self, rhs: Size<T>) { fn sub_assign(&mut self, rhs: Size<T>) {
self.x = self.x.clone() - rhs.width; self.x = self.x.clone() - rhs.width;
self.y = self.y.clone() - rhs.height; self.y = self.y.clone() - rhs.height;
} }
} }
impl<T: Clone + Debug + Add<Output = T> + Copy> AddAssign<T> for Point<T> { impl<T> AddAssign<T> for Point<T>
where
T: Add<Output = T> + Clone + Default + Debug,
{
fn add_assign(&mut self, rhs: T) { fn add_assign(&mut self, rhs: T) {
self.x = self.x.clone() + rhs; self.x = self.x.clone() + rhs.clone();
self.y = self.y.clone() + rhs; self.y = self.y.clone() + rhs;
} }
} }
impl<T: Clone + Debug + Div<S, Output = T>, S: Clone> Div<S> for Point<T> { impl<T, S> Div<S> for Point<T>
where
T: Div<S, Output = T> + Clone + Default + Debug,
S: Clone,
{
type Output = Self; type Output = Self;
fn div(self, rhs: S) -> Self::Output { fn div(self, rhs: S) -> Self::Output {
@ -87,7 +102,10 @@ impl<T: Clone + Debug + Div<S, Output = T>, S: Clone> Div<S> for Point<T> {
} }
} }
impl<T: Clone + Debug + cmp::PartialOrd> Point<T> { impl<T> Point<T>
where
T: PartialOrd + Clone + Default + Debug,
{
pub fn max(&self, other: &Self) -> Self { pub fn max(&self, other: &Self) -> Self {
Point { Point {
x: if self.x >= other.x { x: if self.x >= other.x {
@ -119,7 +137,7 @@ impl<T: Clone + Debug + cmp::PartialOrd> Point<T> {
} }
} }
impl<T: Clone + Debug> Clone for Point<T> { impl<T: Clone + Default + Debug> Clone for Point<T> {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
x: self.x.clone(), x: self.x.clone(),
@ -131,17 +149,26 @@ impl<T: Clone + Debug> Clone for Point<T> {
#[derive(Refineable, Default, Clone, Copy, PartialEq, Div, Hash)] #[derive(Refineable, Default, Clone, Copy, PartialEq, Div, Hash)]
#[refineable(debug)] #[refineable(debug)]
#[repr(C)] #[repr(C)]
pub struct Size<T: Clone + Debug> { pub struct Size<T: Clone + Default + Debug> {
pub width: T, pub width: T,
pub height: T, pub height: T,
} }
pub fn size<T: Clone + Debug>(width: T, height: T) -> Size<T> { pub fn size<T>(width: T, height: T) -> Size<T>
where
T: Clone + Default + Debug,
{
Size { width, height } Size { width, height }
} }
impl<T: Clone + Debug> Size<T> { impl<T> Size<T>
pub fn map<U: Clone + Debug, F: Fn(T) -> U>(&self, f: F) -> Size<U> { where
T: Clone + Default + Debug,
{
pub fn map<U>(&self, f: impl Fn(T) -> U) -> Size<U>
where
U: Clone + Default + Debug,
{
Size { Size {
width: f(self.width.clone()), width: f(self.width.clone()),
height: f(self.height.clone()), height: f(self.height.clone()),
@ -158,7 +185,10 @@ impl Size<Pixels> {
} }
} }
impl<T: Clone + Debug + Ord> Size<T> { impl<T> Size<T>
where
T: Ord + Clone + Default + Debug,
{
pub fn max(&self, other: &Self) -> Self { pub fn max(&self, other: &Self) -> Self {
Size { Size {
width: if self.width >= other.width { width: if self.width >= other.width {
@ -177,8 +207,8 @@ impl<T: Clone + Debug + Ord> Size<T> {
impl<T, Rhs> Mul<Rhs> for Size<T> impl<T, Rhs> Mul<Rhs> for Size<T>
where where
T: Mul<Rhs, Output = Rhs> + Debug + Clone, T: Mul<Rhs, Output = Rhs> + Clone + Default + Debug,
Rhs: Debug + Clone, Rhs: Clone + Default + Debug,
{ {
type Output = Size<Rhs>; type Output = Size<Rhs>;
@ -190,16 +220,23 @@ where
} }
} }
impl<T: Clone + Debug + Mul<S, Output = T>, S: Clone> MulAssign<S> for Size<T> { impl<T, S> MulAssign<S> for Size<T>
where
T: Mul<S, Output = T> + Clone + Default + Debug,
S: Clone,
{
fn mul_assign(&mut self, rhs: S) { fn mul_assign(&mut self, rhs: S) {
self.width = self.width.clone() * rhs.clone(); self.width = self.width.clone() * rhs.clone();
self.height = self.height.clone() * rhs; self.height = self.height.clone() * rhs;
} }
} }
impl<T: Eq + Debug + Clone> Eq for Size<T> {} impl<T> Eq for Size<T> where T: Eq + Default + Debug + Clone {}
impl<T: Clone + Debug> Debug for Size<T> { impl<T> Debug for Size<T>
where
T: Clone + Default + Debug,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Size {{ {:?} × {:?} }}", self.width, self.height) write!(f, "Size {{ {:?} × {:?} }}", self.width, self.height)
} }
@ -244,12 +281,15 @@ impl Size<Length> {
#[derive(Refineable, Clone, Default, Debug, Eq, PartialEq)] #[derive(Refineable, Clone, Default, Debug, Eq, PartialEq)]
#[refineable(debug)] #[refineable(debug)]
#[repr(C)] #[repr(C)]
pub struct Bounds<T: Clone + Debug + Default> { pub struct Bounds<T: Clone + Default + Debug> {
pub origin: Point<T>, pub origin: Point<T>,
pub size: Size<T>, pub size: Size<T>,
} }
impl<T: Clone + Debug + Sub<Output = T> + Default> Bounds<T> { impl<T> Bounds<T>
where
T: Clone + Debug + Sub<Output = T> + Default,
{
pub fn from_corners(upper_left: Point<T>, lower_right: Point<T>) -> Self { pub fn from_corners(upper_left: Point<T>, lower_right: Point<T>) -> Self {
let origin = Point { let origin = Point {
x: upper_left.x.clone(), x: upper_left.x.clone(),
@ -263,7 +303,10 @@ impl<T: Clone + Debug + Sub<Output = T> + Default> Bounds<T> {
} }
} }
impl<T: Clone + Debug + PartialOrd + Add<T, Output = T> + Sub<Output = T> + Default> Bounds<T> { impl<T> Bounds<T>
where
T: Clone + Debug + PartialOrd + Add<T, Output = T> + Sub<Output = T> + Default,
{
pub fn intersects(&self, other: &Bounds<T>) -> bool { pub fn intersects(&self, other: &Bounds<T>) -> bool {
let my_lower_right = self.lower_right(); let my_lower_right = self.lower_right();
let their_lower_right = other.lower_right(); let their_lower_right = other.lower_right();
@ -283,7 +326,7 @@ impl<T: Clone + Debug + PartialOrd + Add<T, Output = T> + Sub<Output = T> + Defa
} }
} }
impl<T: Clone + Debug + PartialOrd + Add<T, Output = T> + Sub<Output = T>> Bounds<T> { impl<T: Clone + Default + Debug + PartialOrd + Add<T, Output = T> + Sub<Output = T>> Bounds<T> {
pub fn intersect(&self, other: &Self) -> Self { pub fn intersect(&self, other: &Self) -> Self {
let upper_left = self.origin.max(&other.origin); let upper_left = self.origin.max(&other.origin);
let lower_right = self.lower_right().min(&other.lower_right()); let lower_right = self.lower_right().min(&other.lower_right());
@ -299,9 +342,9 @@ impl<T: Clone + Debug + PartialOrd + Add<T, Output = T> + Sub<Output = T>> Bound
impl<T, Rhs> Mul<Rhs> for Bounds<T> impl<T, Rhs> Mul<Rhs> for Bounds<T>
where where
T: Mul<Rhs, Output = Rhs> + Clone + Debug, T: Mul<Rhs, Output = Rhs> + Clone + Default + Debug,
Point<T>: Mul<Rhs, Output = Point<Rhs>>, Point<T>: Mul<Rhs, Output = Point<Rhs>>,
Rhs: Clone + Debug, Rhs: Clone + Default + Debug,
{ {
type Output = Bounds<Rhs>; type Output = Bounds<Rhs>;
@ -313,16 +356,22 @@ where
} }
} }
impl<T: Clone + Debug + Mul<S, Output = T>, S: Clone> MulAssign<S> for Bounds<T> { impl<T, S> MulAssign<S> for Bounds<T>
where
T: Mul<S, Output = T> + Clone + Default + Debug,
S: Clone,
{
fn mul_assign(&mut self, rhs: S) { fn mul_assign(&mut self, rhs: S) {
self.origin *= rhs.clone(); self.origin *= rhs.clone();
self.size *= rhs; self.size *= rhs;
} }
} }
impl<T: Clone + Debug + Div<S, Output = T>, S: Clone> Div<S> for Bounds<T> impl<T, S> Div<S> for Bounds<T>
where where
Size<T>: Div<S, Output = Size<T>>, Size<T>: Div<S, Output = Size<T>>,
T: Div<S, Output = T> + Default + Clone + Debug,
S: Clone,
{ {
type Output = Self; type Output = Self;
@ -334,7 +383,10 @@ where
} }
} }
impl<T: Clone + Debug + Add<T, Output = T>> Bounds<T> { impl<T> Bounds<T>
where
T: Add<T, Output = T> + Clone + Default + Debug,
{
pub fn upper_right(&self) -> Point<T> { pub fn upper_right(&self) -> Point<T> {
Point { Point {
x: self.origin.x.clone() + self.size.width.clone(), x: self.origin.x.clone() + self.size.width.clone(),
@ -357,7 +409,10 @@ impl<T: Clone + Debug + Add<T, Output = T>> Bounds<T> {
} }
} }
impl<T: Clone + Debug + PartialOrd + Add<T, Output = T>> Bounds<T> { impl<T> Bounds<T>
where
T: Add<T, Output = T> + PartialOrd + Clone + Default + Debug,
{
pub fn contains_point(&self, point: Point<T>) -> bool { pub fn contains_point(&self, point: Point<T>) -> bool {
point.x >= self.origin.x point.x >= self.origin.x
&& point.x <= self.origin.x.clone() + self.size.width.clone() && point.x <= self.origin.x.clone() + self.size.width.clone()
@ -365,7 +420,10 @@ impl<T: Clone + Debug + PartialOrd + Add<T, Output = T>> Bounds<T> {
&& point.y <= self.origin.y.clone() + self.size.height.clone() && point.y <= self.origin.y.clone() + self.size.height.clone()
} }
pub fn map<U: Clone + Debug, F: Fn(T) -> U>(&self, f: F) -> Bounds<U> { pub fn map<U>(&self, f: impl Fn(T) -> U) -> Bounds<U>
where
U: Clone + Default + Debug,
{
Bounds { Bounds {
origin: self.origin.map(&f), origin: self.origin.map(&f),
size: self.size.map(f), size: self.size.map(f),
@ -382,19 +440,22 @@ impl Bounds<Pixels> {
} }
} }
impl<T: Clone + Debug + Copy> Copy for Bounds<T> {} impl<T: Clone + Debug + Copy + Default> Copy for Bounds<T> {}
#[derive(Refineable, Clone, Default, Debug, Eq, PartialEq)] #[derive(Refineable, Clone, Default, Debug, Eq, PartialEq)]
#[refineable(debug)] #[refineable(debug)]
#[repr(C)] #[repr(C)]
pub struct Edges<T: Clone + Debug> { pub struct Edges<T: Clone + Default + Debug> {
pub top: T, pub top: T,
pub right: T, pub right: T,
pub bottom: T, pub bottom: T,
pub left: T, pub left: T,
} }
impl<T: Clone + Debug + Mul<Output = T>> Mul for Edges<T> { impl<T> Mul for Edges<T>
where
T: Mul<Output = T> + Clone + Default + Debug,
{
type Output = Self; type Output = Self;
fn mul(self, rhs: Self) -> Self::Output { fn mul(self, rhs: Self) -> Self::Output {
@ -407,19 +468,26 @@ impl<T: Clone + Debug + Mul<Output = T>> Mul for Edges<T> {
} }
} }
impl<T: Clone + Debug + Mul<S, Output = T>, S: Clone> MulAssign<S> for Edges<T> { impl<T, S> MulAssign<S> for Edges<T>
where
T: Mul<S, Output = T> + Clone + Default + Debug,
S: Clone,
{
fn mul_assign(&mut self, rhs: S) { fn mul_assign(&mut self, rhs: S) {
self.top = self.top.clone() * rhs.clone(); self.top = self.top.clone() * rhs.clone();
self.right = self.right.clone() * rhs.clone(); self.right = self.right.clone() * rhs.clone();
self.bottom = self.bottom.clone() * rhs.clone(); self.bottom = self.bottom.clone() * rhs.clone();
self.left = self.left.clone() * rhs.clone(); self.left = self.left.clone() * rhs;
} }
} }
impl<T: Clone + Debug + Copy> Copy for Edges<T> {} impl<T: Clone + Default + Debug + Copy> Copy for Edges<T> {}
impl<T: Clone + Debug> Edges<T> { impl<T: Clone + Default + Debug> Edges<T> {
pub fn map<U: Clone + Debug, F: Fn(&T) -> U>(&self, f: F) -> Edges<U> { pub fn map<U>(&self, f: impl Fn(&T) -> U) -> Edges<U>
where
U: Clone + Default + Debug,
{
Edges { Edges {
top: f(&self.top), top: f(&self.top),
right: f(&self.right), right: f(&self.right),
@ -501,7 +569,7 @@ impl Edges<Pixels> {
#[derive(Refineable, Clone, Default, Debug, Eq, PartialEq)] #[derive(Refineable, Clone, Default, Debug, Eq, PartialEq)]
#[refineable(debug)] #[refineable(debug)]
#[repr(C)] #[repr(C)]
pub struct Corners<T: Clone + Debug> { pub struct Corners<T: Clone + Default + Debug> {
pub top_left: T, pub top_left: T,
pub top_right: T, pub top_right: T,
pub bottom_right: T, pub bottom_right: T,
@ -531,8 +599,11 @@ impl Corners<Pixels> {
} }
} }
impl<T: Clone + Debug> Corners<T> { impl<T: Clone + Default + Debug> Corners<T> {
pub fn map<U: Clone + Debug, F: Fn(&T) -> U>(&self, f: F) -> Corners<U> { pub fn map<U>(&self, f: impl Fn(&T) -> U) -> Corners<U>
where
U: Clone + Default + Debug,
{
Corners { Corners {
top_left: f(&self.top_left), top_left: f(&self.top_left),
top_right: f(&self.top_right), top_right: f(&self.top_right),
@ -542,7 +613,10 @@ impl<T: Clone + Debug> Corners<T> {
} }
} }
impl<T: Clone + Debug + Mul<Output = T>> Mul for Corners<T> { impl<T> Mul for Corners<T>
where
T: Mul<Output = T> + Clone + Default + Debug,
{
type Output = Self; type Output = Self;
fn mul(self, rhs: Self) -> Self::Output { fn mul(self, rhs: Self) -> Self::Output {
@ -555,7 +629,11 @@ impl<T: Clone + Debug + Mul<Output = T>> Mul for Corners<T> {
} }
} }
impl<T: Clone + Debug + Mul<S, Output = T>, S: Clone> MulAssign<S> for Corners<T> { impl<T, S> MulAssign<S> for Corners<T>
where
T: Mul<S, Output = T> + Clone + Default + Debug,
S: Clone,
{
fn mul_assign(&mut self, rhs: S) { fn mul_assign(&mut self, rhs: S) {
self.top_left = self.top_left.clone() * rhs.clone(); self.top_left = self.top_left.clone() * rhs.clone();
self.top_right = self.top_right.clone() * rhs.clone(); self.top_right = self.top_right.clone() * rhs.clone();
@ -564,7 +642,7 @@ impl<T: Clone + Debug + Mul<S, Output = T>, S: Clone> MulAssign<S> for Corners<T
} }
} }
impl<T: Clone + Debug + Copy> Copy for Corners<T> {} impl<T> Copy for Corners<T> where T: Copy + Clone + Default + Debug {}
#[derive(Clone, Copy, Default, Add, AddAssign, Sub, SubAssign, Div, Neg, PartialEq, PartialOrd)] #[derive(Clone, Copy, Default, Add, AddAssign, Sub, SubAssign, Div, Neg, PartialEq, PartialOrd)]
#[repr(transparent)] #[repr(transparent)]
@ -1016,25 +1094,31 @@ impl IsZero for Length {
} }
} }
impl<T: IsZero + Debug + Clone> IsZero for Point<T> { impl<T: IsZero + Debug + Clone + Default> IsZero for Point<T> {
fn is_zero(&self) -> bool { fn is_zero(&self) -> bool {
self.x.is_zero() && self.y.is_zero() self.x.is_zero() && self.y.is_zero()
} }
} }
impl<T: IsZero + Debug + Clone> IsZero for Size<T> { impl<T> IsZero for Size<T>
where
T: IsZero + Default + Debug + Clone,
{
fn is_zero(&self) -> bool { fn is_zero(&self) -> bool {
self.width.is_zero() || self.height.is_zero() self.width.is_zero() || self.height.is_zero()
} }
} }
impl<T: IsZero + Debug + Clone> IsZero for Bounds<T> { impl<T: IsZero + Debug + Clone + Default> IsZero for Bounds<T> {
fn is_zero(&self) -> bool { fn is_zero(&self) -> bool {
self.size.is_zero() self.size.is_zero()
} }
} }
impl<T: IsZero + Debug + Clone> IsZero for Corners<T> { impl<T> IsZero for Corners<T>
where
T: IsZero + Clone + Default + Debug,
{
fn is_zero(&self) -> bool { fn is_zero(&self) -> bool {
self.top_left.is_zero() self.top_left.is_zero()
&& self.top_right.is_zero() && self.top_right.is_zero()

4
crates/gpui3/src/scene.rs
View file

@ -595,7 +595,7 @@ impl From<PolychromeSprite> for Primitive {
pub(crate) struct PathId(pub(crate) usize); pub(crate) struct PathId(pub(crate) usize);
#[derive(Debug)] #[derive(Debug)]
pub struct Path<P: Clone + Debug> { pub struct Path<P: Clone + Default + Debug> {
pub(crate) id: PathId, pub(crate) id: PathId,
order: u32, order: u32,
pub(crate) bounds: Bounds<P>, pub(crate) bounds: Bounds<P>,
@ -736,7 +736,7 @@ impl From<Path<ScaledPixels>> for Primitive {
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
#[repr(C)] #[repr(C)]
pub struct PathVertex<P: Clone + Debug> { pub struct PathVertex<P: Clone + Default + Debug> {
pub(crate) xy_position: Point<P>, pub(crate) xy_position: Point<P>,
pub(crate) st_position: Point<f32>, pub(crate) st_position: Point<f32>,
pub(crate) content_mask: ContentMask<P>, pub(crate) content_mask: ContentMask<P>,

59
crates/gpui3/src/taffy.rs
View file

@ -2,7 +2,7 @@ use super::{AbsoluteLength, Bounds, DefiniteLength, Edges, Length, Pixels, Point
use collections::HashMap; use collections::HashMap;
use std::fmt::Debug; use std::fmt::Debug;
use taffy::{ use taffy::{
geometry::Size as TaffySize, geometry::{Point as TaffyPoint, Rect as TaffyRect, Size as TaffySize},
style::AvailableSpace as TaffyAvailableSpace, style::AvailableSpace as TaffyAvailableSpace,
tree::{Measurable, MeasureFunc, NodeId}, tree::{Measurable, MeasureFunc, NodeId},
Taffy, Taffy,
@ -321,11 +321,12 @@ impl ToTaffy<taffy::style::LengthPercentage> for AbsoluteLength {
} }
} }
impl<T, T2: Clone + Debug> From<taffy::geometry::Point<T>> for Point<T2> impl<T, T2> From<TaffyPoint<T>> for Point<T2>
where where
T: Into<T2>, T: Into<T2>,
T2: Clone + Default + Debug,
{ {
fn from(point: taffy::geometry::Point<T>) -> Point<T2> { fn from(point: TaffyPoint<T>) -> Point<T2> {
Point { Point {
x: point.x.into(), x: point.x.into(),
y: point.y.into(), y: point.y.into(),
@ -333,33 +334,36 @@ where
} }
} }
impl<T: Clone + Debug, T2> Into<taffy::geometry::Point<T2>> for Point<T> impl<T, T2> Into<TaffyPoint<T2>> for Point<T>
where where
T: Into<T2>, T: Into<T2> + Clone + Default + Debug,
{ {
fn into(self) -> taffy::geometry::Point<T2> { fn into(self) -> TaffyPoint<T2> {
taffy::geometry::Point { TaffyPoint {
x: self.x.into(), x: self.x.into(),
y: self.y.into(), y: self.y.into(),
} }
} }
} }
impl<T: ToTaffy<U> + Clone + Debug, U> ToTaffy<taffy::geometry::Size<U>> for Size<T> { impl<T, U> ToTaffy<TaffySize<U>> for Size<T>
fn to_taffy(&self, rem_size: Pixels) -> taffy::geometry::Size<U> { where
taffy::geometry::Size { T: ToTaffy<U> + Clone + Default + Debug,
{
fn to_taffy(&self, rem_size: Pixels) -> TaffySize<U> {
TaffySize {
width: self.width.to_taffy(rem_size).into(), width: self.width.to_taffy(rem_size).into(),
height: self.height.to_taffy(rem_size).into(), height: self.height.to_taffy(rem_size).into(),
} }
} }
} }
impl<T, U> ToTaffy<taffy::geometry::Rect<U>> for Edges<T> impl<T, U> ToTaffy<TaffyRect<U>> for Edges<T>
where where
T: ToTaffy<U> + Clone + Debug, T: ToTaffy<U> + Clone + Default + Debug,
{ {
fn to_taffy(&self, rem_size: Pixels) -> taffy::geometry::Rect<U> { fn to_taffy(&self, rem_size: Pixels) -> TaffyRect<U> {
taffy::geometry::Rect { TaffyRect {
top: self.top.to_taffy(rem_size).into(), top: self.top.to_taffy(rem_size).into(),
right: self.right.to_taffy(rem_size).into(), right: self.right.to_taffy(rem_size).into(),
bottom: self.bottom.to_taffy(rem_size).into(), bottom: self.bottom.to_taffy(rem_size).into(),
@ -368,8 +372,12 @@ where
} }
} }
impl<T: Into<U>, U: Clone + Debug> From<TaffySize<T>> for Size<U> { impl<T, U> From<TaffySize<T>> for Size<U>
fn from(taffy_size: taffy::geometry::Size<T>) -> Self { where
T: Into<U>,
U: Clone + Default + Debug,
{
fn from(taffy_size: TaffySize<T>) -> Self {
Size { Size {
width: taffy_size.width.into(), width: taffy_size.width.into(),
height: taffy_size.height.into(), height: taffy_size.height.into(),
@ -377,29 +385,24 @@ impl<T: Into<U>, U: Clone + Debug> From<TaffySize<T>> for Size<U> {
} }
} }
impl<T: Into<U> + Clone + Debug, U> From<Size<T>> for taffy::geometry::Size<U> { impl<T, U> From<Size<T>> for TaffySize<U>
where
T: Into<U> + Clone + Default + Debug,
{
fn from(size: Size<T>) -> Self { fn from(size: Size<T>) -> Self {
taffy::geometry::Size { TaffySize {
width: size.width.into(), width: size.width.into(),
height: size.height.into(), height: size.height.into(),
} }
} }
} }
// impl From<TaffySize<Option<f32>>> for Size<Option<Pixels>> { #[derive(Copy, Clone, Default, Debug)]
// fn from(value: TaffySize<Option<f32>>) -> Self {
// Self {
// width: value.width.map(Into::into),
// height: value.height.map(Into::into),
// }
// }
// }
#[derive(Copy, Clone, Debug)]
pub enum AvailableSpace { pub enum AvailableSpace {
/// The amount of space available is the specified number of pixels /// The amount of space available is the specified number of pixels
Definite(Pixels), Definite(Pixels),
/// The amount of space available is indefinite and the node should be laid out under a min-content constraint /// The amount of space available is indefinite and the node should be laid out under a min-content constraint
#[default]
MinContent, MinContent,
/// The amount of space available is indefinite and the node should be laid out under a max-content constraint /// The amount of space available is indefinite and the node should be laid out under a max-content constraint
MaxContent, MaxContent,

2
crates/gpui3/src/window.rs
View file

@ -132,7 +132,7 @@ impl Window {
#[derive(Clone, Debug, Default, PartialEq, Eq)] #[derive(Clone, Debug, Default, PartialEq, Eq)]
#[repr(C)] #[repr(C)]
pub struct ContentMask<P: Clone + Debug> { pub struct ContentMask<P: Clone + Default + Debug> {
pub bounds: Bounds<P>, pub bounds: Bounds<P>,
} }