ferrosonic 0.5.3

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

//! Main layout and rendering

use ratatui::{
    layout::{Constraint, Layout},
    Frame,
};

use crate::app::state::{AppState, LayoutAreas, Page};

use super::footer::Footer;
use super::header::Header;
use super::pages;
use super::widgets::{CavaWidget, NowPlayingWidget};

/// Draw the entire UI
pub fn draw(frame: &mut Frame, state: &mut AppState) {
    let area = frame.area();

    let cava_active = state.settings_state.cava_enabled && !state.cava_screen.is_empty();

    // Main layout:
    // [Header]          - 1 line
    // [Cava]            - ~40% (optional, only when cava is active)
    // [Page Content]    - flexible
    // [Now Playing]     - 7 lines
    // [Footer]          - 1 line

    let (header_area, cava_area, content_area, now_playing_area, footer_area) = if cava_active {
        let chunks = Layout::vertical([
            Constraint::Length(1),                                         // Header
            Constraint::Percentage(state.settings_state.cava_size as u16), // Cava visualizer
            Constraint::Min(10),                                           // Page content
            Constraint::Length(7),                                         // Now playing
            Constraint::Length(1),                                         // Footer
        ])
        .split(area);
        (chunks[0], Some(chunks[1]), chunks[2], chunks[3], chunks[4])
    } else {
        let chunks = Layout::vertical([
            Constraint::Length(1), // Header
            Constraint::Min(10),   // Page content
            Constraint::Length(7), // Now playing
            Constraint::Length(1), // Footer
        ])
        .split(area);
        (chunks[0], None, chunks[1], chunks[2], chunks[3])
    };

    // Compute dual-pane splits for pages that use them
    let (content_left, content_right) = match state.page {
        Page::Artists | Page::Playlists => {
            let panes =
                Layout::horizontal([Constraint::Percentage(40), Constraint::Percentage(60)])
                    .split(content_area);
            (Some(panes[0]), Some(panes[1]))
        }
        _ => (None, None),
    };

    // Store layout areas for mouse hit-testing
    state.layout = LayoutAreas {
        header: header_area,
        content: content_area,
        now_playing: now_playing_area,
        content_left,
        content_right,
    };

    // Render header
    let colors = *state.settings_state.theme_colors();
    let header = Header::new(state.page, state.now_playing.state, colors);
    frame.render_widget(header, header_area);

    // Render cava visualizer if active
    if let Some(cava_rect) = cava_area {
        let cava_widget = CavaWidget::new(&state.cava_screen);
        frame.render_widget(cava_widget, cava_rect);
    }

    // Render current page
    match state.page {
        Page::Songs => {
            pages::songs::render(frame, content_area, state);
        }
        Page::Artists => {
            pages::artists::render(frame, content_area, state);
        }
        Page::Queue => {
            pages::queue::render(frame, content_area, state);
        }
        Page::Playlists => {
            pages::playlists::render(frame, content_area, state);
        }
        Page::Server => {
            pages::server::render(frame, content_area, state);
        }
        Page::Settings => {
            pages::settings::render(frame, content_area, state);
        }
    }

    // Render now playing
    let now_playing = NowPlayingWidget::new(&state.now_playing, colors);
    frame.render_widget(now_playing, now_playing_area);

    // Render footer
    let footer = Footer::new(state.page, colors)
        .sample_rate(state.now_playing.sample_rate)
        .notification(state.notification.as_ref());
    frame.render_widget(footer, footer_area);
}