ferrosonic 0.8.1

A terminal-based Subsonic music client with bit-perfect audio playback
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

//! Progress bar widget with seek support

use ratatui::{
    buffer::Buffer,
    layout::Rect,
    style::{Color, Style},
    widgets::Widget,
};

/// A horizontal progress bar with time display
#[allow(dead_code)]
pub struct ProgressBar<'a> {
    /// Progress value (0.0 to 1.0)
    progress: f64,
    /// Current position formatted
    position_text: &'a str,
    /// Total duration formatted
    duration_text: &'a str,
    /// Filled portion style
    filled_style: Style,
    /// Empty portion style
    empty_style: Style,
    /// Text style
    text_style: Style,
}

#[allow(dead_code)]
impl<'a> ProgressBar<'a> {
    pub fn new(progress: f64, position_text: &'a str, duration_text: &'a str) -> Self {
        Self {
            progress: progress.clamp(0.0, 1.0),
            position_text,
            duration_text,
            filled_style: Style::default().bg(Color::Blue),
            empty_style: Style::default().bg(Color::DarkGray),
            text_style: Style::default().fg(Color::White),
        }
    }

    pub fn filled_style(mut self, style: Style) -> Self {
        self.filled_style = style;
        self
    }

    pub fn empty_style(mut self, style: Style) -> Self {
        self.empty_style = style;
        self
    }

    pub fn text_style(mut self, style: Style) -> Self {
        self.text_style = style;
        self
    }

    /// Calculate position from x coordinate within the bar area
    pub fn position_from_x(area: Rect, x: u16) -> Option<f64> {
        // Account for time text margins
        let bar_start = area.x + 8; // "00:00 " prefix
        let bar_end = area.x + area.width - 8; // " 00:00" suffix

        if x >= bar_start && x < bar_end {
            let bar_width = bar_end - bar_start;
            let relative_x = x - bar_start;
            Some(relative_x as f64 / bar_width as f64)
        } else {
            None
        }
    }
}

impl Widget for ProgressBar<'_> {
    fn render(self, area: Rect, buf: &mut Buffer) {
        if area.width < 20 || area.height < 1 {
            return;
        }

        // Format: "00:00 [==========----------] 00:00"
        let pos_width = self.position_text.len();
        let dur_width = self.duration_text.len();

        // Draw position text
        buf.set_string(area.x, area.y, self.position_text, self.text_style);

        // Draw duration text
        let dur_x = area.x + area.width - dur_width as u16;
        buf.set_string(dur_x, area.y, self.duration_text, self.text_style);

        // Calculate bar area
        let bar_x = area.x + pos_width as u16 + 1;
        let bar_width = area
            .width
            .saturating_sub((pos_width + dur_width + 2) as u16);

        if bar_width > 0 {
            let filled_width = (bar_width as f64 * self.progress) as u16;

            // Draw filled portion
            for x in bar_x..(bar_x + filled_width) {
                buf[(x, area.y)].set_char('━').set_style(self.filled_style);
            }

            // Draw empty portion
            for x in (bar_x + filled_width)..(bar_x + bar_width) {
                buf[(x, area.y)].set_char('─').set_style(self.empty_style);
            }
        }
    }
}

/// Vertical gauge (for volume, etc.)
#[allow(dead_code)]
pub struct VerticalBar {
    /// Value (0.0 to 1.0)
    value: f64,
    /// Filled style
    filled_style: Style,
    /// Empty style
    empty_style: Style,
}

#[allow(dead_code)]
impl VerticalBar {
    pub fn new(value: f64) -> Self {
        Self {
            value: value.clamp(0.0, 1.0),
            filled_style: Style::default().bg(Color::Blue),
            empty_style: Style::default().bg(Color::DarkGray),
        }
    }

    pub fn filled_style(mut self, style: Style) -> Self {
        self.filled_style = style;
        self
    }

    pub fn empty_style(mut self, style: Style) -> Self {
        self.empty_style = style;
        self
    }
}

impl Widget for VerticalBar {
    fn render(self, area: Rect, buf: &mut Buffer) {
        if area.height < 1 || area.width < 1 {
            return;
        }

        let filled_height = (area.height as f64 * self.value) as u16;
        let empty_start = area.y + area.height - filled_height;

        // Draw empty portion (top)
        for y in area.y..empty_start {
            for x in area.x..(area.x + area.width) {
                buf[(x, y)].set_char('░').set_style(self.empty_style);
            }
        }

        // Draw filled portion (bottom)
        for y in empty_start..(area.y + area.height) {
            for x in area.x..(area.x + area.width) {
                buf[(x, y)].set_char('█').set_style(self.filled_style);
            }
        }
    }
}