app/dialogs.py

@@ -22,7 +22,7 @@ class TrackSelectDialog(QDialog):
         self,
         session: scoped_session,
         new_row_number: int,
-        source_model: PlaylistModel,
+        model: PlaylistModel,
         add_to_header: Optional[bool] = False,
         *args,
         **kwargs,
@@ -34,7 +34,7 @@ class TrackSelectDialog(QDialog):
         super().__init__(*args, **kwargs)
         self.session = session
         self.new_row_number = new_row_number
-        self.source_model = source_model
+        self.model = model
         self.add_to_header = add_to_header
         self.ui = Ui_Dialog()
         self.ui.setupUi(self)
@@ -75,7 +75,7 @@ class TrackSelectDialog(QDialog):
 
         if not track_id:
             if note:
-                self.source_model.insert_row(self.new_row_number, track_id, note)
+                self.model.insert_row(self.new_row_number, track_id, note)
                 self.ui.txtNote.clear()
                 return
             else:
@@ -87,7 +87,7 @@ class TrackSelectDialog(QDialog):
 
         # Check whether track is already in playlist
         move_existing = False
-        existing_prd = self.source_model.is_track_in_playlist(track_id)
+        existing_prd = self.model.is_track_in_playlist(track_id)
         if existing_prd is not None:
             if ask_yes_no(
                 "Duplicate row",
@@ -98,17 +98,17 @@ class TrackSelectDialog(QDialog):
 
         if self.add_to_header:
             if move_existing and existing_prd:  # "and existing_prd" for mypy's benefit
-                self.source_model.move_track_to_header(self.new_row_number, existing_prd, note)
+                self.model.move_track_to_header(self.new_row_number, existing_prd, note)
             else:
-                self.source_model.add_track_to_header(self.new_row_number, track_id)
+                self.model.add_track_to_header(self.new_row_number, track_id)
             # Close dialog - we can only add one track to a header
             self.accept()
         else:
             # Adding a new track row
             if move_existing and existing_prd:  # "and existing_prd" for mypy's benefit
-                self.source_model.move_track_add_note(self.new_row_number, existing_prd, note)
+                self.model.move_track_add_note(self.new_row_number, existing_prd, note)
             else:
-                self.source_model.insert_row(self.new_row_number, track_id, note)
+                self.model.insert_row(self.new_row_number, track_id, note)
 
     def add_selected_and_close(self) -> None:
         """Handle Add and Close button"""

app/musicmuster.py

@@ -148,11 +148,11 @@ class ImportTrack(QObject):
     import_finished = pyqtSignal()
 
     def __init__(
-        self, filenames: List[str], source_model: PlaylistModel, row_number: Optional[int]
+        self, filenames: List[str], model: PlaylistModel, row_number: Optional[int]
     ) -> None:
         super().__init__()
         self.filenames = filenames
-        self.source_model = source_model
+        self.model = model
         self.next_row_number = row_number
         self.signals = MusicMusterSignals()
 
@@ -179,7 +179,7 @@ class ImportTrack(QObject):
                 # previous additions in this loop. So, commit now to
                 # lock in what we've just done.
                 session.commit()
-                self.source_model.insert_row(self.next_row_number, track.id, "")
+                self.model.insert_row(self.next_row_number, track.id, "")
                 self.next_row_number += 1
             self.signals.status_message_signal.emit(
                 f"{len(self.filenames)} tracks imported", 10000
@@ -216,11 +216,11 @@ class Window(QMainWindow, Ui_MainWindow):
         FadeCurve.GraphWidget = self.widgetFadeVolume
 
         self.active_tab = lambda: self.tabPlaylist.currentWidget()
-        self.active_proxy_model = lambda: self.tabPlaylist.currentWidget().model()
+        self.active_model = lambda: self.tabPlaylist.currentWidget().model()
         self.move_source_rows: Optional[List[int]] = None
         self.move_source_model: Optional[PlaylistProxyModel] = None
-        self.audacity_file_path: Optional[str] = None
 
+        self.load_last_playlists()
         if Config.CARTS_HIDE:
             self.cartsWidget.hide()
             self.frame_6.hide()
@@ -233,7 +233,6 @@ class Window(QMainWindow, Ui_MainWindow):
         self.timer1000.start(1000)
         self.signals = MusicMusterSignals()
         self.connect_signals_slots()
-        self.load_last_playlists()
 
     def about(self) -> None:
         """Get git tag and database name"""
@@ -542,7 +541,6 @@ class Window(QMainWindow, Ui_MainWindow):
         self.btnStop.clicked.connect(self.stop)
         self.hdrCurrentTrack.clicked.connect(self.show_current)
         self.hdrNextTrack.clicked.connect(self.show_next)
-        self.tabPlaylist.currentChanged.connect(self.tab_change)
         self.tabPlaylist.tabCloseRequested.connect(self.close_tab)
         self.tabBar = self.tabPlaylist.tabBar()
         self.txtSearch.textChanged.connect(self.search_playlist_text_changed)
@@ -593,6 +591,7 @@ class Window(QMainWindow, Ui_MainWindow):
             playlist_id=playlist.id,
         )
         idx = self.tabPlaylist.addTab(playlist_tab, playlist.name)
+        self.tabPlaylist.setCurrentIndex(idx)
 
         return idx
 
@@ -604,7 +603,7 @@ class Window(QMainWindow, Ui_MainWindow):
         # Save the selected PlaylistRows items ready for a later
         # paste
         self.move_source_rows = self.active_tab().get_selected_rows()
-        self.move_source_model = self.active_proxy_model()
+        self.move_source_model = self.active_model()
 
     def debug(self):
         """Invoke debugger"""
@@ -759,11 +758,11 @@ class Window(QMainWindow, Ui_MainWindow):
 
         if self.hide_played_tracks:
             self.hide_played_tracks = False
-            self.active_proxy_model().hide_played_tracks(False)
+            self.active_model().hide_played_tracks(False)
             self.btnHidePlayed.setText("Hide played")
         else:
             self.hide_played_tracks = True
-            self.active_proxy_model().hide_played_tracks(True)
+            self.active_model().hide_played_tracks(True)
             self.btnHidePlayed.setText("Show played")
 
     def import_track(self) -> None:
@@ -829,8 +828,8 @@ class Window(QMainWindow, Ui_MainWindow):
         self.import_thread = QThread()
         self.worker = ImportTrack(
             new_tracks,
-            self.active_proxy_model(),
-            self.active_tab().source_model_selected_row_number(),
+            self.active_model(),
+            self.active_tab().selected_model_row_number(),
         )
         self.worker.moveToThread(self.import_thread)
         self.import_thread.started.connect(self.worker.run)
@@ -842,8 +841,12 @@ class Window(QMainWindow, Ui_MainWindow):
     def insert_header(self) -> None:
         """Show dialog box to enter header text and add to playlist"""
 
-        proxy_model = self.active_proxy_model()
-        if proxy_model is None:
+        try:
+            model = cast(PlaylistModel, self.active_tab().model())
+            if model is None:
+                return
+        except AttributeError:
+            # Just return if there's no visible playlist tab model
             return
 
         # Get header text
@@ -853,8 +856,8 @@ class Window(QMainWindow, Ui_MainWindow):
         dlg.resize(500, 100)
         ok = dlg.exec()
         if ok:
-            proxy_model.insert_row(
-                proposed_row_number=self.active_tab().source_model_selected_row_number(),
+            model.insert_row(
+                proposed_row_number=self.active_tab().selected_model_row_number(),
                 note=dlg.textValue(),
             )
 
@@ -864,8 +867,8 @@ class Window(QMainWindow, Ui_MainWindow):
         with Session() as session:
             dlg = TrackSelectDialog(
                 session=session,
-                new_row_number=self.active_tab().source_model_selected_row_number(),
-                source_model=self.active_proxy_model(),
+                new_row_number=self.active_tab().selected_model_row_number(),
+                model=self.active_model(),
             )
             dlg.exec()
 
@@ -894,11 +897,11 @@ class Window(QMainWindow, Ui_MainWindow):
         Display songfacts page for title in highlighted row
         """
 
-        row_number = self.active_tab().source_model_selected_row_number()
+        row_number = self.active_tab().selected_model_row_number()
         if row_number is None:
             return
 
-        track_info = self.active_proxy_model().get_row_info(row_number)
+        track_info = self.active_model().get_row_info(row_number)
         if track_info is None:
             return
 
@@ -909,11 +912,11 @@ class Window(QMainWindow, Ui_MainWindow):
         Display Wikipedia page for title in highlighted row
         """
 
-        row_number = self.active_tab().source_model_selected_row_number()
+        row_number = self.active_tab().selected_model_row_number()
         if row_number is None:
             return
 
-        track_info = self.active_proxy_model().get_row_info(row_number)
+        track_info = self.active_model().get_row_info(row_number)
         if track_info is None:
             return
 
@@ -950,7 +953,7 @@ class Window(QMainWindow, Ui_MainWindow):
                 to_row = 0
 
         # Move rows
-        self.active_proxy_model().move_rows_between_playlists(
+        self.active_model().move_rows_between_playlists(
             row_numbers, to_row, to_playlist_id
         )
 
@@ -970,7 +973,7 @@ class Window(QMainWindow, Ui_MainWindow):
         Move unplayed rows to another playlist
         """
 
-        unplayed_rows = self.active_proxy_model().get_unplayed_rows()
+        unplayed_rows = self.active_model().get_unplayed_rows()
         if not unplayed_rows:
             return
         self.move_playlist_rows(unplayed_rows)
@@ -1008,11 +1011,9 @@ class Window(QMainWindow, Ui_MainWindow):
             dlg.exec()
             playlist = dlg.playlist
             if playlist:
-                idx = self.create_playlist_tab(playlist)
+                self.create_playlist_tab(playlist)
                 playlist.mark_open()
 
-        self.tabPlaylist.setCurrentIndex(idx)
-
     def paste_rows(self) -> None:
         """
         Paste earlier cut rows.
@@ -1021,16 +1022,16 @@ class Window(QMainWindow, Ui_MainWindow):
         if self.move_source_rows is None or self.move_source_model is None:
             return
 
-        to_playlist_model = self.active_tab().source_model
+        to_playlist_model = self.active_tab().data_model
         selected_rows = self.active_tab().get_selected_rows()
         if selected_rows:
             destination_row = selected_rows[0]
         else:
-            destination_row = self.active_proxy_model().rowCount()
+            destination_row = self.active_model().rowCount()
 
         if (
             to_playlist_model.playlist_id
-            == self.move_source_model.source_model.playlist_id
+            == self.move_source_model.data_model.playlist_id
         ):
             self.move_source_model.move_rows(self.move_source_rows, destination_row)
         else:
@@ -1108,7 +1109,7 @@ class Window(QMainWindow, Ui_MainWindow):
             sleep(0.1)
 
         # Notify model
-        self.active_proxy_model().current_track_started()
+        self.active_model().current_track_started()
 
         # Note that track is now playing
         self.playing = True
@@ -1239,7 +1240,7 @@ class Window(QMainWindow, Ui_MainWindow):
         Incremental search of playlist
         """
 
-        self.active_proxy_model().set_incremental_search(self.txtSearch.text())
+        self.active_model().set_incremental_search(self.txtSearch.text())
 
     def select_next_row(self) -> None:
         """Select next or first row in playlist"""
@@ -1329,8 +1330,8 @@ class Window(QMainWindow, Ui_MainWindow):
                     self.tabPlaylist.setCurrentIndex(idx)
                     break
 
-        display_row = self.active_proxy_model().mapFromSource(
-            self.active_proxy_model().source_model.index(plt.plr_rownum, 0)
+        display_row = self.active_model().mapFromSource(
+            self.active_model().data_model.index(plt.plr_rownum, 0)
         ).row()
         self.tabPlaylist.currentWidget().scroll_to_top(display_row)
 
@@ -1408,7 +1409,7 @@ class Window(QMainWindow, Ui_MainWindow):
             track_sequence.now = PlaylistTrack()
 
         # Tell model previous track has finished
-        self.active_proxy_model().previous_track_ended()
+        self.active_model().previous_track_ended()
 
         # Reset clocks
         self.frame_fade.setStyleSheet("")
@@ -1423,13 +1424,6 @@ class Window(QMainWindow, Ui_MainWindow):
         # Enable controls
         self.enable_play_next_controls()
 
-    def tab_change(self):
-        """Called when active tab changed"""
-
-        tab = self.active_tab()
-        if tab:
-            tab.resizeRowsToContents()
-
     def tick_10ms(self) -> None:
         """
         Called every 10ms

app/playlistmodel.py

@@ -1353,14 +1353,14 @@ class PlaylistProxyModel(QSortFilterProxyModel):
 
     def __init__(
         self,
-        source_model: PlaylistModel,
+        data_model: PlaylistModel,
         *args,
         **kwargs,
     ):
-        self.source_model = source_model
+        self.data_model = data_model
         super().__init__(*args, **kwargs)
 
-        self.setSourceModel(source_model)
+        self.setSourceModel(data_model)
         # Search all columns
         self.setFilterKeyColumn(-1)
 
@@ -1369,8 +1369,8 @@ class PlaylistProxyModel(QSortFilterProxyModel):
         Subclass to filter by played status
         """
 
-        if self.source_model.played_tracks_hidden:
-            if self.source_model.is_played_row(source_row):
+        if self.data_model.played_tracks_hidden:
+            if self.data_model.is_played_row(source_row):
                 # Don't hide current or next track
                 with Session() as session:
                     if track_sequence.next.plr_id:
@@ -1378,7 +1378,7 @@ class PlaylistProxyModel(QSortFilterProxyModel):
                         if (
                             next_plr
                             and next_plr.plr_rownum == source_row
-                            and next_plr.playlist_id == self.source_model.playlist_id
+                            and next_plr.playlist_id == self.data_model.playlist_id
                         ):
                             return True
                     if track_sequence.now.plr_id:
@@ -1386,7 +1386,7 @@ class PlaylistProxyModel(QSortFilterProxyModel):
                         if (
                             now_plr
                             and now_plr.plr_rownum == source_row
-                            and now_plr.playlist_id == self.source_model.playlist_id
+                            and now_plr.playlist_id == self.data_model.playlist_id
                         ):
                             return True
                     # Don't hide previous track until
@@ -1399,7 +1399,7 @@ class PlaylistProxyModel(QSortFilterProxyModel):
                         if (
                             previous_plr
                             and previous_plr.plr_rownum == source_row
-                            and previous_plr.playlist_id == self.source_model.playlist_id
+                            and previous_plr.playlist_id == self.data_model.playlist_id
                         ):
                             if track_sequence.now.start_time:
                                 if datetime.now() > (
@@ -1418,7 +1418,7 @@ class PlaylistProxyModel(QSortFilterProxyModel):
                                     # true next time through.
                                     QTimer.singleShot(
                                         Config.HIDE_AFTER_PLAYING_OFFSET + 100,
-                                        lambda: self.source_model.invalidate_row(
+                                        lambda: self.data_model.invalidate_row(
                                             source_row
                                         ),
                                     )
@@ -1445,28 +1445,28 @@ class PlaylistProxyModel(QSortFilterProxyModel):
     # ######################################
 
     def current_track_started(self):
-        return self.source_model.current_track_started()
+        return self.data_model.current_track_started()
 
     def delete_rows(self, row_numbers: List[int]) -> None:
-        return self.source_model.delete_rows(row_numbers)
+        return self.data_model.delete_rows(row_numbers)
 
     def get_duplicate_rows(self) -> List[int]:
-        return self.source_model.get_duplicate_rows()
+        return self.data_model.get_duplicate_rows()
 
     def get_rows_duration(self, row_numbers: List[int]) -> int:
-        return self.source_model.get_rows_duration(row_numbers)
+        return self.data_model.get_rows_duration(row_numbers)
 
     def get_row_info(self, row_number: int) -> PlaylistRowData:
-        return self.source_model.get_row_info(row_number)
+        return self.data_model.get_row_info(row_number)
 
     def get_row_track_path(self, row_number: int) -> str:
-        return self.source_model.get_row_track_path(row_number)
+        return self.data_model.get_row_track_path(row_number)
 
     def get_unplayed_rows(self) -> List[int]:
-        return self.source_model.get_unplayed_rows()
+        return self.data_model.get_unplayed_rows()
 
     def hide_played_tracks(self, hide: bool) -> None:
-        return self.source_model.hide_played_tracks(hide)
+        return self.data_model.hide_played_tracks(hide)
 
     def insert_row(
         self,
@@ -1474,65 +1474,65 @@ class PlaylistProxyModel(QSortFilterProxyModel):
         track_id: Optional[int] = None,
         note: Optional[str] = None,
     ) -> None:
-        return self.source_model.insert_row(proposed_row_number, track_id, note)
+        return self.data_model.insert_row(proposed_row_number, track_id, note)
 
     def is_header_row(self, row_number: int) -> bool:
-        return self.source_model.is_header_row(row_number)
+        return self.data_model.is_header_row(row_number)
 
     def is_played_row(self, row_number: int) -> bool:
-        return self.source_model.is_played_row(row_number)
+        return self.data_model.is_played_row(row_number)
 
     def is_track_in_playlist(self, track_id: int) -> Optional[PlaylistRowData]:
-        return self.source_model.is_track_in_playlist(track_id)
+        return self.data_model.is_track_in_playlist(track_id)
 
     def mark_unplayed(self, row_numbers: List[int]) -> None:
-        return self.source_model.mark_unplayed(row_numbers)
+        return self.data_model.mark_unplayed(row_numbers)
 
     def move_rows(self, from_rows: List[int], to_row_number: int) -> None:
-        return self.source_model.move_rows(from_rows, to_row_number)
+        return self.data_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.source_model.move_rows_between_playlists(
+        return self.data_model.move_rows_between_playlists(
             from_rows, to_row_number, to_playlist_id
         )
 
     def move_track_add_note(
         self, new_row_number: int, existing_prd: PlaylistRowData, note: str
     ) -> None:
-        return self.source_model.move_track_add_note(new_row_number, existing_prd, note)
+        return self.data_model.move_track_add_note(new_row_number, existing_prd, note)
 
     def move_track_to_header(
         self, header_row_number: int, existing_prd: PlaylistRowData, note: Optional[str]
     ) -> None:
-        return self.source_model.move_track_to_header(
+        return self.data_model.move_track_to_header(
             header_row_number, existing_prd, note
         )
 
     def previous_track_ended(self) -> None:
-        return self.source_model.previous_track_ended()
+        return self.data_model.previous_track_ended()
 
     def remove_track(self, row_number: int) -> None:
-        return self.source_model.remove_track(row_number)
+        return self.data_model.remove_track(row_number)
 
     def rescan_track(self, row_number: int) -> None:
-        return self.source_model.rescan_track(row_number)
+        return self.data_model.rescan_track(row_number)
 
     def set_next_row(self, row_number: Optional[int]) -> None:
-        return self.source_model.set_next_row(row_number)
+        return self.data_model.set_next_row(row_number)
 
     def sort_by_artist(self, row_numbers: List[int]) -> None:
-        return self.source_model.sort_by_artist(row_numbers)
+        return self.data_model.sort_by_artist(row_numbers)
 
     def sort_by_duration(self, row_numbers: List[int]) -> None:
-        return self.source_model.sort_by_duration(row_numbers)
+        return self.data_model.sort_by_duration(row_numbers)
 
     def sort_by_lastplayed(self, row_numbers: List[int]) -> None:
-        return self.source_model.sort_by_lastplayed(row_numbers)
+        return self.data_model.sort_by_lastplayed(row_numbers)
 
     def sort_by_title(self, row_numbers: List[int]) -> None:
-        return self.source_model.sort_by_title(row_numbers)
+        return self.data_model.sort_by_title(row_numbers)
 
     def update_track_times(self) -> None:
-        return self.source_model.update_track_times()
+        return self.data_model.update_track_times()

app/playlists.py

@@ -54,9 +54,9 @@ class EscapeDelegate(QStyledItemDelegate):
     - checks with user before abandoning edit on Escape
     """
 
-    def __init__(self, parent, source_model: PlaylistModel) -> None:
+    def __init__(self, parent, data_model: PlaylistModel) -> None:
         super().__init__(parent)
-        self.source_model = source_model
+        self.data_model = data_model
         self.signals = MusicMusterSignals()
 
     def createEditor(
@@ -116,18 +116,24 @@ class EscapeDelegate(QStyledItemDelegate):
         return False
 
     def setEditorData(self, editor, index):
-        proxy_model = index.model()
-        edit_index = proxy_model.mapToSource(index)
+        model = index.model()
+        if hasattr(model, "mapToSource"):
+            edit_index = model.mapToSource(index)
+        else:
+            edit_index = index
 
-        self.original_text = self.source_model.data(edit_index, Qt.ItemDataRole.EditRole)
+        self.original_text = self.data_model.data(edit_index, Qt.ItemDataRole.EditRole)
         editor.setPlainText(self.original_text.value())
 
     def setModelData(self, editor, model, index):
-        proxy_model = index.model()
-        edit_index = proxy_model.mapToSource(index)
+        model = index.model()
+        if hasattr(model, "mapToSource"):
+            edit_index = model.mapToSource(index)
+        else:
+            edit_index = index
 
         value = editor.toPlainText().strip()
-        self.source_model.setData(edit_index, value, Qt.ItemDataRole.EditRole)
+        self.data_model.setData(edit_index, value, Qt.ItemDataRole.EditRole)
 
     def updateEditorGeometry(self, editor, option, index):
         editor.setGeometry(option.rect)
@@ -168,9 +174,9 @@ class PlaylistTab(QTableView):
         self.playlist_id = playlist_id
 
         # Set up widget
-        self.source_model = PlaylistModel(playlist_id)
-        self.proxy_model = PlaylistProxyModel(self.source_model)
-        self.setItemDelegate(EscapeDelegate(self, self.source_model))
+        self.data_model = PlaylistModel(playlist_id)
+        self.proxy_model = PlaylistProxyModel(self.data_model)
+        self.setItemDelegate(EscapeDelegate(self, self.data_model))
         self.setAlternatingRowColors(True)
         self.setVerticalScrollMode(QAbstractItemView.ScrollMode.ScrollPerPixel)
         self.setDragDropMode(QAbstractItemView.DragDropMode.InternalMove)
@@ -188,7 +194,7 @@ class PlaylistTab(QTableView):
 
         # Connect signals
         self.signals = MusicMusterSignals()
-        self.signals.resize_rows_signal.connect(self.resize_rows)
+        self.signals.resize_rows_signal.connect(self.resizeRowsToContents)
         self.signals.span_cells_signal.connect(self._span_cells)
 
         # Selection model
@@ -198,20 +204,9 @@ class PlaylistTab(QTableView):
         # Load playlist rows
         self.setModel(self.proxy_model)
         self._set_column_widths()
-        # Stretch last column *after* setting column widths which is
-        # *much* faster
-        h_header = self.horizontalHeader()
-        if isinstance(h_header, QHeaderView):
-            h_header.sectionResized.connect(self._column_resize)
-            h_header.setStretchLastSection(True)
-        # Setting ResizeToContents causes screen flash on load
-        # v_header = self.verticalHeader()
-        # if v_header:
-        #     print("HEADER")
-        #     v_header.setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)
-        QTimer.singleShot(300, self.resizeRowsToContents)
+        self.resizeRowsToContents()
 
-    # ########## Overridden class functions ##########
+    # ########## Overrident class functions ##########
 
     def closeEditor(
         self, editor: QWidget | None, hint: QAbstractItemDelegate.EndEditHint
@@ -229,7 +224,7 @@ class PlaylistTab(QTableView):
 
         # Update start times in case a start time in a note has been
         # edited
-        self.source_model.update_track_times()
+        self.data_model.update_track_times()
 
         # Deselect edited line
         self.clear_selection()
@@ -246,11 +241,11 @@ class PlaylistTab(QTableView):
         to_model_row = self.proxy_model.mapToSource(to_index).row()
 
         if (
-            0 <= min(from_rows) <= self.source_model.rowCount()
-            and 0 <= max(from_rows) <= self.source_model.rowCount()
-            and 0 <= to_model_row <= self.source_model.rowCount()
+            0 <= min(from_rows) <= self.data_model.rowCount()
+            and 0 <= max(from_rows) <= self.data_model.rowCount()
+            and 0 <= to_model_row <= self.data_model.rowCount()
         ):
-            self.source_model.move_rows(from_rows, to_model_row)
+            self.data_model.move_rows(from_rows, to_model_row)
 
             # Reset drag mode to allow row selection by dragging
             self.setDragEnabled(False)
@@ -287,7 +282,7 @@ class PlaylistTab(QTableView):
         if len(selected_rows) == 0:
             self.musicmuster.lblSumPlaytime.setText("")
         else:
-            selected_duration = self.source_model.get_rows_duration(
+            selected_duration = self.data_model.get_rows_duration(
                 self.get_selected_rows()
             )
             if selected_duration > 0:
@@ -325,7 +320,7 @@ class PlaylistTab(QTableView):
     def _add_track(self) -> None:
         """Add a track to a section header making it a normal track row"""
 
-        model_row_number = self.source_model_selected_row_number()
+        model_row_number = self.selected_model_row_number()
         if model_row_number is None:
             return
 
@@ -333,7 +328,7 @@ class PlaylistTab(QTableView):
             dlg = TrackSelectDialog(
                 session=session,
                 new_row_number=model_row_number,
-                source_model=self.source_model,
+                model=self.data_model,
                 add_to_header=True,
             )
             dlg.exec()
@@ -342,28 +337,25 @@ class PlaylistTab(QTableView):
         """Used to process context (right-click) menu, which is defined here"""
 
         self.menu.clear()
-        proxy_model = self.proxy_model
+        model = self.proxy_model
 
-        index = proxy_model.index(item.row(), item.column())
-        model_row_number = proxy_model.mapToSource(index).row()
+        display_row_number = item.row()
+        if hasattr(model, "mapToSource"):
+            index = model.index(item.row(), item.column())
+            model_row_number = model.mapToSource(index).row()
+        else:
+            model_row_number = display_row_number
 
-        header_row = proxy_model.is_header_row(model_row_number)
+        header_row = model.is_header_row(model_row_number)
         track_row = not header_row
         current_row = model_row_number == track_sequence.now.plr_rownum
         next_row = model_row_number == track_sequence.next.plr_rownum
-        track_path = self.source_model.get_row_info(model_row_number).path
 
-        # Open/import in/from Audacity
+        # Open in Audacity
         if track_row and not current_row:
-            if track_path == self.musicmuster.audacity_file_path:
-                # This track was opened in Audacity
-                self._add_context_menu(
-                    "Update from Audacity", lambda: self._import_from_audacity(model_row_number)
-                )
-            else:
-                self._add_context_menu(
-                    "Open in Audacity", lambda: self._open_in_audacity(model_row_number)
-                )
+            self._add_context_menu(
+                "Open in Audacity", lambda: self.open_in_audacity(model_row_number)
+            )
 
         # Rescan
         if track_row and not current_row:
@@ -381,7 +373,7 @@ class PlaylistTab(QTableView):
         # Remove track from row
         if track_row and not current_row and not next_row:
             self._add_context_menu(
-                "Remove track from row", lambda: proxy_model.remove_track(model_row_number)
+                "Remove track from row", lambda: model.remove_track(model_row_number)
             )
 
         # Add track to section header (ie, make this a track row)
@@ -392,7 +384,7 @@ class PlaylistTab(QTableView):
         self.menu.addSeparator()
 
         # Mark unplayed
-        if track_row and proxy_model.is_played_row(model_row_number):
+        if track_row and model.is_played_row(model_row_number):
             self._add_context_menu(
                 "Mark unplayed",
                 lambda: self._mark_as_unplayed(self.get_selected_rows()),
@@ -411,22 +403,22 @@ class PlaylistTab(QTableView):
         sort_menu = self.menu.addMenu("Sort")
         self._add_context_menu(
             "by title",
-            lambda: proxy_model.sort_by_title(self.get_selected_rows()),
+            lambda: model.sort_by_title(self.get_selected_rows()),
             parent_menu=sort_menu,
         )
         self._add_context_menu(
             "by artist",
-            lambda: proxy_model.sort_by_artist(self.get_selected_rows()),
+            lambda: model.sort_by_artist(self.get_selected_rows()),
             parent_menu=sort_menu,
         )
         self._add_context_menu(
             "by duration",
-            lambda: proxy_model.sort_by_duration(self.get_selected_rows()),
+            lambda: model.sort_by_duration(self.get_selected_rows()),
             parent_menu=sort_menu,
         )
         self._add_context_menu(
             "by last played",
-            lambda: proxy_model.sort_by_lastplayed(self.get_selected_rows()),
+            lambda: model.sort_by_lastplayed(self.get_selected_rows()),
             parent_menu=sort_menu,
         )
 
@@ -481,7 +473,7 @@ class PlaylistTab(QTableView):
         to the clipboard. Otherwise, return None.
         """
 
-        track_path = self.source_model.get_row_info(row_number).path
+        track_path = self.data_model.get_row_info(row_number).path
         if not track_path:
             return
 
@@ -518,7 +510,7 @@ class PlaylistTab(QTableView):
         if not ask_yes_no("Delete rows", f"Really delete {row_count} row{plural}?"):
             return
 
-        self.source_model.delete_rows(self.selected_model_row_numbers())
+        self.data_model.delete_rows(self.selected_model_row_numbers())
         self.clear_selection()
 
     def get_selected_row_track_path(self) -> str:
@@ -527,10 +519,10 @@ class PlaylistTab(QTableView):
         row does not have a track, return empty string.
         """
 
-        model_row_number = self.source_model_selected_row_number()
+        model_row_number = self.selected_model_row_number()
         if model_row_number is None:
             return ""
-        return self.source_model.get_row_track_path(model_row_number)
+        return self.data_model.get_row_track_path(model_row_number)
 
     def get_selected_rows(self) -> List[int]:
         """Return a list of model-selected row numbers sorted by row"""
@@ -548,28 +540,10 @@ class PlaylistTab(QTableView):
             )
         )
 
-    def _import_from_audacity(self, row_number: int) -> None:
-        """
-        Import current Audacity track to passed row
-        """
-
-        # Notify user if audacity not running
-        if "audacity" not in [i.name() for i in psutil.process_iter()]:
-            show_warning(self.musicmuster, "Audacity", "Audacity is not running")
-            return
-
-        audacity = self.audacity
-        if not audacity:
-            return
-
-        audacity.export_file()
-        self.musicmuster.audacity_file_path = None
-        self._rescan(row_number)
-
     def _info_row(self, row_number: int) -> None:
         """Display popup with info re row"""
 
-        prd = self.source_model.get_row_info(row_number)
+        prd = self.data_model.get_row_info(row_number)
         if prd:
             txt = (
                 f"Title: {prd.title}\n"
@@ -588,10 +562,10 @@ class PlaylistTab(QTableView):
     def _mark_as_unplayed(self, row_numbers: List[int]) -> None:
         """Rescan track"""
 
-        self.source_model.mark_unplayed(row_numbers)
+        self.data_model.mark_unplayed(row_numbers)
         self.clear_selection()
 
-    def _open_in_audacity(self, row_number: int) -> None:
+    def open_in_audacity(self, row_number: int) -> None:
         """
         Open track in passed row in Audacity
         """
@@ -601,30 +575,26 @@ class PlaylistTab(QTableView):
             show_warning(self.musicmuster, "Audacity", "Audacity is not running")
             return
 
-        path = self.source_model.get_row_track_path(row_number)
+        path = self.data_model.get_row_track_path(row_number)
         if not path:
             return
 
-        self.musicmuster.audacity_file_path = path
-        self.audacity = AudacityManager()
-        self.audacity.open_file(path)
+        audacity = AudacityManager()
+        audacity.open_file(path)
+        if ask_yes_no(
+            "Export file",
+            "Click yes to export file, no to ignore",
+            parent=self.musicmuster,
+        ):
+            audacity.export_file()
+            self._rescan(row_number)
 
     def _rescan(self, row_number: int) -> None:
         """Rescan track"""
 
-        self.source_model.rescan_track(row_number)
+        self.data_model.rescan_track(row_number)
         self.clear_selection()
 
-    def resize_rows(self, playlist_id: int) -> None:
-        """
-        If playlist_id is us, resize rows
-        """
-
-        if playlist_id != self.playlist_id:
-            return
-
-        self.resizeRowsToContents()
-
     def scroll_to_top(self, row_number: int) -> None:
         """
         Scroll to put passed row_number Config.SCROLL_TOP_MARGIN from the
@@ -649,14 +619,14 @@ class PlaylistTab(QTableView):
         # We need to be in MultiSelection mode
         self.setSelectionMode(QAbstractItemView.SelectionMode.MultiSelection)
         # Get the duplicate rows
-        duplicate_rows = self.source_model.get_duplicate_rows()
+        duplicate_rows = self.data_model.get_duplicate_rows()
         # Select the rows
         for duplicate_row in duplicate_rows:
             self.selectRow(duplicate_row)
         # Reset selection mode
         self.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection)
 
-    def source_model_selected_row_number(self) -> Optional[int]:
+    def selected_model_row_number(self) -> Optional[int]:
         """
         Return the model row number corresponding to the selected row or None
         """
@@ -717,23 +687,29 @@ class PlaylistTab(QTableView):
 
         # Last column is set to stretch so ignore it here
         with Session() as session:
-            for column_number in range(header.count() - 1):
+            for column_number in range(header.count() - 2):
                 attr_name = f"playlist_col_{column_number}_width"
                 record = Settings.get_int_settings(session, attr_name)
                 if record.f_int is not None:
                     self.setColumnWidth(column_number, record.f_int)
                 else:
                     self.setColumnWidth(column_number, Config.DEFAULT_COLUMN_WIDTH)
+        # Stretch last column *after* setting column widths which is
+        # *much* faster
+        h_header = self.horizontalHeader()
+        if isinstance(h_header, QHeaderView):
+            h_header.sectionResized.connect(self._column_resize)
+            h_header.setStretchLastSection(True)
 
     def set_row_as_next_track(self) -> None:
         """
         Set selected row as next track
         """
 
-        model_row_number = self.source_model_selected_row_number()
+        model_row_number = self.selected_model_row_number()
         if model_row_number is None:
             return
-        self.source_model.set_next_row(model_row_number)
+        self.data_model.set_next_row(model_row_number)
         self.clearSelection()
 
     def _span_cells(
@@ -746,10 +722,11 @@ class PlaylistTab(QTableView):
         if playlist_id != self.playlist_id:
             return
 
-        proxy_model = self.proxy_model
-        edit_index = proxy_model.mapFromSource(self.source_model.createIndex(row, column))
-        row = edit_index.row()
-        column = edit_index.column()
+        model = self.proxy_model
+        if hasattr(model, "mapToSource"):
+            edit_index = model.mapFromSource(self.data_model.createIndex(row, column))
+            row = edit_index.row()
+            column = edit_index.column()
 
         # Don't set spanning if already in place because that is seen as
         # a change to the view and thus it refreshes the data which
@@ -765,5 +742,5 @@ class PlaylistTab(QTableView):
     def _unmark_as_next(self) -> None:
         """Rescan track"""
 
-        self.source_model.set_next_row(None)
+        self.data_model.set_next_row(None)
         self.clear_selection()