concord 2.5.13

A terminal user interface client for Discord
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Plans dashboard redraw transactions around terminal pixel media.
//!
//! Placement cleanup and animation frame replacement have the same display
//! requirement: the terminal must not present the partially updated pixel layer.
//! Keeping that policy here avoids terminal-, protocol-, and media-format checks in
//! the event loop.

use crossterm::{
    execute,
    terminal::{BeginSynchronizedUpdate, EndSynchronizedUpdate},
};
use ratatui::{DefaultTerminal, layout::Rect};

use crate::tui::state::DashboardState;

use super::media_runtime::{
    DashboardMediaRuntime, clear_image_surfaces_frame, draw_dashboard_frame,
};

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) struct RedrawPlan {
    pub(super) clear_stale_media: bool,
    pub(super) synchronized: bool,
}

#[derive(Default)]
pub(super) struct DashboardRedrawState {
    media_animation_pending: bool,
}

impl DashboardRedrawState {
    pub(super) fn request_media_animation(&mut self) {
        self.media_animation_pending = true;
    }

    pub(super) fn take_plan(&mut self, clear_stale_media: bool) -> RedrawPlan {
        let media_animation_pending = std::mem::take(&mut self.media_animation_pending);
        RedrawPlan {
            clear_stale_media,
            synchronized: clear_stale_media || media_animation_pending,
        }
    }
}

pub(super) fn draw_dashboard_transaction(
    terminal: &mut DefaultTerminal,
    state: &mut DashboardState,
    media_runtime: &mut DashboardMediaRuntime,
    last_frame_area: &mut Rect,
    plan: RedrawPlan,
) -> std::io::Result<()> {
    if plan.synchronized {
        let _ = execute!(terminal.backend_mut(), BeginSynchronizedUpdate);
    }

    let draw_result = (|| -> std::io::Result<()> {
        if plan.clear_stale_media {
            terminal.draw(|frame| {
                *last_frame_area = clear_image_surfaces_frame(frame, state, media_runtime);
            })?;
        }
        terminal.draw(|frame| {
            *last_frame_area = draw_dashboard_frame(frame, state, media_runtime);
        })?;
        Ok(())
    })();

    // Ending the transaction is best-effort, like beginning it. It must still be
    // attempted after a draw error so a supporting terminal does not keep showing
    // the previous frame indefinitely.
    if plan.synchronized {
        let _ = execute!(terminal.backend_mut(), EndSynchronizedUpdate);
    }

    draw_result
}

#[cfg(test)]
mod tests {
    use super::{DashboardRedrawState, RedrawPlan};

    #[test]
    fn redraw_plan_synchronizes_media_animation_and_placement_cleanup() {
        let cases = [
            (
                "static redraw",
                false,
                false,
                RedrawPlan {
                    clear_stale_media: false,
                    synchronized: false,
                },
            ),
            (
                "placement cleanup",
                true,
                false,
                RedrawPlan {
                    clear_stale_media: true,
                    synchronized: true,
                },
            ),
            (
                "media animation",
                false,
                true,
                RedrawPlan {
                    clear_stale_media: false,
                    synchronized: true,
                },
            ),
            (
                "animation with placement cleanup",
                true,
                true,
                RedrawPlan {
                    clear_stale_media: true,
                    synchronized: true,
                },
            ),
        ];

        for (label, clear_stale_media, animated_media_advanced, expected) in cases {
            let mut state = DashboardRedrawState::default();
            if animated_media_advanced {
                state.request_media_animation();
            }

            assert_eq!(state.take_plan(clear_stale_media), expected, "{label}");
            assert_eq!(
                state.take_plan(false),
                RedrawPlan {
                    clear_stale_media: false,
                    synchronized: false,
                },
                "{label} should consume the pending animation redraw"
            );
        }
    }
}