More signal / signal handler cleanups

app/classes.py

@@ -279,14 +279,14 @@ class MusicMusterSignals(QObject):
     # Emited when a track starts playing
     signal_track_started = pyqtSignal()
 
+    # Emitted when track ends or is manually faded
+    signal_track_ended = pyqtSignal(int)
+
     # Used by model to signal spanning of cells to playlist for headers
     span_cells_signal = pyqtSignal(int, int, int, int, int)
 
     # Dispay status message to user
     status_message_signal = pyqtSignal(str, int)
 
-    # Emitted when track ends or is manually faded
-    signal_track_ended = pyqtSignal(int)
-
     def __post_init__(self):
         super().__init__()

app/music_manager.py

@@ -101,7 +101,7 @@ class Music:
         if not self.player.get_position() > 0 and self.player.is_playing():
             return
 
-        self.signal_track_ended()
+        self.emit_signal_track_ended()
 
         self.fader_worker = _FadeTrack(self.player, fade_seconds=fade_seconds)
         self.fader_worker.finished.connect(self.player.release)
@@ -225,7 +225,7 @@ class Music:
                 log.debug(f"Volume reset from {volume=}")
             sleep(0.1)
 
-    def signal_track_ended(self) -> None:
+    def emit_signal_track_ended(self) -> None:
         """
         Multiple parts of the Music class can signal that the track has
         ended. Handle them all here to ensure that only one such signal
@@ -254,7 +254,7 @@ class Music:
             self.player.stop()
         self.player.release()
         self.player = None
-        self.signal_track_ended()
+        self.emit_signal_track_ended()
 
     def track_end_event_handler(self, event: vlc.Event) -> None:
         """
@@ -262,4 +262,4 @@ class Music:
         """
 
         log.debug("track_end_event_handler() called")
-        self.signal_track_ended()
+        self.emit_signal_track_ended()

app/musicmuster.py

@@ -1726,11 +1726,11 @@ class Window(QMainWindow):
 
         self.signals.enable_escape_signal.connect(self.enable_escape_signal_handler)
         self.signals.show_warning_signal.connect(self.show_warning)
-        self.signals.signal_next_track_changed.connect(self.signal_next_track_changed_handler)
+        self.signals.signal_next_track_changed.connect(self.next_track_changed_handler)
-        self.signals.signal_set_next_track.connect(self.signal_set_next_track_handler)
+        self.signals.signal_set_next_track.connect(self.set_next_track_handler)
         self.signals.status_message_signal.connect(self.show_status_message)
-        self.signals.signal_track_ended.connect(self.end_of_track_actions)
+        self.signals.signal_track_ended.connect(self.track_ended_handler)
-        self.signals.signal_playlist_selected_rows.connect(self.signal_playlist_selected_rows_handler)
+        self.signals.signal_playlist_selected_rows.connect(self.playlist_selected_rows_handler)
 
         self.timer10.timeout.connect(self.tick_10ms)
         self.timer500.timeout.connect(self.tick_500ms)
@@ -1749,6 +1749,8 @@ class Window(QMainWindow):
         # how current_row_or_end is used
         if self.current.selected_row_numbers:
             return self.current.selected_row_numbers[0]
+        if not self.current.base_model:
+            return 0    # hack, but mostly there WILL be a current model
         return self.current.base_model.rowCount()
 
     def debug(self, checked: bool = False) -> None:
@@ -1803,7 +1805,7 @@ class Window(QMainWindow):
             self.menu_actions["clear_selection"].setEnabled(enabled)
 
     # @log_call
-    def end_of_track_actions(self) -> None:
+    def track_ended_handler(self) -> None:
         """
         Called by signal_track_ended
 
@@ -1906,7 +1908,7 @@ class Window(QMainWindow):
                 self.current.base_model.hide_played_tracks(True)
 
         # Reset row heights
-        self._active_tab().resize_rows()
+        self.signals.resize_rows_signal.emit(self.current.playlist_id)
 
     def import_files_wrapper(self, checked: bool = False) -> None:
         """
@@ -2091,7 +2093,7 @@ class Window(QMainWindow):
                 from_rows, to_row, to_playlist_model.playlist_id
             )
 
-        self._active_tab().resize_rows()
+        self.signals.resize_rows_signal.emit(self.current.playlist_id)
         self._active_tab().clear_selection()
 
         # If we move a row to immediately under the current track, make
@@ -2101,7 +2103,7 @@ class Window(QMainWindow):
             and self.track_sequence.current.playlist_id == to_playlist_model.playlist_id
             and to_row == self.track_sequence.current.row_number + 1
         ):
-            to_playlist_model.set_next_row(to_row)
+            to_playlist_model.set_next_row_handler(to_row)
 
     # @log_call
     def play_next(self, position: float | None = None, checked: bool = False) -> None:
@@ -2144,7 +2146,7 @@ class Window(QMainWindow):
         if self.track_sequence.current:
             self.track_sequence.current.fade()
 
-        # Move next track to current track. end_of_track_actions() will
+        # Move next track to current track. signal_track_ended_handler() will
         # have been called when previous track ended or when fade() was
         # called above, and that in turn will have saved current track to
         # previous_track
@@ -2514,7 +2516,7 @@ class Window(QMainWindow):
 
         self.current.selected_row_numbers = selected_rows.rows
 
-    def signal_set_next_track_handler(self, plr: PlaylistRow) -> None:
+    def set_next_track_handler(self, plr: PlaylistRow) -> None:
         """
         Handle signal_set_next_track
         """
@@ -2522,7 +2524,7 @@ class Window(QMainWindow):
         self.track_sequence.set_next(plr)
         self.signals.signal_next_track_changed.emit()
 
-    def signal_next_track_changed_handler(self) -> None:
+    def next_track_changed_handler(self) -> None:
         """
         Handle next track changed
         """

app/playlistmodel.py

@@ -93,17 +93,15 @@ class PlaylistModel(QAbstractTableModel):
         self.played_tracks_hidden = False
 
         # Connect signals
-        self.signals.signal_add_track_to_header.connect(self.add_track_to_header)
+        self.signals.signal_add_track_to_header.connect(self.signal_add_track_to_header_handler)
-        self.signals.signal_begin_insert_rows.connect(self.begin_insert_rows)
+        self.signals.signal_begin_insert_rows.connect(self.begin_insert_rows_handler)
-        self.signals.signal_end_insert_rows.connect(self.end_insert_rows)
+        self.signals.signal_end_insert_rows.connect(self.end_insert_rows_handler)
         self.signals.signal_insert_track.connect(self.insert_row_signal_handler)
-        self.signals.signal_playlist_selected_rows.connect(self.signal_playlist_selected_rows_handler)
+        self.signals.signal_playlist_selected_rows.connect(self.playlist_selected_rows_handler)
-        self.signals.signal_set_next_row.connect(self.set_next_row)
+        self.signals.signal_set_next_row.connect(self.set_next_row_handler)
-        self.signals.signal_track_started.connect(self.track_started)
+        self.signals.signal_track_started.connect(self.track_started_handler)
-        self.signals.signal_track_ended.connect(self.previous_track_ended)
+        self.signals.signal_track_ended.connect(self.signal_track_ended_handler)
-        self.signals.signal_next_track_changed.connect(
+        self.signals.signal_next_track_changed.connect(self.next_track_changed_handler)
-            self.signal_next_track_changed_handler
-        )
 
         # Populate self.playlist_rows
         for dto in ds.playlistrows_by_playlist(self.playlist_id):
@@ -152,7 +150,7 @@ class PlaylistModel(QAbstractTableModel):
         return header_row
 
     # @log_call
-    def add_track_to_header(self, track_and_playlist: TrackAndPlaylist) -> None:
+    def signal_add_track_to_header_handler(self, track_and_playlist: TrackAndPlaylist) -> None:
         """
         Handle signal_add_track_to_header
         """
@@ -251,7 +249,7 @@ class PlaylistModel(QAbstractTableModel):
         return len(Col)
 
     # @log_call
-    def track_started(self) -> None:
+    def track_started_handler(self) -> None:
         """
         Handle signal_track_started signal.
 
@@ -896,7 +894,7 @@ class PlaylistModel(QAbstractTableModel):
         self.track_sequence.update()
         self.update_track_times()
 
-    def begin_insert_rows(self, insert_rows: InsertRows) -> None:
+    def begin_insert_rows_handler(self, insert_rows: InsertRows) -> None:
         """
         Prepare model to insert rows
         """
@@ -906,7 +904,7 @@ class PlaylistModel(QAbstractTableModel):
 
         super().beginInsertRows(QModelIndex(), insert_rows.from_row, insert_rows.to_row)
 
-    def end_insert_rows(self, playlist_id: int) -> None:
+    def end_insert_rows_handler(self, playlist_id: int) -> None:
         """
         End insert rows
         """
@@ -972,7 +970,7 @@ class PlaylistModel(QAbstractTableModel):
                         return
 
     # @log_call
-    def previous_track_ended(self, playlist_id: int) -> None:
+    def signal_track_ended_handler(self, playlist_id: int) -> None:
         """
         Notification from signal_track_ended that the previous track has ended.
 
@@ -988,12 +986,12 @@ class PlaylistModel(QAbstractTableModel):
         # Sanity check
         if not self.track_sequence.previous:
             log.error(
-                f"{self}: playlistmodel:previous_track_ended called with no current track"
+                f"{self}: playlistmodel:signal_track_ended_handler called with no current track"
             )
             return
         if self.track_sequence.previous.row_number is None:
             log.error(
-                f"{self}: previous_track_ended called with no row number "
+                f"{self}: signal_track_ended_handler called with no row number "
                 f"({self.track_sequence.previous=})"
             )
             return
@@ -1255,7 +1253,7 @@ class PlaylistModel(QAbstractTableModel):
         return True
 
     # @log_call
-    def signal_playlist_selected_rows_handler(self, selected_rows: SelectedRows) -> None:
+    def playlist_selected_rows_handler(self, selected_rows: SelectedRows) -> None:
         """
         Handle signal_playlist_selected_rows to keep track of which rows
         are selected in the view
@@ -1267,7 +1265,7 @@ class PlaylistModel(QAbstractTableModel):
         self.selected_rows = [self.playlist_rows[a] for a in selected_rows.rows]
 
     # @log_call
-    def set_next_row(self, playlist_id: int) -> None:
+    def set_next_row_handler(self, playlist_id: int) -> None:
         """
         Handle signal_set_next_row
         """
@@ -1306,7 +1304,7 @@ class PlaylistModel(QAbstractTableModel):
 
         self.signals.signal_set_next_track.emit(plr)
 
-    def signal_next_track_changed_handler(self) -> None:
+    def next_track_changed_handler(self) -> None:
         """
         Handle next track changed
         """

app/playlists.py

@@ -41,7 +41,6 @@ from classes import (
     MusicMusterSignals,
     PlaylistStyle,
     SelectedRows,
-    TrackAndPlaylist,
     TrackInfo
 )
 from config import Config
@@ -310,9 +309,9 @@ class PlaylistTab(QTableView):
 
         # Connect signals
         self.signals = MusicMusterSignals()
-        self.signals.resize_rows_signal.connect(self.resize_rows)
+        self.signals.resize_rows_signal.connect(self.resize_rows_handler)
-        self.signals.span_cells_signal.connect(self._span_cells)
+        self.signals.span_cells_signal.connect(self._span_cells_handler)
-        self.signals.signal_track_started.connect(self.track_started)
+        self.signals.signal_track_started.connect(self.track_started_handler)
 
         # Selection model
         self.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
@@ -343,7 +342,7 @@ class PlaylistTab(QTableView):
             v_header.sectionHandleDoubleClicked.connect(self.resizeRowToContents)
 
         # Setting ResizeToContents causes screen flash on load
-        self.resize_rows()
+        self.resize_rows_handler()
 
     # ########## Overridden class functions ##########
 
@@ -359,7 +358,7 @@ class PlaylistTab(QTableView):
         super(PlaylistTab, self).closeEditor(editor, hint)
 
         # Optimise row heights after increasing row height for editing
-        self.resize_rows()
+        self.resize_rows_handler()
 
         # Update start times in case a start time in a note has been
         # edited
@@ -430,11 +429,11 @@ class PlaylistTab(QTableView):
             self.clear_selection()
 
             # Resize rows
-            self.resize_rows()
+            self.resize_rows_handler()
 
             # Set next row if we are immediately under current row
             if set_next_row:
-                self.get_base_model().set_next_row(set_next_row)
+                self.get_base_model().set_next_row_handler(set_next_row)
 
             event.accept()
 
@@ -729,7 +728,7 @@ class PlaylistTab(QTableView):
             cb.setText(track_path, mode=cb.Mode.Clipboard)
 
     # @log_call
-    def track_started(self) -> None:
+    def track_started_handler(self) -> None:
         """
         Called when track starts playing
         """
@@ -965,7 +964,7 @@ class PlaylistTab(QTableView):
         self.get_base_model().rescan_track(row_number)
         self.clear_selection()
 
-    def resize_rows(self, playlist_id: Optional[int] = None) -> None:
+    def resize_rows_handler(self, playlist_id: Optional[int] = None) -> None:
         """
         If playlist_id is us, resize rows
         """
@@ -1092,10 +1091,10 @@ class PlaylistTab(QTableView):
         log.debug(f"set_row_as_next_track() {model_row_number=}")
         if model_row_number is None:
             return
-        self.get_base_model().set_next_row(model_row_number)
+        self.get_base_model().set_next_row_handler(model_row_number)
         self.clearSelection()
 
-    def _span_cells(
+    def _span_cells_handler(
         self, playlist_id: int, row: int, column: int, rowSpan: int, columnSpan: int
     ) -> None:
         """

tests/test_playlistmodel.py

@@ -225,7 +225,7 @@ class TestMMMiscRowMove(unittest.TestCase):
         self.model.selected_rows = [self.model.playlist_rows[insert_row]]
 
         prd = self.model.playlist_rows[1]
-        self.model.add_track_to_header(
+        self.model.signal_add_track_to_header_handler(
             TrackAndPlaylist(playlist_id=self.model.playlist_id, track_id=prd.track_id)
         )