egui_charts/ui/timeframe_toolbar/

timeframe_bar.rs

//! Date range preset buttons with an optional adjustment toggle.
//!
//! [`TimeframeBar`] returns the selected [`QuickTimeframe`] range for the host to
//! apply to the viewport; these controls do not change the bar interval.

use crate::icons::icons as embedded_icons;
use crate::localization as l10n;
use crate::theme::ThemeExt;
use crate::theme::{Theme, follow_active_theme, theme_derived};
use crate::tokens::DESIGN_TOKENS;
use chrono::{Local, Timelike};
use egui::{Color32, Pos2, Rect, Sense, Stroke, Ui, Vec2};

/// Quick timeframe options
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum QuickTimeframe {
    /// 1 Day
    OneDay,
    /// 5 Days
    FiveDays,
    /// 1 Month
    OneMonth,
    /// 3 Months
    ThreeMonths,
    /// 6 Months
    SixMonths,
    /// Year to Date
    YearToDate,
    /// 1 Year
    OneYear,
    /// 5 Years
    FiveYears,
    /// All available data
    All,
}

impl QuickTimeframe {
    /// Display label for this value.
    pub fn label(&self) -> &'static str {
        match self {
            QuickTimeframe::OneDay => "1D",
            QuickTimeframe::FiveDays => "5D",
            QuickTimeframe::OneMonth => "1M",
            QuickTimeframe::ThreeMonths => "3M",
            QuickTimeframe::SixMonths => "6M",
            QuickTimeframe::YearToDate => "YTD",
            QuickTimeframe::OneYear => "1Y",
            QuickTimeframe::FiveYears => "5Y",
            QuickTimeframe::All => "All",
        }
    }
}

/// Configuration for the timeframe bar
#[derive(Clone, Debug)]
pub struct TimeframeBarConfig {
    /// Height, in egui logical points.
    pub height: f32,
    /// Background color.
    pub bg_color: Color32,
    /// Text color.
    pub text_color: Color32,
    /// Active text color.
    pub active_text_color: Color32,
    /// Active background.
    pub active_bg: Color32,
    /// Hover background.
    pub hover_bg: Color32,
    /// Border color.
    pub border_color: Color32,
    /// Button padding, in egui logical points.
    pub btn_padding: f32,
}

impl TimeframeBarConfig {
    /// Create config from `theme`
    pub fn from_theme(theme: &Theme) -> Self {
        let ui = &theme.ui;
        Self {
            height: DESIGN_TOKENS.sizing.toolbar.bottom_height,
            bg_color: Color32::TRANSPARENT, // Let parent Frame show through
            text_color: ui.text_secondary,
            active_text_color: ui.text,
            active_bg: ui.btn_bg_active,
            hover_bg: ui.btn_bg_hover,
            border_color: ui.border,
            btn_padding: theme.spacing.lg,
        }
    }
}

impl Default for TimeframeBarConfig {
    fn default() -> Self {
        // Default uses light UI chrome theme
        Self::from_theme(&Theme::dark())
    }
}

theme_derived!(TimeframeBarConfig {
    height,
    bg_color,
    text_color,
    active_text_color,
    active_bg,
    hover_bg,
    border_color,
    btn_padding
});

/// Action returned by the timeframe bar
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum TimeframeBarAction {
    /// No action taken
    None,
    /// A quick timeframe was selected
    TimeframeSelected(QuickTimeframe),
    /// The date range selector icon was clicked
    DateRangeClicked,
    /// Dividend adjustment toggled (new state)
    AdjToggled(bool),
}

/// Bottom Timeframe Quick-Select Bar
pub struct TimeframeBar {
    /// Display and layout options for this component.
    pub config: TimeframeBarConfig,
    /// Currently selected date range preset.
    pub active_timeframe: QuickTimeframe,
    /// Whether to display the adjustment toggle.
    pub show_adj: bool,
    /// Whether the adjustment toggle is selected.
    pub adj_enabled: bool,
    /// Theme and config `config` was last derived from; `None` when the caller supplied it.
    config_theme: Option<(Theme, TimeframeBarConfig)>,
}

impl Default for TimeframeBar {
    fn default() -> Self {
        Self {
            config: TimeframeBarConfig::default(),
            active_timeframe: QuickTimeframe::OneDay,
            show_adj: true,
            adj_enabled: true,
            config_theme: Some((Theme::dark(), TimeframeBarConfig::default())),
        }
    }
}

impl TimeframeBar {
    /// Create a new timeframe bar with default configuration
    pub fn new() -> Self {
        Self::default()
    }

    /// Set a custom configuration
    pub fn with_config(mut self, config: TimeframeBarConfig) -> Self {
        self.config = config;
        self.config_theme = None;
        self
    }

    /// Set the initially active timeframe
    pub fn with_active_timeframe(mut self, tf: QuickTimeframe) -> Self {
        self.active_timeframe = tf;
        self
    }

    /// Show the timeframe bar
    pub fn show(&mut self, ui: &mut Ui) -> TimeframeBarAction {
        follow_active_theme(
            ui.ctx(),
            &mut self.config_theme,
            &mut self.config,
            TimeframeBarConfig::from_theme,
        );
        let mut action = TimeframeBarAction::None;

        let (response, painter) = ui.allocate_painter(
            Vec2::new(ui.available_width(), self.config.height),
            Sense::hover(),
        );
        let rect = response.rect;

        // Background - REMOVED: Let parent Frame's fill show through
        // painter.rect_filled(rect, 0.0, self.config.bg_color);

        // Top border
        painter.line_segment(
            [rect.left_top(), rect.right_top()],
            Stroke::new(DESIGN_TOKENS.stroke.hairline, self.config.border_color),
        );

        let mut x = rect.min.x + 8.0;
        let center_y = rect.center().y;

        // Date range selector icon
        let date_icon_rect = Rect::from_center_size(
            Pos2::new(x + 10.0, center_y),
            Vec2::splat(DESIGN_TOKENS.sizing.icon_md),
        );
        let date_res = ui.allocate_rect(date_icon_rect, Sense::click());
        let translated_label = l10n::text(ui.ctx(), "Go to date");
        date_res.widget_info(|| {
            egui::WidgetInfo::labeled(egui::Role::Button, date_res.enabled(), &translated_label)
        });
        crate::styles::focus::draw_focus_ring(ui, &date_res, ui.active_theme().radius.sm);
        if date_res.hovered() {
            painter.rect_filled(
                date_icon_rect,
                ui.active_theme().radius.sm,
                self.config.hover_bg,
            );
        }
        // Render calendar icon
        let icon_size = 12.0;
        let icon_rect = Rect::from_center_size(date_icon_rect.center(), Vec2::splat(icon_size));
        embedded_icons::WIDGET_BAR_CALENDAR
            .as_image_tinted(Vec2::splat(icon_size), self.config.text_color)
            .paint_at(ui, icon_rect);
        if date_res.clicked() {
            action = TimeframeBarAction::DateRangeClicked;
        }

        x += 28.0;

        // Separator
        painter.line_segment(
            [
                Pos2::new(x, rect.min.y + 4.0),
                Pos2::new(x, rect.max.y - 4.0),
            ],
            Stroke::new(DESIGN_TOKENS.stroke.hairline, self.config.border_color),
        );
        x += 8.0;

        // Timeframe btns
        let timeframes = [
            QuickTimeframe::OneDay,
            QuickTimeframe::FiveDays,
            QuickTimeframe::OneMonth,
            QuickTimeframe::ThreeMonths,
            QuickTimeframe::SixMonths,
            QuickTimeframe::YearToDate,
            QuickTimeframe::OneYear,
            QuickTimeframe::FiveYears,
            QuickTimeframe::All,
        ];

        for tf in timeframes.iter() {
            let label = tf.label();
            let galley = painter.layout_no_wrap(
                l10n::text(ui.ctx(), label),
                egui::FontId::proportional(ui.active_theme().text.small),
                self.config.text_color,
            );

            let btn_width = galley.size().x + self.config.btn_padding * 2.0;
            let btn_rect = Rect::from_min_size(
                Pos2::new(x, rect.min.y + 4.0),
                Vec2::new(btn_width, self.config.height - 8.0),
            );

            let btn_res = ui.allocate_rect(btn_rect, Sense::click());
            crate::styles::focus::draw_focus_ring(ui, &btn_res, ui.active_theme().radius.sm);
            let is_active = *tf == self.active_timeframe;
            let translated_label = l10n::text(ui.ctx(), label);
            btn_res.widget_info(|| {
                egui::WidgetInfo::selected(
                    egui::Role::Button,
                    btn_res.enabled(),
                    is_active,
                    &translated_label,
                )
            });
            let is_hovered = btn_res.hovered();
            let is_pressed = btn_res.is_pointer_button_down_on();

            // Button background (with press feedback)
            if is_active {
                painter.rect_filled(btn_rect, ui.active_theme().radius.sm, self.config.active_bg);
            } else if is_pressed {
                // Pressed state - use active background
                painter.rect_filled(btn_rect, ui.active_theme().radius.sm, self.config.active_bg);
            } else if is_hovered {
                painter.rect_filled(btn_rect, ui.active_theme().radius.sm, self.config.hover_bg);
            }

            // Button text
            let text_color = if is_active || is_pressed {
                self.config.active_text_color
            } else {
                self.config.text_color
            };

            let text_galley = painter.layout_no_wrap(
                l10n::text(ui.ctx(), label),
                egui::FontId::proportional(ui.active_theme().text.small),
                text_color,
            );
            painter.galley(
                Pos2::new(
                    btn_rect.center().x - text_galley.size().x / 2.0,
                    center_y - text_galley.size().y / 2.0,
                ),
                text_galley,
                Color32::TRANSPARENT,
            );

            if btn_res.clicked() {
                self.active_timeframe = *tf;
                action = TimeframeBarAction::TimeframeSelected(*tf);
            }

            x += btn_width + 4.0;
        }

        // Right side - current time and ADJ toggle
        let right_x = rect.max.x - 8.0;

        // ADJ toggle
        if self.show_adj {
            let adj_text = "ADJ";
            let adj_galley = painter.layout_no_wrap(
                l10n::text(ui.ctx(), adj_text),
                egui::FontId::proportional(ui.active_theme().text.tiny),
                if self.adj_enabled {
                    self.config.active_text_color
                } else {
                    self.config.text_color
                },
            );
            let adj_button_rect = Rect::from_min_size(
                Pos2::new(
                    right_x - adj_galley.size().x - 12.0 - 70.0,
                    rect.min.y + 4.0,
                ),
                Vec2::new(adj_galley.size().x + 12.0, self.config.height - 8.0),
            );
            let adj_res = ui.allocate_rect(adj_button_rect, Sense::click());
            let translated_label = l10n::text(ui.ctx(), "Adjust for dividends");
            adj_res.widget_info(|| {
                egui::WidgetInfo::selected(
                    egui::Role::Button,
                    adj_res.enabled(),
                    self.adj_enabled,
                    &translated_label,
                )
            });
            crate::styles::focus::draw_focus_ring(ui, &adj_res, ui.active_theme().radius.sm);

            if adj_res.hovered() || self.adj_enabled {
                painter.rect_filled(
                    adj_button_rect,
                    ui.active_theme().radius.sm,
                    self.config.active_bg,
                );
            }

            let adj_draw_galley = painter.layout_no_wrap(
                l10n::text(ui.ctx(), adj_text),
                egui::FontId::proportional(ui.active_theme().text.tiny),
                if self.adj_enabled {
                    self.config.active_text_color
                } else {
                    self.config.text_color
                },
            );
            painter.galley(
                Pos2::new(
                    adj_button_rect.center().x - adj_draw_galley.size().x / 2.0,
                    center_y - adj_draw_galley.size().y / 2.0,
                ),
                adj_draw_galley,
                Color32::TRANSPARENT,
            );

            if adj_res.clicked() {
                self.adj_enabled = !self.adj_enabled;
                action = TimeframeBarAction::AdjToggled(self.adj_enabled);
            }
        }

        // Current time (UTC)
        let now = Local::now();
        let time_str = format!(
            "{:02}:{:02}:{:02} UTC",
            now.hour(),
            now.minute(),
            now.second()
        );
        let time_galley = painter.layout_no_wrap(
            l10n::text(ui.ctx(), time_str),
            egui::FontId::proportional(ui.active_theme().text.tiny),
            self.config.text_color,
        );
        painter.galley(
            Pos2::new(
                right_x - time_galley.size().x,
                center_y - time_galley.size().y / 2.0,
            ),
            time_galley,
            Color32::TRANSPARENT,
        );

        action
    }

    /// Select the displayed date range preset.
    pub fn set_active_timeframe(&mut self, tf: QuickTimeframe) {
        self.active_timeframe = tf;
    }
}