egui-charts 0.2.0

High-performance financial charting engine for egui — candlesticks, 95 drawing tools, 130+ indicators, and a full design-token theme system
Documentation 
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

//! Connection Status Indicator
//!
//! Displays a small indicator showing the WebSocket connection state.
//! Used in the top toolbar to show real-time data connectivity.

use crate::icons::{Icon, icons};
use crate::styles::icons as icon_sizes;
use crate::tokens::DESIGN_TOKENS;
use crate::ui::model::ConnectionState;
use egui::{Color32, Response, RichText, Ui, Vec2, Widget};

/// Connection status indicator widget
pub struct ConnectionStatusIndicator<'a> {
    /// Current connection state
    state: &'a ConnectionState,
    /// Whether to show text label
    show_label: bool,
}

impl<'a> ConnectionStatusIndicator<'a> {
    /// Create a new connection status indicator
    pub fn new(state: &'a ConnectionState) -> Self {
        Self {
            state,
            show_label: false,
        }
    }

    /// Show text label alongside the indicator
    #[must_use]
    pub fn with_label(mut self) -> Self {
        self.show_label = true;
        self
    }

    /// Get color for the current state
    fn state_color(&self) -> Color32 {
        match self.state {
            ConnectionState::Connected => DESIGN_TOKENS.semantic.extended.bullish,
            ConnectionState::Connecting => DESIGN_TOKENS.semantic.status.caution,
            ConnectionState::Reconnecting { .. } => DESIGN_TOKENS.semantic.status.caution,
            ConnectionState::Disconnected => DESIGN_TOKENS.semantic.ui.text_muted_dark,
            ConnectionState::Failed(_) => DESIGN_TOKENS.semantic.extended.bearish,
        }
    }

    /// Get icon for the current state
    fn state_icon(&self) -> &'static Icon {
        match self.state {
            ConnectionState::Connected => &icons::STATUS_CONNECTED,
            ConnectionState::Connecting | ConnectionState::Reconnecting { .. } => {
                &icons::STATUS_CONNECTING
            }
            ConnectionState::Disconnected => &icons::STATUS_DISCONNECTED,
            ConnectionState::Failed(_) => &icons::STATUS_ERROR,
        }
    }

    /// Get label text for the current state
    fn state_label(&self) -> &'static str {
        match self.state {
            ConnectionState::Connected => "Live",
            ConnectionState::Connecting => "Connecting...",
            ConnectionState::Reconnecting { attempt: _ } => {
                // Can't include attempt in static str, so just show generic
                "Reconnecting..."
            }
            ConnectionState::Disconnected => "Offline",
            ConnectionState::Failed(_) => "Error",
        }
    }
}

impl<'a> Widget for ConnectionStatusIndicator<'a> {
    fn ui(self, ui: &mut Ui) -> Response {
        let color = self.state_color();
        let icon = self.state_icon();

        ui.horizontal(|ui| {
            ui.spacing_mut().item_spacing.x = DESIGN_TOKENS.spacing.xs;

            // Icon - use SVG with tint color
            ui.add(icon.as_image_tinted(Vec2::splat(icon_sizes::XS), color));

            // Optional label
            if self.show_label {
                ui.label(RichText::new(self.state_label()).color(color).size(11.0));
            }
        })
        .response
    }
}

/// Show a connection status indicator in the UI
///
/// This is a convenience function for showing the indicator inline.
pub fn show_connection_status(ui: &mut Ui, state: &ConnectionState) -> Response {
    ConnectionStatusIndicator::new(state).ui(ui)
}

/// Show a connection status indicator with label
pub fn show_connection_status_with_label(ui: &mut Ui, state: &ConnectionState) -> Response {
    ConnectionStatusIndicator::new(state).with_label().ui(ui)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_state_icons() {
        let connected = ConnectionStatusIndicator::new(&ConnectionState::Connected);
        assert_eq!(connected.state_icon(), &icons::STATUS_CONNECTED);

        let disconnected = ConnectionStatusIndicator::new(&ConnectionState::Disconnected);
        assert_eq!(disconnected.state_icon(), &icons::STATUS_DISCONNECTED);

        let failed_state = ConnectionState::Failed("error".to_string());
        let failed = ConnectionStatusIndicator::new(&failed_state);
        assert_eq!(failed.state_icon(), &icons::STATUS_ERROR);
    }
}