1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502
//! A typed representation of [CSS style properties](https://css-tricks.com/snippets/css/a-guide-to-flexbox/) in Rust. Used as input to layout computation.
mod alignment;
mod dimension;
#[cfg(feature = "flexbox")]
mod flex;
pub use self::alignment::{AlignContent, AlignItems, AlignSelf, JustifyContent, JustifyItems, JustifySelf};
pub use self::dimension::{AvailableSpace, Dimension, LengthPercentage, LengthPercentageAuto};
#[cfg(feature = "flexbox")]
pub use self::flex::{FlexDirection, FlexWrap};
#[cfg(feature = "grid")]
mod grid;
#[cfg(feature = "grid")]
pub(crate) use self::grid::{GenericGridPlacement, OriginZeroGridPlacement};
#[cfg(feature = "grid")]
pub use self::grid::{
GridAutoFlow, GridPlacement, GridTrackRepetition, MaxTrackSizingFunction, MinTrackSizingFunction,
NonRepeatedTrackSizingFunction, TrackSizingFunction,
};
use crate::geometry::{Point, Rect, Size};
#[cfg(feature = "grid")]
use crate::geometry::Line;
#[cfg(feature = "serde")]
use crate::style_helpers;
#[cfg(feature = "grid")]
use crate::util::sys::GridTrackVec;
/// Sets the layout used for the children of this node
///
/// The default values depends on on which feature flags are enabled. The order of precedence is: Flex, Grid, Block, None.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum Display {
/// The children will follow the block layout algorithm
#[cfg(feature = "block_layout")]
Block,
/// The children will follow the flexbox layout algorithm
#[cfg(feature = "flexbox")]
Flex,
/// The children will follow the CSS Grid layout algorithm
#[cfg(feature = "grid")]
Grid,
/// The children will not be laid out, and will follow absolute positioning
None,
}
impl Display {
/// The default of Display.
#[cfg(feature = "flexbox")]
pub const DEFAULT: Display = Display::Flex;
/// The default of Display.
#[cfg(all(feature = "grid", not(feature = "flexbox")))]
pub const DEFAULT: Display = Display::Grid;
/// The default of Display.
#[cfg(all(feature = "block_layout", not(feature = "flexbox"), not(feature = "grid")))]
pub const DEFAULT: Display = Display::Block;
/// The default of Display.
#[cfg(all(not(feature = "flexbox"), not(feature = "grid"), not(feature = "block_layout")))]
pub const DEFAULT: Display = Display::None;
}
impl core::fmt::Display for Display {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Display::None => write!(f, "NONE"),
#[cfg(feature = "block_layout")]
Display::Block => write!(f, "BLOCK"),
#[cfg(feature = "flexbox")]
Display::Flex => write!(f, "FLEX"),
#[cfg(feature = "grid")]
Display::Grid => write!(f, "GRID"),
}
}
}
impl Default for Display {
fn default() -> Self {
Self::DEFAULT
}
}
/// The positioning strategy for this item.
///
/// This controls both how the origin is determined for the [`Style::position`] field,
/// and whether or not the item will be controlled by flexbox's layout algorithm.
///
/// WARNING: this enum follows the behavior of [CSS's `position` property](https://developer.mozilla.org/en-US/docs/Web/CSS/position),
/// which can be unintuitive.
///
/// [`Position::Relative`] is the default value, in contrast to the default behavior in CSS.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum Position {
/// The offset is computed relative to the final position given by the layout algorithm.
/// Offsets do not affect the position of any other items; they are effectively a correction factor applied at the end.
Relative,
/// The offset is computed relative to this item's closest positioned ancestor, if any.
/// Otherwise, it is placed relative to the origin.
/// No space is created for the item in the page layout, and its size will not be altered.
///
/// WARNING: to opt-out of layouting entirely, you must use [`Display::None`] instead on your [`Style`] object.
Absolute,
}
impl Default for Position {
fn default() -> Self {
Self::Relative
}
}
/// How children overflowing their container should affect layout
///
/// In CSS the primary effect of this property is to control whether contents of a parent container that overflow that container should
/// be displayed anyway, be clipped, or trigger the container to become a scroll container. However it also has secondary effects on layout,
/// the main ones being:
///
/// - The automatic minimum size Flexbox/CSS Grid items with non-`Visible` overflow is `0` rather than being content based
/// - `Overflow::Scroll` nodes have space in the layout reserved for a scrollbar (width controlled by the `scrollbar_width` property)
///
/// In Taffy, we only implement the layout related secondary effects as we are not concerned with drawing/painting. The amount of space reserved for
/// a scrollbar is controlled by the `scrollbar_width` property. If this is `0` then `Scroll` behaves identically to `Hidden`.
///
/// <https://developer.mozilla.org/en-US/docs/Web/CSS/overflow>
#[derive(Copy, Clone, PartialEq, Eq, Debug, Default)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub enum Overflow {
/// The automatic minimum size of this node as a flexbox/grid item should be based on the size of its content.
/// Content that overflows this node *should* contribute to the scroll region of its parent.
#[default]
Visible,
/// The automatic minimum size of this node as a flexbox/grid item should be based on the size of its content.
/// Content that overflows this node should *not* contribute to the scroll region of its parent.
Clip,
/// The automatic minimum size of this node as a flexbox/grid item should be `0`.
/// Content that overflows this node should *not* contribute to the scroll region of its parent.
Hidden,
/// The automatic minimum size of this node as a flexbox/grid item should be `0`. Additionally, space should be reserved
/// for a scrollbar. The amount of space reserved is controlled by the `scrollbar_width` property.
/// Content that overflows this node should *not* contribute to the scroll region of its parent.
Scroll,
}
impl Overflow {
/// Returns true for overflow modes that contain their contents (`Overflow::Hidden`, `Overflow::Scroll`, `Overflow::Auto`)
/// or else false for overflow modes that allow their contains to spill (`Overflow::Visible`).
#[inline(always)]
pub(crate) fn is_scroll_container(self) -> bool {
match self {
Self::Visible | Self::Clip => false,
Self::Hidden | Self::Scroll => true,
}
}
/// Returns `Some(0.0)` if the overflow mode would cause the automatic minimum size of a Flexbox or CSS Grid item
/// to be `0`. Else returns None.
#[inline(always)]
pub(crate) fn maybe_into_automatic_min_size(self) -> Option<f32> {
match self.is_scroll_container() {
true => Some(0.0),
false => None,
}
}
}
/// A typed representation of the CSS style information for a single node.
///
/// The most important idea in flexbox is the notion of a "main" and "cross" axis, which are always perpendicular to each other.
/// The orientation of these axes are controlled via the [`FlexDirection`] field of this struct.
///
/// This struct follows the [CSS equivalent](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Flexible_Box_Layout/Basic_Concepts_of_Flexbox) directly;
/// information about the behavior on the web should transfer directly.
///
/// Detailed information about the exact behavior of each of these fields
/// can be found on [MDN](https://developer.mozilla.org/en-US/docs/Web/CSS) by searching for the field name.
/// The distinction between margin, padding and border is explained well in
/// this [introduction to the box model](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Box_Model/Introduction_to_the_CSS_box_model).
///
/// If the behavior does not match the flexbox layout algorithm on the web, please file a bug!
#[derive(Clone, PartialEq, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", serde(default))]
pub struct Style {
/// What layout strategy should be used?
pub display: Display,
// Overflow properties
/// How children overflowing their container should affect layout
pub overflow: Point<Overflow>,
/// How much space (in points) should be reserved for the scrollbars of `Overflow::Scroll` and `Overflow::Auto` nodes.
pub scrollbar_width: f32,
// Position properties
/// What should the `position` value of this struct use as a base offset?
pub position: Position,
/// How should the position of this element be tweaked relative to the layout defined?
#[cfg_attr(feature = "serde", serde(default = "style_helpers::auto"))]
pub inset: Rect<LengthPercentageAuto>,
// Size properies
/// Sets the initial size of the item
#[cfg_attr(feature = "serde", serde(default = "style_helpers::auto"))]
pub size: Size<Dimension>,
/// Controls the minimum size of the item
#[cfg_attr(feature = "serde", serde(default = "style_helpers::auto"))]
pub min_size: Size<Dimension>,
/// Controls the maximum size of the item
#[cfg_attr(feature = "serde", serde(default = "style_helpers::auto"))]
pub max_size: Size<Dimension>,
/// Sets the preferred aspect ratio for the item
///
/// The ratio is calculated as width divided by height.
pub aspect_ratio: Option<f32>,
// Spacing Properties
/// How large should the margin be on each side?
#[cfg_attr(feature = "serde", serde(default = "style_helpers::zero"))]
pub margin: Rect<LengthPercentageAuto>,
/// How large should the padding be on each side?
#[cfg_attr(feature = "serde", serde(default = "style_helpers::zero"))]
pub padding: Rect<LengthPercentage>,
/// How large should the border be on each side?
#[cfg_attr(feature = "serde", serde(default = "style_helpers::zero"))]
pub border: Rect<LengthPercentage>,
// Alignment properties
/// How this node's children aligned in the cross/block axis?
#[cfg(any(feature = "flexbox", feature = "grid"))]
pub align_items: Option<AlignItems>,
/// How this node should be aligned in the cross/block axis
/// Falls back to the parents [`AlignItems`] if not set
#[cfg(any(feature = "flexbox", feature = "grid"))]
pub align_self: Option<AlignSelf>,
/// How this node's children should be aligned in the inline axis
#[cfg(feature = "grid")]
pub justify_items: Option<AlignItems>,
/// How this node should be aligned in the inline axis
/// Falls back to the parents [`JustifyItems`] if not set
#[cfg(feature = "grid")]
pub justify_self: Option<AlignSelf>,
/// How should content contained within this item be aligned in the cross/block axis
#[cfg(any(feature = "flexbox", feature = "grid"))]
pub align_content: Option<AlignContent>,
/// How should contained within this item be aligned in the main/inline axis
#[cfg(any(feature = "flexbox", feature = "grid"))]
pub justify_content: Option<JustifyContent>,
/// How large should the gaps between items in a grid or flex container be?
#[cfg(any(feature = "flexbox", feature = "grid"))]
#[cfg_attr(feature = "serde", serde(default = "style_helpers::zero"))]
pub gap: Size<LengthPercentage>,
// Flexbox properies
/// Which direction does the main axis flow in?
#[cfg(feature = "flexbox")]
pub flex_direction: FlexDirection,
/// Should elements wrap, or stay in a single line?
#[cfg(feature = "flexbox")]
pub flex_wrap: FlexWrap,
/// Sets the initial main axis size of the item
#[cfg(feature = "flexbox")]
pub flex_basis: Dimension,
/// The relative rate at which this item grows when it is expanding to fill space
///
/// 0.0 is the default value, and this value must be positive.
#[cfg(feature = "flexbox")]
pub flex_grow: f32,
/// The relative rate at which this item shrinks when it is contracting to fit into space
///
/// 1.0 is the default value, and this value must be positive.
#[cfg(feature = "flexbox")]
pub flex_shrink: f32,
// Grid container properies
/// Defines the track sizing functions (widths) of the grid rows
#[cfg(feature = "grid")]
pub grid_template_rows: GridTrackVec<TrackSizingFunction>,
/// Defines the track sizing functions (heights) of the grid columns
#[cfg(feature = "grid")]
pub grid_template_columns: GridTrackVec<TrackSizingFunction>,
/// Defines the size of implicitly created rows
#[cfg(feature = "grid")]
pub grid_auto_rows: GridTrackVec<NonRepeatedTrackSizingFunction>,
/// Defined the size of implicitly created columns
#[cfg(feature = "grid")]
pub grid_auto_columns: GridTrackVec<NonRepeatedTrackSizingFunction>,
/// Controls how items get placed into the grid for auto-placed items
#[cfg(feature = "grid")]
pub grid_auto_flow: GridAutoFlow,
// Grid child properties
/// Defines which row in the grid the item should start and end at
#[cfg(feature = "grid")]
pub grid_row: Line<GridPlacement>,
/// Defines which column in the grid the item should start and end at
#[cfg(feature = "grid")]
pub grid_column: Line<GridPlacement>,
}
impl Style {
/// The [`Default`] layout, in a form that can be used in const functions
pub const DEFAULT: Style = Style {
display: Display::DEFAULT,
overflow: Point { x: Overflow::Visible, y: Overflow::Visible },
scrollbar_width: 0.0,
position: Position::Relative,
inset: Rect::auto(),
margin: Rect::zero(),
padding: Rect::zero(),
border: Rect::zero(),
size: Size::auto(),
min_size: Size::auto(),
max_size: Size::auto(),
aspect_ratio: None,
#[cfg(any(feature = "flexbox", feature = "grid"))]
gap: Size::zero(),
// Aligment
#[cfg(any(feature = "flexbox", feature = "grid"))]
align_items: None,
#[cfg(any(feature = "flexbox", feature = "grid"))]
align_self: None,
#[cfg(feature = "grid")]
justify_items: None,
#[cfg(feature = "grid")]
justify_self: None,
#[cfg(any(feature = "flexbox", feature = "grid"))]
align_content: None,
#[cfg(any(feature = "flexbox", feature = "grid"))]
justify_content: None,
// Flexbox
#[cfg(feature = "flexbox")]
flex_direction: FlexDirection::Row,
#[cfg(feature = "flexbox")]
flex_wrap: FlexWrap::NoWrap,
#[cfg(feature = "flexbox")]
flex_grow: 0.0,
#[cfg(feature = "flexbox")]
flex_shrink: 1.0,
#[cfg(feature = "flexbox")]
flex_basis: Dimension::Auto,
// Grid
#[cfg(feature = "grid")]
grid_template_rows: GridTrackVec::new(),
#[cfg(feature = "grid")]
grid_template_columns: GridTrackVec::new(),
#[cfg(feature = "grid")]
grid_auto_rows: GridTrackVec::new(),
#[cfg(feature = "grid")]
grid_auto_columns: GridTrackVec::new(),
#[cfg(feature = "grid")]
grid_auto_flow: GridAutoFlow::Row,
#[cfg(feature = "grid")]
grid_row: Line { start: GridPlacement::Auto, end: GridPlacement::Auto },
#[cfg(feature = "grid")]
grid_column: Line { start: GridPlacement::Auto, end: GridPlacement::Auto },
};
}
impl Default for Style {
fn default() -> Self {
Style::DEFAULT
}
}
#[cfg(test)]
mod tests {
use super::Style;
use crate::geometry::*;
#[test]
fn defaults_match() {
#[cfg(feature = "grid")]
use super::GridPlacement;
let old_defaults = Style {
display: Default::default(),
overflow: Default::default(),
scrollbar_width: 0.0,
position: Default::default(),
#[cfg(feature = "flexbox")]
flex_direction: Default::default(),
#[cfg(feature = "flexbox")]
flex_wrap: Default::default(),
#[cfg(any(feature = "flexbox", feature = "grid"))]
align_items: Default::default(),
#[cfg(any(feature = "flexbox", feature = "grid"))]
align_self: Default::default(),
#[cfg(feature = "grid")]
justify_items: Default::default(),
#[cfg(feature = "grid")]
justify_self: Default::default(),
#[cfg(any(feature = "flexbox", feature = "grid"))]
align_content: Default::default(),
#[cfg(any(feature = "flexbox", feature = "grid"))]
justify_content: Default::default(),
inset: Rect::auto(),
margin: Rect::zero(),
padding: Rect::zero(),
border: Rect::zero(),
gap: Size::zero(),
#[cfg(feature = "flexbox")]
flex_grow: 0.0,
#[cfg(feature = "flexbox")]
flex_shrink: 1.0,
#[cfg(feature = "flexbox")]
flex_basis: super::Dimension::Auto,
size: Size::auto(),
min_size: Size::auto(),
max_size: Size::auto(),
aspect_ratio: Default::default(),
#[cfg(feature = "grid")]
grid_template_rows: Default::default(),
#[cfg(feature = "grid")]
grid_template_columns: Default::default(),
#[cfg(feature = "grid")]
grid_auto_rows: Default::default(),
#[cfg(feature = "grid")]
grid_auto_columns: Default::default(),
#[cfg(feature = "grid")]
grid_auto_flow: Default::default(),
#[cfg(feature = "grid")]
grid_row: Line { start: GridPlacement::Auto, end: GridPlacement::Auto },
#[cfg(feature = "grid")]
grid_column: Line { start: GridPlacement::Auto, end: GridPlacement::Auto },
};
assert_eq!(Style::DEFAULT, Style::default());
assert_eq!(Style::DEFAULT, old_defaults);
}
// NOTE: Please feel free the update the sizes in this test as required. This test is here to prevent unintentional size changes
// and to serve as accurate up-to-date documentation on the sizes.
#[test]
fn style_sizes() {
use super::*;
fn assert_type_size<T>(expected_size: usize) {
let name = ::core::any::type_name::<T>();
let name = name.replace("taffy::geometry::", "");
let name = name.replace("taffy::style::dimension::", "");
let name = name.replace("taffy::style::alignment::", "");
let name = name.replace("taffy::style::flex::", "");
let name = name.replace("taffy::style::grid::", "");
assert_eq!(
::core::mem::size_of::<T>(),
expected_size,
"Expected {} for be {} byte(s) but it was {} byte(s)",
name,
expected_size,
::core::mem::size_of::<T>(),
);
}
// Display and Position
assert_type_size::<Display>(1);
assert_type_size::<Position>(1);
assert_type_size::<Overflow>(1);
// Dimensions and aggregations of Dimensions
assert_type_size::<f32>(4);
assert_type_size::<LengthPercentage>(8);
assert_type_size::<LengthPercentageAuto>(8);
assert_type_size::<Dimension>(8);
assert_type_size::<Size<LengthPercentage>>(16);
assert_type_size::<Size<LengthPercentageAuto>>(16);
assert_type_size::<Size<Dimension>>(16);
assert_type_size::<Rect<LengthPercentage>>(32);
assert_type_size::<Rect<LengthPercentageAuto>>(32);
assert_type_size::<Rect<Dimension>>(32);
// Alignment
assert_type_size::<AlignContent>(1);
assert_type_size::<AlignItems>(1);
assert_type_size::<Option<AlignItems>>(1);
// Flexbox Container
assert_type_size::<FlexDirection>(1);
assert_type_size::<FlexWrap>(1);
// CSS Grid Container
assert_type_size::<GridAutoFlow>(1);
assert_type_size::<MinTrackSizingFunction>(8);
assert_type_size::<MaxTrackSizingFunction>(12);
assert_type_size::<NonRepeatedTrackSizingFunction>(20);
assert_type_size::<TrackSizingFunction>(32);
assert_type_size::<Vec<NonRepeatedTrackSizingFunction>>(24);
assert_type_size::<Vec<TrackSizingFunction>>(24);
// CSS Grid Item
assert_type_size::<GridPlacement>(4);
assert_type_size::<Line<GridPlacement>>(8);
// Overall
assert_type_size::<Style>(352);
}
}