use std::sync::Arc;
use super::{
button::{Button, ButtonPart, ButtonSize, ButtonVariant},
icons, names,
part_style::{Length, PartAnimation, PartStyle},
recipe::{Case, Interaction, Name, Recipe, ResolvedPart, ResolvedRecipe, Selector},
separator::{Separator, SeparatorPart},
shared::{FADE_IN, FADE_OUT},
theme::{Themed, current_theme},
};
use crate::{
animation::{AnimatableProperty, AnimatableValue, Keyframes, KeyframesId},
app::{
ctx::Ctx,
events::MouseEvent,
theme::{BorderSize, MotionDuration, MotionEasing, PaletteColor, RadiusSize, ShadowStyle, Theme, TypographyStyle},
},
components::{
Column, Modal, Root, Row, ScrollVertical, Sheet as Draggable, SheetDetent, SheetNode, SheetProps, SheetStyle, Stack,
},
core::Signal,
layout::{
Alignment,
layout_kind::{Justify, ScrollState},
text_style::{FontWeight, TextAlign},
},
node::{Element, border::Border as Edge, color::Color, dimension::Dimension},
};
pub const SHEET_IN_FROM_START: KeyframesId = KeyframesId::new(0xFF51);
pub const SHEET_IN_FROM_END: KeyframesId = KeyframesId::new(0xFF52);
pub const SHEET_IN_FROM_TOP: KeyframesId = KeyframesId::new(0xFF53);
pub const SHEET_IN_FROM_BOTTOM: KeyframesId = KeyframesId::new(0xFF54);
pub const SHEET_OUT_TO_START: KeyframesId = KeyframesId::new(0xFF55);
pub const SHEET_OUT_TO_END: KeyframesId = KeyframesId::new(0xFF56);
pub const SHEET_OUT_TO_TOP: KeyframesId = KeyframesId::new(0xFF57);
pub const SHEET_OUT_TO_BOTTOM: KeyframesId = KeyframesId::new(0xFF58);
pub(crate) fn keyframes() -> [Keyframes; 8] {
let slide = |id: KeyframesId, along: AnimatableProperty, from: f32, to: f32| {
Keyframes::new(id)
.frame(0.0, |frame| {
frame.set(along, AnimatableValue::Percent(from));
})
.frame(1.0, |frame| {
frame.set(along, AnimatableValue::Percent(to));
})
};
use AnimatableProperty::{OffsetX, OffsetY};
[
slide(SHEET_IN_FROM_START, OffsetX, -100.0, 0.0),
slide(SHEET_IN_FROM_END, OffsetX, 100.0, 0.0),
slide(SHEET_IN_FROM_TOP, OffsetY, -100.0, 0.0),
slide(SHEET_IN_FROM_BOTTOM, OffsetY, 100.0, 0.0),
slide(SHEET_OUT_TO_START, OffsetX, 0.0, -100.0),
slide(SHEET_OUT_TO_END, OffsetX, 0.0, 100.0),
slide(SHEET_OUT_TO_TOP, OffsetY, 0.0, -100.0),
slide(SHEET_OUT_TO_BOTTOM, OffsetY, 0.0, 100.0),
]
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum SheetPart {
Veil,
Panel,
Grabber,
Handle,
Header,
Text,
Title,
Description,
Body,
Footer,
Close,
Separator,
}
names!(SheetPart {
Veil => "veil",
Panel => "panel",
Grabber => "grabber",
Handle => "handle",
Header => "header",
Text => "text",
Title => "title",
Description => "description",
Body => "body",
Footer => "footer",
Close => "close",
Separator => "separator",
});
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum SheetSide {
Start,
#[default]
End,
Top,
Bottom,
}
names!(SheetSide {
Start => "start",
End => "end",
Top => "top",
Bottom => "bottom",
});
impl SheetSide {
pub fn is_side(self) -> bool {
matches!(self, Self::Start | Self::End)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum SheetState {
Modal,
ReducedMotion,
}
names!(SheetState {
Modal => "modal",
ReducedMotion => "reduced-motion",
});
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum SheetSize {
Sm,
Md,
Lg,
Full,
}
names!(SheetSize {
Sm => "sm",
Md => "md",
Lg => "lg",
Full => "full",
});
pub type SheetRenderer = Arc<dyn Fn(SheetView) -> Element + Send + Sync>;
pub struct Sheet {
open: Signal<bool>,
side: SheetSide,
title: Option<Arc<str>>,
description: Option<Arc<str>>,
label: Option<Arc<str>>,
body: Vec<Element>,
footer: Vec<Element>,
size: Option<Name>,
close_button: bool,
close_label: Arc<str>,
forced: Option<Interaction>,
grabber: Option<bool>,
dismiss_on_veil: bool,
dismiss_on_escape: bool,
on_dismiss: Vec<Dismiss>,
detents: Vec<SheetDetent>,
detent: Option<Signal<usize>>,
scroll_state: Option<ScrollState>,
body_scrolls: bool,
inline: bool,
states: Vec<Name>,
rules: Recipe,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
type Dismiss = Arc<dyn Fn() + Send + Sync>;
impl Sheet {
pub fn new(open: Signal<bool>) -> Self {
Self {
open,
side: SheetSide::default(),
title: None,
description: None,
label: None,
body: Vec::new(),
footer: Vec::new(),
size: None,
close_button: false,
close_label: super::current_locale().common.close.clone(),
forced: None,
grabber: None,
dismiss_on_veil: true,
dismiss_on_escape: true,
on_dismiss: Vec::new(),
detents: Vec::new(),
detent: None,
scroll_state: None,
body_scrolls: true,
inline: false,
states: Vec::new(),
rules: Recipe::new(),
id: None,
key: None,
}
}
pub fn side(mut self, side: SheetSide) -> Self {
self.side = side;
self
}
pub fn title(mut self, title: &str) -> Self {
self.title = Some(Arc::from(title));
self
}
pub fn description(mut self, description: &str) -> Self {
self.description = Some(Arc::from(description));
self
}
pub fn label(mut self, label: &str) -> Self {
self.label = Some(Arc::from(label));
self
}
pub fn child(mut self, child: impl Into<Element>) -> Self {
self.body.push(child.into());
self
}
pub fn children(mut self, children: impl IntoIterator<Item = impl Into<Element>>) -> Self {
self.body.extend(children.into_iter().map(Into::into));
self
}
pub fn footer(mut self, element: impl Into<Element>) -> Self {
self.footer.push(element.into());
self
}
pub fn size(mut self, size: impl Into<Name>) -> Self {
self.size = Some(size.into());
self
}
pub fn close_button(mut self, close_button: bool) -> Self {
self.close_button = close_button;
self
}
pub fn close_label(mut self, label: &str) -> Self {
self.close_label = Arc::from(label);
self
}
pub fn force(mut self, interaction: Option<Interaction>) -> Self {
self.forced = interaction;
self
}
pub fn grabber(mut self, grabber: bool) -> Self {
self.grabber = Some(grabber);
self
}
pub fn dismiss_on_veil(mut self, dismiss: bool) -> Self {
self.dismiss_on_veil = dismiss;
self
}
pub fn dismiss_on_escape(mut self, dismiss: bool) -> Self {
self.dismiss_on_escape = dismiss;
self
}
pub fn on_dismiss(mut self, handler: impl Fn() + Send + Sync + 'static) -> Self {
self.on_dismiss.push(Arc::new(handler));
self
}
pub fn detents(mut self, detents: impl IntoIterator<Item = SheetDetent>) -> Self {
self.detents = detents.into_iter().collect();
self
}
pub fn detent(mut self, detent: Signal<usize>) -> Self {
self.detent = Some(detent);
self
}
pub fn scroll_state(mut self, scroll: ScrollState) -> Self {
self.scroll_state = Some(scroll);
self
}
pub fn body_scrolls(mut self, scrolls: bool) -> Self {
self.body_scrolls = scrolls;
self
}
pub fn inline(mut self, inline: bool) -> Self {
self.inline = inline;
self
}
pub fn state(mut self, state: impl Into<Name>, on: bool) -> Self {
let state = state.into();
self.states.retain(|held| *held != state);
if on {
self.states.push(state);
}
self
}
pub fn style(mut self, part: impl Into<Name>, style: impl FnOnce(PartStyle) -> PartStyle) -> Self {
self.rules = self.rules.base(part, style);
self
}
pub fn rules(mut self, rules: &Recipe) -> Self {
self.rules = self.rules.extend(rules);
self
}
pub fn id(mut self, id: impl Into<Arc<str>>) -> Self {
self.id = Some(id.into());
self
}
pub fn key(mut self, key: impl Into<Arc<str>>) -> Self {
self.key = Some(key.into());
self
}
fn view(self, theme: &Theme) -> SheetView {
let case = Case {
variant: Some(self.side.into()),
size: self.size,
density: None,
breakpoint: super::current_breakpoint(),
states: self.states.clone(),
}
.state(SheetState::Modal, !self.inline)
.state(SheetState::ReducedMotion, theme.reduced_motion());
SheetView {
side: self.side,
title: self.title,
description: self.description,
label: self.label,
body: self.body,
footer: self.footer,
close_button: self.close_button,
close_label: self.close_label,
forced: self.forced,
grabber: self.grabber.unwrap_or(self.side == SheetSide::Bottom),
dismiss_on_veil: self.dismiss_on_veil,
dismiss_on_escape: self.dismiss_on_escape,
inline: self.inline,
recipe: theme
.resolve::<Sheet>(&case, Some(&self.rules))
.owned_by(self.id.as_ref()),
open: self.open,
detents: self.detents,
detent: self.detent,
scroll_state: self.scroll_state,
on_dismiss: self.on_dismiss,
body_scrolls: self.body_scrolls,
id: self.id,
key: self.key,
}
}
pub fn build(self, theme: &Theme) -> Element {
let view = self.view(theme);
match theme.renderer::<Sheet>() {
Some(renderer) => renderer(view),
None => view.render(),
}
}
pub fn mount(self, ctx: &mut Ctx) -> Element {
let theme = current_theme();
if self.side != SheetSide::Bottom || self.inline {
return self.build(&theme);
}
self.view(&theme).draggable(ctx)
}
}
impl From<Sheet> for Element {
fn from(sheet: Sheet) -> Self {
sheet.build(¤t_theme())
}
}
pub struct SheetView {
pub side: SheetSide,
pub title: Option<Arc<str>>,
pub description: Option<Arc<str>>,
pub label: Option<Arc<str>>,
pub body: Vec<Element>,
pub footer: Vec<Element>,
pub close_button: bool,
pub close_label: Arc<str>,
pub forced: Option<Interaction>,
pub grabber: bool,
pub dismiss_on_veil: bool,
pub dismiss_on_escape: bool,
pub inline: bool,
pub recipe: ResolvedRecipe,
open: Signal<bool>,
on_dismiss: Vec<Dismiss>,
detents: Vec<SheetDetent>,
detent: Option<Signal<usize>>,
scroll_state: Option<ScrollState>,
body_scrolls: bool,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl SheetView {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part)
}
pub fn theme(&self) -> &Theme {
self.recipe.theme()
}
pub fn open(&self) -> &Signal<bool> {
&self.open
}
pub fn closer(&self) -> impl Fn() + Send + Sync + Clone + 'static {
let open = self.open.clone();
move || open.set(false)
}
pub fn dismisser(&self) -> impl Fn() + Send + Sync + Clone + 'static {
let (close, on_dismiss) = (self.closer(), self.on_dismiss.clone());
move || {
close();
for handler in &on_dismiss {
handler();
}
}
}
fn stacked(&self) -> bool {
self.side == SheetSide::Bottom
}
fn name(&self) -> Option<Arc<str>> {
self.title.clone().or_else(|| self.label.clone())
}
pub fn panel(&self) -> Column {
let mut panel = Column::new()
.part(&self.part(SheetPart::Panel))
.max_width(Dimension::Pct(100.0))
.max_height(Dimension::Pct(100.0))
.on_click(|event: MouseEvent| event.stop_propagation())
.describe("a11y_role", "dialog");
if let Some(name) = self.name() {
panel = panel.describe("a11y_name", name);
}
if let Some(id) = &self.id {
panel = panel.id(id.clone());
}
panel
}
pub fn grabber(&self) -> Option<Row> {
if !self.grabber {
return None;
}
Some(
Row::new()
.width(Dimension::Pct(100.0))
.justify(Justify::Center)
.part(&self.part(SheetPart::Grabber))
.child(Row::new().part(&self.part(SheetPart::Handle))),
)
}
pub fn text(&self) -> Option<Column> {
if self.title.is_none() && self.description.is_none() {
return None;
}
let (align, text_align) = if self.stacked() {
(Alignment::Center, TextAlign::Center)
} else {
(Alignment::Start, TextAlign::Left)
};
let mut column = Column::new()
.part(&self.part(SheetPart::Text))
.align_items(align)
.flex_full(1.0, 1.0, Some(0.0))
.min_width(Dimension::Px(0.0));
let fill = Dimension::Pct(100.0);
let text = |part: SheetPart, content: &str| {
let part = self.part(part);
Column::new()
.width(fill.clone())
.part(&part)
.child(part.text(content).width(fill.clone()).text_align(text_align))
};
if let Some(title) = &self.title {
column = column.child(text(SheetPart::Title, title));
}
if let Some(description) = &self.description {
column = column.child(text(SheetPart::Description, description));
}
Some(column)
}
pub fn close(&self) -> Button {
let close = self.dismisser();
Button::new(&self.close_label)
.variant(ButtonVariant::Ghost)
.size(ButtonSize::Sm)
.icon(icons::CLOSE)
.icon_only(true)
.force(self.forced)
.rules(&self.recipe.rules_for(SheetPart::Close, ButtonPart::Root))
.on_click(move |_| close())
}
pub fn header(&self) -> Option<Row> {
let text = self.text();
if text.is_none() && !self.close_button {
return None;
}
let mut header = Row::new()
.width(Dimension::Pct(100.0))
.align_items(Alignment::Start)
.part(&self.part(SheetPart::Header));
if let Some(text) = text {
header = header.child(text);
}
if self.close_button {
header = header.justify(Justify::End).child(self.close());
}
Some(header)
}
pub fn separator(&self) -> Element {
Separator::horizontal()
.rules(&self.recipe.rules_for(SheetPart::Separator, SeparatorPart::Line))
.into()
}
pub fn body(&mut self) -> Option<Element> {
if self.body.is_empty() {
return None;
}
let body = Column::new()
.width(Dimension::Pct(100.0))
.part(&self.part(SheetPart::Body))
.with_children(std::mem::take(&mut self.body));
if !self.body_scrolls {
let grow = if self.side.is_side() { 1.0 } else { 0.0 };
return Some(body.align_items(Alignment::Stretch).flex_full(grow, 1.0, None).into());
}
let mut scroll = ScrollVertical::new(body);
if let Some(state) = &self.scroll_state {
scroll = scroll.with_scroll_state(state.clone());
}
let grow = if self.side.is_side() { 1.0 } else { 0.0 };
Some(scroll.width(Dimension::Pct(100.0)).flex_full(grow, 1.0, None).into())
}
pub fn footer(&mut self) -> Option<Element> {
if self.footer.is_empty() {
return None;
}
let part = self.part(SheetPart::Footer);
let mut footer = std::mem::take(&mut self.footer);
if self.stacked() {
footer.reverse();
return Some(
Column::new()
.width(Dimension::Pct(100.0))
.align_items(Alignment::Stretch)
.part(&part)
.with_children(footer)
.into(),
);
}
Some(
Row::new()
.width(Dimension::Pct(100.0))
.align_items(Alignment::Center)
.justify(Justify::End)
.part(&part)
.with_children(footer)
.into(),
)
}
pub fn contents(&mut self) -> Vec<Element> {
let mut contents: Vec<Element> = Vec::new();
if let Some(grabber) = self.grabber() {
contents.push(grabber.into());
}
if let Some(header) = self.header() {
contents.push(header.into());
}
if let Some(body) = self.body() {
contents.push(body);
}
if let Some(footer) = self.footer() {
if !self.stacked() {
contents.push(self.separator());
}
contents.push(footer);
}
contents
}
pub fn veil(&self, panel: impl Into<Element>) -> Stack {
let full = Dimension::Pct(100.0);
let veil = Column::new().size(full, full).part(&self.part(SheetPart::Veil));
let holder: Element = match self.side {
SheetSide::Start | SheetSide::End => {
let justify = if self.side == SheetSide::Start {
Justify::Start
} else {
Justify::End
};
let mut holder = Row::new()
.size(full, full)
.align_items(Alignment::Stretch)
.justify(justify)
.child(panel);
if self.dismiss_on_veil {
let close = self.dismisser();
holder = holder.on_click(move |_| close());
}
holder.into()
}
SheetSide::Top | SheetSide::Bottom => {
let justify = if self.side == SheetSide::Top {
Justify::Start
} else {
Justify::End
};
let mut holder = Column::new()
.size(full, full)
.align_items(Alignment::Center)
.justify(justify)
.child(panel);
if self.dismiss_on_veil {
let close = self.dismisser();
holder = holder.on_click(move |_| close());
}
holder.into()
}
};
let mut stack = Stack::new().size(full, full).child(veil).child(holder);
if let Some(key) = &self.key {
stack = stack.key(key.clone());
}
stack
}
pub fn modal(&self, panel: impl Into<Element>) -> Element {
let mut modal = Modal::new(self.veil(panel))
.open(self.open.clone())
.target(Root)
.dismiss_on_escape(self.dismiss_on_escape)
.takes_focus(true);
for handler in &self.on_dismiss {
let handler = handler.clone();
modal = modal.on_dismiss(move || handler());
}
modal.into()
}
pub fn render(mut self) -> Element {
let contents = self.contents();
let panel = self.panel().with_children(contents);
if self.inline {
panel.into()
} else {
let panel = self.clear_of_the_edges(panel);
self.modal(panel)
}
}
fn clear_of_the_edges(&self, panel: Column) -> Column {
let Some(window) = super::theme::current_window() else {
return panel;
};
let safe = window.info().safe_area;
let spacing = self.theme().spacing();
let [top, end, bottom, start] = self
.part(SheetPart::Panel)
.rest()
.paddings()
.map(|padding| padding.map_or(0.0, |padding| padding.resolve(&spacing, 0.0)));
let (at_top, at_bottom, at_start, at_end) = match self.side {
SheetSide::Start => (true, true, true, false),
SheetSide::End => (true, true, false, true),
SheetSide::Top => (true, false, true, true),
SheetSide::Bottom => (false, true, true, true),
};
let mut panel = panel;
if at_top && safe.top > 0.0 {
panel = panel.padding_top(top + safe.top);
}
if at_bottom && safe.bottom > 0.0 {
panel = panel.padding_bottom(bottom + safe.bottom);
}
if at_start && safe.left > 0.0 {
panel = panel.padding_left(start + safe.left);
}
if at_end && safe.right > 0.0 {
panel = panel.padding_right(end + safe.right);
}
panel
}
fn draggable(mut self, ctx: &mut Ctx) -> Element {
let panel = self.part(SheetPart::Panel);
let (panel_look, veil_look) = (look(&panel), look(&self.part(SheetPart::Veil)));
let handle_look = look(&self.part(SheetPart::Handle));
let rest = panel.rest();
let theme = self.theme().clone();
let px = |length: Option<Length>| match length.and_then(|length| length.resolve(&theme)) {
Some(Dimension::Px(px)) => Some(px),
_ => None,
};
let detents = if !self.detents.is_empty() {
std::mem::take(&mut self.detents)
} else {
match rest.height {
Some(Length::Fill) => vec![SheetDetent::Large],
height => match px(height) {
Some(height) => vec![SheetDetent::Height(height)],
None => vec![SheetDetent::Content],
},
}
};
let fits_content = detents.iter().all(|detent| *detent == SheetDetent::Content);
let mut style = SheetStyle::new().grabber(false).dim(1.0).corner_radius(0.0);
style.backdrop = Color::new(0, 0, 0, 0);
if let Some(max_width) = px(rest.max_width) {
style.max_width = max_width;
}
let contents = self.contents();
let mut content = Column::new()
.width(Dimension::Pct(100.0))
.part(&spacing(&panel))
.with_children(contents)
.describe("a11y_role", "dialog");
content = if fits_content {
content.max_height(Dimension::Pct(100.0))
} else {
content.height(Dimension::Pct(100.0))
};
if let Some(name) = self.name() {
content = content.describe("a11y_name", name);
}
if let Some(id) = &self.id {
content = content.id(id.clone());
}
let mut props = SheetProps::new(self.open.clone())
.detents(detents)
.style(style)
.dismissable(self.dismiss_on_veil)
.dismiss_on_escape(self.dismiss_on_escape)
.takes_focus(true)
.dress(move |node, column| match node {
SheetNode::Backdrop => column.part(&veil_look),
SheetNode::Panel => column.part(&panel_look),
SheetNode::Grabber => column.part(&handle_look),
});
for handler in &self.on_dismiss {
let handler = handler.clone();
props = props.on_dismiss(move || handler());
}
if let Some(detent) = self.detent.take() {
props = props.detent(detent);
}
if let Some(scroll) = self.scroll_state.take() {
props = props.scroll(scroll);
}
match &self.key {
Some(key) => Draggable::mount_keyed(ctx, key, props, content),
None => Draggable::mount(ctx, props, content),
}
}
}
fn look(part: &ResolvedPart) -> ResolvedPart {
let rest = part.rest();
let look = PartStyle {
background: rest.background,
foreground: rest.foreground,
border: rest.border,
underline: rest.underline,
start_line: rest.start_line,
end_line: rest.end_line,
top_line: rest.top_line,
radius: rest.radius,
shadow: rest.shadow,
..PartStyle::default()
};
only(part.theme(), look)
}
fn spacing(part: &ResolvedPart) -> ResolvedPart {
let rest = part.rest();
let spacing = PartStyle {
padding_x: rest.padding_x,
padding_y: rest.padding_y,
padding_top: rest.padding_top,
padding_bottom: rest.padding_bottom,
padding_start: rest.padding_start,
padding_end: rest.padding_end,
gap: rest.gap,
..PartStyle::default()
};
only(part.theme(), spacing)
}
fn only(theme: &Theme, style: PartStyle) -> ResolvedPart {
let name = Name::new("part");
Recipe::new()
.base(name, |_| style)
.resolve(&Case::default(), theme)
.part(name)
}
impl crate::ui::Styled for Sheet {
type Component = Self;
fn rules(self, rules: &crate::ui::Recipe) -> Self {
Self::rules(self, rules)
}
fn state(self, state: impl Into<crate::ui::Name>, on: bool) -> Self {
Self::state(self, state, on)
}
}
impl Themed for Sheet {
const NAME: &'static str = "sheet";
const ROOT: &'static str = "panel";
type Renderer = SheetRenderer;
fn parts() -> crate::ui::Declared {
SheetPart::declared()
}
fn states() -> crate::ui::Declared {
SheetState::declared()
}
fn recipe() -> Recipe {
use PaletteColor::*;
use SheetPart::{Body, Close, Description, Footer, Grabber, Handle, Header, Panel, Text, Title, Veil};
use SheetSide::{Bottom, End, Start, Top};
use SheetSize::{Full, Lg, Md, Sm};
use SheetState::{Modal, ReducedMotion};
let line = || Edge::inside(BorderSize::Sm, PaletteColor::Border);
let entering = |keyframes| PartAnimation::new(keyframes, MotionDuration::Slow, MotionEasing::Enter);
let leaving = |keyframes| PartAnimation::new(keyframes, MotionDuration::Base, MotionEasing::Exit);
let moving = |side: SheetSide| Selector::new().variant(side).state(Modal);
let sized = |side: SheetSide, size: SheetSize| Selector::new().variant(side).size(size);
let mut recipe = Recipe::new()
.base(Veil, |s| {
s.background(Scrim)
.enter(entering(FADE_IN))
.exit(leaving(FADE_OUT))
})
.base(Panel, |s| {
s.background(Background)
.foreground(Foreground)
.shadow(ShadowStyle::Lg)
})
.base(Header, |s| s.gap(8.0).padding_x(16.0).padding_top(16.0))
.base(Text, |s| s.gap(4.0).padding_start(4.0).padding_top(4.0))
.base(Title, |s| {
s.typography(TypographyStyle::Body)
.font_size(16.0)
.weight(FontWeight::SemiBold)
})
.base(Description, |s| {
s.typography(TypographyStyle::Description)
.font_size(13.0)
.foreground(MutedForeground)
})
.base(Close, |s| {
s.square(24.0)
.radius(RadiusSize::Md)
.foreground(MutedForeground)
})
.base(Body, |s| s.gap(16.0).padding_x(20.0).padding_y(20.0))
.base(Footer, |s| s.gap(8.0).padding_x(20.0).padding_y(16.0))
.variant(Start, Panel, |s| s.width(320.0).height(Length::Fill).end_line(line()))
.variant(End, Panel, |s| s.width(320.0).height(Length::Fill).start_line(line()))
.variant(Top, Panel, |s| s.width(Length::Fill).underline(line()))
.variant(Bottom, Panel, |s| {
s.width(Length::Fill)
.border(line())
.corners(RadiusSize::Xl, RadiusSize::Xl, 0.0, 0.0)
.padding_bottom(20.0)
})
.variant(Bottom, Grabber, |s| s.padding_top(8.0))
.base(Handle, |s| {
s.width(40.0)
.height(4.0)
.radius(RadiusSize::Full)
.background(Muted)
})
.variant(Bottom, Header, |s| s.padding_x(20.0).padding_top(20.0))
.variant(Bottom, Text, |s| s.padding_start(0.0).padding_top(0.0))
.variant(Bottom, Body, |s| s.padding_y(0.0).padding_top(20.0))
.variant(Bottom, Footer, |s| s.padding_y(0.0).padding_top(20.0));
for (size, width, height) in [(Sm, 320.0, 240.0), (Md, 400.0, 360.0), (Lg, 540.0, 480.0)] {
recipe = recipe
.when(sized(Start, size), Panel, |s| s.width(width))
.when(sized(End, size), Panel, |s| s.width(width))
.when(sized(Top, size), Panel, |s| s.height(height))
.when(sized(Bottom, size), Panel, |s| s.height(height));
}
recipe = recipe
.when(sized(Start, Full), Panel, |s| s.width(Length::Fill))
.when(sized(End, Full), Panel, |s| s.width(Length::Fill))
.when(sized(Top, Full), Panel, |s| s.height(Length::Fill))
.when(sized(Bottom, Full), Panel, |s| s.height(Length::Fill));
for (side, coming, going) in [
(Start, SHEET_IN_FROM_START, SHEET_OUT_TO_START),
(End, SHEET_IN_FROM_END, SHEET_OUT_TO_END),
(Top, SHEET_IN_FROM_TOP, SHEET_OUT_TO_TOP),
(Bottom, SHEET_IN_FROM_BOTTOM, SHEET_OUT_TO_BOTTOM),
] {
recipe = recipe.when(moving(side), Panel, |s| s.enter(entering(coming)).exit(leaving(going)));
}
recipe.when(Selector::new().state(Modal).state(ReducedMotion), Panel, |s| {
s.enter(entering(FADE_IN)).exit(leaving(FADE_OUT))
})
}
}