kae/musicmuster
1
0
Fork 0
Code Issues 28 Pull Requests Projects Releases 1 Activity

WIP V3: hide played tracks working

Browse Source
This commit is contained in:
Keith Edmunds 2023-11-27 11:27:25 +00:00
parent 31f7122a7f
commit 02391f04b1
2 changed files with 55 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
app/musicmuster.py
View File

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

96
app/playlistmodel.py
View File

@ -122,6 +122,7 @@ class PlaylistModel(QAbstractTableModel):
self.playlist_rows: dict[int, PlaylistRowData] = {} self.playlist_rows: dict[int, PlaylistRowData] = {}
self.start_end_times: dict[int, StartEndTimes] = {} self.start_end_times: dict[int, StartEndTimes] = {}
self.signals = MusicMusterSignals() 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_header_signal.connect(self.add_track_to_header)
self.signals.add_track_to_playlist_signal.connect(self.add_track) self.signals.add_track_to_playlist_signal.connect(self.add_track)
@ -666,6 +667,16 @@ class PlaylistModel(QAbstractTableModel):
return prd.note 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: def is_header_row(self, row_number: int) -> bool:
""" """
Return True if row is a header row, else False Return True if row is a header row, else False
@ -673,7 +684,7 @@ class PlaylistModel(QAbstractTableModel):
return self.playlist_rows[row_number].path == "" 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 Return True if row is an unplayed track row, else False
""" """
@ -712,7 +723,7 @@ class PlaylistModel(QAbstractTableModel):
""" """
self.dataChanged.emit( 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: def invalidate_rows(self, modified_rows: List[int]) -> None:
@ -1247,6 +1258,16 @@ class PlaylistProxyModel(QSortFilterProxyModel):
# Search all columns # Search all columns
self.setFilterKeyColumn(-1) 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):
return False
return super().filterAcceptsRow(source_row, source_parent)
def set_incremental_search(self, search_string: str) -> None: def set_incremental_search(self, search_string: str) -> None:
""" """
Update search pattern Update search pattern
@ -1262,25 +1283,26 @@ class PlaylistProxyModel(QSortFilterProxyModel):
# Forward functions not handled in proxy # 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: 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]: 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: 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: 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: 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( def insert_row(
self, self,
@ -1288,65 +1310,53 @@ class PlaylistProxyModel(QSortFilterProxyModel):
track_id: Optional[int] = None, track_id: Optional[int] = None,
note: Optional[str] = None, note: Optional[str] = None,
) -> 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: 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: 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: 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( def move_rows_between_playlists(
self, from_rows: List[int], to_row_number: int, to_playlist_id: int self, from_rows: List[int], to_row_number: int, to_playlist_id: int
) -> None: ) -> 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 from_rows, to_row_number, to_playlist_id
) )
def open_in_audacity(self, row_number: int) -> None: 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: 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: 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: 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: 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: 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: 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: 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: def update_track_times(self) -> None:
model = cast(PlaylistModel, self.sourceModel()) return self.playlist_model.update_track_times()
return model.update_track_times()