bevy_pf 0.2.9

A XAML / WPF-like UI framework for Bevy: XAML in macros or files, styling with resources, and the common WPF control set.
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

//! Toast / Snackbar / Growl notifications (MaterialDesign Snackbar,
//! HandyControl Growl, Notifications.Wpf equivalents).
//!
//! ```ignore
//! bevy_pf::toast::show(world, "Saved!");
//! bevy_pf::toast::show_with(world, "Disk full", toast::Severity::Error, 6.0);
//! ```
//!
//! Toasts stack bottom-right on the overlay layer and dismiss themselves.

use bevy::prelude::*;

use crate::overlay::ensure_overlay_root;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Severity {
    #[default]
    Info,
    Success,
    Warning,
    Error,
}

impl Severity {
    fn colors(self) -> (Color, Color) {
        match self {
            Severity::Info => (Color::srgb_u8(0x2B, 0x33, 0x42), Color::WHITE),
            Severity::Success => (Color::srgb_u8(0x1E, 0x6E, 0x34), Color::WHITE),
            Severity::Warning => (Color::srgb_u8(0x8A, 0x64, 0x00), Color::WHITE),
            Severity::Error => (Color::srgb_u8(0x8F, 0x1F, 0x1F), Color::WHITE),
        }
    }
}

/// A live toast; despawned by the expiry system.
#[derive(Component, Debug)]
pub struct PfToast {
    pub expires_at: f32,
}

/// The bottom-right stack that hosts toasts.
#[derive(Component, Debug)]
pub struct PfToastHost;

fn ensure_host(world: &mut World) -> Entity {
    let mut query = world.query_filtered::<Entity, With<PfToastHost>>();
    if let Some(host) = query.iter(world).next() {
        return host;
    }
    let overlay = ensure_overlay_root(world);
    let host = world
        .spawn((
            Node {
                position_type: PositionType::Absolute,
                right: Val::Px(16.0),
                bottom: Val::Px(16.0),
                display: Display::Flex,
                flex_direction: FlexDirection::ColumnReverse,
                row_gap: Val::Px(8.0),
                align_items: AlignItems::FlexEnd,
                ..Default::default()
            },
            bevy::picking::Pickable::IGNORE,
            PfToastHost,
        ))
        .id();
    world.entity_mut(overlay).add_children(&[host]);
    host
}

/// Show an info toast for 4 seconds.
pub fn show(world: &mut World, message: &str) -> Entity {
    show_with(world, message, Severity::Info, 4.0)
}

/// Show a toast with severity colors and a custom duration.
pub fn show_with(world: &mut World, message: &str, severity: Severity, secs: f32) -> Entity {
    let host = ensure_host(world);
    let now = world
        .get_resource::<Time>()
        .map(|t| t.elapsed_secs())
        .unwrap_or(0.0);
    let (bg, fg) = severity.colors();
    let label = world
        .spawn((
            Node::default(),
            bevy::ui::widget::Text::new(message),
            bevy::text::TextFont {
                font_size: bevy::text::FontSize::Px(13.0),
                font: crate::fonts::default_font(),
                ..Default::default()
            },
            bevy::text::TextColor(fg),
        ))
        .id();
    let toast = world
        .spawn((
            Node {
                padding: UiRect::axes(Val::Px(14.0), Val::Px(9.0)),
                border_radius: bevy::ui::BorderRadius::all(Val::Px(6.0)),
                ..Default::default()
            },
            BackgroundColor(bg),
            PfToast {
                expires_at: now + secs.max(0.5),
            },
        ))
        .id();
    world.entity_mut(toast).add_children(&[label]);
    world.entity_mut(host).add_children(&[toast]);
    toast
}

/// Despawn toasts whose time is up.
pub(crate) fn expire_toasts(
    time: Res<Time>,
    toasts: Query<(Entity, &PfToast)>,
    mut commands: Commands,
) {
    let now = time.elapsed_secs();
    for (entity, toast) in &toasts {
        if now >= toast.expires_at {
            commands.entity(entity).despawn();
        }
    }
}