app/musicmuster.py

@@ -427,13 +427,6 @@ class Window(QMainWindow, Ui_MainWindow):
                     btn.setStyleSheet("background-color: " + colour + ";\n")
                     btn.pgb.setValue(0)
 
-    def clear_next(self) -> None:
-        """
-        Clear next track
-        """
-
-        self.next_track = PlaylistTrack()
-
     def clear_selection(self) -> None:
         """ Clear selected row"""
 
@@ -1190,7 +1183,7 @@ class Window(QMainWindow, Ui_MainWindow):
             # stop_playing() above has called end_of_track_actions()
             # which will have populated self.previous_track
             self.current_track = self.next_track
-            self.clear_next()
+            self.next_track = PlaylistTrack()
 
             if not self.current_track.track_id:
                 log.debug("musicmuster.play_next(): no id for next track")
@@ -1497,7 +1490,7 @@ class Window(QMainWindow, Ui_MainWindow):
                                 QColor(Config.COLOUR_NORMAL_TAB))
 
             # Discard now-incorrect next_track PlaylistTrack
-            self.clear_next()
+            self.next_track = PlaylistTrack()
 
         self.next_track.set_plr(session, plr, playlist_tab)
         if self.next_track.playlist_tab:
@@ -1826,7 +1819,7 @@ class DbDialog(QDialog):
 
 class DownloadCSV(QDialog):
     def __init__(self, parent=None):
-        super().__init__()
+        super().__init__(*args, **kwargs)
 
         self.ui = Ui_DateSelect()
         self.ui.setupUi(self)
@@ -1838,7 +1831,7 @@ class DownloadCSV(QDialog):
 
 class SelectPlaylistDialog(QDialog):
     def __init__(self, parent=None, playlists=None, session=None):
-        super().__init__()
+        super().__init__(*args, **kwargs)
 
         if playlists is None:
             return

app/playlists.py

@@ -265,132 +265,111 @@ class PlaylistTab(QTableWidget):
             self.menu = QMenu(self)
             item = self.itemAt(event.pos())
             if item is not None:
-                with Session() as session:
+                row_number = item.row()
-                    row_number = item.row()
+                track_id = self._get_row_track_id(row_number)
-                    plr_id = self._get_playlistrow_id(row_number)
+                track_row = track_id > 0
-                    plr = session.get(PlaylistRows, plr_id)
+                header_row = not track_row
-                    track_id = plr.track_id
+                if track_row:
-                    track_row = track_id is not None
+                    current = (
-                    header_row = not track_row
+                        row_number == self._get_current_track_row_number()
-                    if track_row:
+                    )
-                        current = (
+                    next_row = row_number == self._get_next_track_row_number()
-                            row_number == self._get_current_track_row_number()
+                else:
-                        )
+                    current = next_row = False
-                        next_row = (
-                            row_number == self._get_next_track_row_number())
-                    else:
-                        current = next_row = False
 
-                    # Mark unplayed / un-next
+                # Cut/paste
-                    sep = False
+                act_cut = self.menu.addAction(
-                    if plr.played:
+                    "Mark for moving")
-                        sep = True
+                act_cut.triggered.connect(
-                        act_unplay = self.menu.addAction("Mark unplayed")
+                    lambda: self.musicmuster.cut_rows())
-                        act_unplay.triggered.connect(
-                            lambda: self._mark_unplayed(plr))
-                    if next_row:
-                        sep = True
-                        act_unnext = self.menu.addAction(
-                            "Unmark as next track")
-                        act_unnext.triggered.connect(
-                            lambda: self._mark_unnext(row_number))
-                    if sep:
-                        self.menu.addSeparator()
 
-                    # Cut/paste
+                act_paste = self.menu.addAction(
-                    act_cut = self.menu.addAction(
+                    "Paste")
-                        "Mark for moving")
+                act_paste.setDisabled(
-                    act_cut.triggered.connect(
+                    self.musicmuster.selected_plrs is None)
-                        lambda: self.musicmuster.cut_rows())
+                act_paste.triggered.connect(
+                    lambda: self.musicmuster.paste_rows())
 
-                    act_paste = self.menu.addAction(
+                self.menu.addSeparator()
-                        "Paste")
+
-                    act_paste.setDisabled(
+                if track_row:
-                        self.musicmuster.selected_plrs is None)
+                    # Info
-                    act_paste.triggered.connect(
+                    act_info = self.menu.addAction('Info')
-                        lambda: self.musicmuster.paste_rows())
+                    act_info.triggered.connect(
+                        lambda: self._info_row(track_id)
+                    )
+                    act_copypath = self.menu.addAction("Copy track path")
+                    act_copypath.triggered.connect(
+                        lambda: self._copy_path(row_number))
 
                     self.menu.addSeparator()
 
-                    if track_row:
+                    # Play with mplayer
-                        # Info
+                    act_mplayer = self.menu.addAction(
-                        act_info = self.menu.addAction('Info')
+                        "Play with mplayer")
-                        act_info.triggered.connect(
+                    act_mplayer.triggered.connect(
-                            lambda: self._info_row(track_id)
+                        lambda: self._mplayer_play(track_id))
-                        )
-                        act_copypath = self.menu.addAction("Copy track path")
-                        act_copypath.triggered.connect(
-                            lambda: self._copy_path(row_number))
 
-                        self.menu.addSeparator()
+                    # Set next
-
+                    if not current and not next_row:
-                        # Play with mplayer
+                        act_setnext = self.menu.addAction("Set next")
-                        act_mplayer = self.menu.addAction(
+                        with Session() as session:
-                            "Play with mplayer")
-                        act_mplayer.triggered.connect(
-                            lambda: self._mplayer_play(track_id))
-
-                        # Set next
-                        if not current and not next_row:
-                            act_setnext = self.menu.addAction("Set next")
                             act_setnext.triggered.connect(
                                 lambda: self._set_next(session, row_number))
 
-                        if not current:
+                    if not current:
-                            # Open in Audacity
+                        # Open in Audacity
-                            act_audacity = self.menu.addAction(
+                        act_audacity = self.menu.addAction(
-                                "Open in Audacity")
+                            "Open in Audacity")
-                            act_audacity.triggered.connect(
+                        act_audacity.triggered.connect(
-                                lambda: self._open_in_audacity(track_id))
+                            lambda: self._open_in_audacity(track_id))
 
-                            # Rescan
+                        # Rescan
-                            act_rescan = self.menu.addAction("Rescan")
+                        act_rescan = self.menu.addAction("Rescan")
-                            act_rescan.triggered.connect(
+                        act_rescan.triggered.connect(
-                                lambda: self._rescan(row_number, track_id)
+                            lambda: self._rescan(row_number, track_id)
-                            )
+                        )
 
-                            self.menu.addSeparator()
-
-                            # Look up in wikipedia
-                            act_wikip = self.menu.addAction("Wikipedia")
-                            act_wikip.triggered.connect(
-                                lambda: self._wikipedia(row_number)
-                            )
-
-                            # Look up in songfacts
-                            act_songfacts = self.menu.addAction("Songfacts")
-                            act_songfacts.triggered.connect(
-                                lambda: self._songfacts(row_number)
-                            )
-
-                            self.menu.addSeparator()
-
-                            # Remove track
-                            act_remove_track = self.menu.addAction(
-                                'Remove track')
-                            act_remove_track.triggered.connect(
-                                lambda: self._remove_track(row_number)
-                            )
-                    if header_row:
-                        # Add track to section header (ie, make this a track
-                        # row)
-                        act_add_track = self.menu.addAction('Add track')
-                        act_add_track.triggered.connect(
-                            lambda: self._add_track(row_number))
-
-                    if not current and not next_row:
-                        # Remove row
-                        act_delete = self.menu.addAction('Remove row')
-                        act_delete.triggered.connect(self._delete_rows)
-
-                    self.menu.addSeparator()
-
-                    if not current and not next_row:
-                        act_move = self.menu.addAction('Move to playlist...')
-                        act_move.triggered.connect(
-                            self.musicmuster.move_selected)
                         self.menu.addSeparator()
 
+                        # Look up in wikipedia
+                        act_wikip = self.menu.addAction("Wikipedia")
+                        act_wikip.triggered.connect(
+                            lambda: self._wikipedia(row_number)
+                        )
+
+                        # Look up in songfacts
+                        act_songfacts = self.menu.addAction("Songfacts")
+                        act_songfacts.triggered.connect(
+                            lambda: self._songfacts(row_number)
+                        )
+
+                        self.menu.addSeparator()
+
+                        # Remove track
+                        act_remove_track = self.menu.addAction('Remove track')
+                        act_remove_track.triggered.connect(
+                            lambda: self._remove_track(row_number)
+                        )
+                if header_row:
+                    # Add track to section header (ie, make this a track
+                    # row)
+                    act_add_track = self.menu.addAction('Add track')
+                    act_add_track.triggered.connect(
+                        lambda: self._add_track(row_number))
+
+                if not current and not next_row:
+                    # Remove row
+                    act_delete = self.menu.addAction('Remove row')
+                    act_delete.triggered.connect(self._delete_rows)
+
+                self.menu.addSeparator()
+
+                if not current and not next_row:
+                    act_move = self.menu.addAction('Move to playlist...')
+                    act_move.triggered.connect(self.musicmuster.move_selected)
+                    self.menu.addSeparator()
+
         return super(PlaylistTab, self).eventFilter(source, event)
 
     def mouseReleaseEvent(self, event):
@@ -555,12 +534,8 @@ class PlaylistTab(QTableWidget):
                     plr_id = self._get_playlistrow_id(row)
                     plr_item = session.get(PlaylistRows, plr_id)
                     item = self.item(row, note_column)
-                    if not item:
+                    if not plr_item or not plr_item.note or not item:
                         return False
-                    if not plr_item:
-                        return False
-                    if not plr_item.note:
-                        plr_item.note = ''
                     item.setText(plr_item.note)
 
             # Connect signal so we know when cell has changed.
@@ -1258,7 +1233,7 @@ class PlaylistTab(QTableWidget):
             _ = self._set_item_text(row, ROW_NOTES, plr.note)
 
             start_gap_item = self._set_item_text(row, START_GAP,
-                                                 str(track.start_gap))
+                                                 track.start_gap)
             if track.start_gap and track.start_gap >= 500:
                 start_gap_item.setBackground(QColor(Config.COLOUR_LONG_START))
 
@@ -1594,27 +1569,6 @@ class PlaylistTab(QTableWidget):
                 and pos.y() >= rect.center().y()  # noqa W503
         )
 
-    def _mark_unnext(self, row: int) -> None:
-        """
-        Unmark passed row as next track
-        """
-
-        self.musicmuster.clear_next()
-        with Session() as session:
-            self.update_display(session)
-        self.musicmuster.update_headers()
-
-    def _mark_unplayed(self, plr: PlaylistRows) -> None:
-        """
-        Mark passed row as unplayed in this playlist
-        """
-
-        with Session() as session:
-            session.add(plr)
-            plr.played = False
-            session.flush()
-            self.update_display(session)
-
     def _move_row(self, session: scoped_session, plr: PlaylistRows,
                   new_row_number: int) -> None:
         """Move playlist row to new_row_number using parent copy/paste"""
@@ -2047,8 +2001,8 @@ class PlaylistTab(QTableWidget):
 
         _ = self._set_item_text(row, TITLE, track.title)
         _ = self._set_item_text(row, ARTIST, track.artist)
-        _ = self._set_item_text(row, DURATION, ms_to_mmss(track.duration))
+        _ = self._set_item_text(row, DURATION, track.duration)
-        _ = self._set_item_text(row, BITRATE, str(track.bitrate))
+        _ = self._set_item_text(row, BITRATE, track.bitrate)
 
         self.update_display(session)