Fix can't add track to header row

Fixes #166
Fixex #138

app/musicmuster.py

@@ -427,6 +427,13 @@ 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"""
 
@@ -1183,7 +1190,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.next_track = PlaylistTrack()
+            self.clear_next()
 
             if not self.current_track.track_id:
                 log.debug("musicmuster.play_next(): no id for next track")
@@ -1490,7 +1497,7 @@ class Window(QMainWindow, Ui_MainWindow):
                                 QColor(Config.COLOUR_NORMAL_TAB))
 
             # Discard now-incorrect next_track PlaylistTrack
-            self.next_track = PlaylistTrack()
+            self.clear_next()
 
         self.next_track.set_plr(session, plr, playlist_tab)
         if self.next_track.playlist_tab:
@@ -1819,7 +1826,7 @@ class DbDialog(QDialog):
 
 class DownloadCSV(QDialog):
     def __init__(self, parent=None):
-        super().__init__(*args, **kwargs)
+        super().__init__()
 
         self.ui = Ui_DateSelect()
         self.ui.setupUi(self)
@@ -1831,7 +1838,7 @@ class DownloadCSV(QDialog):
 
 class SelectPlaylistDialog(QDialog):
     def __init__(self, parent=None, playlists=None, session=None):
-        super().__init__(*args, **kwargs)
+        super().__init__()
 
         if playlists is None:
             return

app/playlists.py

@@ -265,111 +265,132 @@ class PlaylistTab(QTableWidget):
             self.menu = QMenu(self)
             item = self.itemAt(event.pos())
             if item is not None:
-                row_number = item.row()
+                with Session() as session:
-                track_id = self._get_row_track_id(row_number)
+                    row_number = item.row()
-                track_row = track_id > 0
+                    plr_id = self._get_playlistrow_id(row_number)
-                header_row = not track_row
+                    plr = session.get(PlaylistRows, plr_id)
-                if track_row:
+                    track_id = plr.track_id
-                    current = (
+                    track_row = track_id is not None
-                        row_number == self._get_current_track_row_number()
+                    header_row = not track_row
-                    )
+                    if track_row:
-                    next_row = row_number == self._get_next_track_row_number()
+                        current = (
-                else:
+                            row_number == self._get_current_track_row_number()
-                    current = next_row = False
+                        )
+                        next_row = (
+                            row_number == self._get_next_track_row_number())
+                    else:
+                        current = next_row = False
 
-                # Cut/paste
+                    # Mark unplayed / un-next
-                act_cut = self.menu.addAction(
+                    sep = False
-                    "Mark for moving")
+                    if plr.played:
-                act_cut.triggered.connect(
+                        sep = True
-                    lambda: self.musicmuster.cut_rows())
+                        act_unplay = self.menu.addAction("Mark unplayed")
+                        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()
 
-                act_paste = self.menu.addAction(
+                    # Cut/paste
-                    "Paste")
+                    act_cut = self.menu.addAction(
-                act_paste.setDisabled(
+                        "Mark for moving")
-                    self.musicmuster.selected_plrs is None)
+                    act_cut.triggered.connect(
-                act_paste.triggered.connect(
+                        lambda: self.musicmuster.cut_rows())
-                    lambda: self.musicmuster.paste_rows())
 
-                self.menu.addSeparator()
+                    act_paste = self.menu.addAction(
-
+                        "Paste")
-                if track_row:
+                    act_paste.setDisabled(
-                    # Info
+                        self.musicmuster.selected_plrs is None)
-                    act_info = self.menu.addAction('Info')
+                    act_paste.triggered.connect(
-                    act_info.triggered.connect(
+                        lambda: self.musicmuster.paste_rows())
-                        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()
 
-                    # Play with mplayer
+                    if track_row:
-                    act_mplayer = self.menu.addAction(
+                        # Info
-                        "Play with mplayer")
+                        act_info = self.menu.addAction('Info')
-                    act_mplayer.triggered.connect(
+                        act_info.triggered.connect(
-                        lambda: self._mplayer_play(track_id))
+                            lambda: self._info_row(track_id)
+                        )
+                        act_copypath = self.menu.addAction("Copy track path")
+                        act_copypath.triggered.connect(
+                            lambda: self._copy_path(row_number))
 
-                    # Set next
+                        self.menu.addSeparator()
-                    if not current and not next_row:
+
-                        act_setnext = self.menu.addAction("Set next")
+                        # Play with mplayer
-                        with Session() as session:
+                        act_mplayer = self.menu.addAction(
+                            "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()
+                            self.menu.addSeparator()
 
-                        # Look up in wikipedia
+                            # Look up in wikipedia
-                        act_wikip = self.menu.addAction("Wikipedia")
+                            act_wikip = self.menu.addAction("Wikipedia")
-                        act_wikip.triggered.connect(
+                            act_wikip.triggered.connect(
-                            lambda: self._wikipedia(row_number)
+                                lambda: self._wikipedia(row_number)
-                        )
+                            )
 
-                        # Look up in songfacts
+                            # Look up in songfacts
-                        act_songfacts = self.menu.addAction("Songfacts")
+                            act_songfacts = self.menu.addAction("Songfacts")
-                        act_songfacts.triggered.connect(
+                            act_songfacts.triggered.connect(
-                            lambda: self._songfacts(row_number)
+                                lambda: self._songfacts(row_number)
-                        )
+                            )
 
-                        self.menu.addSeparator()
+                            self.menu.addSeparator()
 
-                        # Remove track
+                            # Remove track
-                        act_remove_track = self.menu.addAction('Remove track')
+                            act_remove_track = self.menu.addAction(
-                        act_remove_track.triggered.connect(
+                                'Remove track')
-                            lambda: self._remove_track(row_number)
+                            act_remove_track.triggered.connect(
-                        )
+                                lambda: self._remove_track(row_number)
-                if header_row:
+                            )
-                    # Add track to section header (ie, make this a track
+                    if header_row:
-                    # row)
+                        # Add track to section header (ie, make this a track
-                    act_add_track = self.menu.addAction('Add track')
+                        # row)
-                    act_add_track.triggered.connect(
+                        act_add_track = self.menu.addAction('Add track')
-                        lambda: self._add_track(row_number))
+                        act_add_track.triggered.connect(
+                            lambda: self._add_track(row_number))
 
-                if not current and not next_row:
+                    if not current and not next_row:
-                    # Remove row
+                        # Remove row
-                    act_delete = self.menu.addAction('Remove row')
+                        act_delete = self.menu.addAction('Remove row')
-                    act_delete.triggered.connect(self._delete_rows)
+                        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()
 
+                    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):
@@ -534,8 +555,12 @@ 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 plr_item or not plr_item.note or not item:
+                    if 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.
@@ -1233,7 +1258,7 @@ class PlaylistTab(QTableWidget):
             _ = self._set_item_text(row, ROW_NOTES, plr.note)
 
             start_gap_item = self._set_item_text(row, START_GAP,
-                                                 track.start_gap)
+                                                 str(track.start_gap))
             if track.start_gap and track.start_gap >= 500:
                 start_gap_item.setBackground(QColor(Config.COLOUR_LONG_START))
 
@@ -1569,6 +1594,27 @@ 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"""
@@ -2001,8 +2047,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, track.duration)
+        _ = self._set_item_text(row, DURATION, ms_to_mmss(track.duration))
-        _ = self._set_item_text(row, BITRATE, track.bitrate)
+        _ = self._set_item_text(row, BITRATE, str(track.bitrate))
 
         self.update_display(session)