app/musicmuster.py

@@ -762,13 +762,14 @@ 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,7 +122,6 @@ 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)
@@ -667,16 +666,6 @@ 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
@@ -684,7 +673,7 @@ class PlaylistModel(QAbstractTableModel):
 
         return self.playlist_rows[row_number].path == ""
 
-    def is_played_row(self, row_number: int) -> bool:
+    def is_unplayed_row(self, row_number: int) -> bool:
         """
         Return True if row is an unplayed track row, else False
         """
@@ -723,7 +712,7 @@ class PlaylistModel(QAbstractTableModel):
         """
 
         self.dataChanged.emit(
-            self.index(modified_row, 0), self.index(modified_row, self.columnCount() - 1)
+            self.index(modified_row, 0), self.index(modified_row, self.columnCount())
         )
 
     def invalidate_rows(self, modified_rows: List[int]) -> None:
@@ -1031,14 +1020,12 @@ 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
 
@@ -1260,32 +1247,6 @@ 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
@@ -1301,26 +1262,25 @@ 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:
-        return self.playlist_model.delete_rows(row_numbers)
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.delete_rows(row_numbers)
 
     def get_duplicate_rows(self) -> List[int]:
-        return self.playlist_model.get_duplicate_rows()
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.get_duplicate_rows()
 
     def get_rows_duration(self, row_numbers: List[int]) -> int:
-        return self.playlist_model.get_rows_duration(row_numbers)
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.get_rows_duration(row_numbers)
 
     def get_row_info(self, row_number: int) -> PlaylistRowData:
-        return self.playlist_model.get_row_info(row_number)
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.get_row_info(row_number)
 
     def get_row_track_path(self, row_number: int) -> str:
-        return self.playlist_model.get_row_track_path(row_number)
+        model = cast(PlaylistModel, self.sourceModel())
-
+        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,
@@ -1328,53 +1288,65 @@ class PlaylistProxyModel(QSortFilterProxyModel):
         track_id: Optional[int] = None,
         note: Optional[str] = None,
     ) -> None:
-        return self.playlist_model.insert_row(proposed_row_number, track_id, note)
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.insert_row(proposed_row_number, track_id, note)
 
     def is_header_row(self, row_number: int) -> bool:
-        return self.playlist_model.is_header_row(row_number)
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.is_header_row(row_number)
 
-    def is_played_row(self, row_number: int) -> bool:
+    def is_unplayed_row(self, row_number: int) -> bool:
-        return self.playlist_model.is_played_row(row_number)
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.is_unplayed_row(row_number)
 
     def mark_unplayed(self, row_numbers: List[int]) -> None:
-        return self.playlist_model.mark_unplayed(row_numbers)
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.mark_unplayed(row_numbers)
 
     def move_rows(self, from_rows: List[int], to_row_number: int) -> None:
-        return self.playlist_model.move_rows(from_rows, to_row_number)
+        model = cast(PlaylistModel, self.sourceModel())
+        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:
-        return self.playlist_model.move_rows_between_playlists(
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.move_rows_between_playlists(
             from_rows, to_row_number, to_playlist_id
         )
 
     def open_in_audacity(self, row_number: int) -> None:
-        return self.playlist_model.open_in_audacity(row_number)
+        model = cast(PlaylistModel, self.sourceModel())
-
+        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:
-        return self.playlist_model.remove_track(row_number)
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.remove_track(row_number)
 
     def rescan_track(self, row_number: int) -> None:
-        return self.playlist_model.rescan_track(row_number)
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.rescan_track(row_number)
 
     def set_next_row(self, row_number: Optional[int]) -> None:
-        return self.playlist_model.set_next_row(row_number)
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.set_next_row(row_number)
 
     def sort_by_artist(self, row_numbers: List[int]) -> None:
-        return self.playlist_model.sort_by_artist(row_numbers)
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.sort_by_artist(row_numbers)
 
     def sort_by_duration(self, row_numbers: List[int]) -> None:
-        return self.playlist_model.sort_by_duration(row_numbers)
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.sort_by_duration(row_numbers)
 
     def sort_by_lastplayed(self, row_numbers: List[int]) -> None:
-        return self.playlist_model.sort_by_lastplayed(row_numbers)
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.sort_by_lastplayed(row_numbers)
 
     def sort_by_title(self, row_numbers: List[int]) -> None:
-        return self.playlist_model.sort_by_title(row_numbers)
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.sort_by_title(row_numbers)
 
     def update_track_times(self) -> None:
-        return self.playlist_model.update_track_times()
+        model = cast(PlaylistModel, self.sourceModel())
+        return model.update_track_times()

test_playlistmodel.py

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