use std::sync::{
Arc, Mutex,
atomic::{AtomicBool, Ordering},
};
use super::{
icon::Icon,
icons,
menu::{Menu, MenuItem},
names,
part_style::{Length, PartStyle},
recipe::{Case, Interaction, Name, Recipe, ResolvedPart, ResolvedRecipe},
shared::{fading, glyph, one_line, pressable},
theme::{Themed, current_theme},
};
use crate::{
app::{
component::Component,
ctx::Ctx,
events::{DragEvent, KeyboardEvent, MouseButtonMask},
theme::{BorderSize, IconSize, PaletteColor, RadiusSize, ShadowStyle, Theme, TypographyStyle},
},
components::{self, Column, Row, ScrollVertical, Stack},
core::{ElementRef, Signal, SignalValue},
layout::{Alignment, layout_kind::Justify, text_style::FontWeight},
node::{CursorIcon, Element, HitTestBehavior, border::Border, dimension::Dimension},
};
type Handler = Arc<dyn Fn() + Send + Sync>;
#[derive(Clone)]
struct HeaderButton {
icon: Name,
label: Arc<str>,
on_click: Handler,
}
#[derive(Clone)]
struct HeaderMenu {
open: Signal<bool>,
items: Arc<dyn Fn() -> Vec<MenuItem> + Send + Sync>,
}
pub(super) fn header_button(
part: &ResolvedPart,
icon: &Name,
label: &Arc<str>,
on_click: Handler,
) -> components::Button {
pressable(part, false)
.align_items(Alignment::Center)
.describe("a11y_role", "button")
.describe("a11y_name", label.clone())
.on_click(move |_| on_click())
.child(Icon::new(icon.clone()).size(IconSize::Sm).build(part.theme()))
}
fn header_menu(part: &ResolvedPart, label: &Arc<str>, menu: HeaderMenu) -> Element {
let anchor = ElementRef::new();
let toggle = menu.open.clone();
let button = header_button(
part,
&Name::new(icons::MORE_HORIZONTAL),
label,
Arc::new(move || toggle.update(|open| *open = !*open)),
)
.ref_element(anchor.clone())
.describe("a11y_haspopup", "menu")
.describe("a11y_expanded", if menu.open.get() { "true" } else { "false" });
Column::new()
.overflow_visible()
.child(button)
.child(Menu::new(menu.open, anchor).items((menu.items)()))
.into()
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum PanelHeaderPart {
Root,
Media,
Title,
Actions,
Button,
}
names!(PanelHeaderPart {
Root => "root",
Media => "media",
Title => "title",
Actions => "actions",
Button => "button",
});
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum PanelHeaderState {
Media,
}
names!(PanelHeaderState {
Media => "media",
});
pub type PanelHeaderRenderer = Arc<dyn Fn(PanelHeaderView) -> Element + Send + Sync>;
pub struct PanelHeader {
title: Arc<str>,
media: Option<Element>,
buttons: Vec<HeaderButton>,
menu: Option<HeaderMenu>,
on_close: Vec<Handler>,
more_label: Arc<str>,
close_label: Arc<str>,
level: u32,
states: Vec<Name>,
rules: Recipe,
forced: Option<Interaction>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl PanelHeader {
pub fn new(title: &str) -> Self {
Self {
title: Arc::from(title),
media: None,
buttons: Vec::new(),
menu: None,
on_close: Vec::new(),
more_label: super::current_locale().common.more.clone(),
close_label: super::current_locale().common.close.clone(),
level: 2,
states: Vec::new(),
rules: Recipe::new(),
forced: None,
id: None,
key: None,
}
}
pub fn media(mut self, media: impl Into<Element>) -> Self {
self.media = Some(media.into());
self
}
pub fn button(mut self, icon: impl Into<Name>, label: &str, on_click: impl Fn() + Send + Sync + 'static) -> Self {
self.buttons.push(HeaderButton {
icon: icon.into(),
label: Arc::from(label),
on_click: Arc::new(on_click),
});
self
}
pub fn menu<I: IntoIterator<Item = MenuItem>>(
mut self,
open: Signal<bool>,
items: impl Fn() -> I + Send + Sync + 'static,
) -> Self {
self.menu = Some(HeaderMenu {
open,
items: Arc::new(move || items().into_iter().collect()),
});
self
}
pub fn on_close(mut self, handler: impl Fn() + Send + Sync + 'static) -> Self {
self.on_close.push(Arc::new(handler));
self
}
pub fn more_label(mut self, label: &str) -> Self {
self.more_label = Arc::from(label);
self
}
pub fn close_label(mut self, label: &str) -> Self {
self.close_label = Arc::from(label);
self
}
pub fn level(mut self, level: u32) -> Self {
self.level = level;
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 force(mut self, interaction: Option<Interaction>) -> Self {
self.forced = interaction;
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
}
pub fn build(self, theme: &Theme) -> Element {
let case = Case {
variant: None,
size: None,
density: None,
breakpoint: super::current_breakpoint(),
states: self.states.clone(),
}
.state(PanelHeaderState::Media, self.media.is_some());
let recipe = theme
.resolve::<PanelHeader>(&case, Some(&self.rules))
.owned_by(self.id.as_ref());
let view = PanelHeaderView {
title: self.title,
media: self.media,
buttons: self.buttons,
menu: self.menu,
on_close: self.on_close,
more_label: self.more_label,
close_label: self.close_label,
level: self.level,
recipe,
forced: self.forced,
id: self.id,
key: self.key,
};
match theme.renderer::<PanelHeader>() {
Some(renderer) => renderer(view),
None => view.render(),
}
}
}
impl From<PanelHeader> for Element {
fn from(header: PanelHeader) -> Self {
header.build(¤t_theme())
}
}
pub struct PanelHeaderView {
pub title: Arc<str>,
pub media: Option<Element>,
buttons: Vec<HeaderButton>,
menu: Option<HeaderMenu>,
on_close: Vec<Handler>,
more_label: Arc<str>,
close_label: Arc<str>,
level: u32,
pub recipe: ResolvedRecipe,
forced: Option<Interaction>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl PanelHeaderView {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part).forced(self.forced)
}
pub fn theme(&self) -> &Theme {
self.recipe.theme()
}
pub fn title(&self) -> Element {
let part = self.part(PanelHeaderPart::Title);
Row::new()
.flex(1.0)
.min_width(0.0)
.part(&part)
.describe("a11y_role", "heading")
.describe("a11y_name", self.title.clone())
.describe("a11y_level", self.level.to_string())
.child(one_line(&part, &self.title.to_uppercase()))
.into()
}
pub fn actions(&self) -> Row {
let button = self.part(PanelHeaderPart::Button);
let mut actions = Row::new()
.align_items(Alignment::Center)
.overflow_visible()
.part(&self.part(PanelHeaderPart::Actions));
for each in &self.buttons {
actions = actions.child(header_button(&button, &each.icon, &each.label, each.on_click.clone()));
}
if let Some(menu) = self.menu.clone() {
actions = actions.child(header_menu(&button.clone().keyed("more"), &self.more_label, menu));
}
if !self.on_close.is_empty() {
let handlers = self.on_close.clone();
actions = actions.child(header_button(
&button.clone().keyed("close"),
&Name::new(icons::CLOSE),
&self.close_label,
Arc::new(move || handlers.iter().for_each(|handler| handler())),
));
}
actions
}
pub fn render(mut self) -> Element {
let mut root = Row::new()
.align_items(Alignment::Center)
.overflow_visible()
.part(&self.part(PanelHeaderPart::Root));
if let Some(media) = self.media.take() {
root = root.child(Row::new().part(&self.part(PanelHeaderPart::Media)).child(media));
}
root = root.child(self.title()).child(self.actions());
if let Some(id) = &self.id {
root = root.id(id.clone());
}
if let Some(key) = &self.key {
root = root.key(key.clone());
}
root.into()
}
}
impl crate::ui::Styled for PanelHeader {
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 PanelHeader {
const NAME: &'static str = "panel_header";
type Renderer = PanelHeaderRenderer;
fn parts() -> crate::ui::Declared {
PanelHeaderPart::declared()
}
fn states() -> crate::ui::Declared {
PanelHeaderState::declared()
}
fn recipe() -> Recipe {
use PaletteColor::{Border as Line, Foreground, Highlight, MutedForeground};
use PanelHeaderPart::{Actions, Button, Media, Root, Title};
Recipe::new()
.base(Root, |s| {
s.height(30.0)
.padding_start(10.0)
.padding_end(4.0)
.gap(8.0)
.background(PaletteColor::Bar)
.underline(Border::inside(BorderSize::Sm, Line))
})
.base(Media, |s| s.foreground(MutedForeground))
.base(Title, |s| {
s.typography(TypographyStyle::Label)
.font_size(11.0)
.weight(FontWeight::SemiBold)
.letter_spacing(0.6)
.foreground(MutedForeground)
})
.base(Actions, |s| s.gap(0.0))
.base(Button, button_style)
.hovered(Button, |s| s.background(Highlight))
.focus_visible(Button, |s| s.focus_ring())
.base(Button, |s| s.foreground(Foreground))
}
}
pub(super) fn button_style(style: PartStyle) -> PartStyle {
fading(style.square(22.0).radius(RadiusSize::Sm).cursor(CursorIcon::Pointer))
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum FloatingPanelPart {
Root,
Header,
Grip,
Media,
Title,
Actions,
Button,
Body,
Footer,
ResizeGrip,
Edge,
}
names!(FloatingPanelPart {
Root => "root",
Header => "header",
Grip => "grip",
Media => "media",
Title => "title",
Actions => "actions",
Button => "button",
Body => "body",
Footer => "footer",
ResizeGrip => "resize_grip",
Edge => "edge",
});
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum FloatingPanelState {
Active,
Collapsed,
Sized,
Resizable,
Media,
}
names!(FloatingPanelState {
Active => "active",
Collapsed => "collapsed",
Sized => "sized",
Resizable => "resizable",
Media => "media",
});
pub type FloatingPanelRenderer = Arc<dyn Fn(FloatingPanelView) -> Element + Send + Sync>;
pub type PanelPosition = (f32, f32);
pub type PanelSize = (f32, f32);
#[derive(Clone)]
pub struct FloatingPanel {
title: Arc<str>,
media: Option<Element>,
children: Vec<Element>,
buttons: Vec<HeaderButton>,
menu: Option<HeaderMenu>,
open: Option<Signal<bool>>,
default_open: bool,
on_open_change: Vec<Arc<dyn Fn(bool) + Send + Sync>>,
collapsible: bool,
on_dismiss: Vec<Handler>,
close_button: bool,
dismiss_on_escape: bool,
position: Kept<PanelPosition>,
size: Kept<Option<PanelSize>>,
min_size: PanelSize,
resizable: bool,
label: Option<Arc<str>>,
move_label: Arc<str>,
resize_label: Arc<str>,
collapse_label: Arc<str>,
more_label: Arc<str>,
close_label: Arc<str>,
states: Vec<Name>,
rules: Recipe,
forced: Option<Interaction>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
on_active_change: Vec<Arc<dyn Fn(bool) + Send + Sync>>,
layered: Option<Layered>,
pub(crate) docked: Option<DockHooks>,
}
#[derive(Clone)]
pub(crate) struct DockHooks {
pub(crate) drag: Arc<dyn Fn(&DragEvent) + Send + Sync>,
pub(crate) settled: Handler,
}
#[derive(Clone)]
struct Layered {
activate: Handler,
deactivate: Handler,
active: bool,
}
#[derive(Clone)]
enum Hold<T: SignalValue> {
Signal(Signal<T>),
Value(T),
Own(T),
}
#[derive(Clone)]
struct Kept<T: SignalValue> {
hold: Hold<T>,
heard: Vec<Arc<dyn Fn(T) + Send + Sync>>,
}
impl<T: Clone + Send + Sync + SignalValue + 'static> Kept<T> {
fn own(value: T) -> Self {
Self {
hold: Hold::Own(value),
heard: Vec::new(),
}
}
fn get(&self, own: &Signal<T>) -> T {
match &self.hold {
Hold::Signal(signal) => signal.get(),
Hold::Value(value) => value.clone(),
Hold::Own(_) => own.get(),
}
}
fn setter(&self, own: &Signal<T>) -> Arc<dyn Fn(T) + Send + Sync>
where
T: PartialEq,
{
let (hold, heard, own) = (self.hold.clone(), self.heard.clone(), own.clone());
Arc::new(move |value: T| {
let now = match &hold {
Hold::Signal(signal) => signal.get_untracked(),
Hold::Value(value) => value.clone(),
Hold::Own(_) => own.get_untracked(),
};
if now == value {
return;
}
match &hold {
Hold::Signal(signal) => signal.set(value.clone()),
Hold::Value(_) => {}
Hold::Own(_) => own.set(value.clone()),
}
for handler in &heard {
handler(value.clone());
}
})
}
}
impl FloatingPanel {
pub fn new(title: &str) -> Self {
Self {
title: Arc::from(title),
media: None,
children: Vec::new(),
buttons: Vec::new(),
menu: None,
open: None,
default_open: true,
on_open_change: Vec::new(),
collapsible: true,
on_dismiss: Vec::new(),
close_button: true,
dismiss_on_escape: true,
position: Kept::own((16.0, 16.0)),
size: Kept::own(None),
min_size: (160.0, 80.0),
resizable: true,
label: None,
move_label: super::current_locale().navigation.move_panel.clone(),
resize_label: super::current_locale().navigation.resize.clone(),
collapse_label: super::current_locale().navigation.collapse.clone(),
more_label: super::current_locale().common.more.clone(),
close_label: super::current_locale().common.close.clone(),
states: Vec::new(),
rules: Recipe::new(),
forced: None,
id: None,
key: None,
on_active_change: Vec::new(),
layered: None,
docked: None,
}
}
pub fn child(mut self, child: impl Into<Element>) -> Self {
self.children.push(child.into());
self
}
pub fn children(mut self, children: impl IntoIterator<Item = impl Into<Element>>) -> Self {
self.children.extend(children.into_iter().map(Into::into));
self
}
pub fn media(mut self, media: impl Into<Element>) -> Self {
self.media = Some(media.into());
self
}
pub fn button(mut self, icon: impl Into<Name>, label: &str, on_click: impl Fn() + Send + Sync + 'static) -> Self {
self.buttons.push(HeaderButton {
icon: icon.into(),
label: Arc::from(label),
on_click: Arc::new(on_click),
});
self
}
pub fn menu<I: IntoIterator<Item = MenuItem>>(
mut self,
open: Signal<bool>,
items: impl Fn() -> I + Send + Sync + 'static,
) -> Self {
self.menu = Some(HeaderMenu {
open,
items: Arc::new(move || items().into_iter().collect()),
});
self
}
pub fn open(mut self, open: Signal<bool>) -> Self {
self.open = Some(open);
self
}
pub fn default_open(mut self, open: bool) -> Self {
self.default_open = open;
self
}
pub fn on_open_change(mut self, handler: impl Fn(bool) + Send + Sync + 'static) -> Self {
self.on_open_change.push(Arc::new(handler));
self
}
pub fn on_active_change(mut self, handler: impl Fn(bool) + Send + Sync + 'static) -> Self {
self.on_active_change.push(Arc::new(handler));
self
}
pub fn collapsible(mut self, collapsible: bool) -> Self {
self.collapsible = collapsible;
self
}
pub fn on_dismiss(mut self, handler: impl Fn() + Send + Sync + 'static) -> Self {
self.on_dismiss.push(Arc::new(handler));
self
}
pub fn close_button(mut self, close_button: bool) -> Self {
self.close_button = close_button;
self
}
pub fn dismiss_on_escape(mut self, dismiss: bool) -> Self {
self.dismiss_on_escape = dismiss;
self
}
pub fn position(mut self, position: Signal<PanelPosition>) -> Self {
self.position.hold = Hold::Signal(position);
self
}
pub fn position_controlled(
mut self,
position: PanelPosition,
on_position_change: impl Fn(PanelPosition) + Send + Sync + 'static,
) -> Self {
self.position.hold = Hold::Value(position);
self.on_position_change(on_position_change)
}
pub fn default_position(mut self, position: PanelPosition) -> Self {
if let Hold::Own(_) = self.position.hold {
self.position.hold = Hold::Own(position);
}
self
}
pub fn on_position_change(mut self, handler: impl Fn(PanelPosition) + Send + Sync + 'static) -> Self {
self.position.heard.push(Arc::new(handler));
self
}
pub fn size(mut self, size: Signal<Option<PanelSize>>) -> Self {
let heard = std::mem::take(&mut self.size.heard);
self.size = Kept {
hold: Hold::Signal(size),
heard,
};
self
}
pub fn size_controlled(
mut self,
size: Option<PanelSize>,
on_size_change: impl Fn(PanelSize) + Send + Sync + 'static,
) -> Self {
self.size.hold = Hold::Value(size);
self.on_size_change(on_size_change)
}
pub fn default_size(mut self, size: PanelSize) -> Self {
if let Hold::Own(_) = self.size.hold {
self.size.hold = Hold::Own(Some(size));
}
self
}
pub fn on_size_change(mut self, handler: impl Fn(PanelSize) + Send + Sync + 'static) -> Self {
self.size.heard.push(Arc::new(move |size: Option<PanelSize>| {
if let Some(size) = size {
handler(size);
}
}));
self
}
pub fn min_size(mut self, size: PanelSize) -> Self {
self.min_size = size;
self
}
pub fn resizable(mut self, resizable: bool) -> Self {
self.resizable = resizable;
self
}
pub fn label(mut self, label: &str) -> Self {
self.label = Some(Arc::from(label));
self
}
pub fn move_label(mut self, label: &str) -> Self {
self.move_label = Arc::from(label);
self
}
pub fn resize_label(mut self, label: &str) -> Self {
self.resize_label = Arc::from(label);
self
}
pub fn collapse_label(mut self, label: &str) -> Self {
self.collapse_label = Arc::from(label);
self
}
pub fn more_label(mut self, label: &str) -> Self {
self.more_label = Arc::from(label);
self
}
pub fn close_label(mut self, label: &str) -> Self {
self.close_label = Arc::from(label);
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 force(mut self, interaction: Option<Interaction>) -> Self {
self.forced = interaction;
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
}
pub fn build(self, theme: &Theme) -> Element {
let own = Own::detached(&self);
self.core().build(theme, &own)
}
pub fn mount(self, ctx: &mut Ctx) -> Element {
let key = self.key.clone().unwrap_or_else(|| self.title.clone());
ctx.mount_keyed::<PanelHost>(&key, PanelProps { core: self.core() })
}
fn core(self) -> Core {
Core {
title: self.title,
media: self.media,
children: self.children,
buttons: self.buttons,
menu: self.menu,
open: self.open,
default_open: self.default_open,
on_open_change: self.on_open_change,
collapsible: self.collapsible,
on_dismiss: self.on_dismiss,
close_button: self.close_button,
dismiss_on_escape: self.dismiss_on_escape,
position: self.position,
size: self.size,
min_size: self.min_size,
resizable: self.resizable,
label: self.label,
move_label: self.move_label,
resize_label: self.resize_label,
collapse_label: self.collapse_label,
more_label: self.more_label,
close_label: self.close_label,
states: self.states,
rules: self.rules,
forced: self.forced,
id: self.id,
on_active_change: self.on_active_change,
layered: self.layered,
docked: self.docked,
}
}
}
impl From<FloatingPanel> for Element {
fn from(panel: FloatingPanel) -> Self {
panel.build(¤t_theme())
}
}
#[derive(Clone)]
struct Core {
title: Arc<str>,
media: Option<Element>,
children: Vec<Element>,
buttons: Vec<HeaderButton>,
menu: Option<HeaderMenu>,
open: Option<Signal<bool>>,
default_open: bool,
on_open_change: Vec<Arc<dyn Fn(bool) + Send + Sync>>,
collapsible: bool,
on_dismiss: Vec<Handler>,
close_button: bool,
dismiss_on_escape: bool,
position: Kept<PanelPosition>,
size: Kept<Option<PanelSize>>,
min_size: PanelSize,
resizable: bool,
label: Option<Arc<str>>,
move_label: Arc<str>,
resize_label: Arc<str>,
collapse_label: Arc<str>,
more_label: Arc<str>,
close_label: Arc<str>,
states: Vec<Name>,
rules: Recipe,
forced: Option<Interaction>,
id: Option<Arc<str>>,
on_active_change: Vec<Arc<dyn Fn(bool) + Send + Sync>>,
layered: Option<Layered>,
docked: Option<DockHooks>,
}
#[derive(Clone)]
struct Own {
open: Signal<bool>,
position: Signal<PanelPosition>,
size: Signal<Option<PanelSize>>,
layer: ElementRef,
panel: ElementRef,
drag: Arc<Mutex<Option<(PanelPosition, PanelSize)>>>,
mounted: bool,
active: Signal<bool>,
menu_open: Arc<AtomicBool>,
}
impl Own {
fn detached(panel: &FloatingPanel) -> Self {
let start = |kept: &Hold<PanelPosition>| match kept {
Hold::Own(value) | Hold::Value(value) => *value,
Hold::Signal(signal) => signal.get_untracked(),
};
let size = match &panel.size.hold {
Hold::Own(value) | Hold::Value(value) => *value,
Hold::Signal(signal) => signal.get_untracked(),
};
Self {
open: Signal::new(panel.default_open),
position: Signal::new(start(&panel.position.hold)),
size: Signal::new(size),
layer: ElementRef::new(),
panel: ElementRef::new(),
drag: Arc::new(Mutex::new(None)),
mounted: false,
active: Signal::new(true),
menu_open: Arc::new(AtomicBool::new(false)),
}
}
}
#[derive(Clone, Copy)]
struct Edges {
start: bool,
end: bool,
bottom: bool,
}
impl Core {
fn activity(&self, own: &Own) -> (Handler, Handler) {
if let Some(layered) = &self.layered {
return (layered.activate.clone(), layered.deactivate.clone());
}
let turn = |to: bool| -> Handler {
let (active, handlers) = (own.active.clone(), self.on_active_change.clone());
Arc::new(move || {
if active.get_untracked() != to {
active.set(to);
handlers.iter().for_each(|handler| handler(to));
}
})
};
(turn(true), turn(false))
}
fn build(self, theme: &Theme, own: &Own) -> Element {
let open = match &self.open {
Some(open) => open.get(),
None => own.open.get(),
};
let size = self.size.get(&own.size);
let active = match &self.layered {
Some(layered) => layered.active,
None => own.active.get(),
};
let case = Case {
variant: None,
size: None,
density: None,
breakpoint: super::current_breakpoint(),
states: self.states.clone(),
}
.state(FloatingPanelState::Active, active)
.state(FloatingPanelState::Collapsed, !open)
.state(FloatingPanelState::Sized, size.is_some() && open)
.state(FloatingPanelState::Resizable, self.resizable)
.state(FloatingPanelState::Media, self.media.is_some());
let recipe = theme
.resolve::<FloatingPanel>(&case, Some(&self.rules))
.owned_by(self.id.as_ref());
let view = FloatingPanelView {
title: self.title.clone(),
open,
position: self.position.get(&own.position),
size,
active,
recipe,
core: self,
own: own.clone(),
};
match theme.renderer::<FloatingPanel>() {
Some(renderer) => renderer(view),
None => view.render(),
}
}
}
pub struct FloatingPanelView {
pub title: Arc<str>,
pub open: bool,
pub position: PanelPosition,
pub size: Option<PanelSize>,
pub active: bool,
pub recipe: ResolvedRecipe,
core: Core,
own: Own,
}
impl FloatingPanelView {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part).forced(self.core.forced)
}
pub fn theme(&self) -> &Theme {
self.recipe.theme()
}
fn id_of(&self, suffix: &str) -> Option<String> {
self.core.id.as_ref().map(|id| format!("{id}-{suffix}"))
}
fn mover(&self) -> impl Fn(PanelPosition) + Send + Sync + Clone + 'static {
let set = self.core.position.setter(&self.own.position);
let (layer, panel) = (self.own.layer.clone(), self.own.panel.clone());
move |(x, y): PanelPosition| {
let (room_width, room_height) = (layer.width(), layer.height());
let (width, height) = (panel.width(), panel.height());
let x = x.min(room_width - width).max(0.0);
let y = y.min(room_height - height).max(0.0);
set((x.round(), y.round()));
}
}
fn resizer(&self, edges: Edges) -> impl Fn(PanelPosition, PanelSize, f32, f32) + Send + Sync + Clone + 'static {
let set_size = self.core.size.setter(&self.own.size);
let set_position = self.core.position.setter(&self.own.position);
let (layer, min) = (self.own.layer.clone(), self.core.min_size);
move |(x, y): PanelPosition, (width, height): PanelSize, dx: f32, dy: f32| {
let (room_width, room_height) = (layer.width(), layer.height());
let (mut x, mut width, mut height) = (x, width, height);
if edges.end {
width = (width + dx).max(min.0).min(room_width - x);
}
if edges.start {
let moved = dx.min(width - min.0).max(-x);
x += moved;
width -= moved;
}
if edges.bottom {
height = (height + dy).max(min.1).min(room_height - y);
}
set_position((x.round(), y.round()));
set_size(Some((width.round(), height.round())));
}
}
fn now(&self) -> (PanelPosition, PanelSize) {
let size = self
.size
.unwrap_or_else(|| (self.own.panel.width(), self.own.panel.height()));
(self.position, size)
}
pub fn grip(&self) -> Element {
let part = self.part(FloatingPanelPart::Grip);
let mut grip = pressable(&part, false)
.align_items(Alignment::Center)
.describe("a11y_role", "button")
.describe("a11y_name", format!("{} {}", self.core.move_label, self.title))
.describe("a11y_description", super::current_locale().navigation.move_hint.clone())
.child(glyph(&part, Name::new(icons::GRIP_VERTICAL), false));
if self.own.mounted {
let (mover, position, docked) = (self.mover(), self.position, self.core.docked.clone());
grip = grip.on_key_down(move |event: KeyboardEvent| {
if !event.focus_within || event.ctrl || event.alt || event.meta {
return;
}
let step = if event.shift { 1.0 } else { 10.0 };
let (x, y) = position;
let to = match event.key.as_str() {
"ArrowLeft" => (x - step, y),
"ArrowRight" => (x + step, y),
"ArrowUp" => (x, y - step),
"ArrowDown" => (x, y + step),
_ => return,
};
event.prevent_default();
mover(to);
if let Some(docked) = &docked {
(docked.settled)();
}
});
}
if let Some(id) = self.id_of("grip") {
grip = grip.id(id);
}
grip.into()
}
pub fn header(&self) -> Row {
let mut header = Row::new()
.align_items(Alignment::Center)
.overflow_visible()
.part(&self.part(FloatingPanelPart::Header))
.child(self.grip());
if self.own.mounted {
let (mover, drag, start) = (self.mover(), self.own.drag.clone(), self.now());
let (began, ended) = (drag.clone(), drag.clone());
let (moving, ending) = (self.core.docked.clone(), self.core.docked.clone());
header = header
.start_drag_buttons(MouseButtonMask::LEFT)
.on_drag_start(move |_: DragEvent| *began.lock().unwrap() = Some(start))
.on_drag_move(move |event: DragEvent| {
let start = *drag.lock().unwrap();
if let Some(((x, y), _)) = start {
mover((x + event.total_delta_x, y + event.total_delta_y));
}
if let Some(docked) = &moving {
(docked.drag)(&event);
}
})
.on_drag_end(move |event: DragEvent| {
*ended.lock().unwrap() = None;
if let Some(docked) = &ending {
(docked.drag)(&event);
(docked.settled)();
}
});
}
header
}
pub fn title(&self) -> Element {
let part = self.part(FloatingPanelPart::Title);
Row::new()
.flex(1.0)
.min_width(0.0)
.part(&part)
.child(one_line(&part, &self.title))
.into()
}
pub fn actions(&self) -> Row {
let button = self.part(FloatingPanelPart::Button);
let mut actions = Row::new()
.align_items(Alignment::Center)
.overflow_visible()
.part(&self.part(FloatingPanelPart::Actions));
for each in &self.core.buttons {
actions = actions.child(header_button(&button, &each.icon, &each.label, each.on_click.clone()));
}
if let Some(menu) = self.core.menu.clone() {
actions = actions.child(header_menu(&button, &self.core.more_label, menu));
}
if self.core.collapsible {
let (open, own, heard) = (
self.core.open.clone(),
self.own.open.clone(),
self.core.on_open_change.clone(),
);
let now = self.open;
let mut collapse = header_button(
&button,
&Name::new(if now { icons::MINUS } else { icons::PLUS }),
&self.core.collapse_label,
Arc::new(move || {
match &open {
Some(open) => open.set(!now),
None => own.set(!now),
}
for handler in &heard {
handler(!now);
}
}),
)
.describe("a11y_expanded", if now { "true" } else { "false" });
if let Some(id) = self.id_of("collapse") {
collapse = collapse.id(id);
}
actions = actions.child(collapse);
}
if self.core.close_button && !self.core.on_dismiss.is_empty() {
let handlers = self.core.on_dismiss.clone();
let mut close = header_button(
&button,
&Name::new(icons::CLOSE),
&self.core.close_label,
Arc::new(move || handlers.iter().for_each(|handler| handler())),
);
if let Some(id) = self.id_of("close") {
close = close.id(id);
}
actions = actions.child(close);
}
actions
}
pub fn body(&mut self) -> Element {
let children = std::mem::take(&mut self.core.children);
let body = Column::new()
.align_items(Alignment::Stretch)
.part(&self.part(FloatingPanelPart::Body))
.with_children(children);
if self.size.is_some() {
ScrollVertical::new(body)
.width(Dimension::Pct(100.0))
.flex_full(1.0, 1.0, None)
.into()
} else {
body.into()
}
}
fn resize_handle(&self, handle: components::Button, edges: Edges) -> components::Button {
if !self.own.mounted {
return handle;
}
let (resize, drag, start) = (self.resizer(edges), self.own.drag.clone(), self.now());
let (began, ended) = (drag.clone(), drag.clone());
let docked = self.core.docked.clone();
handle
.start_drag_buttons(MouseButtonMask::LEFT)
.on_drag_start(move |_: DragEvent| *began.lock().unwrap() = Some(start))
.on_drag_move(move |event: DragEvent| {
let start = *drag.lock().unwrap();
if let Some((position, size)) = start {
resize(position, size, event.total_delta_x, event.total_delta_y);
}
})
.on_drag_end(move |_: DragEvent| {
*ended.lock().unwrap() = None;
if let Some(docked) = &docked {
(docked.settled)();
}
})
}
pub fn resize_grip(&self) -> Element {
let part = self.part(FloatingPanelPart::ResizeGrip);
let edges = Edges {
start: false,
end: true,
bottom: true,
};
let mut grip = pressable(&part, false)
.describe("a11y_role", "button")
.describe("a11y_name", format!("{} {}", self.core.resize_label, self.title))
.describe(
"a11y_description",
super::current_locale().navigation.resize_hint.clone(),
)
.child(glyph(&part, Name::new(icons::GRIP), false));
grip = self.resize_handle(grip, edges);
if self.own.mounted {
let (resize, (position, size), docked) = (self.resizer(edges), self.now(), self.core.docked.clone());
grip = grip.on_key_down(move |event: KeyboardEvent| {
if !event.focus_within || event.ctrl || event.alt || event.meta {
return;
}
let step = if event.shift { 1.0 } else { 10.0 };
let (dx, dy) = match event.key.as_str() {
"ArrowLeft" => (-step, 0.0),
"ArrowRight" => (step, 0.0),
"ArrowUp" => (0.0, -step),
"ArrowDown" => (0.0, step),
_ => return,
};
event.prevent_default();
resize(position, size, dx, dy);
if let Some(docked) = &docked {
(docked.settled)();
}
});
}
if let Some(id) = self.id_of("resize") {
grip = grip.id(id);
}
grip.into()
}
pub fn footer(&self) -> Element {
let row = pressable(&self.part(FloatingPanelPart::Footer), false)
.tab_index(-1)
.justify(Justify::End)
.align_items(Alignment::End)
.child(self.resize_grip());
self
.resize_handle(
row,
Edges {
start: false,
end: false,
bottom: true,
},
)
.into()
}
pub fn edges(&self) -> Vec<Element> {
let width = self.size.map(|(width, _)| width);
let part = self.part(FloatingPanelPart::Edge);
let side = match part.rest().width {
Some(Length::Px(px)) => px,
_ => 4.0,
};
let edge = |x: f32, edges: Edges, cursor: CursorIcon| {
let mut handle = pressable(&part, false)
.tab_index(-1)
.absolute(x, 0.0, Dimension::Px(side), Dimension::Pct(100.0))
.cursor(cursor);
if let Some(id) = self.id_of(if edges.start { "edge-start" } else { "edge-end" }) {
handle = handle.id(id);
}
self.resize_handle(handle, edges).into()
};
let mut edges = vec![edge(
0.0,
Edges {
start: true,
end: false,
bottom: false,
},
CursorIcon::EwResize,
)];
if let Some(width) = width.or_else(|| self.panel_width()) {
edges.push(edge(
width - side,
Edges {
start: false,
end: true,
bottom: false,
},
CursorIcon::EwResize,
));
}
edges
}
fn panel_width(&self) -> Option<f32> {
match self.part(FloatingPanelPart::Root).rest().width {
Some(Length::Px(px)) => Some(px),
_ => None,
}
}
pub fn root(&self) -> Stack {
let (x, y) = self.position;
let mut root = Stack::new()
.part(&self.part(FloatingPanelPart::Root))
.ref_element(self.own.panel.clone())
.absolute_position(x, y)
.describe("a11y_role", "dialog")
.describe(
"a11y_name",
self.core.label.clone().unwrap_or_else(|| self.title.clone()),
);
if let Some((width, height)) = self.size {
root = root.width(width);
if self.open {
root = root.height(height);
}
}
if self.own.mounted {
let (activate, deactivate) = self.core.activity(&self.own);
let pressed = activate.clone();
root = root.on_mouse_down(move |_| pressed());
let (menu, menu_open) = (
self.core.menu.as_ref().map(|menu| menu.open.clone()),
self.own.menu_open.clone(),
);
root = root.on_key_up(move |event: KeyboardEvent| {
if event.focus_within {
activate();
} else if !menu.as_ref().is_some_and(|open| open.get_untracked()) && !menu_open.load(Ordering::Relaxed) {
deactivate();
}
});
}
if self.core.dismiss_on_escape && !self.core.on_dismiss.is_empty() {
let handlers = self.core.on_dismiss.clone();
root = root.on_key_down(move |event: KeyboardEvent| {
if event.focus_within && event.key == "Escape" && !event.default_prevented() {
event.prevent_default();
handlers.iter().for_each(|handler| handler());
}
});
}
if let Some(id) = &self.core.id {
root = root.id(id.clone());
}
root
}
pub fn render(mut self) -> Element {
let mut header = self.header();
if let Some(media) = self.core.media.take() {
header = header.child(Row::new().part(&self.part(FloatingPanelPart::Media)).child(media));
}
header = header.child(self.title()).child(self.actions());
let mut column = Column::new()
.align_items(Alignment::Stretch)
.width(Dimension::Pct(100.0))
.child(header);
if self.size.is_some() && self.open {
column = column.height(Dimension::Pct(100.0));
}
let mut panel = self.root();
if self.open {
column = column.child(self.body());
if self.core.resizable {
column = column.child(self.footer());
panel = panel.child(column).with_children(self.edges());
} else {
panel = panel.child(column);
}
} else {
panel = panel.child(column);
}
Stack::new()
.absolute(0.0, 0.0, Dimension::Pct(100.0), Dimension::Pct(100.0))
.hit_test(HitTestBehavior::ContentOnly)
.overflow_visible()
.ref_element(self.own.layer.clone())
.child(panel)
.into()
}
}
struct PanelProps {
core: Core,
}
impl PartialEq for PanelProps {
fn eq(&self, _: &Self) -> bool {
false
}
}
impl crate::app::component::DevtoolsInspectable for PanelProps {}
struct PanelHost {
own: Own,
}
impl Component for PanelHost {
type Props = PanelProps;
fn create(ctx: &mut Ctx) -> Self {
let start = ctx.props::<PanelProps>();
let (open, position, size) = (
start.core.default_open,
match &start.core.position.hold {
Hold::Own(value) | Hold::Value(value) => *value,
Hold::Signal(signal) => signal.get_untracked(),
},
match &start.core.size.hold {
Hold::Own(value) | Hold::Value(value) => *value,
Hold::Signal(signal) => signal.get_untracked(),
},
);
Self {
own: Own {
open: ctx.signal(open),
position: ctx.signal(position),
size: ctx.signal(size),
layer: ElementRef::new(),
panel: ElementRef::new(),
drag: Arc::new(Mutex::new(None)),
mounted: true,
active: ctx.signal(false),
menu_open: Arc::new(AtomicBool::new(false)),
},
}
}
fn render(&self, ctx: &mut Ctx) -> impl Into<Element> {
let core = ctx.props::<PanelProps>().core.clone();
let menu = core.menu.as_ref().map(|menu| menu.open.clone());
let menu_open = self.own.menu_open.clone();
menu_open.store(
menu.as_ref().is_some_and(|open| open.get_untracked()),
Ordering::Relaxed,
);
let (_, deactivate) = core.activity(&self.own);
ctx.on_click_outside(self.own.panel.clone(), move |_| {
let open = menu.as_ref().is_some_and(|open| open.get_untracked());
if !open && !menu_open.load(Ordering::Relaxed) {
deactivate();
}
});
core.build(¤t_theme(), &self.own)
}
}
impl crate::ui::Styled for FloatingPanel {
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 FloatingPanel {
const NAME: &'static str = "floating_panel";
type Renderer = FloatingPanelRenderer;
fn parts() -> crate::ui::Declared {
FloatingPanelPart::declared()
}
fn states() -> crate::ui::Declared {
FloatingPanelState::declared()
}
fn recipe() -> Recipe {
use FloatingPanelPart::{Actions, Body, Button, Edge, Footer, Grip, Header, Media, ResizeGrip, Root, Title};
use FloatingPanelState::Active;
use PaletteColor::{Border as Line, Foreground, Highlight, MutedForeground, Popover, PopoverForeground};
Recipe::new()
.base(Root, |s| {
s.width(240.0)
.background(Popover)
.foreground(PopoverForeground)
.border(Border::inside(BorderSize::Sm, Line))
.radius(RadiusSize::Lg)
.shadow(ShadowStyle::Lg)
})
.base(Header, |s| {
s.height(30.0)
.padding_start(6.0)
.padding_end(4.0)
.gap(4.0)
.background(PaletteColor::Bar)
.underline(Border::inside(BorderSize::Sm, Line))
.cursor(CursorIcon::Grab)
})
.base(Grip, |s| {
fading(
s.square(IconSize::Sm)
.radius(RadiusSize::Sm)
.foreground(MutedForeground)
.cursor(CursorIcon::Grab),
)
})
.focus_visible(Grip, |s| s.focus_ring())
.base(Media, |s| s.foreground(MutedForeground))
.base(Title, |s| {
s.typography(TypographyStyle::Body)
.font_size(12.0)
.weight(FontWeight::SemiBold)
.foreground(MutedForeground)
})
.state(Active, Title, |s| s.foreground(Foreground))
.base(Actions, |s| s.gap(0.0))
.base(Button, |s| button_style(s).foreground(Foreground))
.hovered(Button, |s| s.background(Highlight))
.focus_visible(Button, |s| s.focus_ring())
.base(Body, |s| s.padding_x(4.0).padding_y(4.0).gap(2.0))
.base(Footer, |s| {
s.height(22.0)
.padding_end(3.0)
.padding_bottom(3.0)
.cursor(CursorIcon::NsResize)
})
.base(ResizeGrip, |s| {
fading(
s.square(10.0)
.radius(RadiusSize::Sm)
.foreground(MutedForeground)
.cursor(CursorIcon::NwseResize),
)
})
.focus_visible(ResizeGrip, |s| s.focus_ring())
.base(Edge, |s| s.width(4.0))
}
}
#[derive(Clone)]
pub struct FloatingPanels {
panels: Vec<FloatingPanel>,
active: Option<Signal<Option<Arc<str>>>>,
on_active_change: Vec<Arc<dyn Fn(Option<&str>) + Send + Sync>>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl Default for FloatingPanels {
fn default() -> Self {
Self::new()
}
}
impl FloatingPanels {
pub fn new() -> Self {
Self {
panels: Vec::new(),
active: None,
on_active_change: Vec::new(),
id: None,
key: None,
}
}
pub fn panel(mut self, panel: FloatingPanel) -> Self {
self.panels.push(panel);
self
}
pub fn panels(mut self, panels: impl IntoIterator<Item = FloatingPanel>) -> Self {
self.panels.extend(panels);
self
}
pub fn active(mut self, active: Signal<Option<Arc<str>>>) -> Self {
self.active = Some(active);
self
}
pub fn on_active_change(mut self, handler: impl Fn(Option<&str>) + Send + Sync + 'static) -> Self {
self.on_active_change.push(Arc::new(handler));
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
}
pub fn mount(self, ctx: &mut Ctx) -> Element {
let key = self.key.clone().unwrap_or_else(|| Arc::from("floating_panels"));
ctx.mount_keyed::<LayerHost>(&key, LayerProps { layer: self })
}
}
struct LayerProps {
layer: FloatingPanels,
}
impl PartialEq for LayerProps {
fn eq(&self, _: &Self) -> bool {
false
}
}
impl crate::app::component::DevtoolsInspectable for LayerProps {}
struct LayerHost {
order: Signal<Vec<Arc<str>>>,
active: Signal<Option<Arc<str>>>,
}
type ActiveHandlers = (
Vec<Arc<dyn Fn(Option<&str>) + Send + Sync>>,
Vec<(Arc<str>, Vec<Arc<dyn Fn(bool) + Send + Sync>>)>,
);
impl Component for LayerHost {
type Props = LayerProps;
fn create(ctx: &mut Ctx) -> Self {
Self {
order: ctx.signal(Vec::new()),
active: ctx.signal(None),
}
}
fn render(&self, ctx: &mut Ctx) -> impl Into<Element> {
let layer = ctx.props::<LayerProps>().layer.clone();
let keyed: Vec<(Arc<str>, FloatingPanel)> = layer
.panels
.into_iter()
.map(|panel| (panel.key.clone().unwrap_or_else(|| panel.title.clone()), panel))
.collect();
let mut order: Vec<Arc<str>> = self
.order
.get()
.into_iter()
.filter(|key| keyed.iter().any(|(held, _)| held == key))
.collect();
for (key, _) in &keyed {
if !order.contains(key) {
order.push(key.clone());
}
}
let active_signal = layer.active.clone().unwrap_or_else(|| self.active.clone());
let active = active_signal.get();
let heard: Arc<ActiveHandlers> = Arc::new((
layer.on_active_change.clone(),
keyed
.iter()
.map(|(key, panel)| (key.clone(), panel.on_active_change.clone()))
.collect(),
));
let change = move |to: Option<Arc<str>>| {
let from = active_signal.get_untracked();
if from == to {
return;
}
active_signal.set(to.clone());
for (key, handlers) in &heard.1 {
if from.as_ref() == Some(key) {
handlers.iter().for_each(|handler| handler(false));
}
if to.as_ref() == Some(key) {
handlers.iter().for_each(|handler| handler(true));
}
}
heard.0.iter().for_each(|handler| handler(to.as_deref()));
};
let mut panels: Vec<(usize, Element)> = Vec::new();
for (key, panel) in keyed {
let activate = {
let (signal, key, now, change) = (self.order.clone(), key.clone(), order.clone(), change.clone());
Arc::new(move || {
if now.last() != Some(&key) {
let mut next = now.clone();
next.retain(|held| *held != key);
next.push(key.clone());
signal.set(next);
}
change(Some(key.clone()));
}) as Handler
};
let deactivate = {
let (key, change) = (key.clone(), change.clone());
let active = layer.active.clone().unwrap_or_else(|| self.active.clone());
Arc::new(move || {
if active.get_untracked().as_ref() == Some(&key) {
change(None);
}
}) as Handler
};
let at = order.iter().position(|held| *held == key).unwrap_or(0);
let mut panel = panel.key(key.clone());
panel.layered = Some(Layered {
activate,
deactivate,
active: active.as_ref() == Some(&key),
});
panels.push((at, panel.mount(ctx)));
}
panels.sort_by_key(|(at, _)| *at);
let mut stack = Stack::new()
.absolute(0.0, 0.0, Dimension::Pct(100.0), Dimension::Pct(100.0))
.hit_test(HitTestBehavior::ContentOnly)
.overflow_visible()
.with_children(panels.into_iter().map(|(_, panel)| panel));
if let Some(id) = layer.id {
stack = stack.id(id);
}
stack
}
}