WIP V3: Don't hide next/current row

app/musicmuster.py

@@ -762,14 +762,13 @@ class Window(QMainWindow, Ui_MainWindow):
 
         if self.hide_played_tracks:
             self.hide_played_tracks = False
+            self.active_model().hide_played_tracks(False)
             self.btnHidePlayed.setText("Hide played")
         else:
             self.hide_played_tracks = True
+            self.active_model().hide_played_tracks(True)
             self.btnHidePlayed.setText("Show played")
 
-        # Update displayed playlist
-        self.active_tab().hide_or_show_played_tracks()
-
     def import_track(self) -> None:
         """Import track file"""
 

app/playlistmodel.py

@@ -122,6 +122,7 @@ class PlaylistModel(QAbstractTableModel):
         self.playlist_rows: dict[int, PlaylistRowData] = {}
         self.start_end_times: dict[int, StartEndTimes] = {}
         self.signals = MusicMusterSignals()
+        self.played_tracks_hidden = False
 
         self.signals.add_track_to_header_signal.connect(self.add_track_to_header)
         self.signals.add_track_to_playlist_signal.connect(self.add_track)
@@ -666,6 +667,16 @@ class PlaylistModel(QAbstractTableModel):
 
         return prd.note
 
+    def hide_played_tracks(self, hide: bool) -> None:
+        """
+        Set played tracks hidden according to 'hide'
+        """
+
+        self.played_tracks_hidden = hide
+        for row_number in range(len(self.playlist_rows)):
+            if self.is_played_row(row_number):
+                self.invalidate_row(row_number)
+
     def is_header_row(self, row_number: int) -> bool:
         """
         Return True if row is a header row, else False
@@ -673,7 +684,7 @@ class PlaylistModel(QAbstractTableModel):
 
         return self.playlist_rows[row_number].path == ""
 
-    def is_unplayed_row(self, row_number: int) -> bool:
+    def is_played_row(self, row_number: int) -> bool:
         """
         Return True if row is an unplayed track row, else False
         """
@@ -712,7 +723,7 @@ class PlaylistModel(QAbstractTableModel):
         """
 
         self.dataChanged.emit(
-            self.index(modified_row, 0), self.index(modified_row, self.columnCount())
+            self.index(modified_row, 0), self.index(modified_row, self.columnCount() - 1)
         )
 
     def invalidate_rows(self, modified_rows: List[int]) -> None:
@@ -1020,12 +1031,14 @@ class PlaylistModel(QAbstractTableModel):
         Set row_number as next track. If row_number is None, clear next track.
         """
 
+        next_row_was = track_sequence.next.plr_rownum
+        if next_row_was is not None:
+            self.invalidate_row(next_row_was)
+
         if row_number is None:
-            next_row_was = track_sequence.next.plr_rownum
             if next_row_was is None:
                 return
             track_sequence.next = PlaylistTrack()
-            self.invalidate_row(next_row_was)
             self.signals.next_track_changed_signal.emit()
             return
 
@@ -1247,6 +1260,32 @@ class PlaylistProxyModel(QSortFilterProxyModel):
         # Search all columns
         self.setFilterKeyColumn(-1)
 
+    def filterAcceptsRow(self, source_row: int, source_parent: QModelIndex) -> bool:
+        """
+        Subclass to filter by played status
+        """
+
+        if self.playlist_model.played_tracks_hidden:
+            if self.playlist_model.is_played_row(source_row):
+                # Don't hide current or next track
+                with Session() as session:
+                    next_plr = session.get(PlaylistRows, track_sequence.next.plr_id)
+                    if (
+                        next_plr
+                        and next_plr.plr_rownum == source_row
+                        and next_plr.playlist_id == self.playlist_model.playlist_id
+                    ):
+                        return True
+                    now_plr = session.get(PlaylistRows, track_sequence.now.plr_id)
+                    if (
+                        now_plr
+                        and now_plr.plr_rownum == source_row
+                        and now_plr.playlist_id == self.playlist_model.playlist_id
+                    ):
+                        return True
+                return False
+        return super().filterAcceptsRow(source_row, source_parent)
+
     def set_incremental_search(self, search_string: str) -> None:
         """
         Update search pattern
@@ -1262,25 +1301,26 @@ class PlaylistProxyModel(QSortFilterProxyModel):
     # Forward functions not handled in proxy
     # ######################################
 
+    def current_track_started(self):
+        return self.playlist_model.current_track_started()
+
     def delete_rows(self, row_numbers: List[int]) -> None:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.delete_rows(row_numbers)
-        return model.delete_rows(row_numbers)
 
     def get_duplicate_rows(self) -> List[int]:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.get_duplicate_rows()
-        return model.get_duplicate_rows()
 
     def get_rows_duration(self, row_numbers: List[int]) -> int:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.get_rows_duration(row_numbers)
-        return model.get_rows_duration(row_numbers)
 
     def get_row_info(self, row_number: int) -> PlaylistRowData:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.get_row_info(row_number)
-        return model.get_row_info(row_number)
 
     def get_row_track_path(self, row_number: int) -> str:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.get_row_track_path(row_number)
-        return model.get_row_track_path(row_number)
+
+    def hide_played_tracks(self, hide: bool) -> None:
+        return self.playlist_model.hide_played_tracks(hide)
 
     def insert_row(
         self,
@@ -1288,65 +1328,53 @@ class PlaylistProxyModel(QSortFilterProxyModel):
         track_id: Optional[int] = None,
         note: Optional[str] = None,
     ) -> None:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.insert_row(proposed_row_number, track_id, note)
-        return model.insert_row(proposed_row_number, track_id, note)
 
     def is_header_row(self, row_number: int) -> bool:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.is_header_row(row_number)
-        return model.is_header_row(row_number)
 
-    def is_unplayed_row(self, row_number: int) -> bool:
+    def is_played_row(self, row_number: int) -> bool:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.is_played_row(row_number)
-        return model.is_unplayed_row(row_number)
 
     def mark_unplayed(self, row_numbers: List[int]) -> None:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.mark_unplayed(row_numbers)
-        return model.mark_unplayed(row_numbers)
 
     def move_rows(self, from_rows: List[int], to_row_number: int) -> None:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.move_rows(from_rows, to_row_number)
-        return model.move_rows(from_rows, to_row_number)
 
     def move_rows_between_playlists(
         self, from_rows: List[int], to_row_number: int, to_playlist_id: int
     ) -> None:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.move_rows_between_playlists(
-        return model.move_rows_between_playlists(
             from_rows, to_row_number, to_playlist_id
         )
 
     def open_in_audacity(self, row_number: int) -> None:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.open_in_audacity(row_number)
-        return model.open_in_audacity(row_number)
+
+    def previous_track_ended(self) -> None:
+        return self.playlist_model.previous_track_ended()
 
     def remove_track(self, row_number: int) -> None:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.remove_track(row_number)
-        return model.remove_track(row_number)
 
     def rescan_track(self, row_number: int) -> None:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.rescan_track(row_number)
-        return model.rescan_track(row_number)
 
     def set_next_row(self, row_number: Optional[int]) -> None:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.set_next_row(row_number)
-        return model.set_next_row(row_number)
 
     def sort_by_artist(self, row_numbers: List[int]) -> None:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.sort_by_artist(row_numbers)
-        return model.sort_by_artist(row_numbers)
 
     def sort_by_duration(self, row_numbers: List[int]) -> None:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.sort_by_duration(row_numbers)
-        return model.sort_by_duration(row_numbers)
 
     def sort_by_lastplayed(self, row_numbers: List[int]) -> None:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.sort_by_lastplayed(row_numbers)
-        return model.sort_by_lastplayed(row_numbers)
 
     def sort_by_title(self, row_numbers: List[int]) -> None:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.sort_by_title(row_numbers)
-        return model.sort_by_title(row_numbers)
 
     def update_track_times(self) -> None:
-        model = cast(PlaylistModel, self.sourceModel())
+        return self.playlist_model.update_track_times()
-        return model.update_track_times()

test_playlistmodel.py

@@ -43,8 +43,7 @@ def create_model_with_playlist_rows(
     # Create a model
     model = playlistmodel.PlaylistModel(playlist.id)
     for row in range(rows):
-        plr = model.insert_row(proposed_row_number=row, note=str(row))
+        model.insert_row(proposed_row_number=row, note=str(row))
-        model.playlist_rows[plr.plr_rownum] = playlistmodel.PlaylistRowData(plr)
 
     session.commit()
     return model