gtm 0.2.83

Feature rich and cross platform terminal audio 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
139

// Copyright (c) 2026
// Author: prjctimg <prjctimg@outlook.com>
// Floating picker panels for settings and search
//
// This is free software released under the GPL-3.0 license.

/// Every picker variant.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PickerId {
    Queue,
    YTSearch,
    SearchLibrary,
    SpotifySearch,
    SpotifyLink,
    Equalizer,
    CommandPalette,
    About,
    SleepTimer,
    ThemePicker,
    Help,
    PlaylistSelect,
    /// Multi-select track list shown after creating a new playlist, so tracks
    /// can be picked (persistently highlighted) before Ctrl+Enter commits them.
    PlaylistTrackSelect,
    EditMetadata,
    Crossfade,
    VisualizerPreset,
    FooterPreset,
    ProgressStyle,
    Settings,
    Notifications,
    NotificationSettings,
}

/// Which list a fuzzy-finder picker searches. `Tab` cycles through these.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum PickerSource {
    #[default]
    All,
    Tracks,
    Artists,
    Albums,
    Playlists,
}

impl PickerSource {
    pub fn label(&self) -> &'static str {
        match self {
            Self::All => "All",
            Self::Tracks => "Tracks",
            Self::Artists => "Artists",
            Self::Albums => "Albums",
            Self::Playlists => "Playlists",
        }
    }

    pub fn next(&self) -> Self {
        match self {
            Self::All => Self::Tracks,
            Self::Tracks => Self::Artists,
            Self::Artists => Self::Albums,
            Self::Albums => Self::Playlists,
            Self::Playlists => Self::All,
        }
    }
}

/// Active picker instance: state + metadata.
pub struct Picker {
    pub id: PickerId,
    pub query: String,
    pub selected: usize,
    /// Top row of the visible window (1-row-at-a-time scroll model).
    /// Only advances when the selection leaves the viewport, so the
    /// list never recenters or jumps.
    pub viewport_offset: usize,
    /// List the fuzzy finder filters over (`Tab` cycles it).
    pub source: PickerSource,
}

impl Picker {
    pub fn new(id: PickerId) -> Self {
        Self {
            id,
            query: String::new(),
            selected: 0,
            viewport_offset: 0,
            source: PickerSource::default(),
        }
    }
}

/// Manages the stack of open pickers (LIFO).
pub struct PickerManager {
    pub stack: Vec<Picker>,
}

impl PickerManager {
    pub fn new() -> Self {
        Self { stack: Vec::new() }
    }

    pub fn is_open(&self) -> bool {
        !self.stack.is_empty()
    }

    pub fn top(&self) -> Option<&Picker> {
        self.stack.last()
    }

    pub fn top_mut(&mut self) -> Option<&mut Picker> {
        self.stack.last_mut()
    }

    pub fn open(&mut self, id: PickerId) {
        // Avoid duplicates
        if !self.stack.iter().any(|o| o.id == id) {
            self.stack.push(Picker::new(id));
        }
    }

    pub fn open_with_selection(&mut self, id: PickerId, selected: usize) {
        if !self.stack.iter().any(|o| o.id == id) {
            let mut picker = Picker::new(id);
            picker.selected = selected;
            self.stack.push(picker);
        }
    }

    pub fn close_top(&mut self) {
        self.stack.pop();
    }
}

impl Default for PickerManager {
    fn default() -> Self {
        Self::new()
    }
}