1952 lines
68 KiB
Python
1952 lines
68 KiB
Python
from collections import namedtuple
|
|
|
|
from typing import List, Optional
|
|
from PyQt5 import QtCore
|
|
from PyQt5.QtCore import Qt
|
|
from PyQt5.QtGui import (
|
|
QBrush,
|
|
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"<PlaylistTab(id={self.playlist_id}"
|
|
#
|
|
# # ########## Events ##########
|
|
#
|
|
# def closeEditor(self, editor, hint): # review
|
|
# super(PlaylistTab, self).closeEditor(editor, hint)
|
|
# self.cellEditingEnded.emit()
|
|
|
|
def dropEvent(self, event: QDropEvent) -> 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 get_selected_playlistrow_ids(self) -> Optional[List]:
|
|
"""
|
|
Return a list of PlaylistRow ids of the selected rows
|
|
"""
|
|
|
|
return [self._get_playlistrow_id(a) for a in self._selected_rows()]
|
|
|
|
# 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 marker"""
|
|
|
|
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
|
|
# self.save_playlist(session)
|
|
self.update_display(session)
|
|
|
|
def remove_selected_rows(self) -> None:
|
|
"""Remove selected rows from display"""
|
|
|
|
# Remove rows from display. Do so in reverse order so that
|
|
# row numbers remain valid.
|
|
for row in sorted(self._selected_rows(), reverse=True):
|
|
self.removeRow(row)
|
|
# Reset drag mode
|
|
self.setDragEnabled(False)
|
|
|
|
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
|
|
# Reset colour in case it was current/next
|
|
self._set_row_colour(row, None)
|
|
|
|
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
|
|
|
|
Actions required:
|
|
- Delete the rows from the PlaylistRows table
|
|
- Correct the row numbers in the PlaylistRows table
|
|
- Remove the rows from the display
|
|
"""
|
|
|
|
# Delete rows from database
|
|
plr_ids = self.get_selected_playlistrow_ids()
|
|
with Session() as session:
|
|
PlaylistRows.delete_rows(session, plr_ids)
|
|
|
|
# Fix up row numbers left in this playlist
|
|
PlaylistRows.fixup_rownumbers(session, self.playlist_id)
|
|
# Remove selected rows from display
|
|
self.remove_selected_rows()
|
|
|
|
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, columns['userdata'].idx).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
|
|
|
|
selected_rows = self._selected_rows()
|
|
# 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 _selected_rows(self) -> Optional[List[int]]:
|
|
"""Return a list of selected row numbers"""
|
|
|
|
# Use a set to deduplicate result (a selected row will have all
|
|
# items in that row selected)
|
|
return [row for row in set([a.row() for a in self.selectedItems()])]
|
|
|
|
#
|
|
# 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: Optional[QColor] = None) -> None:
|
|
"""
|
|
Set or reset row background colour
|
|
"""
|
|
|
|
j: int
|
|
|
|
if colour:
|
|
brush = QBrush(colour)
|
|
else:
|
|
brush = QBrush()
|
|
|
|
for j in range(1, self.columnCount()):
|
|
if self.item(row, j):
|
|
self.item(row, j).setBackground(brush)
|
|
#
|
|
# 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)
|