Struct ReplayState 

pub struct ReplayState {

    pub playback_state: PlaybackState,
    pub speed: ReplaySpeed,
    pub curr_bar: usize,
    pub total_bars: usize,
    pub visible_bars: usize,
    pub start_date: Option<DateTime<Utc>>,
    pub end_date: Option<DateTime<Utc>>,
    pub curr_date: Option<DateTime<Utc>>,
    pub symbol: Option<String>,
    pub speed_dropdown_open: bool,
    pub date_picker_open: bool,
    pub settings_open: bool,
    pub markers: Vec<ReplayMarker>,
    /* private fields */
}

Main replay state

Fields

playback_state: PlaybackState

Current playback state

speed: ReplaySpeed

Current playback speed

curr_bar: usize

Current bar index (0-based)

total_bars: usize

Total number of bars available

visible_bars: usize

Visible bar count (how many bars to show on chart)

start_date: Option<DateTime<Utc>>

Start date of replay data

end_date: Option<DateTime<Utc>>

End date of replay data

curr_date: Option<DateTime<Utc>>

Current date/time at playback position

symbol: Option<String>

Symbol being replayed

speed_dropdown_open: bool

Whether speed dropdown is open

date_picker_open: bool

Whether date picker is open

settings_open: bool

Whether settings panel is open

markers: Vec<ReplayMarker>

User-placed markers

Implementations

impl ReplayState

pub fn new() -> Self

Create new replay state

pub fn init( &mut self, total_bars: usize, start_date: DateTime<Utc>, end_date: DateTime<Utc>, symbol: String, )

Initialize replay with data params

pub fn set_bar_duration(&mut self, seconds: f64)

Set the bar duration (time between bars at 1x speed)

pub fn is_active(&self) -> bool

Check if replay mode is active

pub fn is_playing(&self) -> bool

Check if currently playing

pub fn progress(&self) -> f32

Get progress as percentage (0.0 - 1.0)

pub fn remaining_bars(&self) -> usize

Get remaining bars

pub fn at_end(&self) -> bool

Check if at the end

pub fn at_start(&self) -> bool

Check if at the beginning

pub fn play(&mut self)

Start playing

pub fn pause(&mut self)

Pause playback

pub fn toggle_play_pause(&mut self)

Toggle play/pause

pub fn stop(&mut self)

Stop and exit replay mode

pub fn reset(&mut self)

Reset to beginning without exiting replay mode

pub fn enter_replay_mode(&mut self)

Enter replay mode

pub fn exit_replay_mode(&mut self)

Exit replay mode

pub fn step_forward(&mut self)

Step forward one bar

pub fn step_backward(&mut self)

Step backward one bar

pub fn jump_to_bar(&mut self, bar: usize)

Jump to specific bar

pub fn jump_to_percent(&mut self, percent: f32)

Jump to percentage position

pub fn set_speed(&mut self, speed: ReplaySpeed)

Set playback speed

pub fn speed_up(&mut self)

Increase speed

pub fn slow_down(&mut self)

Decrease speed

pub fn add_marker(&mut self, label: Option<String>, color: Option<[u8; 4]>)

Add a marker at current position

pub fn remove_marker(&mut self, bar_idx: usize)

Remove marker at bar index

pub fn clear_markers(&mut self)

Clear all markers

pub fn visible_markers( &self, start_bar: usize, end_bar: usize, ) -> Vec<&ReplayMarker>

Get markers in visible range

pub fn update(&mut self) -> usize

Update playback state. Call this each frame. Returns the number of bars actually advanced (usually 0 or 1).

pub fn update_curr_date(&mut self, bar_ts: &[DateTime<Utc>])

Update current date based on bar index

pub fn sync_from( &mut self, active: bool, playing: bool, current_bar: usize, total_bars: usize, speed: ReplaySpeed, )

Sync replay state from external values.

active / playing drive the playback state machine, current_bar / total_bars sync position, and speed sets playback rate.

Trait Implementations

impl Clone for ReplayState

fn clone(&self) -> ReplayState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ReplayState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ReplayState

fn default() -> Self

Returns the “default value” for a type.