use gpui::{
div, prelude::*, px, relative, AlignItems, AnyElement, App, Div, JustifyContent, Pixels,
StyleRefinement, Window,
};
use crate::components::direction::{is_rtl, DirectionalStyled};
use crate::{
styles::ApplyStyleOverrides,
sx::{Sx, SxStyled},
};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum MainAxisAlignment {
#[default]
Start,
End,
Center,
SpaceBetween,
SpaceAround,
SpaceEvenly,
}
impl MainAxisAlignment {
pub(super) fn justify_content(self) -> JustifyContent {
match self {
Self::Start => JustifyContent::FlexStart,
Self::End => JustifyContent::FlexEnd,
Self::Center => JustifyContent::Center,
Self::SpaceBetween => JustifyContent::SpaceBetween,
Self::SpaceAround => JustifyContent::SpaceAround,
Self::SpaceEvenly => JustifyContent::SpaceEvenly,
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum CrossAxisAlignment {
Start,
End,
#[default]
Center,
Stretch,
Baseline,
}
impl CrossAxisAlignment {
pub(super) fn align_items(self, vertical: bool) -> AlignItems {
let mirrored = vertical && is_rtl();
match self {
Self::Start if mirrored => AlignItems::FlexEnd,
Self::End if mirrored => AlignItems::FlexStart,
Self::Start => AlignItems::FlexStart,
Self::End => AlignItems::FlexEnd,
Self::Center => AlignItems::Center,
Self::Stretch => AlignItems::Stretch,
Self::Baseline => AlignItems::Baseline,
}
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum MainAxisSize {
Min,
#[default]
Max,
}
struct FlexProps {
main_axis_alignment: MainAxisAlignment,
cross_axis_alignment: CrossAxisAlignment,
main_axis_size: MainAxisSize,
spacing: Pixels,
children: Vec<AnyElement>,
}
impl FlexProps {
pub(super) fn new() -> Self {
Self {
main_axis_alignment: MainAxisAlignment::Start,
cross_axis_alignment: CrossAxisAlignment::Center,
main_axis_size: MainAxisSize::Max,
spacing: px(0.),
children: Vec::new(),
}
}
pub(super) fn render(self, vertical: bool) -> Div {
let mut flex = div().flex_dir().gap(self.spacing);
if vertical {
flex = flex.flex_col();
}
flex.style().justify_content = Some(self.main_axis_alignment.justify_content());
flex.style().align_items = Some(self.cross_axis_alignment.align_items(vertical));
match (self.main_axis_size, vertical) {
(MainAxisSize::Max, false) => flex = flex.w_full(),
(MainAxisSize::Max, true) => flex = flex.h_full(),
(MainAxisSize::Min, _) => {}
}
flex.children(self.children)
}
}
macro_rules! flex_widget {
($(#[$doc:meta])* $name:ident, vertical: $vertical:expr) => {
$(#[$doc])*
#[derive(IntoElement)]
pub struct $name {
props: FlexProps,
sx: Sx,
style_overrides: StyleRefinement,
}
crate::implement_style_overrides!($name);
impl $name {
#[must_use]
pub fn new() -> Self {
Self {
props: FlexProps::new(),
sx: Sx::new(),
style_overrides: StyleRefinement::default(),
}
}
#[must_use]
pub fn main_axis_alignment(mut self, alignment: MainAxisAlignment) -> Self {
self.props.main_axis_alignment = alignment;
self
}
#[must_use]
pub fn cross_axis_alignment(mut self, alignment: CrossAxisAlignment) -> Self {
self.props.cross_axis_alignment = alignment;
self
}
#[must_use]
pub fn main_axis_size(mut self, size: MainAxisSize) -> Self {
self.props.main_axis_size = size;
self
}
#[must_use]
pub fn spacing(mut self, spacing: impl Into<Pixels>) -> Self {
self.props.spacing = spacing.into();
self
}
}
impl Default for $name {
fn default() -> Self {
Self::new()
}
}
impl ParentElement for $name {
fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
self.props.children.extend(elements);
}
}
impl RenderOnce for $name {
fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement {
self.props
.render($vertical)
.sx(&self.sx)
.apply_style_overrides(&self.style_overrides)
}
}
};
}
flex_widget!(
Row,
vertical: false
);
flex_widget!(
Column,
vertical: true
);
pub(super) fn fill_box(children: Vec<AnyElement>) -> Div {
let rows = children.len().max(1) as u16;
div().grid().grid_cols(1).grid_rows(rows).children(children)
}
#[derive(IntoElement)]
pub struct Expanded {
flex: f32,
children: Vec<AnyElement>,
sx: Sx,
style_overrides: StyleRefinement,
}
crate::implement_style_overrides!(Expanded);
impl Expanded {
#[must_use]
pub fn new() -> Self {
Self {
flex: 1.,
children: Vec::new(),
sx: Sx::new(),
style_overrides: StyleRefinement::default(),
}
}
#[must_use]
pub fn flex(mut self, flex: f32) -> Self {
self.flex = flex;
self
}
}
impl Default for Expanded {
fn default() -> Self {
Self::new()
}
}
impl ParentElement for Expanded {
fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
self.children.extend(elements);
}
}
impl RenderOnce for Expanded {
fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement {
let mut expanded = fill_box(self.children).min_w(px(0.)).min_h(px(0.));
let style = expanded.style();
style.flex_grow = Some(self.flex);
style.flex_shrink = Some(1.);
style.flex_basis = Some(relative(0.).into());
expanded
.sx(&self.sx)
.apply_style_overrides(&self.style_overrides)
}
}
#[derive(IntoElement)]
pub struct Flexible {
flex: f32,
children: Vec<AnyElement>,
sx: Sx,
style_overrides: StyleRefinement,
}
crate::implement_style_overrides!(Flexible);
impl Flexible {
#[must_use]
pub fn new() -> Self {
Self {
flex: 1.,
children: Vec::new(),
sx: Sx::new(),
style_overrides: StyleRefinement::default(),
}
}
#[must_use]
pub fn flex(mut self, flex: f32) -> Self {
self.flex = flex;
self
}
}
impl Default for Flexible {
fn default() -> Self {
Self::new()
}
}
impl ParentElement for Flexible {
fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
self.children.extend(elements);
}
}
impl RenderOnce for Flexible {
fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement {
let mut flexible = div()
.flex_dir()
.flex_col()
.items_start()
.min_w(px(0.))
.min_h(px(0.))
.children(self.children);
let style = flexible.style();
style.flex_grow = Some(self.flex);
style.flex_shrink = Some(1.);
flexible
.sx(&self.sx)
.apply_style_overrides(&self.style_overrides)
}
}
#[derive(IntoElement)]
pub struct Spacer {
flex: f32,
}
impl Spacer {
#[must_use]
pub fn new() -> Self {
Self { flex: 1. }
}
#[must_use]
pub fn flex(mut self, flex: f32) -> Self {
self.flex = flex;
self
}
}
impl Default for Spacer {
fn default() -> Self {
Self::new()
}
}
impl RenderOnce for Spacer {
fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement {
let mut spacer = div();
let style = spacer.style();
style.flex_grow = Some(self.flex);
style.flex_shrink = Some(1.);
style.flex_basis = Some(relative(0.).into());
spacer
}
}