ab/furumi_tui
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

Added Visual select for multiple tracks, added Queue management. Added info for tracks

Browse Source
This commit is contained in:
Ultradesu
2026-06-15 12:28:34 +01:00
parent 5b624443d5
commit ba5a73816e
13 changed files with 1017 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/app/action.rs
+10 -1
View File
@@ -28,8 +28,11 @@ pub enum Action {
ToggleShuffle,
CycleRepeat,
ToggleLike,
ToggleTrackSelection,
OpenTrackInfo,
QueueAddNext,
QueueAddLast,
RemoveFromQueue,
ClearQueue,
GoToRelease,
AddToPlaylist,
@@ -86,10 +89,13 @@ impl Action {
| Action::CycleRepeat => Category::Playback,
Action::QueueAddNext
| Action::QueueAddLast
| Action::RemoveFromQueue
| Action::ClearQueue
| Action::AddToPlaylist
| Action::NewPlaylist
| Action::ToggleLike => Category::Queue,
| Action::ToggleLike
| Action::ToggleTrackSelection
| Action::OpenTrackInfo => Category::Queue,
Action::MoveUp
| Action::MoveDown
| Action::MoveLeft
@@ -157,8 +163,11 @@ impl Action {
Action::ToggleShuffle => "Toggle shuffle".into(),
Action::CycleRepeat => "Cycle repeat mode".into(),
Action::ToggleLike => "Like / unlike".into(),
Action::ToggleTrackSelection => "Track line selection".into(),
Action::OpenTrackInfo => "Track info".into(),
Action::QueueAddNext => "Queue: add next".into(),
Action::QueueAddLast => "Queue: add to end".into(),
Action::RemoveFromQueue => "Queue: remove selected".into(),
Action::ClearQueue => "Queue: clear".into(),
Action::GoToRelease => "Open the track's release".into(),
Action::AddToPlaylist => "Add track to a playlist…".into(),
src/app/mod.rs
+69 -14
View File
@@ -431,7 +431,7 @@ fn spawn_art_fetch(
/// Execute a side effect requested by update().
fn perform_effect(state: &mut AppState, runtime: &mut Runtime, effect: Effect) {
if perform_remote_effect(state, runtime, effect) {
if perform_remote_effect(state, runtime, &effect) {
return;
}
match effect {
@@ -480,27 +480,52 @@ fn perform_effect(state: &mut AppState, runtime: &mut Runtime, effect: Effect) {
}
});
}
Effect::ToggleLike { track_id } => {
Effect::ToggleLikes { track_ids } => {
if track_ids.is_empty() {
return;
}
let Some(api) = runtime.api.clone() else {
return;
};
let tx = runtime.event_tx.clone();
tokio::spawn(async move {
match api.toggle_like(track_id).await {
Ok(liked) => {
let _ = tx.send(AppEvent::LikeToggled { track_id, liked });
}
Err(err) => {
tracing::warn!(%err, track_id, "like toggle failed");
let _ = tx.send(AppEvent::StatusMessage(format!("like failed: {err}")));
for track_id in track_ids {
match api.toggle_like(track_id).await {
Ok(liked) => {
let _ = tx.send(AppEvent::LikeToggled { track_id, liked });
}
Err(err) => {
tracing::warn!(%err, track_id, "like toggle failed");
let _ = tx.send(AppEvent::StatusMessage(format!("like failed: {err}")));
break;
}
}
}
});
}
Effect::RemoveQueueIndices {
restart_paused,
stop,
..
} => {
if stop {
runtime.player.stop();
push_state_now(state, runtime);
push_media_update(state, runtime, true);
} else if let Some(paused) = restart_paused {
start_current_audio(state, runtime, 0.0, paused);
push_state_now(state, runtime);
push_media_metadata(state, runtime);
push_media_update(state, runtime, true);
} else {
push_state_now(state, runtime);
push_media_update(state, runtime, true);
}
}
}
}
fn perform_remote_effect(state: &mut AppState, runtime: &Runtime, effect: Effect) -> bool {
fn perform_remote_effect(state: &mut AppState, runtime: &Runtime, effect: &Effect) -> bool {
let Some(target) = state.devices.remote_target_id().map(str::to_string) else {
return false;
};
@@ -528,7 +553,7 @@ fn perform_remote_effect(state: &mut AppState, runtime: &Runtime, effect: Effect
true
}
Effect::SeekBy(delta) => {
let target_time = (state.player.position_secs + delta as f64).max(0.0);
let target_time = (state.player.position_secs + *delta as f64).max(0.0);
state.player.position_secs = target_time;
send_device_command(
runtime,
@@ -543,7 +568,7 @@ fn perform_remote_effect(state: &mut AppState, runtime: &Runtime, effect: Effect
runtime,
target,
"set_volume",
serde_json::json!({ "volume": f64::from(volume) / 100.0 }),
serde_json::json!({ "volume": f64::from(*volume) / 100.0 }),
);
true
}
@@ -559,7 +584,20 @@ fn perform_remote_effect(state: &mut AppState, runtime: &Runtime, effect: Effect
);
true
}
Effect::EnqueueRelease { .. } | Effect::ToggleLike { .. } => false,
Effect::RemoveQueueIndices { indices, .. } => {
let mut indices = indices.clone();
indices.sort_unstable_by(|a, b| b.cmp(a));
for index in indices {
send_device_command(
runtime,
target.clone(),
"queue_remove",
serde_json::json!({ "index": index }),
);
}
true
}
Effect::EnqueueRelease { .. } | Effect::ToggleLikes { .. } => false,
}
}
@@ -1181,15 +1219,26 @@ fn apply_options_payload(state: &mut AppState, payload: &serde_json::Value) {
}
}
fn remove_queue_index(state: &mut AppState, runtime: &Runtime, index: usize) {
fn remove_queue_index(state: &mut AppState, runtime: &mut Runtime, index: usize) {
if index >= state.player.queue.len() {
return;
}
let current_id = state.player.current.as_ref().map(|track| track.id);
let removed_current = state
.player
.queue
.get(index)
.is_some_and(|track| Some(track.id) == current_id);
let was_loaded = state.player.playing;
let was_paused = state.player.paused;
state.player.queue.remove(index);
state.player.prefetched_pos = None;
state.track_selection.clear();
if state.player.queue.is_empty() {
state.player = state::PlayerBar::default();
runtime.player.stop();
push_state_now(state, runtime);
push_media_update(state, runtime, true);
return;
}
state.player.queue_pos = current_id
@@ -1197,6 +1246,12 @@ fn remove_queue_index(state: &mut AppState, runtime: &Runtime, index: usize) {
.unwrap_or_else(|| state.player.queue_pos.min(state.player.queue.len() - 1));
state.player.current = state.player.queue.get(state.player.queue_pos).cloned();
state.queue_tab.cursor = state.queue_tab.cursor.min(state.player.queue.len() - 1);
if removed_current && was_loaded {
start_current_audio(state, runtime, 0.0, was_paused);
push_media_metadata(state, runtime);
push_media_update(state, runtime, true);
}
push_state_now(state, runtime);
}
fn move_queue_index(state: &mut AppState, from: usize, to: usize) {
src/app/popup.rs
+57
View File
@@ -23,6 +23,11 @@ pub fn handle_key(state: &mut AppState, runtime: &Runtime, key: KeyEvent) {
busy,
} => handle_name_entry(state, runtime, for_track, input, busy, key),
Popup::Devices { cursor } => handle_devices(state, runtime, cursor, key),
Popup::TrackInfo {
tracks,
cursor,
scroll,
} => handle_track_info(state, tracks, cursor, scroll, key),
Popup::LogDetail(entry) => match key.code {
KeyCode::Esc | KeyCode::Enter | KeyCode::Char('q') => {}
_ => state.popup = Some(Popup::LogDetail(entry)),
@@ -75,6 +80,58 @@ fn handle_devices(state: &mut AppState, runtime: &Runtime, cursor: usize, key: K
}
}
fn handle_track_info(
state: &mut AppState,
tracks: Vec<TrackItem>,
cursor: usize,
scroll: usize,
key: KeyEvent,
) {
let len = tracks.len();
match key.code {
KeyCode::Esc | KeyCode::Enter | KeyCode::Char('q') => {}
KeyCode::Up | KeyCode::Char('k') => {
state.popup = Some(Popup::TrackInfo {
tracks,
cursor,
scroll: scroll.saturating_sub(1),
});
}
KeyCode::Down | KeyCode::Char('j') => {
state.popup = Some(Popup::TrackInfo {
tracks,
cursor,
scroll: scroll + 1,
});
}
KeyCode::Left | KeyCode::Char('h') => {
state.popup = Some(Popup::TrackInfo {
tracks,
cursor: cursor.saturating_sub(1),
scroll: 0,
});
}
KeyCode::Right | KeyCode::Char('l') => {
state.popup = Some(Popup::TrackInfo {
tracks,
cursor: if len == 0 {
0
} else {
(cursor + 1).min(len - 1)
},
scroll: 0,
});
}
_ => {
state.popup = Some(Popup::TrackInfo {
tracks,
cursor: cursor.min(len.saturating_sub(1)),
scroll,
});
}
}
}
fn handle_picker(
state: &mut AppState,
runtime: &Runtime,
src/app/state.rs
+72
View File
@@ -186,6 +186,71 @@ pub struct QueueTab {
pub cursor: usize,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TrackSelectionScope {
ArtistTop(i64),
ArtistFeatured(i64),
Release(i64),
Playlist(i64),
Queue,
}
/// Vim-like Shift-V selection for line-oriented track lists. The selected
/// range is always contiguous: anchor is where visual mode started, cursor is
/// extended by normal navigation.
#[derive(Debug, Clone, Default)]
pub struct TrackSelection {
pub scope: Option<TrackSelectionScope>,
pub anchor: usize,
pub cursor: usize,
}
impl TrackSelection {
pub fn is_active(&self) -> bool {
self.scope.is_some()
}
pub fn is_active_for(&self, scope: &TrackSelectionScope) -> bool {
self.scope.as_ref() == Some(scope)
}
pub fn start(&mut self, scope: TrackSelectionScope, cursor: usize) {
self.scope = Some(scope);
self.anchor = cursor;
self.cursor = cursor;
}
pub fn clear(&mut self) {
self.scope = None;
self.anchor = 0;
self.cursor = 0;
}
pub fn set_cursor(&mut self, scope: TrackSelectionScope, cursor: usize) {
if self.scope.as_ref() == Some(&scope) {
self.cursor = cursor;
}
}
pub fn contains(&self, scope: &TrackSelectionScope, index: usize) -> bool {
if self.scope.as_ref() != Some(scope) {
return false;
}
let start = self.anchor.min(self.cursor);
let end = self.anchor.max(self.cursor);
(start..=end).contains(&index)
}
pub fn indices(&self, scope: &TrackSelectionScope, len: usize) -> Option<Vec<usize>> {
if len == 0 || self.scope.as_ref() != Some(scope) {
return None;
}
let start = self.anchor.min(self.cursor).min(len - 1);
let end = self.anchor.max(self.cursor).min(len - 1);
Some((start..=end).collect())
}
}
/// Severity steps for the Logs tab filter, cycled with the view-toggle key.
pub const LOG_LEVELS: [tracing::Level; 5] = [
tracing::Level::ERROR,
@@ -263,6 +328,12 @@ pub enum Popup {
},
/// Connected devices list; Enter transfers active playback to the row.
Devices { cursor: usize },
/// Track metadata viewer; left/right switch between selected tracks.
TrackInfo {
tracks: Vec<TrackItem>,
cursor: usize,
scroll: usize,
},
/// Full, wrapped view of one log entry (Enter on the Logs tab).
LogDetail(crate::config::logging::LogEntry),
}
@@ -519,6 +590,7 @@ pub struct AppState {
pub logs: LogsTab,
pub devices: DevicesState,
pub queue_tab: QueueTab,
pub track_selection: TrackSelection,
/// Shift-J jump in flight: focus this (release, track) once the release
/// view finishes loading.
pub pending_release_focus: Option<(i64, i64)>,
src/app/update.rs
+573 -20
View File
@@ -5,7 +5,7 @@ use crate::api::models::TrackItem;
use super::state::{
AppState, GlobalView, Loadable, OpenedPlaylist, SearchState, TILE_HEIGHT, TILE_WIDTH, Tab,
ViewMode, release_display_order, release_rows,
TrackSelectionScope, ViewMode, release_display_order, release_rows,
};
pub const QUIT_CONFIRM_WINDOW: Duration = Duration::from_millis(1500);
@@ -13,7 +13,7 @@ pub const QUIT_CONFIRM_HINT: &str = "press quit again to exit";
/// Side effects requested by `update()`; executed by the app loop, which
/// owns the Runtime (audio controller, API client). Keeps update() pure.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Effect {
/// (Re)start playback of `queue[queue_pos]`.
PlayCurrent,
@@ -28,8 +28,13 @@ pub enum Effect {
id: i64,
next: bool,
},
ToggleLike {
track_id: i64,
ToggleLikes {
track_ids: Vec<i64>,
},
RemoveQueueIndices {
indices: Vec<usize>,
restart_paused: Option<bool>,
stop: bool,
},
}
@@ -203,23 +208,62 @@ pub fn update(state: &mut AppState, action: Action) -> Option<Effect> {
None
}
Action::Select => select_current(state),
Action::Back if state.track_selection.is_active() => {
state.track_selection.clear();
state.status_message = Some("selection cleared".into());
None
}
Action::Back => {
go_back(state);
None
}
Action::ToggleLike => {
let target =
selected_track(state)
.map(|t| t.id)
.or(state.player.current.as_ref().map(|t| t.id));
match target {
Some(track_id) => Some(Effect::ToggleLike { track_id }),
None => {
state.status_message = Some("no track selected".into());
None
}
let tracks = selected_tracks(state);
let track_ids: Vec<i64> = if tracks.is_empty() {
state
.player
.current
.as_ref()
.map(|track| vec![track.id])
.unwrap_or_default()
} else {
tracks.into_iter().map(|track| track.id).collect()
};
if track_ids.is_empty() {
state.status_message = Some("no track selected".into());
None
} else {
let should_like = track_ids.iter().any(|id| !state.likes.contains(id));
let toggles: Vec<i64> = track_ids
.into_iter()
.filter(|id| state.likes.contains(id) != should_like)
.collect();
state.status_message = Some(if should_like {
format!("liking {} track(s)", toggles.len())
} else {
format!("removing like from {} track(s)", toggles.len())
});
Some(Effect::ToggleLikes { track_ids: toggles })
}
}
Action::ToggleTrackSelection => {
toggle_track_selection(state);
None
}
Action::OpenTrackInfo => {
let tracks = selected_tracks(state);
if tracks.is_empty() {
state.status_message = Some("no track selected".into());
} else {
state.popup = Some(super::state::Popup::TrackInfo {
tracks,
cursor: 0,
scroll: 0,
});
}
None
}
Action::RemoveFromQueue => remove_selected_from_queue(state),
Action::QueueAddNext => queue_add(state, true),
Action::QueueAddLast => queue_add(state, false),
Action::GoToRelease => {
@@ -258,6 +302,7 @@ pub fn update(state: &mut AppState, action: Action) -> Option<Effect> {
state.player.prefetched_pos = None;
state.player.original_order = None;
state.queue_tab.cursor = 0;
state.track_selection.clear();
if had_tracks {
state.status_message = Some("queue cleared".into());
Some(Effect::StopPlayback)
@@ -271,6 +316,309 @@ pub fn update(state: &mut AppState, action: Action) -> Option<Effect> {
}
}
fn toggle_track_selection(state: &mut AppState) {
let Some((scope, cursor, len)) = current_track_list_context(state) else {
state.status_message = Some("track selection is unavailable here".into());
return;
};
if len == 0 {
state.status_message = Some("no tracks here".into());
return;
}
if state.track_selection.is_active_for(&scope) {
state.track_selection.clear();
state.status_message = Some("selection cleared".into());
} else {
state.track_selection.start(scope, cursor);
visual_selection_status(state);
}
}
fn visual_selection_status(state: &mut AppState) {
let Some((scope, _, len)) = current_track_list_context(state) else {
return;
};
if let Some(indices) = state.track_selection.indices(&scope, len) {
state.status_message = Some(format!("-- VISUAL LINE -- {} track(s)", indices.len()));
}
}
fn refresh_track_selection_cursor(state: &mut AppState) {
let Some((scope, cursor, _)) = current_track_list_context(state) else {
state.track_selection.clear();
return;
};
state.track_selection.set_cursor(scope, cursor);
if state.track_selection.is_active() {
visual_selection_status(state);
}
}
fn set_track_scope_cursor(state: &mut AppState, scope: &TrackSelectionScope, value: usize) {
match scope {
TrackSelectionScope::ArtistTop(id) => {
if matches!(
state.global.stack.last(),
Some(GlobalView::Artist { id: current, .. }) if current == id
) {
set_view_cursor(state, value);
}
}
TrackSelectionScope::ArtistFeatured(id) => {
let Some(GlobalView::Artist { id: current, .. }) = state.global.stack.last() else {
return;
};
if current != id {
return;
}
let Some(Loadable::Ready(detail)) = state.artist_views.get(id) else {
return;
};
let flat = detail.top_tracks.len() + detail.releases.len() + value;
set_view_cursor(state, flat);
}
TrackSelectionScope::Release(id) => {
if matches!(
state.global.stack.last(),
Some(GlobalView::Release { id: current, .. }) if current == id
) {
set_view_cursor(state, value);
}
}
TrackSelectionScope::Playlist(id) => {
if let Some(opened) = &mut state.playlists.opened {
if opened.id == *id {
opened.cursor = value;
}
}
}
TrackSelectionScope::Queue => {
state.queue_tab.cursor = value;
}
}
}
fn current_track_list_context(state: &AppState) -> Option<(TrackSelectionScope, usize, usize)> {
match state.active_tab {
Tab::Global => match state.global.stack.last()? {
GlobalView::Artist { id, cursor } => match state.artist_views.get(id)? {
Loadable::Ready(detail) => {
let tracks = detail.top_tracks.len();
let releases = detail.releases.len();
if *cursor < tracks {
Some((TrackSelectionScope::ArtistTop(*id), *cursor, tracks))
} else {
let featured = cursor.checked_sub(tracks + releases)?;
(featured < detail.featured_tracks.len()).then_some((
TrackSelectionScope::ArtistFeatured(*id),
featured,
detail.featured_tracks.len(),
))
}
}
_ => None,
},
GlobalView::Release { id, cursor } => match state.release_views.get(id)? {
Loadable::Ready(detail) => Some((
TrackSelectionScope::Release(*id),
*cursor,
detail.tracks.len(),
)),
_ => None,
},
_ => None,
},
Tab::Playlists => {
let opened = state.playlists.opened.as_ref()?;
let len = playlist_tracks(state, opened.id)?.len();
Some((TrackSelectionScope::Playlist(opened.id), opened.cursor, len))
}
Tab::Queue => Some((
TrackSelectionScope::Queue,
state.queue_tab.cursor,
state.player.queue.len(),
)),
Tab::Logs => None,
}
}
fn current_track_list(state: &AppState) -> Option<(TrackSelectionScope, usize, &[TrackItem])> {
match state.active_tab {
Tab::Global => match state.global.stack.last()? {
GlobalView::Artist { id, cursor } => match state.artist_views.get(id)? {
Loadable::Ready(detail) => {
let tracks = detail.top_tracks.len();
let releases = detail.releases.len();
if *cursor < tracks {
Some((
TrackSelectionScope::ArtistTop(*id),
*cursor,
&detail.top_tracks,
))
} else {
let featured = cursor.checked_sub(tracks + releases)?;
(featured < detail.featured_tracks.len()).then_some((
TrackSelectionScope::ArtistFeatured(*id),
featured,
&detail.featured_tracks,
))
}
}
_ => None,
},
GlobalView::Release { id, cursor } => match state.release_views.get(id)? {
Loadable::Ready(detail) => {
Some((TrackSelectionScope::Release(*id), *cursor, &detail.tracks))
}
_ => None,
},
_ => None,
},
Tab::Playlists => {
let opened = state.playlists.opened.as_ref()?;
Some((
TrackSelectionScope::Playlist(opened.id),
opened.cursor,
playlist_tracks(state, opened.id)?,
))
}
Tab::Queue => Some((
TrackSelectionScope::Queue,
state.queue_tab.cursor,
&state.player.queue,
)),
Tab::Logs => None,
}
}
pub fn selected_tracks(state: &AppState) -> Vec<TrackItem> {
let Some((scope, cursor, tracks)) = current_track_list(state) else {
return selected_track(state).into_iter().collect();
};
let indices = state
.track_selection
.indices(&scope, tracks.len())
.unwrap_or_else(|| vec![cursor.min(tracks.len().saturating_sub(1))]);
indices
.into_iter()
.filter_map(|index| tracks.get(index).cloned())
.collect()
}
fn selected_queue_indices(state: &AppState) -> Vec<usize> {
if state.active_tab != Tab::Queue || state.player.queue.is_empty() {
return Vec::new();
}
state
.track_selection
.indices(&TrackSelectionScope::Queue, state.player.queue.len())
.unwrap_or_else(|| vec![state.queue_tab.cursor.min(state.player.queue.len() - 1)])
}
fn remove_selected_from_queue(state: &mut AppState) -> Option<Effect> {
let indices = selected_queue_indices(state);
if indices.is_empty() {
state.status_message = Some("queue is empty".into());
return None;
}
let outcome = remove_queue_indices(state, &indices);
state.status_message = Some(format!("removed {} track(s) from queue", indices.len()));
Some(Effect::RemoveQueueIndices {
indices,
restart_paused: outcome.restart_paused,
stop: outcome.stop,
})
}
struct QueueRemovalOutcome {
restart_paused: Option<bool>,
stop: bool,
}
fn remove_queue_indices(state: &mut AppState, indices: &[usize]) -> QueueRemovalOutcome {
let len = state.player.queue.len();
let mut unique: Vec<usize> = indices
.iter()
.copied()
.filter(|index| *index < len)
.collect();
unique.sort_unstable();
unique.dedup();
if unique.is_empty() {
return QueueRemovalOutcome {
restart_paused: None,
stop: false,
};
}
let old_queue_pos = state.player.queue_pos;
let current_id = state.player.current.as_ref().map(|track| track.id);
let current_removed = current_id.is_some_and(|id| {
unique.iter().any(|index| {
state
.player
.queue
.get(*index)
.is_some_and(|track| track.id == id)
})
});
let removed_before_current = unique
.iter()
.filter(|index| **index < old_queue_pos)
.count();
let was_loaded = state.player.playing;
let was_paused = state.player.paused;
for index in unique.iter().rev() {
state.player.queue.remove(*index);
}
state.player.prefetched_pos = None;
state.track_selection.clear();
if state.player.queue.is_empty() {
state.player = super::state::PlayerBar::default();
state.queue_tab.cursor = 0;
return QueueRemovalOutcome {
restart_paused: None,
stop: true,
};
}
if current_removed {
let desired = old_queue_pos.saturating_sub(removed_before_current);
state.player.queue_pos = desired.min(state.player.queue.len() - 1);
state.player.current = state.player.queue.get(state.player.queue_pos).cloned();
state.player.position_secs = 0.0;
state.player.track_started_at = None;
state.queue_tab.cursor = state.queue_tab.cursor.min(state.player.queue.len() - 1);
return QueueRemovalOutcome {
restart_paused: was_loaded.then_some(was_paused),
stop: false,
};
}
if let Some(id) = current_id {
if let Some(position) = state.player.queue.iter().position(|track| track.id == id) {
state.player.queue_pos = position;
}
} else {
state.player.queue_pos = state.player.queue_pos.min(state.player.queue.len() - 1);
}
state.player.current = current_id.and_then(|id| {
state
.player
.queue
.iter()
.find(|track| track.id == id)
.cloned()
});
state.queue_tab.cursor = state.queue_tab.cursor.min(state.player.queue.len() - 1);
QueueRemovalOutcome {
restart_paused: None,
stop: false,
}
}
/// The track under the cursor in whatever view is showing tracks.
pub fn selected_track(state: &AppState) -> Option<TrackItem> {
match state.active_tab {
@@ -343,13 +691,19 @@ fn selected_release_id(state: &AppState) -> Option<i64> {
/// a / shift-a: queue the selection — a single track directly, a release via
/// an async fetch effect.
fn queue_add(state: &mut AppState, next: bool) -> Option<Effect> {
if let Some(track) = selected_track(state) {
let title = track.title.clone();
enqueue_tracks(state, vec![track], next);
state.status_message = Some(if next {
let tracks = selected_tracks(state);
if !tracks.is_empty() {
let count = tracks.len();
let title = tracks[0].title.clone();
enqueue_tracks(state, tracks, next);
state.status_message = Some(if count == 1 && next {
format!("queued next: {title}")
} else {
} else if count == 1 {
format!("queued: {title}")
} else if next {
format!("queued next: {count} tracks")
} else {
format!("queued: {count} tracks")
});
return None;
}
@@ -620,6 +974,18 @@ fn move_selection(state: &mut AppState, dx: isize, dy: isize) {
}
return;
}
if state.track_selection.is_active()
&& dx == 0
&& let Some((scope, cursor, len)) = current_track_list_context(state)
{
if len == 0 {
return;
}
let next = (cursor as isize + dy).clamp(0, len as isize - 1) as usize;
set_track_scope_cursor(state, &scope, next);
refresh_track_selection_cursor(state);
return;
}
if state.active_tab == Tab::Playlists {
let len = playlists_view_len(state);
if len == 0 {
@@ -629,10 +995,12 @@ fn move_selection(state: &mut AppState, dx: isize, dy: isize) {
match &mut state.playlists.opened {
Some(opened) => {
opened.cursor = (opened.cursor as isize + dy).clamp(0, last) as usize;
refresh_track_selection_cursor(state);
}
None => {
state.playlists.selected =
(state.playlists.selected as isize + dy).clamp(0, last) as usize;
state.track_selection.clear();
}
}
return;
@@ -644,6 +1012,7 @@ fn move_selection(state: &mut AppState, dx: isize, dy: isize) {
}
state.queue_tab.cursor =
(state.queue_tab.cursor as isize + dy).clamp(0, len as isize - 1) as usize;
refresh_track_selection_cursor(state);
return;
}
if state.active_tab != Tab::Global {
@@ -661,6 +1030,7 @@ fn move_selection(state: &mut AppState, dx: isize, dy: isize) {
};
let last = global.artists.len() as isize - 1;
global.selected = (global.selected as isize + step).clamp(0, last) as usize;
state.track_selection.clear();
}
Some(GlobalView::Artist { id, cursor }) => {
let Some(Loadable::Ready(detail)) = state.artist_views.get(&id) else {
@@ -714,6 +1084,7 @@ fn move_selection(state: &mut AppState, dx: isize, dy: isize) {
}
};
set_view_cursor(state, next);
state.track_selection.clear();
}
Some(GlobalView::Release { id, cursor }) => {
let Some(Loadable::Ready(detail)) = state.release_views.get(&id) else {
@@ -725,6 +1096,7 @@ fn move_selection(state: &mut AppState, dx: isize, dy: isize) {
}
let next = (cursor as isize + dy).clamp(0, total - 1);
set_view_cursor(state, next as usize);
refresh_track_selection_cursor(state);
}
Some(GlobalView::Search { cursor }) => {
let total = state.search.results.as_ref().map_or(0, |r| r.len()) as isize;
@@ -733,6 +1105,7 @@ fn move_selection(state: &mut AppState, dx: isize, dy: isize) {
}
let next = (cursor as isize + dy).clamp(0, total - 1);
set_view_cursor(state, next as usize);
state.track_selection.clear();
}
}
}
@@ -782,10 +1155,21 @@ fn current_view_len(state: &AppState) -> usize {
}
fn jump_selection(state: &mut AppState, first: bool) {
if state.track_selection.is_active()
&& let Some((scope, _, len)) = current_track_list_context(state)
{
if len > 0 {
let target = if first { 0 } else { len - 1 };
set_track_scope_cursor(state, &scope, target);
refresh_track_selection_cursor(state);
}
return;
}
if state.active_tab == Tab::Queue {
let len = state.player.queue.len();
if len > 0 {
state.queue_tab.cursor = if first { 0 } else { len - 1 };
refresh_track_selection_cursor(state);
}
return;
}
@@ -817,10 +1201,13 @@ fn jump_selection(state: &mut AppState, first: bool) {
Some(opened) => opened.cursor = target,
None => state.playlists.selected = target,
}
refresh_track_selection_cursor(state);
} else if state.global.stack.is_empty() {
state.global.selected = target;
state.track_selection.clear();
} else {
set_view_cursor(state, target);
refresh_track_selection_cursor(state);
}
}
@@ -1014,6 +1401,7 @@ fn shuffle_range(player: &mut super::state::PlayerBar, start: usize) {
/// Esc/Backspace: pop the navigation stack; leaving a search view resets the
/// search so the next `:/` starts clean.
fn go_back(state: &mut AppState) {
state.track_selection.clear();
match state.active_tab {
Tab::Playlists => {
state.playlists.opened = None;
@@ -1042,11 +1430,13 @@ fn go_back(state: &mut AppState) {
fn switch_tab(state: &mut AppState, tab: Tab) {
state.active_tab = tab;
state.help_visible = false;
state.track_selection.clear();
// Manually leaving a view cancels any pending Shift-J return path.
state.jump_origin = None;
}
fn reset_tab(state: &mut AppState, tab: Tab) {
state.track_selection.clear();
match tab {
Tab::Global => {
if state
@@ -1075,7 +1465,7 @@ fn not_yet(state: &mut AppState, what: &str) {
#[cfg(test)]
mod tests {
use super::*;
use crate::api::models::ArtistCard;
use crate::api::models::{ArtistCard, ArtistDetail, TrackItem};
fn with_artists(n: usize) -> AppState {
let mut state = AppState::default();
@@ -1091,6 +1481,33 @@ mod tests {
state
}
fn test_track(id: i64) -> TrackItem {
TrackItem {
id,
title: format!("t{id}"),
track_number: None,
disc_number: None,
duration_seconds: 1.0,
artists: vec![],
featured_artists: vec![],
release_id: 1,
release_title: "r".into(),
release_year: None,
cover_url: None,
stream_url: format!("/s/{id}"),
uploader_name: String::new(),
audio_format: None,
audio_bitrate: None,
audio_sample_rate: None,
audio_bit_depth: None,
file_size_bytes: None,
lastfm_listeners: None,
lastfm_playcount: None,
lastfm_rating: None,
lastfm_updated_at: None,
}
}
#[test]
fn quit_needs_double_press() {
let mut state = AppState::default();
@@ -1297,6 +1714,7 @@ mod tests {
id,
title: format!("t{id}"),
track_number: None,
disc_number: None,
duration_seconds: 1.0,
artists: vec![],
featured_artists: vec![],
@@ -1305,11 +1723,16 @@ mod tests {
release_year: None,
cover_url: None,
stream_url: format!("/api/player/stream/{id}"),
uploader_name: String::new(),
audio_format: None,
audio_bitrate: None,
audio_sample_rate: None,
audio_bit_depth: None,
file_size_bytes: None,
lastfm_listeners: None,
lastfm_playcount: None,
lastfm_rating: None,
lastfm_updated_at: None,
};
let mut state = AppState::default();
state.player.queue = vec![track(1), track(2)];
@@ -1358,6 +1781,7 @@ mod tests {
id,
title: format!("t{id}"),
track_number: None,
disc_number: None,
duration_seconds: 1.0,
artists: vec![],
featured_artists: vec![],
@@ -1366,11 +1790,16 @@ mod tests {
release_year: None,
cover_url: None,
stream_url: format!("/s/{id}"),
uploader_name: String::new(),
audio_format: None,
audio_bitrate: None,
audio_sample_rate: None,
audio_bit_depth: None,
file_size_bytes: None,
lastfm_listeners: None,
lastfm_playcount: None,
lastfm_rating: None,
lastfm_updated_at: None,
};
let mut state = AppState {
active_tab: Tab::Queue,
@@ -1399,6 +1828,118 @@ mod tests {
assert!(!state.player.playing);
}
#[test]
fn visual_selection_removes_queue_range() {
let mut state = AppState {
active_tab: Tab::Queue,
..AppState::default()
};
state.player.queue = (1..=4).map(test_track).collect();
state.queue_tab.cursor = 1;
assert_eq!(update(&mut state, Action::ToggleTrackSelection), None);
update(&mut state, Action::MoveDown);
let selected: Vec<i64> = selected_tracks(&state)
.into_iter()
.map(|track| track.id)
.collect();
assert_eq!(selected, vec![2, 3]);
assert_eq!(
update(&mut state, Action::RemoveFromQueue),
Some(Effect::RemoveQueueIndices {
indices: vec![1, 2],
restart_paused: None,
stop: false,
})
);
let remaining: Vec<i64> = state.player.queue.iter().map(|track| track.id).collect();
assert_eq!(remaining, vec![1, 4]);
assert!(!state.track_selection.is_active());
}
#[test]
fn artist_top_track_selection_queues_all_selected_tracks() {
let mut state = AppState::default();
state
.global
.stack
.push(GlobalView::Artist { id: 9, cursor: 0 });
state.artist_views.insert(
9,
Loadable::Ready(ArtistDetail {
id: 9,
name: "artist".into(),
image_url: None,
total_track_count: 3,
total_play_count: 0,
top_tracks: (1..=3).map(test_track).collect(),
releases: vec![],
featured_tracks: vec![],
}),
);
update(&mut state, Action::ToggleTrackSelection);
update(&mut state, Action::MoveDown);
assert_eq!(update(&mut state, Action::QueueAddLast), None,);
let queued: Vec<i64> = state.player.queue.iter().map(|track| track.id).collect();
assert_eq!(queued, vec![1, 2]);
}
#[test]
fn removing_current_queue_track_requests_paused_restart() {
let mut state = AppState {
active_tab: Tab::Queue,
..AppState::default()
};
state.player.queue = (1..=3).map(test_track).collect();
state.player.queue_pos = 1;
state.queue_tab.cursor = 1;
state.player.current = Some(test_track(2));
state.player.playing = true;
state.player.paused = true;
assert_eq!(
update(&mut state, Action::RemoveFromQueue),
Some(Effect::RemoveQueueIndices {
indices: vec![1],
restart_paused: Some(true),
stop: false,
})
);
let remaining: Vec<i64> = state.player.queue.iter().map(|track| track.id).collect();
assert_eq!(remaining, vec![1, 3]);
assert_eq!(state.player.queue_pos, 1);
assert_eq!(state.player.current.as_ref().map(|track| track.id), Some(3));
}
#[test]
fn bulk_like_targets_only_tracks_that_need_toggle() {
let mut state = AppState {
active_tab: Tab::Queue,
..AppState::default()
};
state.player.queue = (1..=3).map(test_track).collect();
state.likes.insert(1);
update(&mut state, Action::ToggleTrackSelection);
update(&mut state, Action::SelectLast);
assert_eq!(
update(&mut state, Action::ToggleLike),
Some(Effect::ToggleLikes {
track_ids: vec![2, 3],
})
);
state.likes = [1, 2, 3].into_iter().collect();
assert_eq!(
update(&mut state, Action::ToggleLike),
Some(Effect::ToggleLikes {
track_ids: vec![1, 2, 3],
})
);
}
#[test]
fn shuffle_reorders_tail_and_restores() {
use crate::api::models::TrackItem;
@@ -1406,6 +1947,7 @@ mod tests {
id,
title: format!("t{id}"),
track_number: None,
disc_number: None,
duration_seconds: 1.0,
artists: vec![],
featured_artists: vec![],
@@ -1414,11 +1956,16 @@ mod tests {
release_year: None,
cover_url: None,
stream_url: format!("/s/{id}"),
uploader_name: String::new(),
audio_format: None,
audio_bitrate: None,
audio_sample_rate: None,
audio_bit_depth: None,
file_size_bytes: None,
lastfm_listeners: None,
lastfm_playcount: None,
lastfm_rating: None,
lastfm_updated_at: None,
};
let mut state = AppState::default();
state.player.queue = (1..=8).map(track).collect();
@@ -1449,6 +1996,7 @@ mod tests {
id,
title: format!("t{id}"),
track_number: None,
disc_number: None,
duration_seconds: 1.0,
artists: vec![],
featured_artists: vec![],
@@ -1457,11 +2005,16 @@ mod tests {
release_year: None,
cover_url: None,
stream_url: format!("/s/{id}"),
uploader_name: String::new(),
audio_format: None,
audio_bitrate: None,
audio_sample_rate: None,
audio_bit_depth: None,
file_size_bytes: None,
lastfm_listeners: None,
lastfm_playcount: None,
lastfm_rating: None,
lastfm_updated_at: None,
};
let mut state = AppState {
active_tab: Tab::Queue,