from collections import namedtuple from typing import List, Optional from PyQt5 import QtCore from PyQt5.QtCore import Qt from PyQt5.QtGui import ( QColor, QFont, QDropEvent ) from PyQt5 import QtWidgets from PyQt5.QtWidgets import ( QAbstractItemView, # QApplication, # QInputDialog, # QLineEdit, QMainWindow, QMenu, # QStyledItemDelegate, QMessageBox, QTableWidget, QTableWidgetItem, ) # import helpers # import os import re import subprocess import threading # from config import Config from datetime import datetime # , timedelta from helpers import ( get_relative_date, open_in_audacity ) from log import log from models import ( Playdates, Playlists, PlaylistRows, Settings, Tracks, NoteColours ) from dbconfig import Session start_time_re = re.compile(r"@\d\d:\d\d:\d\d") class RowMeta: CLEAR = 0 NOTE = 1 UNREADABLE = 2 NEXT = 3 CURRENT = 4 PLAYED = 5 # Columns Column = namedtuple("Column", ['idx', 'heading']) columns = {} columns["userdata"] = Column(idx=0, heading=Config.COLUMN_NAME_AUTOPLAY) columns["start_gap"] = Column( idx=1, heading=Config.COLUMN_NAME_LEADING_SILENCE) columns["title"] = Column(idx=2, heading=Config.COLUMN_NAME_TITLE) columns["artist"] = Column(idx=3, heading=Config.COLUMN_NAME_ARTIST) columns["duration"] = Column(idx=4, heading=Config.COLUMN_NAME_LENGTH) columns["start_time"] = Column(idx=5, heading=Config.COLUMN_NAME_START_TIME) columns["end_time"] = Column(idx=6, heading=Config.COLUMN_NAME_END_TIME) columns["lastplayed"] = Column(idx=7, heading=Config.COLUMN_NAME_LAST_PLAYED) columns["row_notes"] = Column(idx=8, heading=Config.COLUMN_NAME_NOTES) # class NoSelectDelegate(QStyledItemDelegate): # """https://stackoverflow.com/questions/72790705/dont-select-text-in-qtablewidget-cell-when-editing/72792962#72792962""" # # def createEditor(self, parent, option, index): # editor = super().createEditor(parent, option, index) # if isinstance(editor, QLineEdit): # def deselect(): # # Important! First disconnect, otherwise editor.deselect() # # will call again this function # editor.selectionChanged.disconnect(deselect) # editor.deselect() # editor.selectionChanged.connect(deselect) # return editor class PlaylistTab(QTableWidget): # cellEditingStarted = QtCore.pyqtSignal(int, int) # cellEditingEnded = QtCore.pyqtSignal() # Qt.UserRoles ROW_FLAGS = Qt.UserRole ROW_TRACK_ID = Qt.UserRole + 1 ROW_DURATION = Qt.UserRole + 2 PLAYLISTROW_ID = Qt.UserRole + 3 def __init__(self, musicmuster: QMainWindow, session: Session, playlist_id: int, *args, **kwargs) -> None: super().__init__(*args, **kwargs) self.musicmuster: QMainWindow = musicmuster self.playlist_id: int = playlist_id self.menu: Optional[QMenu] = None # self.current_track_start_time: Optional[datetime] = None # # # Don't select text on edit # self.setItemDelegate(NoSelectDelegate(self)) # # Set up widget # self.setEditTriggers(QtWidgets.QAbstractItemView.AllEditTriggers) self.setAlternatingRowColors(True) self.setSelectionMode(QtWidgets.QAbstractItemView.ExtendedSelection) self.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows) self.setVerticalScrollMode(QtWidgets.QAbstractItemView.ScrollPerPixel) self.setRowCount(0) self.setColumnCount(len(columns)) # Header row for idx in [a for a in range(len(columns))]: item: QTableWidgetItem = QTableWidgetItem() self.setHorizontalHeaderItem(idx, item) self.horizontalHeader().setMinimumSectionSize(0) self._set_column_widths(session) # Set column headings sorted by idx self.setHorizontalHeaderLabels( [a.heading for a in list(sorted(columns.values(), key=lambda item: item.idx))] ) self.setAcceptDrops(True) self.viewport().setAcceptDrops(True) self.setDragDropOverwriteMode(False) self.setDropIndicatorShown(True) self.setDragDropMode(QAbstractItemView.InternalMove) self.setDragEnabled(False) # This property defines how the widget shows a context menu self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu) # This signal is emitted when the widget's contextMenuPolicy is # Qt::CustomContextMenu, and the user has requested a context # menu on the widget. self.customContextMenuRequested.connect(self._context_menu) self.viewport().installEventFilter(self) self.itemSelectionChanged.connect(self._select_event) self.row_filter: Optional[str] = None # self.editing_cell: bool = False self.selecting_in_progress = False # Connect signals # self.cellChanged.connect(self._cell_changed) # self.cellClicked.connect(self._edit_note_cell) # self.cellEditingEnded.connect(self._cell_edit_ended) # self.cellEditingStarted.connect(self._cell_edit_started) # self.doubleClicked.connect(self._edit_cell) self.horizontalHeader().sectionResized.connect(self._column_resize) # Now load our tracks and notes self.populate(session, self.playlist_id) def _column_resize(self, idx: int, old: int, new: int) -> None: """ Called when column widths are changed. Save column sizes to database """ with Session() as session: for column_name, data in columns.items(): idx = data.idx width = self.columnWidth(idx) attribute_name = f"playlist_{column_name}_col_width" record = Settings.get_int_settings(session, attribute_name) if record.f_int != self.columnWidth(idx): record.update(session, {'f_int': width}) def __repr__(self) -> str: return f" None: """ Handle drag/drop of rows https://stackoverflow.com/questions/26227885/drag-and-drop-rows-within-qtablewidget """ if not event.source() == self: return # We don't accept external drops drop_row: int = self._drop_on(event) rows: List = sorted(set(item.row() for item in self.selectedItems())) rows_to_move = [ [QTableWidgetItem(self.item(row_index, column_index)) for column_index in range(self.columnCount())] for row_index in rows ] for row_index in reversed(rows): self.removeRow(row_index) if row_index < drop_row: drop_row -= 1 for row_index, data in enumerate(rows_to_move): row_index += drop_row self.insertRow(row_index) for column_index, column_data in enumerate(data): self.setItem(row_index, column_index, column_data) event.accept() # The above doesn't handle column spans, which we use in note # rows. Check and fix: for row in range(drop_row, drop_row + len(rows_to_move)): if not self._get_row_track_id(row): self.setSpan(row, 1, 1, len(columns)) # Scroll to drop zone self.scrollToItem(self.item(row, 1)) # Reset drag mode to allow row selection by dragging self.setDragEnabled(False) super().dropEvent(event) log.debug( "playlist.dropEvent(): " f"Moved row(s) {rows} to become row {drop_row}" ) with Session() as session: # checked self.save_playlist(session) self.update_display(session) # def edit(self, index, trigger, event): # result = super(PlaylistTab, self).edit(index, trigger, event) # if result: # self.cellEditingStarted.emit(index.row(), index.column()) # return result def eventFilter(self, source, event): """Used to process context (right-click) menu, which is defined here""" if (event.type() == QtCore.QEvent.MouseButtonPress and # noqa W504 event.buttons() == QtCore.Qt.RightButton and # noqa W504 source is self.viewport()): item = self.itemAt(event.pos()) if item is not None: row_number = item.row() track_id = self._get_row_track_id(row_number) if track_id: current = row_number == self._get_current_track_row() next_row = row_number == self._get_next_track_row() else: current = next_row = False self.menu = QMenu(self) if track_id: # Info act_info = self.menu.addAction('Info') act_info.triggered.connect( lambda: self._info_row(track_id) ) self.menu.addSeparator() # Play with mplayer 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") with Session() as session: act_setnext.triggered.connect( lambda: self._set_next(session, row_number)) # Open in Audacity if not current: act_audacity = self.menu.addAction( "Open in Audacity") act_audacity.triggered.connect( lambda: self._open_in_audacity(track_id)) # Rescan act_rescan = self.menu.addAction("Rescan") act_rescan.triggered.connect( lambda: self._rescan(row_number, track_id) ) self.menu.addSeparator() # Remove track act_remove_track = self.menu.addAction('Remove track') act_remove_track.triggered.connect( lambda: self._remove_track(row_number) ) else: # Add track to section header (ie, make this a track # row) act_add_track = self.menu.addAction('Add track') act_add_track.triggered.connect(self._add_track) 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() # Remove row act_delete = self.menu.addAction('Remove row') act_delete.triggered.connect(self._delete_rows) return super(PlaylistTab, self).eventFilter(source, event) def mouseReleaseEvent(self, event): """ Enable dragging if rows are selected """ if self.selectedItems(): self.setDragEnabled(True) else: self.setDragEnabled(False) super().mouseReleaseEvent(event) # # ########## Externally called functions ########## def clear_selection(self) -> None: """Unselect all tracks and reset drag mode""" self.clearSelection() self.setDragEnabled(False) # def closeEvent(self, event) -> None: # """Save column widths""" # # log.debug(f"playlists.closeEvent()") # with Session() as session: # for column in range(self.columnCount()): # width = self.columnWidth(column) # name = f"playlist_col_{str(column)}_width" # record = Settings.get_int_settings(session, name) # if record.f_int != self.columnWidth(column): # record.update(session, {'f_int': width}) # # # Record playlist as closed # playlist = Playlists.get_by_id(session, self.playlist_id) # playlist.close(session) # # event.accept() # # def clear_next(self, session) -> None: # """Clear next track""" # # self._meta_clear_next() # self.update_display(session) # # def create_note(self) -> None: # """ # Create note # # If a row is selected, set note row to be row above. Otherwise, # set note row to be end of playlist. # """ # # row: Optional[int] = self.get_selected_row() # if not row: # row = self.rowCount() # # # Get note text # dlg: QInputDialog = QInputDialog(self) # dlg.setInputMode(QInputDialog.TextInput) # dlg.setLabelText("Note:") # dlg.resize(500, 100) # ok: int = dlg.exec() # if ok: # with Session() as session: # note: Notes = Notes( # session, self.playlist_id, row, dlg.textValue()) # self._insert_note(session, note, row, True) # checked # # def get_selected_row(self) -> Optional[int]: # """Return row number of first selected row, or None if none selected""" # # if not self.selectionModel().hasSelection(): # return None # else: # return self.selectionModel().selectedRows()[0].row() # # def get_selected_rows(self) -> List[int]: # """Return a sorted list of selected row numbers""" # # rows = self.selectionModel().selectedRows() # return sorted([row.row() for row in rows]) # # def get_selected_title(self) -> Optional[str]: # """Return title of selected row or None""" # # if self.selectionModel().hasSelection(): # row = self.currentRow() # return self.item(row, self.COL_TITLE).text() # else: # return None def insert_row(self, session: Session, row_data: PlaylistRows, repaint: bool = True) -> None: """ Insert a row into playlist tab. If playlist has a row selected, add new row above. Otherwise, add to end of playlist. Note: we ignore the row number in the PlaylistRows record. That is used only to order the query that generates the records. """ if self.selectionModel().hasSelection(): row = self.currentRow() else: row = self.rowCount() self.insertRow(row) # Add row metadata to userdata column userdata_item = QTableWidgetItem() userdata_item.setData(self.ROW_FLAGS, 0) userdata_item.setData(self.PLAYLISTROW_ID, row_data.id) userdata_item.setData(self.ROW_TRACK_ID, row_data.track_id) self.setItem(row, columns['userdata'].idx, userdata_item) if row_data.track_id: # Add track details to items start_gap = row_data.track.start_gap start_gap_item = QTableWidgetItem(str(start_gap)) if start_gap and start_gap >= 500: start_gap_item.setBackground(QColor(Config.COLOUR_LONG_START)) self.setItem(row, columns['start_gap'].idx, start_gap_item) title_item = QTableWidgetItem(row_data.track.title) self.setItem(row, columns['title'].idx, title_item) artist_item = QTableWidgetItem(row_data.track.artist) self.setItem(row, columns['artist'].idx, artist_item) duration_item = QTableWidgetItem( helpers.ms_to_mmss(row_data.track.duration)) self.setItem(row, columns['duration'].idx, duration_item) self._set_row_duration(row, row_data.track.duration) start_item = QTableWidgetItem() self.setItem(row, columns['start_time'].idx, start_item) end_item = QTableWidgetItem() self.setItem(row, columns['end_time'].idx, end_item) # As we have track info, any notes should be contained in # the notes column notes_item = QTableWidgetItem(row_data.note) self.setItem(row, columns['row_notes'].idx, notes_item) last_playtime = Playdates.last_played(session, row_data.track.id) last_played_str = get_relative_date(last_playtime) last_played_item = QTableWidgetItem(last_played_str) self.setItem(row, columns['lastplayed'].idx, last_played_item) # Mark track if file is unreadable if not helpers.file_is_readable(row_data.track.path): self._set_unreadable_row(row) else: # This is a section header so make empty items (row # background won't be coloured without items present). Any # notes should displayed starting in column 0 for i in range(2, len(columns) - 1): self.setItem(row, i, QTableWidgetItem()) notes_item = QTableWidgetItem(row_data.note) self.setItem(row, 1, notes_item) self.setSpan(row, 1, 1, len(columns)) # Save (no) track_id userdata_item.setData(self.ROW_TRACK_ID, 0) if repaint: self.save_playlist(session) self.update_display(session, clear_selection=False) # # def insert_track(self, session: Session, track: Tracks, # repaint: bool = True) -> None: # """ # Insert track into playlist tab. # # If a row is selected, add track above. Otherwise, add to end of # playlist. # """ # # if self.selectionModel().hasSelection(): # row = self.currentRow() # else: # row = self.rowCount() # log.debug( # f"playlists.insert_track({session=}, {track=}, {repaint=}), " # f"{row=}" # ) # # self.insertRow(row) # # # Put an item in COL_USERDATA for later # item: QTableWidgetItem = QTableWidgetItem() # # Add row metadata # item.setData(self.ROW_FLAGS, 0) # self.setItem(row, self.COL_USERDATA, item) # # # Add track details to columns # mss_item: QTableWidgetItem = QTableWidgetItem(str(track.start_gap)) # if track.start_gap and track.start_gap >= 500: # mss_item.setBackground(QColor(Config.COLOUR_LONG_START)) # self.setItem(row, self.COL_MSS, mss_item) # # title_item: QTableWidgetItem = QTableWidgetItem(track.title) # self.setItem(row, self.COL_TITLE, title_item) # # artist_item: QTableWidgetItem = QTableWidgetItem(track.artist) # self.setItem(row, self.COL_ARTIST, artist_item) # # duration_item: QTableWidgetItem = QTableWidgetItem( # helpers.ms_to_mmss(track.duration) # ) # self._set_row_duration(row, track.duration) # self.setItem(row, self.COL_DURATION, duration_item) # # last_playtime: Optional[datetime] = Playdates.last_played( # session, track.id) # last_played_str: str = get_relative_date(last_playtime) # last_played_item: QTableWidgetItem = QTableWidgetItem(last_played_str) # self.setItem(row, self.COL_LAST_PLAYED, last_played_item) # # row_note: Optional[str] = "Play text" # row_note_item: QTableWidgetItem = QTableWidgetItem(row_note) # self.setItem(row, self.COL_ROW_NOTES, row_note_item) # # # Add empty start and stop time because background # # colour won't be set for columns without items # start_item: QTableWidgetItem = QTableWidgetItem() # self.setItem(row, self.COL_START_TIME, start_item) # stop_item: QTableWidgetItem = QTableWidgetItem() # self.setItem(row, self.COL_END_TIME, stop_item) # # # Attach track.id object to row # self._set_row_content(row, track.id) # # # Mark track if file is unreadable # if not helpers.file_is_readable(track.path): # self._set_unreadable_row(row) # # Scroll to new row # self.scrollToItem(title_item, QAbstractItemView.PositionAtCenter) # # if repaint: # self.save_playlist(session) # self.update_display(session, clear_selection=False) # # def move_selected_to_playlist(self, session: Session, playlist_id: int) \ # -> None: # """ # Move selected rows and any immediately preceding notes to # other playlist # """ # # notes_rows = self._get_notes_rows() # destination_row = Playlists.next_free_row(session, playlist_id) # rows_to_remove = [] # # for row in self.get_selected_rows(): # if row in notes_rows: # note_obj = self._get_row_notes_object(row, session) # note_obj.move_row(session, destination_row, playlist_id) # else: # # For tracks, check for a preceding notes row and move # # that as well if it exists # if row - 1 in notes_rows: # note_obj = self._get_row_notes_object(row - 1, session) # note_obj.move_row(session, destination_row, playlist_id) # destination_row += 1 # rows_to_remove.append(row - 1) # # Move track # PlaylistTracks.move_row( # session, row, self.playlist_id, # destination_row, playlist_id # ) # destination_row += 1 # rows_to_remove.append(row) # # # Remove rows. Row number will change as we delete rows so # # remove them in reverse order. # # try: # self.selecting_in_progress = True # for row in sorted(rows_to_remove, reverse=True): # self.removeRow(row) # finally: # self.selecting_in_progress = False # self._select_event() # # self.save_playlist(session) # self.update_display(session) # # def play_started(self, session: Session) -> None: # """ # Notification from musicmuster that track has started playing. # # Actions required: # - Note start time # - Mark next-track row as current # - Mark current row as played # - Scroll to put current track as required # - Set next track # - Update display # """ # # # Note start time # self.current_track_start_time = datetime.now() # # # Mark next-track row as current # current_row = self._get_next_track_row() # if current_row is None: # return # self._set_current_track_row(current_row) # # # Mark current row as played # self._set_played_row(current_row) # # # Scroll to put current track as requiredin middle We want this # # row to be Config.SCROLL_TOP_MARGIN from the top. Rows number # # from zero, so set (current_row - Config.SCROLL_TOP_MARGIN + 1) # # row to be top row # # top_row = max(0, current_row - Config.SCROLL_TOP_MARGIN + 1) # scroll_item = self.item(top_row, self.COL_MSS) # self.scrollToItem(scroll_item, QAbstractItemView.PositionAtTop) # # # Set next track # search_from = current_row + 1 # next_row = self._find_next_track_row(search_from) # if next_row: # self._set_next(session, next_row) # # # Update display # self.update_display(session) # # def play_stopped(self) -> None: # """ # Notification from musicmuster that track has ended. # # Actions required: # - Remove current track marker # - Reset current track start time # - Update display # """ # # self._clear_current_track_row() # self.current_track_start_time = None def populate(self, session: Session, playlist_id: int) -> None: """ Populate from the associated playlist ID """ # data: List[Union[Tuple[List[int], Tracks], Tuple[List[int], Notes]]] \ # = [] # item: Union[Notes, Tracks] # note: Notes # row: int # track: Tracks playlist = session.get(Playlists, playlist_id) # Clear playlist self.setRowCount(0) # Add the rows for row in playlist.rows: self.insert_row(session, row, repaint=False) # Scroll to top scroll_to: QTableWidgetItem = self.item(0, 0) self.scrollToItem(scroll_to, QAbstractItemView.PositionAtTop) # We possibly don't need to save the playlist here, but row # numbers may have changed during population, and it's cheap to do # KAE self.save_playlist(session) self.update_display(session) def save_playlist(self, session: Session) -> None: """ Save playlist to database """ # Iteratate through playlist and check that the row in each # playlist_row object is correct for row in range(self.rowCount()): plr = session.get(PlaylistRows, self._get_playlistrow_id(row)) # Set the row number (even if it's already correct) if plr.row_number != row: log.debug( f"Updating PlaylistRow: {plr.row_number=}, {row=}" ) plr.row_number = row # Any rows in the database with a row_number higher that the # current value of 'row' should not be there. Commit session # first to ensure any changes made above are committed. session.commit() PlaylistRows.delete_higher_rows(session, self.playlist_id, row) # def save_playlist(self, session) -> None: # """ # Save playlist to database. # # For notes: check the database entry is correct and update it if # necessary. Playlists:Note is one:many, so each note may only appear # in one playlist. # # For tracks: erase the playlist tracks and recreate. This is much # simpler than trying to implement any Playlists:Tracks many:many # changes. # """ # # playlist = Playlists.get_by_id(session, self.playlist_id) # # # Notes first # # Create dictionaries indexed by note_id # playlist_notes: Dict[int, Notes] = {} # database_notes: Dict[int, Notes] = {} # notes_rows: List[int] = self._get_notes_rows() # # # PlaylistTab # for row in notes_rows: # note: Notes = self._get_row_notes_object(row, session) # session.add(note) # playlist_notes[note.id] = note # if row != note.row: # log.debug(f"Updating: {playlist.name=}, {row=}, {note.row=}") # note.update(session=session, row=row) # # # Database # for note in playlist.notes: # database_notes[note.id] = note # # # We don't need to check for notes to add to the database as # # they can't exist in the playlist without being in the database # # and pointing at this playlist. # # # Notes to remove from database # for note_id in set(database_notes.keys()) - set(playlist_notes.keys()): # log.debug( # "_save_playlist(): " # f"Delete {note_id=} from {self=} in database" # ) # database_notes[note_id].delete_note(session) # # # Note rows to update in playlist database # for note_id in set(playlist_notes.keys()) & set(database_notes.keys()): # if playlist_notes[note_id].row != database_notes[note_id].row: # log.debug( # f"_save_playlist(): Update notes row in database " # f"from {database_notes[note_id]=} " # f"to {playlist_notes[note_id]=}" # ) # database_notes[note_id].update( # session, row=playlist_notes[note_id].row) # # # Tracks # # Remove all tracks from this playlist # playlist.remove_all_tracks(session) # # Iterate on-screen playlist and add tracks back in # for row in range(self.rowCount()): # if row in notes_rows: # continue # track_id: int = self.item( # row, self.COL_USERDATA).data(self.CONTENT_OBJECT) # playlist.add_track(session, track_id, row) # session.commit() # # def select_next_row(self) -> None: # """ # Select next or first row. Don't select notes. Wrap at last row. # """ # # row: int # selected_rows: List[int] # # selected_rows = [row for row in # set([a.row() for a in self.selectedItems()])] # # we will only handle zero or one selected rows # if len(selected_rows) > 1: # return # # select first row if none selected # if len(selected_rows) == 0: # row = 0 # else: # row = selected_rows[0] + 1 # if row >= self.rowCount(): # row = 0 # # # Don't select notes # wrapped: bool = False # while row in self._get_notes_rows(): # row += 1 # if row >= self.rowCount(): # if wrapped: # # we're already wrapped once, so there are no # # non-notes # return # row = 0 # wrapped = True # # self.selectRow(row) # # def select_played_tracks(self) -> None: # """Select all played tracks in playlist""" # # try: # self.selecting_in_progress = True # self._select_tracks(played=True) # finally: # self.selecting_in_progress = False # self._select_event() # # def select_previous_row(self) -> None: # """ # Select previous or last track. Don't select notes. Wrap at first row. # """ # # row: int # selected_rows: List[int] # # selected_rows = [row for row in # set([a.row() for a in self.selectedItems()])] # # we will only handle zero or one selected rows # if len(selected_rows) > 1: # return # # select last row if none selected # last_row: int = self.rowCount() - 1 # if len(selected_rows) == 0: # row = last_row # else: # row = selected_rows[0] - 1 # if row < 0: # row = last_row # # # Don't select notes # wrapped: bool = False # while row in self._get_notes_rows(): # row -= 1 # if row < 0: # if wrapped: # # we're already wrapped once, so there are no # # non-notes # return # row = last_row # wrapped = True # # self.selectRow(row) # # def select_unplayed_tracks(self) -> None: # """Select all unplayed tracks in playlist""" # # try: # self.selecting_in_progress = True # self._select_tracks(played=False) # finally: # self.selecting_in_progress = False # self._select_event() # # def set_filter(self, text: Optional[str]) -> None: # """Filter rows to only show those containing text""" # # self.row_filter = text # with Session() as session: # self.update_display(session) # # def set_selected_as_next(self) -> None: # """Sets the select track as next to play""" # # row = self.get_selected_row() # if row is None: # return None # # with Session() as session: # self._set_next(session, row) def update_display(self, session, clear_selection: bool = True) -> None: """ Set row colours, fonts, etc Actions required: - Clear selection if required - Render notes in correct colour - Render current, next and unplayable tracks in correct colour - Set start and end times - Show unplayed tracks in bold """ # Clear selection if required if clear_selection: self.clear_selection() current_row: Optional[int] = self._get_current_track_row() next_row: Optional[int] = self._get_next_track_row() played: Optional[List[int]] = self._get_played_track_rows() unreadable: List[int] = self._get_unreadable_track_rows() if self.row_filter: filter_text = self.row_filter.lower() else: filter_text = None next_start_time = None section_start_row = None section_time = 0 # Start time calculations # Don't change start times for tracks that have been played. # For unplayed tracks, if there's a 'current' or 'next' # track marked, populate start times from then onwards. A note # with a start time will reset the next track start time. # Cycle through all rows for row in range(self.rowCount()): # Extract note text from database to ignore section timings playlist_row = session.get(PlaylistRows, self._get_playlistrow_id(row)) note_text = playlist_row.note # Get note colour note_colour = NoteColours.get_colour(session, note_text) if not note_colour: note_colour = Config.COLOUR_NOTES_PLAYLIST # Get track if there is one track_id = self._get_row_track_id(row) track = None if track_id: track = session.get(Tracks, track_id) if track: # Render unplayable tracks in correct colour if not helpers.file_is_readable(track.path): self._set_row_colour(row, QColor(Config.COLOUR_UNREADABLE)) self._set_row_bold(row) continue # Add track time to section time if in timed section if section_start_row is not None: section_time += track.duration # If filtering, only show matching tracks if filter_text: try: if (track.title and filter_text not in track.title.lower() and track.artist and filter_text not in track.artist.lower()): self.hideRow(row) continue else: self.showRow(row) except TypeError: print(f"TypeError: {track=}") else: self.showRow(row) # Colour any note if note_text: (self.item(row, columns['row_notes'].idx) .setBackground(QColor(note_colour))) # Render playing track if row == current_row: # Set start time self._set_row_start_time( row, self.current_track_start_time) # Set last played time to "Today" self.item(row, self.COL_LAST_PLAYED).setText("Today") # Calculate next_start_time next_start_time = self._calculate_end_time( self.current_track_start_time, track.duration) # Set end time self._set_row_end_time(row, next_start_time) # Set colour self._set_row_colour(row, QColor( Config.COLOUR_CURRENT_PLAYLIST)) # Make bold self._set_row_bold(row) continue # Render next track if row == next_row: # Set start time # if there's a track playing, set start time from that if current_row is not None: start_time = self._calculate_end_time( self.current_track_start_time, track.duration) else: # No current track to base from, but don't change # time if it's already set start_time = self._get_row_start_time(row) if not start_time: start_time = next_start_time self._set_row_start_time(row, start_time) # Calculate next_start_time next_start_time = self._calculate_end_time(start_time, track.duration) # Set end time self._set_row_end_time(row, next_start_time) # Set colour self._set_row_colour( row, QColor(Config.COLOUR_NEXT_PLAYLIST)) # Make bold self._set_row_bold(row) continue # This is a track row other than next or current if row in played: # Played today, so update last played column last_playedtime = track.lastplayed last_played_str = get_relative_date(last_playedtime) self.item(row, self.COL_LAST_PLAYED).setText( last_played_str) if self.musicmuster.hide_played_tracks: self.hideRow(row) else: self._set_row_not_bold(row) else: # Set start/end times as we haven't played it yet if next_start_time: self._set_row_start_time(row, next_start_time) next_start_time = self._calculate_end_time( next_start_time, track.duration) # Set end time self._set_row_end_time(row, next_start_time) else: # Clear start and end time self._set_row_start_time(row, None) self._set_row_end_time(row, None) # Don't dim unplayed tracks self._set_row_bold(row) continue # No track associated, so this row is a section header if filter_text: if filter_text not in note_text.lower(): self.hideRow(row) continue else: self.showRow(row) else: self.showRow(row) # Does the note have a start time? row_time = self._get_note_text_time(note_text) if row_time: next_start_time = row_time # Does it delimit a section? if section_start_row is not None: if note_text.endswith("-"): self._set_timed_section(session, section_start_row, section_time) section_start_row = None section_time = 0 elif note_text.endswith("+"): section_start_row = row section_time = 0 self._set_row_colour( row, QColor(note_colour) ) # Section headers are always bold self._set_row_bold(row) continue # Have we had a section start but not end? if section_start_row is not None: self._set_timed_section( session, section_start_row, section_time, no_end=True) # # # ########## Internally called functions ########## def _add_track(self, row: int) -> None: """Add a track to a section header making it a normal track row""" print("playlists._add_track() not yet implemented") def _open_in_audacity(self, track_id: int) -> None: """Open track in Audacity. Audacity must be already running""" with Session() as session: track = session.get(Tracks, track_id) if not track: log.error( f"playlists._open_in_audacity({track_id=}): " "Track not found" ) return open_in_audacity(track.path) def _calculate_end_time(self, start: Optional[datetime], duration: int) -> Optional[datetime]: """Return datetime 'duration' ms after 'start'""" if start is None: return None return start + timedelta(milliseconds=duration) def _context_menu(self, pos): assert self.menu self.menu.exec_(self.mapToGlobal(pos)) # # def _copy_path(self, row: int) -> None: # """ # If passed row is track row, copy the track path to the clipboard. # Otherwise, return None. # """ # # log.debug(f"_copy_path({row})") # # if row in self._get_notes_rows(): # return None # # with Session() as session: # track: Optional[Tracks] = self._get_row_track_object(row, session) # if track: # cb = QApplication.clipboard() # cb.clear(mode=cb.Clipboard) # cb.setText(track.path, mode=cb.Clipboard) # # def _cell_changed(self, row: int, column: int) -> None: # """Called when cell content has changed""" # # if not self.editing_cell: # return # if column not in [self.COL_TITLE, self.COL_ARTIST]: # return # # new_text: str = self.item(row, column).text() # log.debug(f"_cell_changed({row=}, {column=}, {new_text=}") # # with Session() as session: # if row in self._get_notes_rows(): # # Save change to database # note: Notes = self._get_row_notes_object(row, session) # note.update(session, row, new_text) # # Set/clear row start time accordingly # start_time = self._get_note_text_time(new_text) # if start_time: # self._set_row_start_time(row, start_time) # log.debug( # f"_cell_changed:Note {new_text} contains valid " # f"{start_time=}" # ) # else: # # Reset row start time in case it used to have one # self._set_row_start_time(row, None) # log.debug( # f"_cell_changed:Note {new_text} does not contain " # "start time" # ) # else: # track: Tracks = self._get_row_track_object(row, session) # if column == self.COL_ARTIST: # track.update_artist(session, artist=new_text) # elif column == self.COL_TITLE: # track.update_title(session, title=new_text) # else: # log.error("_cell_changed(): unrecognised column") # # def _cell_edit_ended(self) -> None: # """Called when cell edit ends""" # # log.debug("_cell_edit_ended()") # # self.editing_cell = False # # # update_display to update start times, such as when a note has # # been edited # with Session() as session: # self.update_display(session) # # self.musicmuster.enable_play_next_controls() # # def _cell_edit_started(self, row: int, column: int) -> None: # """ # Called when cell editing started. Disable play controls so # that keys work during edit. # """ # # log.debug(f"_cell_edit_started({row=}, {column=})") # # self.editing_cell = True # # Disable play controls so that keyboard input doesn't disturb playing # self.musicmuster.disable_play_next_controls() # # # If this is a note cell and it's a section start, we need to # # remove any existing section timing so user can't edit that. # # Section timing is only in display of item, not in note text in # # database. Keep it simple: if this is a note, pull text from # # database. # # if self._is_note_row(row): # item = self.item(row, self.COL_TITLE) # with Session() as session: # note_object = self._get_row_notes_object(row, session) # if note_object: # item.setText(note_object.note) # return # # def _clear_current_track_row(self) -> None: # """ # Clear current row if there is one. # """ # # current_row: Optional[int] = self._get_current_track_row() # if current_row is not None: # self._meta_clear_attribute(current_row, RowMeta.CURRENT) # # Reset row colour # if current_row % 2: # self._set_row_colour( # current_row, QColor(Config.COLOUR_ODD_PLAYLIST)) # else: # self._set_row_colour( # current_row, QColor(Config.COLOUR_EVEN_PLAYLIST)) # # def _clear_played_row_status(self, row: int) -> None: # """Clear played status on row""" # # self._meta_clear_attribute(row, RowMeta.PLAYED) def _delete_rows(self) -> None: """Delete mutliple rows""" # ***KAE pass # log.debug("playlist._delete_rows()") # # selected_rows: List[int] = sorted( # set(item.row() for item in self.selectedItems()) # ) # rows_to_delete: List[int] = [] # note_rows: Optional[List[int]] = self._get_notes_rows() # row: int # row_object: Union[Tracks, Notes] # # with Session() as session: # for row in selected_rows: # title = self.item(row, self.COL_TITLE).text() # msg = QMessageBox(self) # msg.setIcon(QMessageBox.Warning) # msg.setText(f"Delete '{title}'?") # msg.setStandardButtons( # QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel # ) # msg.setDefaultButton(QMessageBox.No) # msg.setWindowTitle("Delete row") # # Store list of rows to delete # response = msg.exec() # if response == QMessageBox.Yes: # rows_to_delete.append(row) # elif response == QMessageBox.Cancel: # return # # # delete in reverse row order so row numbers don't # # change # playlist = Playlists.get_by_id(session, self.playlist_id) # for row in sorted(rows_to_delete, reverse=True): # if row in note_rows: # note: Notes = self._get_row_notes_object(row, session) # note.delete_note(session) # else: # playlist.remove_track(session, row) # self.removeRow(row) # # self.save_playlist(session) # self.update_display(session) def _drop_on(self, event): """ https://stackoverflow.com/questions/26227885/drag-and-drop-rows-within-qtablewidget """ index = self.indexAt(event.pos()) if not index.isValid(): return self.rowCount() return (index.row() + 1 if self._is_below(event.pos(), index) else index.row()) # def _edit_note_cell(self, row, column): # review # """Called when table is single-clicked""" # # if column in [self.COL_ROW_NOTES]: # item = self.item(row, column) # self.editItem(item) # # def _edit_cell(self, mi): # review # """Called when table is double-clicked""" # # row = mi.row() # column = mi.column() # item = self.item(row, column) # # if column in [self.COL_TITLE, self.COL_ARTIST]: # self.editItem(item) # # def _get_notes_rows(self) -> List[int]: # """Return rows marked as notes, or None""" # # return self._meta_search(RowMeta.NOTE, one=False) # def _get_playlistrow_id(self, row: int) -> int: """Return the playlistrow_id associated with this row""" playlistrow_id = (self.item(row, columns['userdata'].idx) .data(self.PLAYLISTROW_ID)) return playlistrow_id def _get_row_track_id(self, row: int) -> int: """Return the track_id associated with this row or None""" track_id = (self.item(row, columns['userdata'].idx) .data(self.ROW_TRACK_ID)) return track_id # def _find_next_track_row(self, starting_row: int = None) -> Optional[int]: # """ # Find next track to play. If a starting row is given, start there; # else if there's a track selected, start looking from next track; # otherwise, start from top. Skip rows already played. # # If not found, return None. # # If found, return row number. # """ # # if starting_row is None: # current_row = self._get_current_track_row() # if current_row is not None: # starting_row = current_row + 1 # else: # starting_row = 0 # notes_rows = self._get_notes_rows() # played_rows = self._get_played_track_rows() # for row in range(starting_row, self.rowCount()): # if row in notes_rows or row in played_rows: # continue # else: # return row # # return None def _get_current_track_row(self) -> Optional[int]: """Return row marked as current, or None""" row = self._meta_search(RowMeta.CURRENT) if len(row) > 0: return row[0] else: return None def _get_next_track_row(self) -> Optional[int]: """Return row marked as next, or None""" row = self._meta_search(RowMeta.NEXT) if len(row) > 0: return row[0] else: return None @staticmethod def _get_note_text_time(text: str) -> Optional[datetime]: """Return time specified as @hh:mm:ss in text""" match = start_time_re.search(text) if not match: return None try: return datetime.strptime(match.group(0)[1:], Config.NOTE_TIME_FORMAT) except ValueError: return None def _get_played_track_rows(self) -> List[int]: """Return rows marked as played, or None""" return self._meta_search(RowMeta.PLAYED, one=False) def _get_row_duration(self, row: int) -> int: """Return duration associated with this row""" duration = (self.item(row, columns['userdata'].idx) .data(self.ROW_DURATION)) if duration: return duration else: return 0 # # def _get_row_end_time(self, row) -> Optional[datetime]: # """ # Return row end time as string # """ # # try: # if self.item(row, self.COL_END_TIME): # return datetime.strptime(self.item( # row, self.COL_END_TIME).text(), # Config.NOTE_TIME_FORMAT # ) # else: # return None # except ValueError: # return None # # def _get_row_notes_object(self, row: int, session: Session) \ # -> Optional[Notes]: # """Return note associated with this row""" # # note_id = self.item(row, self.COL_USERDATA).data(self.CONTENT_OBJECT) # note = Notes.get_by_id(session, note_id) # return note # # def _get_unplayed_track_rows(self) -> Optional[List[int]]: # """Return rows marked as unplayed, or None""" # # unplayed_rows: Set[int] = set(self._meta_notset(RowMeta.PLAYED)) # notes_rows: Set[int] = set(self._get_notes_rows()) # # return list(unplayed_rows - notes_rows) def _get_row_start_time(self, row: int) -> Optional[datetime]: try: if self.item(row, columns['start_time'].idx): return datetime.strptime(self.item( row, columns['start_time'].idx).text(), Config.NOTE_TIME_FORMAT ) else: return None except ValueError: return None # # def _get_row_track_object(self, row: int, session: Session) \ # -> Optional[Tracks]: # """Return track associated with this row""" # # track_id = self.item(row, self.COL_USERDATA).data(self.CONTENT_OBJECT) # track = Tracks.get_by_id(session, track_id) # return track # # def _get_track_rows(self) -> List[int]: # """Return rows marked as tracks, or None""" # # return self._meta_notset(RowMeta.NOTE) def _get_unreadable_track_rows(self) -> List[int]: """Return rows marked as unreadable, or None""" return self._meta_search(RowMeta.UNREADABLE, one=False) def _info_row(self, track_id: int) -> None: """Display popup with info re row""" with Session() as session: track = session.get(Tracks, track_id) if track: txt = ( f"Title: {track.title}\n" f"Artist: {track.artist}\n" f"Track ID: {track.id}\n" f"Track duration: {helpers.ms_to_mmss(track.duration)}\n" f"Track fade at: {helpers.ms_to_mmss(track.fade_at)}\n" f"Track silence at: {helpers.ms_to_mmss(track.silence_at)}" "\n\n" f"Path: {track.path}\n" ) else: txt = f"Can't find {track_id=}" info: QMessageBox = QMessageBox(self) info.setIcon(QMessageBox.Information) info.setText(txt) info.setStandardButtons(QMessageBox.Ok) info.setDefaultButton(QMessageBox.Cancel) info.exec() # # def _insert_note(self, session: Session, note: Notes, # row: Optional[int] = None, repaint: bool = True) -> None: # """ # Insert a note to playlist tab. # # If a row is given, add note above. Otherwise, add to end of # playlist. # """ # # if row is None: # row = self.rowCount() # log.debug(f"playlist.inset_note(): row={row}") # # self.insertRow(row) # # # Add empty items to unused columns because # # colour won't be set for columns without items # item: QTableWidgetItem = QTableWidgetItem() # self.setItem(row, self.COL_USERDATA, item) # item = QTableWidgetItem() # self.setItem(row, self.COL_MSS, item) # # # Add text of note from title column onwards # titleitem: QTableWidgetItem = QTableWidgetItem(note.note) # self.setItem(row, self.COL_NOTE, titleitem) # self.setSpan(row, self.COL_NOTE, self.NOTE_ROW_SPAN, # self.NOTE_COL_SPAN) # # # Attach note id to row # self._set_row_content(row, note.id) # # # Mark row as a Note row # self._set_note_row(row) # # # Scroll to new row # self.scrollToItem(titleitem, QAbstractItemView.PositionAtCenter) # # if repaint: # self.save_playlist(session) # self.update_display(session, clear_selection=False) def _is_below(self, pos, index): # review """ https://stackoverflow.com/questions/26227885/drag-and-drop-rows-within-qtablewidget """ rect = self.visualRect(index) margin = 2 if pos.y() - rect.top() < margin: return False elif rect.bottom() - pos.y() < margin: return True return ( rect.contains(pos, True) and not (int(self.model().flags(index)) & Qt.ItemIsDropEnabled) and pos.y() >= rect.center().y() # noqa W503 ) # def _is_note_row(self, row: int) -> bool: # """ # Return True if passed row is a note row, else False # """ # # if self._meta_get(row): # if self._meta_get(row) & (1 << RowMeta.NOTE): # return True # return False # # def _meta_clear_attribute(self, row: int, attribute: int) -> None: # """Clear given metadata for row""" # # if row is None: # raise ValueError(f"_meta_clear_attribute({row=}, {attribute=})") # # new_metadata: int = self._meta_get(row) & ~(1 << attribute) # self.item(row, self.COL_USERDATA).setData( # self.ROW_FLAGS, new_metadata) def _meta_clear_next(self) -> None: """ Clear next row if there is one. """ next_row: Optional[int] = self._get_next_track_row() if next_row is not None: self._meta_clear_attribute(next_row, RowMeta.NEXT) def _meta_get(self, row: int) -> int: """Return row metadata""" return (self.item(row, columns['userdata'].idx) .data(self.ROW_FLAGS)) # # def _meta_notset(self, metadata: int) -> List[int]: # """ # Search rows for metadata not set. # # Return a list of matching row numbers. # """ # # matches = [] # for row in range(self.rowCount()): # row_meta = self._meta_get(row) # if row_meta is not None: # if not self._meta_get(row) & (1 << metadata): # matches.append(row) # # return matches def _meta_search(self, metadata: int, one: bool = True) -> List[int]: """ Search rows for metadata. If one is True, check that only one row matches and return the row number. If one is False, return a list of matching row numbers. """ matches = [] for row in range(self.rowCount()): if self._meta_get(row): if self._meta_get(row) & (1 << metadata): matches.append(row) if not one: return matches if len(matches) <= 1: return matches else: log.error( f"Multiple matches for metadata '{metadata}' found " f"in rows: {', '.join([str(x) for x in matches])}" ) raise AttributeError(f"Multiple '{metadata}' metadata {matches}") def _meta_set_attribute(self, row: int, attribute: int) -> None: """Set row metadata""" if row is None: raise ValueError(f"_meta_set_attribute({row=}, {attribute=})") current_metadata: int = self._meta_get(row) if not current_metadata: new_metadata: int = (1 << attribute) else: new_metadata = self._meta_get(row) | (1 << attribute) self.item(row, columns['userdata'].idx).setData( self.ROW_FLAGS, new_metadata) def _mplayer_play(self, track_id: int) -> None: """Play track with mplayer""" with Session() as session: track = session.get(Tracks, track_id) if not track: log.error( f"playlists._mplayer_play({track_id=}): " "Track not found" ) return cmd_list = ['gmplayer', '-vc', 'null', '-vo', 'null', track.path] thread = threading.Thread( target=self._run_subprocess, args=(cmd_list,)) thread.start() def _remove_track(self, row: int) -> None: """Remove track from row, making it a section header""" # Update playlist_rows record with Session() as session: plr = session.get(PlaylistRows, self._get_playlistrow_id(row)) plr.track_id = None # We can't have null text if not plr.note: plr.note = Config.TEXT_NO_TRACK_NO_NOTE session.commit() # Clear track text items for i in range(2, len(columns)): self.item(row, i).setText("") # Set note text in correct column for section head self.item(row, 1).setText(plr.note) # Remove row duration self._set_row_duration(row, 0) # Remote track_id from row self.item(row, columns['userdata'].idx).setData( self.ROW_TRACK_ID, 0) # Span the rows self.setSpan(row, 1, 1, len(columns)) # And refresh display self.update_display(session) def _rescan(self, row: int, track_id: int) -> None: """Rescan track""" with Session() as session: track = session.get(Tracks, track_id) if not track: log.error( f"playlists._open_in_audacity({track_id=}): " "Track not found" ) return track.rescan(session) self._update_row(session, row, track) def _run_subprocess(self, args): """Run args in subprocess""" subprocess.call(args) # # def _set_current_track_row(self, row: int) -> None: # """Mark this row as current track""" # # self._clear_current_track_row() # self._meta_set_attribute(row, RowMeta.CURRENT) def _set_next_track_row(self, row: int) -> None: """Mark this row as next track""" self._meta_clear_next() self._meta_set_attribute(row, RowMeta.NEXT) # # def _set_note_row(self, row: int) -> None: # """Mark this row as a note""" # # self._meta_set_attribute(row, RowMeta.NOTE) # # def _set_played_row(self, row: int) -> None: # """Mark this row as played""" # # self._meta_set_attribute(row, RowMeta.PLAYED) def _set_unreadable_row(self, row: int) -> None: """Mark this row as unreadable""" self._meta_set_attribute(row, RowMeta.UNREADABLE) def _select_event(self) -> None: """ Called when item selection changes. If multiple rows are selected, display sum of durations in status bar. """ # If we are in the process of selecting multiple tracks, no-op here if self.selecting_in_progress: return # Get the row number of all selected items and put into a set # to deduplicate selected_rows = set([item.row() for item in self.selectedItems()]) # If no rows are selected, we have nothing to do if len(selected_rows) == 0: self.musicmuster.lblSumPlaytime.setText("") return ms = 0 for row in selected_rows: ms += self._get_row_duration(row) # Only paint message if there are selected track rows if ms > 0: self.musicmuster.lblSumPlaytime.setText( f"Selected duration: {helpers.ms_to_mmss(ms)}") else: self.musicmuster.lblSumPlaytime.setText("") # # def _select_tracks(self, played: bool) -> None: # """ # Select all played (played=True) or unplayed (played=False) # tracks in playlist # """ # # # Need to allow multiple rows to be selected # self.setSelectionMode(QtWidgets.QAbstractItemView.MultiSelection) # self.clear_selection() # # if played: # rows = self._get_played_track_rows() # else: # rows = self._get_unplayed_track_rows() # # for row in rows: # self.selectRow(row) # # # Reset extended selection # self.setSelectionMode(QtWidgets.QAbstractItemView.ExtendedSelection) def _set_column_widths(self, session: Session) -> None: """Column widths from settings""" for column_name, data in columns.items(): idx = data.idx attr_name = f"playlist_{column_name}_col_width" record: Settings = Settings.get_int_settings(session, attr_name) if record and record.f_int is not None: self.setColumnWidth(idx, record.f_int) else: self.setColumnWidth(idx, Config.DEFAULT_COLUMN_WIDTH) def _set_next(self, session: Session, row_number: int) -> None: """ Set passed row as next track to play. Actions required: - Check row has a track - Check track is readable - Mark as next track - Update display - Notify musicmuster """ track_id = self._get_row_track_id(row_number) if not track_id: log.error( f"playlists._set_next({row_number=}) has no track associated" ) return track = session.get(Tracks, track_id) if not track: log.error(f"playlists._set_next({row_number=}): Track not found") return # Check track is readable if not helpers.file_is_readable(track.path): self._set_unreadable_row(row_number) return None # Mark as next track self._set_next_track_row(row_number) # Update display self.update_display(session) # Notify musicmuster self.musicmuster.this_is_the_next_track(self, track, session) def _set_row_bold(self, row: int, bold: bool = True) -> None: """Make row bold (bold=True) or not bold""" j: int boldfont: QFont = QFont() boldfont.setBold(bold) for j in range(self.columnCount()): if self.item(row, j): self.item(row, j).setFont(boldfont) def _set_row_colour(self, row: int, colour: QColor) -> None: """Set row background colour""" j: int for j in range(1, self.columnCount()): if self.item(row, j): self.item(row, j).setBackground(colour) # # def _set_row_content(self, row: int, object_id: int) -> None: # """Set content associated with this row""" # # assert self.item(row, self.COL_USERDATA) # # self.item(row, self.COL_USERDATA).setData( # self.CONTENT_OBJECT, object_id) def _set_row_duration(self, row: int, ms: int) -> None: """Set duration of this row in row metadata""" self.item(row, columns['userdata'].idx).setData(self.ROW_DURATION, ms) def _set_row_end_time(self, row: int, time: Optional[datetime]) -> None: """Set passed row end time to passed time""" try: time_str: str = time.strftime(Config.TRACK_TIME_FORMAT) except AttributeError: time_str = "" item = QTableWidgetItem(time_str) self.setItem(row, columns['end_time'].idx, item) def _set_row_not_bold(self, row: int) -> None: """Set row to not be bold""" self._set_row_bold(row, False) def _set_row_start_time(self, row: int, time: Optional[datetime]) -> None: """Set passed row start time to passed time""" try: time_str: str = time.strftime(Config.TRACK_TIME_FORMAT) except AttributeError: time_str = "" item: QTableWidgetItem = QTableWidgetItem(time_str) self.setItem(row, columns['start_time'].idx, item) # # def _set_timed_section(self, session, start_row, ms, no_end=False): # """Add duration to a marked section""" # # duration = helpers.ms_to_mmss(ms) # note_object = self._get_row_notes_object(start_row, session) # if not note_object: # log.error("Can't get note_object in playlists._set_timed_section") # note_text = note_object.note # caveat = "" # if no_end: # caveat = " (to end of playlist)" # display_text = note_text + ' [' + duration + caveat + ']' # item = self.item(start_row, self.COL_TITLE) # item.setText(display_text) def _update_row(self, session, row: int, track: Tracks) -> None: """ Update the passed row with info from the passed track. """ columns['start_time'].idx item_startgap = self.item(row, columns['start_gap'].idx) item_startgap.setText(str(track.start_gap)) if track.start_gap >= 500: item_startgap.setBackground(QColor(Config.COLOUR_LONG_START)) else: item_startgap.setBackground(QColor("white")) item_title = self.item(row, columns['title'].idx) item_title.setText(track.title) item_artist = self.item(row, columns['artist'].idx) item_artist.setText(track.artist) item_duration = self.item(row, columns['duration'].idx) item_duration.setText(helpers.ms_to_mmss(track.duration)) self.update_display(session)