Fix auto-play next track during pause/unpause transitions

When rapidly pressing play/pause, MPV briefly reports idle-active as true during state transitions. Combined with our player_state being set to Playing after unpause, this incorrectly triggered the auto-play next track logic. Fix: Add is_paused() check to auto-play condition to ensure we only advance to next track when the current track actually ends, not during pause state transitions.
Document state management architecture principles
2025-12-11 16:20:14 +01:00 · 2025-12-11 16:11:45 +01:00 · 2025-12-11 15:37:28 +01:00 · 2025-12-11 15:32:37 +01:00 · 2025-12-11 15:16:57 +01:00 · 2025-12-09 12:33:52 +01:00
5 changed files with 205 additions and 209 deletions
--- a/CLAUDE.md
+++ b/CLAUDE.md
@ -14,6 +14,29 @@ A high-performance Rust-based TUI player for playing music and video files. Buil

 ## Architecture

+### State Management
+
+**CRITICAL:** Player state must be derived from MPV, not maintained separately.
+
+**Single Source of Truth:** MPV properties via IPC
+- `idle-active` (bool) - No file loaded or file ended
+- `pause` (bool) - Playback is paused
+
+**Derive PlayerState:**
+```rust
+if player.is_idle → PlayerState::Stopped
+if !player.is_idle && player.is_paused → PlayerState::Paused
+if !player.is_idle && !player.is_paused → PlayerState::Playing
+```
+
+**Rationale:**
+- Eliminates state synchronization bugs
+- MPV is always the authoritative source
+- No need to update state in multiple places
+- Simpler auto-play logic
+
+**Anti-pattern:** DO NOT maintain `state.player_state` that can desync from MPV
+
 ### Cache-Only Operation

 **CRITICAL:** Left panel shows ONLY cached data. Never browse filesystem directly during operation.
--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "cm-player"
-version = "0.1.13"
+version = "0.1.22"
 edition = "2021"

 [dependencies]
--- a/src/main.rs
+++ b/src/main.rs
@ -96,6 +96,8 @@ fn action_play_selection(state: &mut AppState, player: &mut player::Player) -> R
    state.play_selection();
    if let Some(ref path) = state.current_file {
        player.play(path)?;
+        // Explicitly resume playback in case MPV was paused
+        player.resume()?;
        state.player_state = PlayerState::Playing;
        player.update_metadata();
        tracing::info!("Playing: {:?} (playlist: {} tracks)", path, state.playlist.len());
@ -126,6 +128,7 @@ fn action_toggle_play_pause(state: &mut AppState, player: &mut player::Player) -
                state.player_state = PlayerState::Playing;
                if let Some(ref path) = state.current_file {
                    player.play(path)?;
+                    player.resume()?;
                    player.update_metadata();
                    tracing::info!("Restarting playback: {:?}", path);
                }
@ -144,6 +147,108 @@ fn action_stop(state: &mut AppState, player: &mut player::Player) -> Result<()>
    Ok(())
 }

+fn action_remove_from_playlist(state: &mut AppState, player: &mut player::Player) -> Result<()> {
+    let was_playing_removed = state.playlist_index == state.selected_playlist_index;
+    state.remove_selected_playlist_item();
+
+    if state.playlist.is_empty() {
+        state.player_state = PlayerState::Stopped;
+        state.current_file = None;
+        player.stop()?;
+    } else if was_playing_removed && state.player_state == PlayerState::Playing {
+        state.current_file = Some(state.playlist[state.playlist_index].clone());
+        if let Some(ref path) = state.current_file {
+            player.play(path)?;
+            // Explicitly resume playback in case MPV was paused
+            player.resume()?;
+            player.update_metadata();
+        }
+    }
+    Ok(())
+}
+
+fn action_play_from_playlist(state: &mut AppState, player: &mut player::Player, preserve_pause: bool) -> Result<()> {
+    state.playlist_index = state.selected_playlist_index;
+    state.current_file = Some(state.playlist[state.playlist_index].clone());
+
+    if preserve_pause {
+        match state.player_state {
+            PlayerState::Playing => {
+                if let Some(ref path) = state.current_file {
+                    player.play(path)?;
+                    player.resume()?;
+                    player.update_metadata();
+                    tracing::info!("Jumped to track: {:?}", path);
+                }
+            }
+            PlayerState::Paused => {
+                if let Some(ref path) = state.current_file {
+                    player.play(path)?;
+                    player.update_metadata();
+                    player.pause()?;
+                    tracing::info!("Jumped to track (paused): {:?}", path);
+                }
+            }
+            PlayerState::Stopped => {
+                state.player_state = PlayerState::Playing;
+                if let Some(ref path) = state.current_file {
+                    player.play(path)?;
+                    player.resume()?;
+                    player.update_metadata();
+                    tracing::info!("Started playing track: {:?}", path);
+                }
+            }
+        }
+    } else {
+        state.player_state = PlayerState::Playing;
+        if let Some(ref path) = state.current_file {
+            player.play(path)?;
+            // Explicitly resume playback in case MPV was paused
+            player.resume()?;
+            player.update_metadata();
+            tracing::info!("Playing from playlist: {:?}", path);
+        }
+    }
+    Ok(())
+}
+
+fn handle_context_menu_action(menu_type: state::ContextMenuType, selected: usize, state: &mut AppState, player: &mut player::Player) -> Result<()> {
+    match menu_type {
+        state::ContextMenuType::FilePanel => {
+            match selected {
+                0 => action_play_selection(state, player)?,
+                1 => state.add_to_playlist(),
+                _ => {}
+            }
+        }
+        state::ContextMenuType::Playlist => {
+            match selected {
+                0 => action_remove_from_playlist(state, player)?,
+                1 => {
+                    state.shuffle_playlist();
+                    tracing::info!("Playlist randomised from context menu");
+                }
+                _ => {}
+            }
+        }
+        state::ContextMenuType::TitleBar => {
+            match selected {
+                0 => action_stop(state, player)?,
+                1 => {
+                    state.cycle_play_mode();
+                    tracing::info!("Play mode: {:?}", state.play_mode);
+                }
+                2 => {
+                    state.show_refresh_confirm = true;
+                    tracing::info!("Refresh requested from context menu");
+                }
+                _ => {}
+            }
+        }
+    }
+    Ok(())
+}
+
 async fn run_app<B: ratatui::backend::Backend>(
    terminal: &mut Terminal<B>,
    state: &mut AppState,
@ -183,8 +288,10 @@ async fn run_app<B: ratatui::backend::Backend>(
            let new_position = player.get_position().unwrap_or(0.0);
            let new_duration = player.get_duration().unwrap_or(0.0);

-            // Only mark as changed if position moved by at least 0.5 seconds
-            if (new_position - last_position).abs() >= 0.5 {
+            // Only update if displayed value (rounded to seconds) changed
+            let old_display_secs = last_position as u32;
+            let new_display_secs = new_position as u32;
+            if new_display_secs != old_display_secs {
                state.current_position = new_position;
                last_position = new_position;
                state_changed = true;
@ -197,7 +304,8 @@ async fn run_app<B: ratatui::backend::Backend>(

            // Check if track ended and play next (but only if track was actually loaded AND played)
            // Require position > 0.5 to ensure track actually started playing (not just loaded)
-            if player.is_idle() && state.player_state == PlayerState::Playing && state.current_duration > 0.0 && state.current_position > 0.5 {
+            // Also check !is_paused to avoid triggering during pause/unpause transitions
+            if player.is_idle() && !player.is_paused() && state.player_state == PlayerState::Playing && state.current_duration > 0.0 && state.current_position > 0.5 {
                state.play_next();
                // play_next() handles the play mode and may stop if in Normal mode at end
                if state.player_state == PlayerState::Playing {
@ -208,6 +316,7 @@ async fn run_app<B: ratatui::backend::Backend>(
                        last_position = 0.0;

                        player.play(path)?;
+                        player.resume()?;
                    }
                    // Update metadata immediately when track changes
                    player.update_metadata();
@ -348,7 +457,7 @@ async fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<
                let max_items = match menu.menu_type {
                    ContextMenuType::FilePanel => 2,
                    ContextMenuType::Playlist => 2,
-                    ContextMenuType::TitleBar => 3,
+                    ContextMenuType::TitleBar => 4,
                };
                if menu.selected_index < max_items - 1 {
                    menu.selected_index += 1;
@ -359,64 +468,7 @@ async fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<
                let menu_type = menu.menu_type;
                let selected = menu.selected_index;
                state.context_menu = None;
-
-                match menu_type {
-                    ContextMenuType::FilePanel => {
-                        match selected {
-                            0 => action_play_selection(state, player)?,
-                            1 => state.add_to_playlist(),
-                            _ => {}
-                        }
-                    }
-                    ContextMenuType::Playlist => {
-                        match selected {
-                            0 => {
-                                // Remove
-                                let was_playing_removed = state.playlist_index == state.selected_playlist_index;
-                                state.remove_selected_playlist_item();
-
-                                // Handle edge cases after removal
-                                if state.playlist.is_empty() {
-                                    state.player_state = PlayerState::Stopped;
-                                    state.current_file = None;
-                                    player.stop()?;
-                                } else if was_playing_removed && state.player_state == PlayerState::Playing {
-                                    // Removed currently playing track, start new one at same index
-                                    state.current_file = Some(state.playlist[state.playlist_index].clone());
-                                    if let Some(ref path) = state.current_file {
-                                        player.play(path)?;
-                                        player.update_metadata();
-                                    }
-                                }
-                            }
-                            1 => {
-                                // Randomise
-                                state.shuffle_playlist();
-                                tracing::info!("Playlist randomised from context menu");
-                            }
-                            _ => {}
-                        }
-                    }
-                    ContextMenuType::TitleBar => {
-                        match selected {
-                            0 => {
-                                // Stop
-                                action_stop(state, player)?;
-                            }
-                            1 => {
-                                // Toggle Loop
-                                state.cycle_play_mode();
-                                tracing::info!("Play mode: {:?}", state.play_mode);
-                            }
-                            2 => {
-                                // Refresh
-                                state.show_refresh_confirm = true;
-                                tracing::info!("Refresh requested from context menu");
-                            }
-                            _ => {}
-                        }
-                    }
-                }
+                handle_context_menu_action(menu_type, selected, state, player)?;
            }
            KeyCode::Esc => {
                state.context_menu = None;
@ -478,6 +530,7 @@ async fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<
                            // Keep playing
                            if let Some(ref path) = state.current_file {
                                player.play(path)?;
+                                player.resume()?;
                                player.update_metadata(); // Update metadata immediately
                                tracing::info!("Next track: {:?}", path);
                            }
@ -516,6 +569,7 @@ async fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<
                            // Keep playing
                            if let Some(ref path) = state.current_file {
                                player.play(path)?;
+                                player.resume()?;
                                player.update_metadata(); // Update metadata immediately
                                tracing::info!("Previous track: {:?}", path);
                            }
@ -573,12 +627,12 @@ async fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<
                state.move_selection_down();
            }
        }
-        (KeyCode::Char('h'), _) => {
+        (KeyCode::Char('h'), _) | (KeyCode::Left, _) => {
            if !state.focus_playlist {
                state.collapse_selected();
            }
        }
-        (KeyCode::Char('l'), _) => {
+        (KeyCode::Char('l'), _) | (KeyCode::Right, _) => {
            if !state.focus_playlist {
                state.expand_selected();
            }
@ -602,39 +656,13 @@ async fn handle_key_event<B: ratatui::backend::Backend>(terminal: &mut Terminal<
        }
        (KeyCode::Char('d'), _) => {
            if state.focus_playlist {
-                // Remove selected track from playlist
-                state.remove_selected_playlist_item();
-                // If removed currently playing track, handle it
-                if state.playlist.is_empty() {
-                    state.player_state = PlayerState::Stopped;
-                    state.current_file = None;
-                    player.stop()?;
-                } else if state.playlist_index == state.selected_playlist_index {
-                    // Removed currently playing track, play next one
-                    if state.playlist_index < state.playlist.len() {
-                        state.current_file = Some(state.playlist[state.playlist_index].clone());
-                        if state.player_state == PlayerState::Playing {
-                            if let Some(ref path) = state.current_file {
-                                player.play(path)?;
-                                player.update_metadata();
-                            }
-                        }
-                    }
-                }
+                action_remove_from_playlist(state, player)?;
            }
        }
        (KeyCode::Enter, _) => {
            if state.focus_playlist {
-                // Play selected track from playlist
                if state.selected_playlist_index < state.playlist.len() {
-                    state.playlist_index = state.selected_playlist_index;
-                    state.current_file = Some(state.playlist[state.playlist_index].clone());
-                    state.player_state = PlayerState::Playing;
-                    if let Some(ref path) = state.current_file {
-                        player.play(path)?;
-                        player.update_metadata();
-                        tracing::info!("Playing from playlist: {:?}", path);
-                    }
+                    action_play_from_playlist(state, player, false)?;
                }
            } else {
                action_play_selection(state, player)?;
@ -700,7 +728,7 @@ fn handle_mouse_event(state: &mut AppState, mouse: MouseEvent, title_bar_area: r
        let items = match menu.menu_type {
            ContextMenuType::FilePanel => 2,
            ContextMenuType::Playlist => 2,
-            ContextMenuType::TitleBar => 3,
+            ContextMenuType::TitleBar => 4,
        };
        let popup_width = 13;
        let popup_height = items as u16 + 2; // +2 for borders
@ -756,63 +784,7 @@ fn handle_mouse_event(state: &mut AppState, mouse: MouseEvent, title_bar_area: r
                    let menu_type = menu.menu_type;
                    let selected = relative_y;
                    state.context_menu = None;
-
-                    match menu_type {
-                        ContextMenuType::FilePanel => {
-                            match selected {
-                                0 => action_play_selection(state, player)?,
-                                1 => state.add_to_playlist(),
-                                _ => {}
-                            }
-                        }
-                        ContextMenuType::Playlist => {
-                            match selected {
-                                0 => {
-                                    // Remove
-                                    let was_playing_removed = state.playlist_index == state.selected_playlist_index;
-                                    state.remove_selected_playlist_item();
-
-                                    // Handle edge cases after removal
-                                    if state.playlist.is_empty() {
-                                        state.player_state = PlayerState::Stopped;
-                                        state.current_file = None;
-                                        player.stop()?;
-                                    } else if was_playing_removed && state.player_state == PlayerState::Playing {
-                                        state.current_file = Some(state.playlist[state.playlist_index].clone());
-                                        if let Some(ref path) = state.current_file {
-                                            player.play(path)?;
-                                            player.update_metadata();
-                                        }
-                                    }
-                                }
-                                1 => {
-                                    // Randomise
-                                    state.shuffle_playlist();
-                                    tracing::info!("Playlist randomised from context menu (mouse)");
-                                }
-                                _ => {}
-                            }
-                        }
-                        ContextMenuType::TitleBar => {
-                            match selected {
-                                0 => {
-                                    // Stop
-                                    action_stop(state, player)?;
-                                }
-                                1 => {
-                                    // Toggle Loop
-                                    state.cycle_play_mode();
-                                    tracing::info!("Play mode: {:?} (mouse)", state.play_mode);
-                                }
-                                2 => {
-                                    // Refresh
-                                    state.show_refresh_confirm = true;
-                                    tracing::info!("Refresh requested from context menu (mouse)");
-                                }
-                                _ => {}
-                            }
-                        }
-                    }
+                    handle_context_menu_action(menu_type, selected, state, player)?;
                }
                return Ok(());
            } else {
@ -992,38 +964,9 @@ fn handle_mouse_event(state: &mut AppState, mouse: MouseEvent, title_bar_area: r
                            };

                            if is_double_click {
-                                // Double click = play the track
-                                state.playlist_index = actual_track;
-                                state.current_file = Some(state.playlist[state.playlist_index].clone());
-
-                                match state.player_state {
-                                    PlayerState::Playing => {
-                                        // Keep playing
-                                        if let Some(ref path) = state.current_file {
-                                            player.play(path)?;
-                                            player.update_metadata();
-                                            tracing::info!("Jumped to track: {:?}", path);
-                                        }
-                                    }
-                                    PlayerState::Paused => {
-                                        // Load but stay paused
-                                        if let Some(ref path) = state.current_file {
-                                            player.play(path)?;
-                                            player.update_metadata();
-                                            player.pause()?;
-                                            tracing::info!("Jumped to track (paused): {:?}", path);
-                                        }
-                                    }
-                                    PlayerState::Stopped => {
-                                        // Start playing from clicked track
-                                        state.player_state = PlayerState::Playing;
-                                        if let Some(ref path) = state.current_file {
-                                            player.play(path)?;
-                                            player.update_metadata();
-                                            tracing::info!("Started playing track: {:?}", path);
-                                        }
-                                    }
-                                }
+                                // Double click = play the track (preserve pause state)
+                                state.selected_playlist_index = actual_track;
+                                action_play_from_playlist(state, player, true)?;
                                // Reset click tracking after action
                                state.last_click_time = None;
                                state.last_click_index = None;
--- a/src/player/mod.rs
+++ b/src/player/mod.rs
@ -21,6 +21,7 @@ pub struct Player {
    pub audio_codec: Option<String>,
    pub audio_bitrate: Option<f64>,
    pub sample_rate: Option<i64>,
+    pub cache_duration: Option<f64>,
 }

 impl Player {
@ -62,6 +63,7 @@ impl Player {
            audio_codec: None,
            audio_bitrate: None,
            sample_rate: None,
+            cache_duration: None,
        })
    }

@ -119,6 +121,7 @@ impl Player {
        self.audio_codec = None;
        self.audio_bitrate = None;
        self.sample_rate = None;
+        self.cache_duration = None;

        // Wait for socket to be created and mpv to be ready
        std::thread::sleep(Duration::from_millis(800));
@ -303,6 +306,13 @@ impl Player {
        if let Some(val) = self.get_property("audio-params/samplerate") {
            self.sample_rate = val.as_i64();
        }
+
+        // Update cache duration (how many seconds are buffered ahead)
+        if let Some(val) = self.get_property("demuxer-cache-duration") {
+            self.cache_duration = val.as_f64();
+        } else {
+            self.cache_duration = None;
+        }
    }

    pub fn get_position(&self) -> Option<f64> {
@ -317,6 +327,10 @@ impl Player {
        self.is_idle
    }

+    pub fn is_paused(&self) -> bool {
+        self.is_paused
+    }
+
    pub fn is_process_alive(&mut self) -> bool {
        // Check if mpv process is still running
        match self.process.try_wait() {
--- a/src/ui/mod.rs
+++ b/src/ui/mod.rs
@ -34,7 +34,7 @@ pub fn render(frame: &mut Frame, state: &mut AppState, player: &Player) -> (Rect
        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
        .split(main_chunks[1]);

-    render_title_bar(frame, state, main_chunks[0]);
+    render_title_bar(frame, state, player, main_chunks[0]);
    render_file_panel(frame, state, content_chunks[0]);
    render_right_panel(frame, state, content_chunks[1]);
    render_status_bar(frame, state, player, main_chunks[2]);
@ -147,16 +147,40 @@ fn render_file_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
            // Only show selection bar when file panel has focus
            let is_selected = !state.focus_playlist && idx == state.selected_index;

-            // Add folder icon for directories
+            // Add icon for directories and files
            let icon = if item.node.is_dir {
+                let is_expanded = state.expanded_dirs.contains(&item.node.path);
+                // Nerd font folder icons: \u{eaf7} = open, \u{ea83} = closed
+                let icon_char = if is_expanded { "\u{eaf7}  " } else { "\u{ea83}  " };
+
                // Bold black icon on selection bar, blue otherwise
                if is_selected {
-                    Span::styled("▸ ", Style::default().fg(Theme::background()).add_modifier(Modifier::BOLD))
+                    Span::styled(icon_char, Style::default().fg(Theme::background()).add_modifier(Modifier::BOLD))
                } else {
-                    Span::styled("▸ ", Style::default().fg(Theme::highlight()))
+                    Span::styled(icon_char, Style::default().fg(Theme::highlight()))
                }
            } else {
-                Span::raw("  ")
+                // File icons based on extension
+                let extension = item.node.path.extension()
+                    .and_then(|e| e.to_str())
+                    .unwrap_or("")
+                    .to_lowercase();
+
+                let (icon_char, color) = match extension.as_str() {
+                    // Audio files - music note icon
+                    "mp3" | "flac" | "wav" | "ogg" | "m4a" | "aac" | "wma" | "opus" =>
+                        ("\u{f0e2a}  ", Theme::success()), //
+                    // Video files - film icon
+                    "mp4" | "mkv" | "avi" | "mov" | "webm" | "flv" | "wmv" | "m4v" =>
+                        ("\u{f1c8}  ", Theme::warning()), //
+                    _ => ("   ", Theme::foreground()),
+                };
+
+                if is_selected {
+                    Span::styled(icon_char, Style::default().fg(Theme::background()).add_modifier(Modifier::BOLD))
+                } else {
+                    Span::styled(icon_char, Style::default().fg(color))
+                }
            };
            let name_spans = if in_search && !search_query.is_empty() {
                highlight_search_matches(&item.node.name, &search_query, is_selected)
@ -201,20 +225,13 @@ fn render_file_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
        items.push(more_item);
    }

-    let title_style = if !state.focus_playlist {
-        // File panel has focus - bold title
-        Theme::title_style().add_modifier(Modifier::BOLD)
-    } else {
-        Theme::title_style()
-    };
-
    let list = List::new(items)
        .block(
            Block::default()
                .borders(Borders::ALL)
-                .title("Media Files")
+                .title("files")
                .style(Theme::widget_border_style())
-                .title_style(title_style),
+                .title_style(Theme::title_style()),
        );

    let mut list_state = ListState::default();
@ -311,16 +328,9 @@ fn render_right_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
    }

    let playlist_title = if !state.playlist.is_empty() {
-        format!("Playlist [{}/{}]", state.playlist_index + 1, state.playlist.len())
+        format!("playlist [{}/{}]", state.playlist_index + 1, state.playlist.len())
    } else {
-        "Playlist (empty)".to_string()
-    };
-
-    let playlist_title_style = if state.focus_playlist {
-        // Playlist has focus - bold title
-        Theme::title_style().add_modifier(Modifier::BOLD)
-    } else {
-        Theme::title_style()
+        "playlist (empty)".to_string()
    };

    let playlist_widget = List::new(playlist_items)
@ -329,7 +339,7 @@ fn render_right_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
                .borders(Borders::ALL)
                .title(playlist_title)
                .style(Theme::widget_border_style())
-                .title_style(playlist_title_style),
+                .title_style(Theme::title_style()),
        );

    let mut playlist_state = ListState::default();
@ -339,7 +349,7 @@ fn render_right_panel(frame: &mut Frame, state: &mut AppState, area: Rect) {
    frame.render_stateful_widget(playlist_widget, area, &mut playlist_state);
 }

-fn render_title_bar(frame: &mut Frame, state: &AppState, area: Rect) {
+fn render_title_bar(frame: &mut Frame, state: &AppState, _player: &Player, area: Rect) {
    let background_color = match state.player_state {
        PlayerState::Playing => Theme::success(),     // Green for playing
        PlayerState::Paused => Theme::highlight(),    // Blue for paused
@ -511,7 +521,7 @@ fn render_status_bar(frame: &mut Frame, state: &AppState, player: &Player, area:
            left_parts.push(title.clone());
        }

-        // Right side: Bitrate | Codec | Sample rate
+        // Right side: Bitrate | Codec | Sample rate | Cache
        if let Some(bitrate) = player.audio_bitrate {
            right_parts.push(format!("{:.0} kbps", bitrate));
        }
@ -524,6 +534,12 @@ fn render_status_bar(frame: &mut Frame, state: &AppState, player: &Player, area:
            right_parts.push(format!("{} Hz", samplerate));
        }

+        if let Some(cache_dur) = player.cache_duration {
+            if cache_dur > 0.0 {
+                right_parts.push(format!("{:.1}s", cache_dur));
+            }
+        }
+
        // Create layout for left and right sections
        let chunks = Layout::default()
            .direction(Direction::Horizontal)
Author	SHA1	Message	Date
Christoffer Martinsson	55e3f04e2c	Fix auto-play next track during pause/unpause transitions All checks were successful Build and Release / build-and-release (push) Successful in 53s Details When rapidly pressing play/pause, MPV briefly reports idle-active as true during state transitions. Combined with our player_state being set to Playing after unpause, this incorrectly triggered the auto-play next track logic. Fix: Add is_paused() check to auto-play condition to ensure we only advance to next track when the current track actually ends, not during pause state transitions.	2025-12-11 16:20:14 +01:00
Christoffer Martinsson	1c2c942e4b	Document state management architecture principles Add critical guidelines for deriving player state from MPV rather than maintaining duplicate state. Documents the single source of truth pattern to prevent state synchronization bugs.	2025-12-11 16:11:45 +01:00
Christoffer Martinsson	3e7707e883	Add arrow key support for folder navigation All checks were successful Build and Release / build-and-release (push) Successful in 54s Details Add Left/Right arrow keys as alternatives to h/l for collapsing and expanding folders in the file panel. Provides more intuitive navigation for users not familiar with vim keybindings. - Left arrow: Collapse selected folder (same as 'h') - Right arrow: Expand selected folder (same as 'l')	2025-12-11 15:37:28 +01:00
Christoffer Martinsson	b59d1aed65	Fix MPV pause state bug when loading new files All checks were successful Build and Release / build-and-release (push) Successful in 52s Details When MPV is paused and a new file is loaded via loadfile command, MPV loads the file but remains in a paused state. This caused the UI to show "Playing" while no audio was actually playing. Fix: Explicitly call resume() after every play() call to ensure MPV unpauses when loading new files. This applies to: - Playing new folder/file selections - Playing from playlist - Auto-play next/previous track - Removing currently playing track from playlist Fixes bug where after pause, playing another folder would show "Playing" status but remain silent at 00:00.	2025-12-11 15:32:37 +01:00
Christoffer Martinsson	f1412b4f8c	Refactor to eliminate keyboard/mouse handler disconnects All checks were successful Build and Release / build-and-release (push) Successful in 53s Details Extract duplicate logic into shared action functions to ensure consistent behavior between keyboard and mouse interactions: - action_remove_from_playlist: Unified playlist removal logic - action_play_from_playlist: Unified playlist playback with optional pause state preservation - handle_context_menu_action: Unified context menu execution Fixes: - Remove from playlist now checks index before removal (was broken in keyboard 'd' handler) - Mouse double-click on playlist now preserves pause state - Context menu handling no longer duplicated across 400+ lines All keyboard and mouse actions now use identical code paths, eliminating state bugs from inconsistent implementations.	2025-12-11 15:16:57 +01:00
Christoffer Martinsson	ffe7cd0090	Fix time display to update smoothly All checks were successful Build and Release / build-and-release (push) Successful in 54s Details Change position update logic to only trigger redraw when the displayed value (rounded to seconds) changes, not when the raw float value changes. This eliminates jumpy time display and reduces unnecessary redraws.	2025-12-09 12:33:52 +01:00
Christoffer Martinsson	907a734be3	Remove Cache prefix from cache duration display All checks were successful Build and Release / build-and-release (push) Successful in 55s Details Display cache duration as "1.5s" instead of "Cache:1.5s" in bottom status bar for cleaner presentation alongside other technical metrics.	2025-12-09 12:23:04 +01:00
Christoffer Martinsson	135700ce02	Update cache metric refresh rate to match other metadata All checks were successful Build and Release / build-and-release (push) Successful in 54s Details Move cache duration update from update_properties (~10Hz) to update_metadata (~0.5Hz) to match the refresh rate of codec, bitrate, and sample rate. All bottom status bar metrics now update at the same frequency.	2025-12-09 12:06:59 +01:00
Christoffer Martinsson	ea72368841	Remove buffer mode feature and relocate cache metrics All checks were successful Build and Release / build-and-release (push) Successful in 56s Details - Remove buffer mode toggle (Normal/Large/Huge) as demuxer settings do not significantly impact local file playback - Move cache duration metric from title bar to bottom status bar - Display cache alongside codec, bitrate, and sample rate info - Remove 'b' key binding and Buffer context menu option - Update version to 0.1.15	2025-12-09 11:51:51 +01:00
Christoffer Martinsson	ed6765039c	Add nerd font icons and UI polish All checks were successful Build and Release / build-and-release (push) Successful in 1m18s Details - Add nerd font file type icons: - Folder icons: closed/open folders with visual state - Music files: icon in green (mp3, flac, wav, ogg, etc.) - Video files: icon in yellow (mp4, mkv, avi, mov, etc.) - Add spacing after icons for better readability - Add "Refresh" option to title bar right-click menu - Make all context menus more compact (13 chars wide) - Change panel titles to lowercase: - "Media Files" → "files" - "Playlist" → "playlist" - Remove bold styling from focused panel titles - All icons show as bold black on selection bar - Folders show in blue, music in green, video in yellow	2025-12-08 23:07:28 +01:00