from pprint import pprint from typing import Callable, cast, List, Optional, overload, TYPE_CHECKING from PyQt6.QtCore import ( QEvent, QModelIndex, QObject, QItemSelection, Qt, ) from PyQt6.QtGui import QAction, QKeyEvent from PyQt6.QtWidgets import ( QAbstractItemDelegate, QAbstractItemView, QApplication, QHeaderView, QMenu, QMessageBox, QPlainTextEdit, QStyledItemDelegate, QStyleOptionViewItem, QTableView, QTableWidgetItem, QWidget, QProxyStyle, QStyle, QStyleOption, ) from dbconfig import Session from dialogs import TrackSelectDialog from classes import MusicMusterSignals, track_sequence from config import Config from helpers import ( ask_yes_no, ms_to_mmss, show_OK, show_warning, ) from models import Settings if TYPE_CHECKING: from musicmuster import Window from playlistmodel import PlaylistModel, PlaylistProxyModel class EscapeDelegate(QStyledItemDelegate): """ - increases the height of a row when editing to make editing easier - closes the edit on control-return - checks with user before abandoning edit on Escape """ def __init__(self, parent, data_model: PlaylistModel) -> None: super().__init__(parent) self.data_model = data_model self.signals = MusicMusterSignals() def createEditor( self, parent: Optional[QWidget], option: QStyleOptionViewItem, index: QModelIndex, ): """ Intercept createEditor call and make row just a little bit taller """ self.signals = MusicMusterSignals() self.signals.enable_escape_signal.emit(False) if isinstance(self.parent(), PlaylistTab): p = cast(PlaylistTab, self.parent()) if isinstance(index.data(), str): row = index.row() row_height = p.rowHeight(row) p.setRowHeight(row, row_height + Config.MINIMUM_ROW_HEIGHT) return QPlainTextEdit(parent) return super().createEditor(parent, option, index) def destroyEditor(self, editor: Optional[QWidget], index: QModelIndex) -> None: """ Intercept editor destroyment """ self.signals.enable_escape_signal.emit(True) return super().destroyEditor(editor, index) def eventFilter(self, editor: Optional[QObject], event: Optional[QEvent]) -> bool: """By default, QPlainTextEdit doesn't handle enter or return""" if editor is None or event is None: return False if event.type() == QEvent.Type.KeyPress: key_event = cast(QKeyEvent, event) if key_event.key() == Qt.Key.Key_Return: if key_event.modifiers() == (Qt.KeyboardModifier.ControlModifier): self.commitData.emit(editor) self.closeEditor.emit(editor) return True elif key_event.key() == Qt.Key.Key_Escape: discard_edits = QMessageBox.question( cast(QWidget, self.parent()), "Abandon edit", "Discard changes?" ) if discard_edits == QMessageBox.StandardButton.Yes: self.closeEditor.emit(editor) return True return False def setEditorData(self, editor, index): model = index.model() if hasattr(model, "mapToSource"): edit_index = model.mapToSource(index) else: edit_index = index value = self.data_model.data(edit_index, Qt.ItemDataRole.EditRole) editor.setPlainText(value.value()) def setModelData(self, editor, model, index): model = index.model() if hasattr(model, "mapToSource"): edit_index = model.mapToSource(index) else: edit_index = index value = editor.toPlainText().strip() self.data_model.setData(edit_index, value, Qt.ItemDataRole.EditRole) def updateEditorGeometry(self, editor, option, index): editor.setGeometry(option.rect) class PlaylistStyle(QProxyStyle): def drawPrimitive(self, element, option, painter, widget=None): """ Draw a line across the entire row rather than just the column we're hovering over. """ if ( element == QStyle.PrimitiveElement.PE_IndicatorItemViewItemDrop and not option.rect.isNull() ): option_new = QStyleOption(option) option_new.rect.setLeft(0) if widget: option_new.rect.setRight(widget.width()) option = option_new super().drawPrimitive(element, option, painter, widget) class PlaylistTab(QTableView): """ The playlist view """ def __init__( self, musicmuster: "Window", playlist_id: int, ) -> None: super().__init__() # Save passed settings self.musicmuster = musicmuster self.playlist_id = playlist_id # Set up widget 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) self.setDragDropOverwriteMode(False) self.setAcceptDrops(True) # Set our custom style - this draws the drop indicator across the whole row self.setStyle(PlaylistStyle()) # We will enable dragging when rows are selected. Disabling it # here means we can click and drag to select rows. self.setDragEnabled(False) # Prepare for context menu self.menu = QMenu() self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu) self.customContextMenuRequested.connect(self._context_menu) # Connect signals # This dancing is to satisfy mypy h_header = self.horizontalHeader() if isinstance(h_header, QHeaderView): h_header.sectionResized.connect(self._column_resize) h_header.setStretchLastSection(True) # self.signals.set_next_track_signal.connect(self._reset_next) self.signals = MusicMusterSignals() self.signals.resize_rows_signal.connect(self.resizeRowsToContents) self.signals.span_cells_signal.connect(self._span_cells) # Selection model self.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection) self.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows) # Load playlist rows self.setModel(self.proxy_model) self._set_column_widths() # ########## Overrident class functions ########## def closeEditor( self, editor: QWidget | None, hint: QAbstractItemDelegate.EndEditHint ) -> None: """ Override closeEditor to enable play controls and update display. """ self.musicmuster.enable_play_next_controls() self.musicmuster.actionSetNext.setEnabled(True) self.musicmuster.action_Clear_selection.setEnabled(True) super(PlaylistTab, self).closeEditor(editor, hint) # Optimise row heights after increasing row height for editing self.resizeRowsToContents() # Update start times in case a start time in a note has been # edited self.data_model.update_track_times() # Deselect edited line self.clear_selection() def dropEvent(self, event): if event.source() is not self or ( event.dropAction() != Qt.DropAction.MoveAction and self.dragDropMode() != QAbstractItemView.InternalMove ): super().dropEvent(event) from_rows = self.selected_model_row_numbers() to_row = self.indexAt(event.position().toPoint()).row() if ( 0 <= min(from_rows) <= self.model().rowCount() and 0 <= max(from_rows) <= self.model().rowCount() and 0 <= to_row <= self.model().rowCount() ): self.model().move_rows(from_rows, to_row) # Reset drag mode to allow row selection by dragging self.setDragEnabled(False) # Deselect rows self.clear_selection() # Resize rows self.resizeRowsToContents() event.accept() @overload def edit(self, index: QModelIndex) -> None: ... @overload def edit( self, index: QModelIndex, trigger: QAbstractItemView.EditTrigger, event: Optional[QEvent] ) -> bool: ... def edit(self, index, trigger, event): """ Override QAbstractItemView.edit to catch when editing starts Editing only ever starts with a double click on a cell """ # 'result' will only be true on double-click result = super().edit(index, trigger, event) if result: self.musicmuster.disable_play_next_controls() return result def mouseReleaseEvent(self, event): """ Enable dragging if rows are selected """ if self.selectedIndexes(): self.setDragEnabled(True) else: self.setDragEnabled(False) self.reset() super().mouseReleaseEvent(event) def selectionChanged( self, selected: QItemSelection, deselected: QItemSelection ) -> None: """ Toggle drag behaviour according to whether rows are selected """ selected_rows = self.get_selected_rows() # If no rows are selected, we have nothing to do if len(selected_rows) == 0: self.musicmuster.lblSumPlaytime.setText("") else: selected_duration = self.data_model.get_rows_duration( self.get_selected_rows() ) if selected_duration > 0: self.musicmuster.lblSumPlaytime.setText( f"Selected duration: {ms_to_mmss(selected_duration)}" ) else: self.musicmuster.lblSumPlaytime.setText("") super().selectionChanged(selected, deselected) # ########## Custom functions ########## def _add_context_menu( self, text: str, action: Callable, disabled: bool = False, parent_menu: Optional[QMenu] = None, ) -> Optional[QAction]: """ Add item to self.menu """ if parent_menu is None: parent_menu = self.menu menu_item = parent_menu.addAction(text) if not menu_item: return None menu_item.setDisabled(disabled) menu_item.triggered.connect(action) return menu_item def _add_track(self) -> None: """Add a track to a section header making it a normal track row""" model_row_number = self.selected_model_row_number() if model_row_number is None: return with Session() as session: dlg = TrackSelectDialog( session=session, new_row_number=model_row_number, model=self.data_model, add_to_header=True, ) dlg.exec() def _build_context_menu(self, item: QTableWidgetItem) -> None: """Used to process context (right-click) menu, which is defined here""" self.menu.clear() model = self.proxy_model 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 = 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 # Open in Audacity if track_row and not current_row: self._add_context_menu( "Open in Audacity", lambda: model.open_in_audacity(model_row_number) ) # Rescan if track_row and not current_row: self._add_context_menu( "Rescan track", lambda: self._rescan(model_row_number) ) # ---------------------- self.menu.addSeparator() # Delete row if not current_row and not next_row: self._add_context_menu("Delete row", lambda: self._delete_rows()) # Remove track from row if track_row and not current_row and not next_row: self._add_context_menu( "Remove track from row", lambda: model.remove_track(model_row_number) ) # Add track to section header (ie, make this a track row) if header_row: self._add_context_menu("Add a track", lambda: self._add_track()) # # ---------------------- self.menu.addSeparator() # Mark unplayed 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()), ) # Unmark as next if next_row: self._add_context_menu( "Unmark as next track", lambda: self._unmark_as_next() ) # ---------------------- self.menu.addSeparator() # Sort sort_menu = self.menu.addMenu("Sort") self._add_context_menu( "by title", lambda: model.sort_by_title(self.get_selected_rows()), parent_menu=sort_menu, ) self._add_context_menu( "by artist", lambda: model.sort_by_artist(self.get_selected_rows()), parent_menu=sort_menu, ) self._add_context_menu( "by duration", lambda: model.sort_by_duration(self.get_selected_rows()), parent_menu=sort_menu, ) self._add_context_menu( "by last played", lambda: model.sort_by_lastplayed(self.get_selected_rows()), parent_menu=sort_menu, ) # Info if track_row: self._add_context_menu("Info", lambda: self._info_row(model_row_number)) # Track path if track_row: self._add_context_menu( "Copy track path", lambda: self._copy_path(model_row_number) ) def clear_selection(self) -> None: """Unselect all tracks and reset drag mode""" self.clearSelection() self.setDragEnabled(False) def _column_resize(self, column_number: int, _old: int, _new: int) -> None: """ Called when column width changes. Save new width to database. """ header = self.horizontalHeader() if not header: return # Resize rows if necessary self.resizeRowsToContents() with Session() as session: attr_name = f"playlist_col_{column_number}_width" record = Settings.get_int_settings(session, attr_name) record.f_int = self.columnWidth(column_number) def _context_menu(self, pos): """Display right-click menu""" item = self.indexAt(pos) self._build_context_menu(item) self.menu.exec(self.mapToGlobal(pos)) def _copy_path(self, row_number: int) -> None: """ If passed row_number has a track, copy the track path, single-quoted, to the clipboard. Otherwise, return None. """ track_path = self.data_model.get_row_info(row_number).path if not track_path: return replacements = [ ("'", "\\'"), (" ", "\\ "), ("(", "\\("), (")", "\\)"), ] for old, new in replacements: track_path = track_path.replace(old, new) cb = QApplication.clipboard() if cb: cb.clear(mode=cb.Mode.Clipboard) cb.setText(track_path, mode=cb.Mode.Clipboard) def _delete_rows(self) -> None: """ Delete mutliple rows Actions required: - Confirm deletion should go ahead - Pass to model to do the deed """ rows_to_delete = self.get_selected_rows() row_count = len(rows_to_delete) if row_count < 1: return # Get confirmation plural = "s" if row_count > 1 else "" if not ask_yes_no("Delete rows", f"Really delete {row_count} row{plural}?"): return self.data_model.delete_rows(self.selected_model_row_numbers()) self.clear_selection() def get_selected_row_track_path(self) -> str: """ Return the path of the selected row. If no row selected or selected row does not have a track, return empty string. """ model_row_number = self.selected_model_row_number() if model_row_number is None: return "" return self.data_model.get_row_track_path(model_row_number) def get_selected_rows(self) -> List[int]: """Return a list of selected row numbers sorted by row""" # Use a set to deduplicate result (a selected row will have all # items in that row selected) return sorted(list(set([a.row() for a in self.selectedIndexes()]))) def _info_row(self, row_number: int) -> None: """Display popup with info re row""" prd = self.data_model.get_row_info(row_number) if prd: txt = ( f"Title: {prd.title}\n" f"Artist: {prd.artist}\n" f"Track ID: {prd.track_id}\n" f"Track duration: {ms_to_mmss(prd.duration)}\n" f"Track bitrate: {prd.bitrate}\n" "\n\n" f"Path: {prd.path}\n" ) else: txt = f"Can't find info about row{row_number}" show_OK(self.musicmuster, "Track info", txt) def _mark_as_unplayed(self, row_numbers: List[int]) -> None: """Rescan track""" self.data_model.mark_unplayed(row_numbers) self.clear_selection() def _rescan(self, row_number: int) -> None: """Rescan track""" self.data_model.rescan_track(row_number) self.clear_selection() def scroll_to_top(self, row_number: int) -> None: """ Scroll to put passed row_number Config.SCROLL_TOP_MARGIN from the top. """ if row_number is None: return row_index = self.proxy_model.index(row_number, 0) self.scrollTo(row_index, QAbstractItemView.ScrollHint.PositionAtTop) def select_duplicate_rows(self) -> None: """ Select the last of any rows with duplicate tracks in current playlist. This allows the selection to typically come towards the end of the playlist away from any show specific sections. """ # Clear any selected rows to avoid confustion self.clear_selection() # We need to be in MultiSelection mode self.setSelectionMode(QAbstractItemView.SelectionMode.MultiSelection) # Get the 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 selected_model_row_number(self) -> Optional[int]: """ Return the model row number corresponding to the selected row or None """ selected_index = self._selected_row_index() if selected_index is None: return None if hasattr(self.proxy_model, "mapToSource"): return self.proxy_model.mapToSource(selected_index).row() return selected_index.row() def selected_model_row_numbers(self) -> List[int]: """ Return a list of model row numbers corresponding to the selected rows or an empty list. """ selected_indexes = self._selected_row_indexes() if selected_indexes is None: return [] if hasattr(self.proxy_model, "mapToSource"): return [self.proxy_model.mapToSource(a).row() for a in selected_indexes] return [a.row() for a in selected_indexes] def _selected_row_index(self) -> Optional[QModelIndex]: """ Return the selected row index or None if none selected. """ row_indexes = self._selected_row_indexes() if len(row_indexes) > 1: show_warning( self.musicmuster, "Multiple rows selected", "Select only one row" ) return None elif not row_indexes: return None return row_indexes[0] def _selected_row_indexes(self) -> List[QModelIndex]: """ Return a list of indexes of column 1 of selected rows """ sm = self.selectionModel() if sm and sm.hasSelection(): return sm.selectedRows() return [] def _set_column_widths(self) -> None: """Column widths from settings""" header = self.horizontalHeader() if not header: return # Set width of last column to zero as it's set to stretch self.setColumnWidth(header.count() - 1, 0) # Set remaining column widths from settings with Session() as session: for column_number in range(header.count() - 1): 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) def set_row_as_next_track(self) -> None: """ Set selected row as next track """ model_row_number = self.selected_model_row_number() if model_row_number is None: return self.data_model.set_next_row(model_row_number) self.clearSelection() def _span_cells( self, playlist_id: int, row: int, column: int, rowSpan: int, columnSpan: int ) -> None: """ Implement spanning of cells, initiated by signal """ if playlist_id != self.playlist_id: return 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 # again calls us here. if ( self.rowSpan(row, column) == rowSpan and self.columnSpan(row, column) == columnSpan ): return self.setSpan(row, column, rowSpan, columnSpan) def _unmark_as_next(self) -> None: """Rescan track""" <<<<<<< HEAD self.data_model.set_next_row(None) self.clear_selection() ||||||| parent of 705f3ea (Fix bug with unended timed section) # Reorder rows new_order = [a[0] for a in sorted_rows] self.sort_undo = [ new_order.index(x) + min(new_order) for x in range(min(new_order), max(new_order) + 1) ] self._reorder_rows(new_order) # Reset drag mode to allow row selection by dragging self.setDragEnabled(False) # Save playlist with Session() as session: self.save_playlist(session) self._update_start_end_times(session) def _sort_undo(self): """Undo last sort""" if not self.sort_undo: return new_order = self.sort_undo self._reorder_rows(new_order) self.sort_undo = [ new_order.index(x) + min(new_order) for x in range(min(new_order), max(new_order) + 1) ] # Reset drag mode to allow row selection by dragging self.setDragEnabled(False) # Save playlist with Session() as session: self.save_playlist(session) self._update_start_end_times(session) def _unplayed_track_time_between_rows( self, session: scoped_session, from_plr: PlaylistRows, to_plr: PlaylistRows ) -> int: """ Returns the total unplayed duration of all tracks in rows between from_row and to_row inclusive """ plr_tracks = PlaylistRows.get_rows_with_tracks( session, self.playlist_id, from_plr.plr_rownum, to_plr.plr_rownum ) unplayed_time = 0 unplayed_time = sum( [a.track.duration for a in plr_tracks if a.track.duration and not a.played] ) return unplayed_time def _update_row_track_info( self, session: scoped_session, row: int, track: Tracks ) -> None: """ Update the passed row with info from the passed track. """ _ = self._set_row_artist(row, track.artist) _ = self._set_row_bitrate(row, track.bitrate) _ = self._set_row_duration(row, track.duration) _ = self._set_row_end_time(row, None) if track.playdates: last_play = max([a.lastplayed for a in track.playdates]) else: last_play = Config.EPOCH _ = self._set_row_last_played_time(row, last_play) _ = self._set_row_start_gap(row, track.start_gap) _ = self._set_row_start_time(row, None) _ = self._set_row_title(row, track.title) _ = self._set_row_track_id(row, track.id) _ = self._set_row_track_path(row, track.path) if file_is_unreadable(track.path): self._set_row_colour_unreadable(row) def _update_section_headers(self, session: scoped_session) -> None: """ Update section headers with run time of section """ section_start_rows: List[PlaylistRows] = [] subtotal_from: Optional[PlaylistRows] = None active_row: Optional[int] = None active_endtime: Optional[datetime] = None current_row_prlid = self.musicmuster.current_track.plr_id if current_row_prlid: current_row = self._plrid_to_row_number(current_row_prlid) if current_row: active_row = current_row active_end = self.musicmuster.current_track.end_time else: previous_row_plrid = self.musicmuster.previous_track.plr_id if previous_row_plrid: previous_row = self._plrid_to_row_number(previous_row_plrid) if previous_row: active_row = previous_row active_end = self.musicmuster.previous_track.end_time header_rows = [ self._get_row_plr_id(row_number) for row_number in range(self.rowCount()) if self._get_row_track_id(row_number) == 0 ] plrs = PlaylistRows.plrids_to_plrs(session, self.playlist_id, header_rows) for plr in plrs: # Start of timed section if plr.note.endswith("+"): section_start_rows.append(plr) subtotal_from = plr continue # End of timed section elif plr.note.endswith("-"): try: from_plr = section_start_rows.pop() to_plr = plr unplayed_time = self._unplayed_track_time_between_rows( session, from_plr, to_plr ) if ( active_row and active_row >= from_plr.plr_rownum and active_row <= to_plr.plr_rownum ): time_str = self._get_section_timing_string( unplayed_time, active_end ) else: time_str = self._get_section_timing_string(unplayed_time, None) self._set_row_header_text( session, from_plr.plr_rownum, from_plr.note + time_str ) # Update section end if to_plr.note.strip() == "-": new_text = ( "[End " + re.sub( section_header_cleanup_re, "", from_plr.note, ).strip() + "]" ) self._set_row_header_text(session, to_plr.plr_rownum, new_text) subtotal_from = None except IndexError: # This ending row may have a time left from before a # starting row above was deleted, so replace content self._set_row_header_text(session, plr.plr_rownum, plr.note) continue # Subtotal elif plr.note.endswith("="): if not subtotal_from: return from_plr = subtotal_from to_plr = plr unplayed_time = self._unplayed_track_time_between_rows( session, subtotal_from, to_plr ) if ( active_row and active_row >= from_plr.plr_rownum and active_row <= to_plr.plr_rownum ): time_str = self._get_section_timing_string( unplayed_time, active_end ) else: time_str = self._get_section_timing_string(unplayed_time, None) if to_plr.note.strip() == "=": leader_text = "Subtotal: " else: leader_text = to_plr.note[:-1] + " " new_text = leader_text + time_str self._set_row_header_text(session, to_plr.plr_rownum, new_text) subtotal_from = to_plr # If we still have plrs in section_start_rows, there isn't an end # section row for them possible_plr = self._get_row_plr(session, self.rowCount() - 1) if possible_plr: to_plr = possible_plr for from_plr in section_start_rows: unplayed_time = self._unplayed_track_time_between_rows( session, from_plr, to_plr ) time_str = self._get_section_timing_string( total_time, unplayed_time, no_end=True ) self._set_row_header_text( session, from_plr.plr_rownum, from_plr.note + time_str ) def _update_start_end_times(self, session: scoped_session) -> None: """Update track start and end times""" current_track_end_time = self.musicmuster.current_track.end_time current_track_row = self._get_current_track_row_number() current_track_start_time = self.musicmuster.current_track.start_time next_start_time = None next_track_row = self._get_next_track_row_number() played_rows = self._get_played_rows(session) for row_number in range(self.rowCount()): # Don't change start times for tracks that have been # played other than current/next row if row_number in played_rows and row_number not in [ current_track_row, next_track_row, ]: continue # Get any timing from header row (that's all we need) if self._get_row_track_id(row_number) == 0: note_time = self._get_note_text_time(self._get_row_note(row_number)) if note_time: next_start_time = note_time continue # We have a track. Skip if it is unreadable if file_is_unreadable(self._get_row_path(row_number)): continue # Set next track start from end of current track if row_number == next_track_row: if current_track_end_time: next_start_time = self._set_row_times( row_number, current_track_end_time, self._get_row_duration(row_number), ) continue # Else set track times below if row_number == current_track_row: if not current_track_start_time: continue self._set_row_start_time(row_number, current_track_start_time) self._set_row_end_time(row_number, current_track_end_time) # Next track may be above us so only reset # next_start_time if it's not set if not next_start_time: next_start_time = current_track_end_time continue if not next_start_time: # Clear any existing times self._set_row_start_time(row_number, None) self._set_row_end_time(row_number, None) continue # If we're between the current and next row, zero out # times if ( current_track_row and next_track_row and current_track_row < row_number < next_track_row ): self._set_row_start_time(row_number, None) self._set_row_end_time(row_number, None) else: next_start_time = self._set_row_times( row_number, next_start_time, self._get_row_duration(row_number) ) self._update_section_headers(session) ======= # Reorder rows new_order = [a[0] for a in sorted_rows] self.sort_undo = [ new_order.index(x) + min(new_order) for x in range(min(new_order), max(new_order) + 1) ] self._reorder_rows(new_order) # Reset drag mode to allow row selection by dragging self.setDragEnabled(False) # Save playlist with Session() as session: self.save_playlist(session) self._update_start_end_times(session) def _sort_undo(self): """Undo last sort""" if not self.sort_undo: return new_order = self.sort_undo self._reorder_rows(new_order) self.sort_undo = [ new_order.index(x) + min(new_order) for x in range(min(new_order), max(new_order) + 1) ] # Reset drag mode to allow row selection by dragging self.setDragEnabled(False) # Save playlist with Session() as session: self.save_playlist(session) self._update_start_end_times(session) def _unplayed_track_time_between_rows( self, session: scoped_session, from_plr: PlaylistRows, to_plr: PlaylistRows ) -> int: """ Returns the total unplayed duration of all tracks in rows between from_row and to_row inclusive """ plr_tracks = PlaylistRows.get_rows_with_tracks( session, self.playlist_id, from_plr.plr_rownum, to_plr.plr_rownum ) unplayed_time = 0 unplayed_time = sum( [a.track.duration for a in plr_tracks if a.track.duration and not a.played] ) return unplayed_time def _update_row_track_info( self, session: scoped_session, row: int, track: Tracks ) -> None: """ Update the passed row with info from the passed track. """ _ = self._set_row_artist(row, track.artist) _ = self._set_row_bitrate(row, track.bitrate) _ = self._set_row_duration(row, track.duration) _ = self._set_row_end_time(row, None) if track.playdates: last_play = max([a.lastplayed for a in track.playdates]) else: last_play = Config.EPOCH _ = self._set_row_last_played_time(row, last_play) _ = self._set_row_start_gap(row, track.start_gap) _ = self._set_row_start_time(row, None) _ = self._set_row_title(row, track.title) _ = self._set_row_track_id(row, track.id) _ = self._set_row_track_path(row, track.path) if file_is_unreadable(track.path): self._set_row_colour_unreadable(row) def _update_section_headers(self, session: scoped_session) -> None: """ Update section headers with run time of section """ section_start_rows: List[PlaylistRows] = [] subtotal_from: Optional[PlaylistRows] = None active_row: Optional[int] = None active_endtime: Optional[datetime] = None current_row_prlid = self.musicmuster.current_track.plr_id if current_row_prlid: current_row = self._plrid_to_row_number(current_row_prlid) if current_row: active_row = current_row active_end = self.musicmuster.current_track.end_time else: previous_row_plrid = self.musicmuster.previous_track.plr_id if previous_row_plrid: previous_row = self._plrid_to_row_number(previous_row_plrid) if previous_row: active_row = previous_row active_end = self.musicmuster.previous_track.end_time header_rows = [ self._get_row_plr_id(row_number) for row_number in range(self.rowCount()) if self._get_row_track_id(row_number) == 0 ] plrs = PlaylistRows.plrids_to_plrs(session, self.playlist_id, header_rows) for plr in plrs: # Start of timed section if plr.note.endswith("+"): section_start_rows.append(plr) subtotal_from = plr continue # End of timed section elif plr.note.endswith("-"): try: from_plr = section_start_rows.pop() to_plr = plr unplayed_time = self._unplayed_track_time_between_rows( session, from_plr, to_plr ) if ( active_row and active_row >= from_plr.plr_rownum and active_row <= to_plr.plr_rownum ): time_str = self._get_section_timing_string( unplayed_time, active_end ) else: time_str = self._get_section_timing_string(unplayed_time, None) self._set_row_header_text( session, from_plr.plr_rownum, from_plr.note + time_str ) # Update section end if to_plr.note.strip() == "-": new_text = ( "[End " + re.sub( section_header_cleanup_re, "", from_plr.note, ).strip() + "]" ) self._set_row_header_text(session, to_plr.plr_rownum, new_text) subtotal_from = None except IndexError: # This ending row may have a time left from before a # starting row above was deleted, so replace content self._set_row_header_text(session, plr.plr_rownum, plr.note) continue # Subtotal elif plr.note.endswith("="): if not subtotal_from: return from_plr = subtotal_from to_plr = plr unplayed_time = self._unplayed_track_time_between_rows( session, subtotal_from, to_plr ) if ( active_row and active_row >= from_plr.plr_rownum and active_row <= to_plr.plr_rownum ): time_str = self._get_section_timing_string( unplayed_time, active_end ) else: time_str = self._get_section_timing_string(unplayed_time, None) if to_plr.note.strip() == "=": leader_text = "Subtotal: " else: leader_text = to_plr.note[:-1] + " " new_text = leader_text + time_str self._set_row_header_text(session, to_plr.plr_rownum, new_text) subtotal_from = to_plr # If we still have plrs in section_start_rows, there isn't an end # section row for them possible_plr = self._get_row_plr(session, self.rowCount() - 1) if possible_plr: to_plr = possible_plr for from_plr in section_start_rows: unplayed_time = self._unplayed_track_time_between_rows( session, from_plr, to_plr ) time_str = self._get_section_timing_string( unplayed_time, no_end=True ) self._set_row_header_text( session, from_plr.plr_rownum, from_plr.note + time_str ) def _update_start_end_times(self, session: scoped_session) -> None: """Update track start and end times""" current_track_end_time = self.musicmuster.current_track.end_time current_track_row = self._get_current_track_row_number() current_track_start_time = self.musicmuster.current_track.start_time next_start_time = None next_track_row = self._get_next_track_row_number() played_rows = self._get_played_rows(session) for row_number in range(self.rowCount()): # Don't change start times for tracks that have been # played other than current/next row if row_number in played_rows and row_number not in [ current_track_row, next_track_row, ]: continue # Get any timing from header row (that's all we need) if self._get_row_track_id(row_number) == 0: note_time = self._get_note_text_time(self._get_row_note(row_number)) if note_time: next_start_time = note_time continue # We have a track. Skip if it is unreadable if file_is_unreadable(self._get_row_path(row_number)): continue # Set next track start from end of current track if row_number == next_track_row: if current_track_end_time: next_start_time = self._set_row_times( row_number, current_track_end_time, self._get_row_duration(row_number), ) continue # Else set track times below if row_number == current_track_row: if not current_track_start_time: continue self._set_row_start_time(row_number, current_track_start_time) self._set_row_end_time(row_number, current_track_end_time) # Next track may be above us so only reset # next_start_time if it's not set if not next_start_time: next_start_time = current_track_end_time continue if not next_start_time: # Clear any existing times self._set_row_start_time(row_number, None) self._set_row_end_time(row_number, None) continue # If we're between the current and next row, zero out # times if ( current_track_row and next_track_row and current_track_row < row_number < next_track_row ): self._set_row_start_time(row_number, None) self._set_row_end_time(row_number, None) else: next_start_time = self._set_row_times( row_number, next_start_time, self._get_row_duration(row_number) ) self._update_section_headers(session) >>>>>>> 705f3ea (Fix bug with unended timed section)