1//! Style types for representing lengths / sizes
2
3use crate::geometry::{Rect, Size};
4use crate::style_helpers::{FromLength, FromPercent, TaffyAuto, TaffyMaxContent, TaffyMinContent, TaffyZero};
5use crate::util::sys::abs;
6
7/// A unit of linear measurement
8///
9/// This is commonly combined with [`Rect`], [`Point`](crate::geometry::Point) and [`Size<T>`].
10#[derive(Copy, Clone, PartialEq, Debug)]
11#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
12pub enum LengthPercentage {
13 /// An absolute length in some abstract units. Users of Taffy may define what they correspond
14 /// to in their application (pixels, logical pixels, mm, etc) as they see fit.
15 Length(f32),
16 /// The dimension is stored in percentage relative to the parent item.
17 Percent(f32),
18}
19impl TaffyZero for LengthPercentage {
20 const ZERO: Self = Self::Length(0.0);
21}
22impl FromLength for LengthPercentage {
23 fn from_length<Input: Into<f32> + Copy>(value: Input) -> Self {
24 Self::Length(value.into())
25 }
26}
27impl FromPercent for LengthPercentage {
28 fn from_percent<Input: Into<f32> + Copy>(percent: Input) -> Self {
29 Self::Percent(percent.into())
30 }
31}
32
33/// A unit of linear measurement
34///
35/// This is commonly combined with [`Rect`], [`Point`](crate::geometry::Point) and [`Size<T>`].
36#[derive(Copy, Clone, PartialEq, Debug)]
37#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
38pub enum LengthPercentageAuto {
39 /// An absolute length in some abstract units. Users of Taffy may define what they correspond
40 /// to in their application (pixels, logical pixels, mm, etc) as they see fit.
41 Length(f32),
42 /// The dimension is stored in percentage relative to the parent item.
43 Percent(f32),
44 /// The dimension should be automatically computed
45 Auto,
46 /// The dimension should take up available space in proportion to the parameter
47 #[cfg(feature = "morphorm")]
48 MorphormStretch(f32),
49}
50impl TaffyZero for LengthPercentageAuto {
51 const ZERO: Self = Self::Length(0.0);
52}
53impl TaffyAuto for LengthPercentageAuto {
54 const AUTO: Self = Self::Auto;
55}
56impl FromLength for LengthPercentageAuto {
57 fn from_length<Input: Into<f32> + Copy>(value: Input) -> Self {
58 Self::Length(value.into())
59 }
60}
61impl FromPercent for LengthPercentageAuto {
62 fn from_percent<Input: Into<f32> + Copy>(percent: Input) -> Self {
63 Self::Percent(percent.into())
64 }
65}
66
67impl From<LengthPercentage> for LengthPercentageAuto {
68 fn from(input: LengthPercentage) -> Self {
69 match input {
70 LengthPercentage::Length(value) => Self::Length(value),
71 LengthPercentage::Percent(value) => Self::Percent(value),
72 }
73 }
74}
75
76impl LengthPercentageAuto {
77 /// Returns:
78 /// - Some(length) for Length variants
79 /// - Some(resolved) using the provided context for Percent variants
80 /// - None for Auto variants
81 #[inline(always)]
82 pub fn resolve_to_option(self, context: f32) -> Option<f32> {
83 match self {
84 Self::Length(length) => Some(length),
85 Self::Percent(percent) => Some(context * percent),
86 Self::Auto => None,
87 Self::MorphormStretch(_) => Some(0.0),
88 }
89 }
90
91 /// Returns true if value is LengthPercentageAuto::Auto
92 #[inline(always)]
93 pub fn is_auto(self) -> bool {
94 self == Self::Auto
95 }
96}
97
98/// A unit of linear measurement
99///
100/// This is commonly combined with [`Rect`], [`Point`](crate::geometry::Point) and [`Size<T>`].
101#[derive(Copy, Clone, PartialEq, Debug)]
102#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
103pub enum Dimension {
104 /// An absolute length in some abstract units. Users of Taffy may define what they correspond
105 /// to in their application (pixels, logical pixels, mm, etc) as they see fit.
106 Length(f32),
107 /// The dimension is stored in percentage relative to the parent item.
108 Percent(f32),
109 /// The dimension should be automatically computed
110 Auto,
111 /// The dimension should take up available space in proportion to the parameter
112 #[cfg(feature = "morphorm")]
113 MorphormStretch(f32),
114}
115impl TaffyZero for Dimension {
116 const ZERO: Self = Self::Length(0.0);
117}
118impl TaffyAuto for Dimension {
119 const AUTO: Self = Self::Auto;
120}
121impl FromLength for Dimension {
122 fn from_length<Input: Into<f32> + Copy>(value: Input) -> Self {
123 Self::Length(value.into())
124 }
125}
126impl FromPercent for Dimension {
127 fn from_percent<Input: Into<f32> + Copy>(percent: Input) -> Self {
128 Self::Percent(percent.into())
129 }
130}
131
132impl From<LengthPercentage> for Dimension {
133 fn from(input: LengthPercentage) -> Self {
134 match input {
135 LengthPercentage::Length(value) => Self::Length(value),
136 LengthPercentage::Percent(value) => Self::Percent(value),
137 }
138 }
139}
140
141impl From<LengthPercentageAuto> for Dimension {
142 fn from(input: LengthPercentageAuto) -> Self {
143 match input {
144 LengthPercentageAuto::Length(value) => Self::Length(value),
145 LengthPercentageAuto::Percent(value) => Self::Percent(value),
146 LengthPercentageAuto::Auto => Self::Auto,
147 LengthPercentageAuto::MorphormStretch(val) => Self::MorphormStretch(val),
148 }
149 }
150}
151
152impl Dimension {
153 /// Get Length value if value is Length variant
154 #[cfg(feature = "grid")]
155 pub fn into_option(self) -> Option<f32> {
156 match self {
157 Dimension::Length(value) => Some(value),
158 _ => None,
159 }
160 }
161}
162
163impl Rect<Dimension> {
164 /// Create a new Rect with [`Dimension::Length`]
165 #[must_use]
166 pub const fn from_length(start: f32, end: f32, top: f32, bottom: f32) -> Self {
167 Rect {
168 left: Dimension::Length(start),
169 right: Dimension::Length(end),
170 top: Dimension::Length(top),
171 bottom: Dimension::Length(bottom),
172 }
173 }
174
175 /// Create a new Rect with [`Dimension::Percent`]
176 #[must_use]
177 pub const fn from_percent(start: f32, end: f32, top: f32, bottom: f32) -> Self {
178 Rect {
179 left: Dimension::Percent(start),
180 right: Dimension::Percent(end),
181 top: Dimension::Percent(top),
182 bottom: Dimension::Percent(bottom),
183 }
184 }
185}
186
187/// The amount of space available to a node in a given axis
188/// <https://www.w3.org/TR/css-sizing-3/#available>
189#[derive(Copy, Clone, Debug, PartialEq)]
190pub enum AvailableSpace {
191 /// The amount of space available is the specified number of pixels
192 Definite(f32),
193 /// The amount of space available is indefinite and the node should be laid out under a min-content constraint
194 MinContent,
195 /// The amount of space available is indefinite and the node should be laid out under a max-content constraint
196 MaxContent,
197}
198impl TaffyZero for AvailableSpace {
199 const ZERO: Self = Self::Definite(0.0);
200}
201impl TaffyMaxContent for AvailableSpace {
202 const MAX_CONTENT: Self = Self::MaxContent;
203}
204impl TaffyMinContent for AvailableSpace {
205 const MIN_CONTENT: Self = Self::MinContent;
206}
207impl FromLength for AvailableSpace {
208 fn from_length<Input: Into<f32> + Copy>(value: Input) -> Self {
209 Self::Definite(value.into())
210 }
211}
212
213impl AvailableSpace {
214 /// Returns true for definite values, else false
215 pub fn is_definite(self) -> bool {
216 matches!(self, AvailableSpace::Definite(_))
217 }
218
219 /// Convert to Option
220 /// Definite values become Some(value). Contraints become None.
221 pub fn into_option(self) -> Option<f32> {
222 match self {
223 AvailableSpace::Definite(value) => Some(value),
224 _ => None,
225 }
226 }
227
228 /// Return the definite value or a default value
229 pub fn unwrap_or(self, default: f32) -> f32 {
230 self.into_option().unwrap_or(default)
231 }
232
233 /// Return the definite value. Panic is the value is not definite.
234 #[track_caller]
235 pub fn unwrap(self) -> f32 {
236 self.into_option().unwrap()
237 }
238
239 /// Return self if definite or a default value
240 pub fn or(self, default: AvailableSpace) -> AvailableSpace {
241 match self {
242 AvailableSpace::Definite(_) => self,
243 _ => default,
244 }
245 }
246
247 /// Return self if definite or a the result of the default value callback
248 pub fn or_else(self, default_cb: impl FnOnce() -> AvailableSpace) -> AvailableSpace {
249 match self {
250 AvailableSpace::Definite(_) => self,
251 _ => default_cb(),
252 }
253 }
254
255 /// Return the definite value or the result of the default value callback
256 pub fn unwrap_or_else(self, default_cb: impl FnOnce() -> f32) -> f32 {
257 self.into_option().unwrap_or_else(default_cb)
258 }
259
260 /// If passed value is Some then return AvailableSpace::Definite containing that value, else return self
261 pub fn maybe_set(self, value: Option<f32>) -> AvailableSpace {
262 match value {
263 Some(value) => AvailableSpace::Definite(value),
264 None => self,
265 }
266 }
267
268 /// If passed value is Some then return AvailableSpace::Definite containing that value, else return self
269 pub fn map_definite_value(self, map_function: impl FnOnce(f32) -> f32) -> AvailableSpace {
270 match self {
271 AvailableSpace::Definite(value) => AvailableSpace::Definite(map_function(value)),
272 _ => self,
273 }
274 }
275
276 /// Compute free_space given the passed used_space
277 pub fn compute_free_space(&self, used_space: f32) -> f32 {
278 match self {
279 AvailableSpace::MaxContent => f32::INFINITY,
280 AvailableSpace::MinContent => 0.0,
281 AvailableSpace::Definite(available_space) => available_space - used_space,
282 }
283 }
284
285 /// Compare equality with another AvailableSpace, treating definite values
286 /// that are within f32::EPSILON of each other as equal
287 pub fn is_roughly_equal(self, other: AvailableSpace) -> bool {
288 use AvailableSpace::*;
289 match (self, other) {
290 (Definite(a), Definite(b)) => abs(a - b) < f32::EPSILON,
291 (MinContent, MinContent) => true,
292 (MaxContent, MaxContent) => true,
293 _ => false,
294 }
295 }
296}
297
298impl From<f32> for AvailableSpace {
299 fn from(value: f32) -> Self {
300 Self::Definite(value)
301 }
302}
303
304impl From<Option<f32>> for AvailableSpace {
305 fn from(option: Option<f32>) -> Self {
306 match option {
307 Some(value) => Self::Definite(value),
308 None => Self::MaxContent,
309 }
310 }
311}
312
313impl Size<AvailableSpace> {
314 /// Convert `Size<AvailableSpace>` into `Size<Option<f32>>`
315 pub fn into_options(self) -> Size<Option<f32>> {
316 Size { width: self.width.into_option(), height: self.height.into_option() }
317 }
318
319 /// If passed value is Some then return AvailableSpace::Definite containing that value, else return self
320 pub fn maybe_set(self, value: Size<Option<f32>>) -> Size<AvailableSpace> {
321 Size { width: self.width.maybe_set(value.width), height: self.height.maybe_set(value.height) }
322 }
323}