daemos 0.1.1

A local-only music player
Documentation 
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

pub mod menu_bar;
pub mod modals;
pub mod playback;
pub mod popups;
pub mod tables;
pub mod utils;

use std::{fmt, rc::Rc};

use crossbeam::channel::Sender;
use egui_dock::{DockState, NodeIndex, TabViewer};
use popups::settings::SettingsPopup;
use tables::{playlists::PlaylistTable, tags::TagTable, tasks::TaskTable, tracks::TrackTable};

use crate::{
    components::{
        menu_bar::MenuBar, modals::create_playlist::CreatePlaylistModal, playback::PlaybackBar,
        popups::debug::performance::PerformanceMetricsPopup,
    },
    config::core::SharedConfig,
    context::SharedContext,
    database::connection::DatabaseCommand,
    playback::state::PlayerCommand,
};

#[derive(Debug, Clone)]
pub enum ComponentTab {
    Playlists,
    Tracks,
    Tags,
    Tasks,
}

impl fmt::Display for ComponentTab {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let label = match self {
            ComponentTab::Playlists => "Playlists",
            ComponentTab::Tracks => "Tracks",
            ComponentTab::Tags => "Tags",
            ComponentTab::Tasks => "Tasks",
        };

        write!(f, "{label}")
    }
}

#[derive(Debug, Clone)]
pub struct ComponentChannels {
    database_command_tx: Sender<DatabaseCommand>,
    player_command_tx: Sender<PlayerCommand>,
}

impl ComponentChannels {
    pub fn new(
        database_command_tx: Sender<DatabaseCommand>,
        player_command_tx: Sender<PlayerCommand>,
    ) -> Self {
        Self {
            database_command_tx,
            player_command_tx,
        }
    }
}

pub struct Components {
    pub top_menu_bar: MenuBar,
    pub playback_bar: PlaybackBar,

    pub playlist_table: PlaylistTable,
    pub track_table: TrackTable,
    pub tag_table: TagTable,
    pub task_table: TaskTable,

    pub settings: SettingsPopup,
    pub debug: PerformanceMetricsPopup,
    pub create_playlist: CreatePlaylistModal,
}

impl Components {
    pub fn new(
        config: SharedConfig,
        context: SharedContext,
        channels: Rc<ComponentChannels>,
    ) -> Self {
        Self {
            top_menu_bar: MenuBar::new(context.clone()),
            playback_bar: PlaybackBar::new(config.clone(), context.clone(), channels.clone()),

            playlist_table: PlaylistTable::new(context.clone(), channels.clone()),
            track_table: TrackTable::new(config.clone(), context.clone(), channels.clone()),
            tag_table: TagTable::default(),
            task_table: TaskTable::default(),

            settings: SettingsPopup::new(config.clone(), context.clone()),
            debug: PerformanceMetricsPopup::new(config.clone(), context.clone()),
            create_playlist: CreatePlaylistModal::new(context.clone(), channels.clone()),
        }
    }

    pub fn component_tab_layout(&self) -> DockState<ComponentTab> {
        let mut dock_state = DockState::new(vec![
            ComponentTab::Tracks,
            ComponentTab::Tags,
            ComponentTab::Tasks,
        ]);

        let surface = dock_state.main_surface_mut();

        let [_, _] = surface.split_left(NodeIndex::root(), 0.20, vec![ComponentTab::Playlists]);

        dock_state
    }
}

impl TabViewer for Components {
    type Tab = ComponentTab;

    fn title(&mut self, tab: &mut Self::Tab) -> egui::WidgetText {
        tab.to_string().into()
    }

    fn ui(&mut self, ui: &mut egui::Ui, tab: &mut Self::Tab) {
        match tab {
            ComponentTab::Playlists => {
                self.playlist_table.ui(ui);
            }
            ComponentTab::Tracks => {
                self.track_table.ui(ui);
            }
            ComponentTab::Tags => {
                self.tag_table.ui(ui);
            }
            ComponentTab::Tasks => {
                self.task_table.ui(ui);
            }
        }
    }
}