def __init__(self, parent=None):
super().__init__(parent)
self.setupUi(self)
self.filterhistory = []
self.lastdirectory = None # last used directory in file dialogs
self.nowfiltering = False # whether the filter is currently processing or no
self.nowgroupfiltering = False # whether the group filter is -||-
#self.found = -1 # total in the selected group / all tracks
#self.new = -1 # total new in the *shown* tracks
#self.total = -1
self.prevgroup = None
# icons
icn = QtGui.QIcon(":/regaudio.icon.48.png")
icn.addFile(":/regaudio.icon.32.png")
icn.addFile(":/regaudio.icon.24.png")
icn.addFile(":/regaudio.icon.16.png")
self.setWindowIcon(icn)
# show a warning in case of no configuration
self.showDBWarning()
# setup status
self.statusline = QtGui.QLabel()
self.statusBar().addWidget(self.statusline)
# models
self.datamdl = model.Model()
self.stats = self.datamdl.stats # share statistics
self.tracks = TracksModel(self.datamdl.getTracks())
self.groups = GroupsModel(self.datamdl.getGroups())
#connect feedback first
self.tracks.feedback.connect(self.modelfeedback)
self.groups.feedback.connect(self.modelfeedback)
# set table
self.trackstable.setModel(self.tracks)
self.trackstable.setItemDelegate(TracksDelegate(self.tracks))
self.trackstable.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.trackstable.customContextMenuRequested.connect(self.tracksContextMenu)
self.trackstable.setEditTriggers(QtGui.QAbstractItemView.DoubleClicked |
QtGui.QAbstractItemView.SelectedClicked |
QtGui.QAbstractItemView.EditKeyPressed )
self.trackstable.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
# set groups
self.filtergroups = QtGui.QSortFilterProxyModel(self)
self.filtergroups.setSourceModel(self.groups)
self.filtergroups.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
self.groupbox.setModel(self.filtergroups)
self.groupbox.currentIndexChanged.connect(self.groupSet)
self.groupallbtn.clicked.connect(self.actionGroupAllTracks.activate)
self.groupfavouritebtn.clicked.connect(self.actionGroupFavourite.activate)
self.groupnewbtn.setMenu(self.menuGroupNewImport)
self.groupnewbtn.clicked.connect(self.groupnewbtn.showMenu)
self.groupdeletebtn.clicked.connect(self.actionGroupDelete.activate)
self.grouprenamebtn.clicked.connect(self.actionGroupRename.activate)
self.groupfilterbtn.toggled.connect(self.groupFilterBool)
self.groupfilterline.editingFinished.connect(self.groupFilter)
self.groupfilterline.setEnabled(False)
self.groupfilterline.setVisible(False)
# set paging
self.pagemaxtracksline.setText("100")
self.pagepageline.setText("1")
self.pagemaxtracksline.setValidator(QtGui.QIntValidator())
self.pagepageline.setValidator(QtGui.QIntValidator())
self.pagemaxtracksline.editingFinished.connect(self.filterSet)
self.pagepageline.editingFinished.connect(self.filterSet)
self.pagenextbtn.clicked.connect(self.pagenext)
self.pageprevbtn.clicked.connect(self.pageprev)
#connect filter
self.filterline.editingFinished.connect(self.filterSet)
self.actionFilterReset.triggered.connect(self.filterSetTo)
self.menuFilterHistory.aboutToShow.connect(self.filterHistoryUpdateMenu)
self.filterreset.clicked.connect(self.actionFilterReset.activate)
self.filterrecall.setMenu(self.menuFilterHistory)
self.filterrecall.clicked.connect(self.filterrecall.showMenu)
#connect actions
self.actionTrackDelete.triggered.connect(self.trackDelete)
self.actionTrackNew.triggered.connect(self.trackNew)
self.actionTrackToggleNew.triggered.connect(self.trackToggleNew)
self.actionTrackDetachedCopy.triggered.connect(self.trackDetachedCopy)
receivermm = lambda : self.groupimport(what="mm")
self.actionImport.triggered.connect(receivermm)
self.actionQuit.triggered.connect(self.quit)
self.actionGroupAllTracks.triggered.connect(self.groupAllTracks)
self.actionGroupFavourite.triggered.connect(self.groupFavorite)
self.actionGroupNew.triggered.connect(self.groupNew)
receivercue = lambda : self.groupimport(what="cue")
self.actionGroupImportCue.triggered.connect(receivercue)#self.groupImportCue)
receiverdir = lambda : self.groupimport(what="dir")
self.actionGroupImportDirectory.triggered.connect(receiverdir)#self.groupImportDir)
self.actionGroupDelete.triggered.connect(self.groupDelete)
self.actionGroupRename.triggered.connect(self.groupRename)
self.menuTrack.aboutToShow.connect(self.updateMenuTrack)
self.menuTrackMerge.aboutToShow.connect(self.updateMenuTrackMerge)
self.menuTrackInGroups.aboutToShow.connect(self.updateMenuTrackInGroups)
self.menuTrackAddToGroup.aboutToShow.connect(self.updateMenuTrackAddToGroup)
self.menuTrackRelink.aboutToShow.connect(self.updateMenuTrackRelink)
for act in [["0", lambda : self.trackRating(0), "`"],
["1", lambda : self.trackRating(1), "1"],
["2", lambda : self.trackRating(2), "2"],
["3", lambda : self.trackRating(3), "3"],
["4", lambda : self.trackRating(4), "4"],
["5", lambda : self.trackRating(5), "5"],
["6", lambda : self.trackRating(6), "6"],
["7", lambda : self.trackRating(7), "7"],
["8", lambda : self.trackRating(8), "8"],
["9", lambda : self.trackRating(9), "9"],
["10", lambda : self.trackRating(10), "0"]]:
action = QtGui.QAction(self)
action.setText(act[0])
action.triggered.connect(act[1])
if len(act) == 3:
action.setShortcut(QtGui.QKeySequence.fromString(act[2]))
self.menuRating.addAction(action)
self.trackstable.addAction(action)
# this feeds all the default settings to the model and read the data from db
self.filterSet()
# FIXME the following causes that the model is refreshed three times
self.tracks.sortingreallyenabled = False
self.trackstable.sortByColumn(0,QtCore.Qt.AscendingOrder)
self.trackstable.setSortingEnabled(True)
self.tracks.sortingreallyenabled = True
self.statusupdate()
class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
def __init__(self, parent=None):
super().__init__(parent)
self.setupUi(self)
self.filterhistory = []
self.lastdirectory = None # last used directory in file dialogs
self.nowfiltering = False # whether the filter is currently processing or no
self.nowgroupfiltering = False # whether the group filter is -||-
#self.found = -1 # total in the selected group / all tracks
#self.new = -1 # total new in the *shown* tracks
#self.total = -1
self.prevgroup = None
# icons
icn = QtGui.QIcon(":/regaudio.icon.48.png")
icn.addFile(":/regaudio.icon.32.png")
icn.addFile(":/regaudio.icon.24.png")
icn.addFile(":/regaudio.icon.16.png")
self.setWindowIcon(icn)
# show a warning in case of no configuration
self.showDBWarning()
# setup status
self.statusline = QtGui.QLabel()
self.statusBar().addWidget(self.statusline)
# models
self.datamdl = model.Model()
self.stats = self.datamdl.stats # share statistics
self.tracks = TracksModel(self.datamdl.getTracks())
self.groups = GroupsModel(self.datamdl.getGroups())
#connect feedback first
self.tracks.feedback.connect(self.modelfeedback)
self.groups.feedback.connect(self.modelfeedback)
# set table
self.trackstable.setModel(self.tracks)
self.trackstable.setItemDelegate(TracksDelegate(self.tracks))
self.trackstable.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.trackstable.customContextMenuRequested.connect(self.tracksContextMenu)
self.trackstable.setEditTriggers(QtGui.QAbstractItemView.DoubleClicked |
QtGui.QAbstractItemView.SelectedClicked |
QtGui.QAbstractItemView.EditKeyPressed )
self.trackstable.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
# set groups
self.filtergroups = QtGui.QSortFilterProxyModel(self)
self.filtergroups.setSourceModel(self.groups)
self.filtergroups.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive)
self.groupbox.setModel(self.filtergroups)
self.groupbox.currentIndexChanged.connect(self.groupSet)
self.groupallbtn.clicked.connect(self.actionGroupAllTracks.activate)
self.groupfavouritebtn.clicked.connect(self.actionGroupFavourite.activate)
self.groupnewbtn.setMenu(self.menuGroupNewImport)
self.groupnewbtn.clicked.connect(self.groupnewbtn.showMenu)
self.groupdeletebtn.clicked.connect(self.actionGroupDelete.activate)
self.grouprenamebtn.clicked.connect(self.actionGroupRename.activate)
self.groupfilterbtn.toggled.connect(self.groupFilterBool)
self.groupfilterline.editingFinished.connect(self.groupFilter)
self.groupfilterline.setEnabled(False)
self.groupfilterline.setVisible(False)
# set paging
self.pagemaxtracksline.setText("100")
self.pagepageline.setText("1")
self.pagemaxtracksline.setValidator(QtGui.QIntValidator())
self.pagepageline.setValidator(QtGui.QIntValidator())
self.pagemaxtracksline.editingFinished.connect(self.filterSet)
self.pagepageline.editingFinished.connect(self.filterSet)
self.pagenextbtn.clicked.connect(self.pagenext)
self.pageprevbtn.clicked.connect(self.pageprev)
#connect filter
self.filterline.editingFinished.connect(self.filterSet)
self.actionFilterReset.triggered.connect(self.filterSetTo)
self.menuFilterHistory.aboutToShow.connect(self.filterHistoryUpdateMenu)
self.filterreset.clicked.connect(self.actionFilterReset.activate)
self.filterrecall.setMenu(self.menuFilterHistory)
self.filterrecall.clicked.connect(self.filterrecall.showMenu)
#connect actions
self.actionTrackDelete.triggered.connect(self.trackDelete)
self.actionTrackNew.triggered.connect(self.trackNew)
self.actionTrackToggleNew.triggered.connect(self.trackToggleNew)
self.actionTrackDetachedCopy.triggered.connect(self.trackDetachedCopy)
receivermm = lambda : self.groupimport(what="mm")
self.actionImport.triggered.connect(receivermm)
self.actionQuit.triggered.connect(self.quit)
self.actionGroupAllTracks.triggered.connect(self.groupAllTracks)
self.actionGroupFavourite.triggered.connect(self.groupFavorite)
self.actionGroupNew.triggered.connect(self.groupNew)
receivercue = lambda : self.groupimport(what="cue")
self.actionGroupImportCue.triggered.connect(receivercue)#self.groupImportCue)
receiverdir = lambda : self.groupimport(what="dir")
self.actionGroupImportDirectory.triggered.connect(receiverdir)#self.groupImportDir)
self.actionGroupDelete.triggered.connect(self.groupDelete)
self.actionGroupRename.triggered.connect(self.groupRename)
self.menuTrack.aboutToShow.connect(self.updateMenuTrack)
self.menuTrackMerge.aboutToShow.connect(self.updateMenuTrackMerge)
self.menuTrackInGroups.aboutToShow.connect(self.updateMenuTrackInGroups)
self.menuTrackAddToGroup.aboutToShow.connect(self.updateMenuTrackAddToGroup)
self.menuTrackRelink.aboutToShow.connect(self.updateMenuTrackRelink)
for act in [["0", lambda : self.trackRating(0), "`"],
["1", lambda : self.trackRating(1), "1"],
["2", lambda : self.trackRating(2), "2"],
["3", lambda : self.trackRating(3), "3"],
["4", lambda : self.trackRating(4), "4"],
["5", lambda : self.trackRating(5), "5"],
["6", lambda : self.trackRating(6), "6"],
["7", lambda : self.trackRating(7), "7"],
["8", lambda : self.trackRating(8), "8"],
["9", lambda : self.trackRating(9), "9"],
["10", lambda : self.trackRating(10), "0"]]:
action = QtGui.QAction(self)
action.setText(act[0])
action.triggered.connect(act[1])
if len(act) == 3:
action.setShortcut(QtGui.QKeySequence.fromString(act[2]))
self.menuRating.addAction(action)
self.trackstable.addAction(action)
# this feeds all the default settings to the model and read the data from db
self.filterSet()
# FIXME the following causes that the model is refreshed three times
self.tracks.sortingreallyenabled = False
self.trackstable.sortByColumn(0,QtCore.Qt.AscendingOrder)
self.trackstable.setSortingEnabled(True)
self.tracks.sortingreallyenabled = True
self.statusupdate()
def showDBWarning(self):
if CFG["regaudio"]["default"] == "True":
QtGui.QMessageBox.warning(self, "Default database",
WARNMSG.format(CFGLOC, CFG["regaudio"]["db"])
, buttons=QtGui.QMessageBox.Ok, defaultButton=QtGui.QMessageBox.Ok)
def statusupdate(self):
self.statusline.setText(self.stats.status())
#sline = ""
#if self.found >= 0:
# sline += "{} tracks found".format(self.found)
#if self.new > 0 and self.new != self.found:
# if sline:
# sline += " "
# sline += "{} new".format(self.new)
#if self.total > 0 and self.total != self.found:
# sline += " ({} total tracks)".format(self.total)
#if sline != "":
# self.statusline.setText(sline)
def pagesset(self):
val = self.pagepageline.validator() # int validator
val.setBottom(1)
maxtr = int(self.pagemaxtracksline.text())
if maxtr == 0:
pages = 1
elif self.stats.fltr == 0:
pages = 1
else:
pages = int(self.stats.fltr / maxtr)
if self.stats.fltr % maxtr:
pages += 1
self.pagemaxpagelbl.setText("/ {}".format(pages))
val.setTop(pages)
self.pagebuttons()
self.statusupdate()
def pagenext(self):
page = int(self.pagepageline.text())
self.pagepageline.setText(str(page+1))
self.filterSet()
self.pagebuttons()
def pageprev(self):
page = int(self.pagepageline.text())
if page == 0:
return
self.pagepageline.setText(str(page-1))
self.filterSet()
self.pagebuttons()
def pagebuttons(self):
page = int(self.pagepageline.text())
pagemin = self.pagepageline.validator().bottom()
pagemax = self.pagepageline.validator().top()
self.pagenextbtn.setEnabled(page != pagemax)
self.pageprevbtn.setEnabled(page != pagemin)
def updateMenuTrack(self):
tt = self.trackstable
rows = tt.model().getSelection(tt.selectedIndexes())
gtmode = tt.model().dbmodel.gtmode
# new track is always enabled
# delete should be enabled only if there are tracks selected
self.actionTrackDelete.setEnabled(len(rows) > 0)
# merge should be enabled only if there is more than one track selected
#self.menuTrackMerge.setEnabled(not gtmode and (len(rows) > 1))
self.menuTrackMerge.setEnabled(len(rows) > 1)
# add to group and groups list should be enabled if some tracks are selected
self.menuTrackAddToGroup.setEnabled(len(rows) > 0)
self.menuTrackInGroups.setEnabled(len(rows) > 0)
self.menuTrackRelink.clear()
self.menuTrackRelink.setEnabled(len(rows) == 1 and gtmode)
self.actionTrackDetachedCopy.setEnabled(gtmode)
def updateMenuTrackMerge(self):
self.menuTrackMerge.clear()
tt = self.trackstable
dbmodel = tt.model().dbmodel
rows = tt.model().getSelection(tt.selectedIndexes())
for row in rows:
tt = dbmodel.lst[row]
if dbmodel.gtmode:
tt = tt.track
receiver = lambda row=row: self.trackMerge(rows, row)
self.menuTrackMerge.addAction(tt.menucaption(), receiver)
def updateMenuTrackInGroups(self):
self.menuTrackInGroups.clear()
tt = self.trackstable
dbmodel = tt.model().dbmodel
rows = tt.model().getSelection(tt.selectedIndexes())
# first - make a dict of all the K: group id, V: number of tracks that share the same group
gid_trscaps = {}
for row in rows:
tt = dbmodel.lst[row]
if type(tt) == grouptrack.GroupTrack:
tt = tt.track
for gt in tt.grouptracks:
gid = gt.group.idno # group id
trs = gid_trscaps.setdefault(gid, [0,gt.group.name])[0] + 1 # tracks in that group
gid_trscaps[gid][0] = trs
# if no groups were found make only an informative menu entry
if len(gid_trscaps) == 0:
self.menuTrackInGroups.addAction("No group found")
return
for gid,cntcap in sorted(gid_trscaps.items(), key=lambda x:x[1][1]):
receiver = lambda gid=gid: self.groupFocusGid(gid, True)
#caption = gid_caps[gid]
caption = cntcap[1]
count = cntcap[0]
if count > 1:
caption = "({} tracks) {}".format(count, caption)
self.menuTrackInGroups.addAction(caption, receiver)
def updateMenuTrackAddToGroup(self):
# show maximum MAXGROUPS, show favorites and regular groups if there is at most MAXFAV_RATIO * MAXGROUPS favorites
MAXGROUPS = 10
MAXFAV_RATIO = 0.5
self.menuTrackAddToGroup.clear()
mg = self.groups
mt = self.trackstable.model()
gdb = self.groups.dbmodel
tdb = self.trackstable.model().dbmodel
#if mt.dbmodel.gtmode:
# self.menuTrackAddToGroup.addAction("Not available for group tracks")
# return
tt = self.trackstable
rows = tt.model().getSelection(tt.selectedIndexes())
# each of the tracks can be in multiple groups
gid_cnt = {}
for row in rows:
tt = tdb.lst[row]
if mt.dbmodel.gtmode:
tt = tt.track
for gt in tt.grouptracks:
gid = gt.group.idno # group id
gid_cnt[gid] = gid_cnt.get(gid, 0) + 1 # tracks in that group
nogrps = MAXGROUPS
if gdb.favs >= MAXGROUPS * MAXFAV_RATIO and gdb.favs < MAXGROUPS:
nogrps = MAXGROUPS
showpicker = (nogrps < len(gdb.lst))
for gg in gdb.lst:
if gg is None:
continue
nogrps -= 1
receiver = lambda gid=gg.idno: self.trackAddToGroup(rows, gid)
caption = gg.menucaption()
if gg.idno in gid_cnt:
caption = "({}) ".format(gid_cnt[gg.idno]) + caption
self.menuTrackAddToGroup.addAction(caption, receiver)
if nogrps == 0:
break
if showpicker:
receiver = lambda gid=gg.idno: self.trackAddToGroup(rows, None)
self.menuTrackAddToGroup.addAction("Pick from all ...", receiver)
def updateMenuTrackRelink(self):
rows = self.tracks.getSelection(self.trackstable.selectedIndexes())
assert(len(rows) == 1)
self.menuTrackRelink.clear()
for tid,cap in self.tracks.dbmodel.similar(rows[0]):
receiver = lambda tid=tid:self.trackRelink(tid)
self.menuTrackRelink.addAction(cap, receiver)
def updateMenuGroup(self):
pass
def getlastdirectory(self):
"""return last visited directory for file dialogs"""
ll = self.lastdirectory
if not ll:
return os.path.expanduser("~")
while not os.path.exists(ll) and ll:
ll = os.path.dirname(ll)
if not ll:
return os.path.expanduser("~")
return ll
def groupimport(self, what):
import os.path
if what == "mm":
source = QtGui.QFileDialog.getOpenFileName(self,
caption='Select a MM file', directory=self.getlastdirectory(),
filter='Freemind files (*.mm);;All files (*.*)')
elif what == "cue":
source = QtGui.QFileDialog.getOpenFileNames(self,
caption='Select a Cue file', directory=self.getlastdirectory(),
filter='Cue files (*.cue);;All files (*.*)')
elif what == "dir":
source = QtGui.QFileDialog.getExistingDirectory(self,
caption='Select a directory to import', directory=self.getlastdirectory(),
options=QtGui.QFileDialog.ShowDirsOnly)
if source is None or len(source) == 0:
return
if type(source) is str:
self.lastdirectory = source
else:
self.lastdirectory = source[0]
imp = ImportData(self.datamdl, source)
what2, msg = imp.readdatapre(what, source)
if what2:
result = QtGui.QMessageBox.question(self, "Importing data", msg
, buttons=QtGui.QMessageBox.Yes | QtGui.QMessageBox.No
, defaultButton=QtGui.QMessageBox.No)
if result == QtGui.QMessageBox.Yes:
what = what2
imp.readdata(what, source)
iw = ImportWindow(imp, parent=self)
if not iw.exec_():
return
self.groups.beginResetModel()
gid = imp.store(self.datamdl.getTracks().stats)
self.groups.dbmodel.loadgroups()
self.groups.endResetModel()
self.groupFocusGid(gid)
#self.groupbox.model().layoutChanged.emit()
#self.trackstable.model().layoutChanged.emit()
def groupFilterBool(self, ignored):
self.groupFilter(focusfilter=True)
def groupFilter(self, forcefilter=None, focusfilter=False):
if self.nowgroupfiltering:
return
self.nowgroupfiltering = True
try:
if forcefilter != None:
self.groupfilterline.setText(forcefilter)
self.groupfilterbtn.setChecked(forcefilter != "")
dofilter = self.groupfilterbtn.isChecked()
self.groupfilterline.setVisible(dofilter)
self.groupfilterline.setEnabled(dofilter)
if not dofilter:
self.groupfilterline.setText("")
elif focusfilter:
self.groupfilterline.setFocus(QtCore.Qt.OtherFocusReason)
txt = self.groupfilterline.text()
self.filtergroups.setFilterWildcard(txt)
finally:
self.nowgroupfiltering = False
def groupSet(self):
self.prevgroup = None
self.filterSet()
def groupNew(self):
groupname, ok = QtGui.QInputDialog.getText(self, "New group", "New group name:")
if not ok:
return
#newidx = self.groupbox.model().newGroup(groupname)
newidx = self.groups.newGroup(groupname)
if newidx == -1:
QtGui.QMessageBox.warning(self, "New group",
"Couldn't create the group! Such group already exists!")
return
self.groupFocus(newidx, refresh=True)
def groupDelete(self):
#idx = self.groupbox.currentIndex()
fidx = self.filtergroups.index(self.groupbox.currentIndex(), 0)
idx = self.filtergroups.mapToSource(fidx).row()
if idx == 0:
QtGui.QMessageBox.warning(self, "A warning", "All Tracks is not a group", buttons=QtGui.QMessageBox.Ok, defaultButton=QtGui.QMessageBox.NoButton)
return
#mm = self.groupbox.model()
name = self.groups.getGroup(idx).name
result = QtGui.QMessageBox.question(self, "Delete?", "Delete the group '" + name + "' ?"
, buttons=QtGui.QMessageBox.Yes | QtGui.QMessageBox.No
, defaultButton=QtGui.QMessageBox.No)
if result != QtGui.QMessageBox.Yes:
return
self.groups.removeRows(idx, 1)
#self.groupFocus(0, refresh=True)
def groupRename(self):
#idx = self.groupbox.currentIndex()
fidx = self.filtergroups.index(self.groupbox.currentIndex(), 0)
idx = self.filtergroups.mapToSource(fidx)
idx = idx.row()
if idx == 0:
QtGui.QMessageBox.warning(self, "A warning",
"All Tracks is not a group!",
buttons=QtGui.QMessageBox.Ok,
defaultButton=QtGui.QMessageBox.NoButton)
return
#mm = self.groupbox.model()
#name = mm.getGroup(self.groupbox.currentIndex()).name
name = self.groups.getGroup(idx).name
groupname, ok = QtGui.QInputDialog.getText(self, "Rename group",
"Change group name:" + " "*30, text=name)
if not ok:
return False
if groupname == name:
return
# this will in turn change the index too (handled by feedback)
#self.groups.setData(self.groups.index(idx, 0, QtCore.QModelIndex()), groupname, QtCore.Qt.EditRole)
newidx = self.groups.renameGroup(idx, groupname)
if newidx == None:
QtGui.QMessageBox.warning(self, "Rename group",
"Couldn't rename the group! Such group already exists!")
return
self.groupFocus(newidx)
def groupFavorite(self):
#newidx = self.groupbox.model().favorite(self.groupbox.currentIndex())
fidx = self.filtergroups.index(self.groupbox.currentIndex(), 0)
idx = self.filtergroups.mapToSource(fidx).row()
if idx == 0:
QtGui.QMessageBox.warning(self, "A warning",
"All Tracks is not a group!",
buttons=QtGui.QMessageBox.Ok,
defaultButton=QtGui.QMessageBox.NoButton)
return
newidx = self.groups.favorite(idx)
if newidx == -1:
return
self.groupFocus(newidx)
def groupAllTracks(self):
if self.prevgroup:
self.groupFocus(self.prevgroup, refresh=True)
self.prevgroup = None
else:
fidx = self.filtergroups.index(self.groupbox.currentIndex(), 0)
idx = self.filtergroups.mapToSource(fidx).row()
self.prevgroup = idx
if self.prevgroup == 0:
self.prevgroup = None
self.groupFilter("")
self.groupbox.blockSignals(True)
self.groupbox.setCurrentIndex(0)
self.groupbox.blockSignals(False)
self.filterSet()
def groupFocusGid(self, gid, refresh=False):
self.groupFocus(self.groups.dbmodel.gidToIdx(gid), refresh)
def groupFocus(self, idx, refresh=False):
# this functions is called whener groups have changed, lets invalidate the model
#self.filtergroups.invalidate()
# the idx is points to the original model, its integer
# if the idx cannot be remapped to the new reset the filter and try to focus it again
idx = self.groups.index(idx, 0)
idxmap = self.filtergroups.mapFromSource(idx)
if not idxmap.isValid():
self.groupFilter("") # reset the filter
idxmap = self.filtergroups.mapFromSource(idx)
if not idxmap.isValid():
raise ValueError("groupFocus: invalid group row index {}".format(idx.row()))
self.prevgroup = None
self.groupbox.setCurrentIndex(idxmap.row())
if refresh:
self.filterSet()
def trackAddToGroup(self, rows, gid):
if gid == None:
# show picker of all the groups
db = self.groups.dbmodel
lst = db.getcaptions()
name, ok = QtGui.QInputDialog.getItem(self, "Pick a group",
"Pick the group to add the tracks into",
lst, current=0, editable=False)
# the captions don't include the All tracks group so ..
if not ok:
return
idx = lst.index(name) # slooow
idx += 1
gid = db.lst[idx].idno
d, dc = self.trackstable.model().dbmodel.addtogroup(rows, gid)
if not d:
return
result = QtGui.QMessageBox.question(self, "Add tracks to group", \
"The tracks\n\t{}\nare already in that group?\n\nDo you wish to add them anyway?".format(dc), \
buttons=QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, \
defaultButton=QtGui.QMessageBox.No)
if result != QtGui.QMessageBox.Yes:
return
self.trackstable.model().dbmodel.addtogroup(d, gid, force=True)
self.filterSet()
def trackDelete(self):
tt = self.trackstable
dbmodel = tt.model().dbmodel
rows = tt.model().getSelection(tt.selectedIndexes())
rowsranges = utils.re_rangebyone(sorted(rows), count=True)
if tt.model().dbmodel.gtmode:
result = QtGui.QMessageBox.question(self, "Delete grouptracks", \
"Delete just the selected group tracks (yes) or also the tracks (all)?", \
buttons=QtGui.QMessageBox.Yes | QtGui.QMessageBox.No | QtGui.QMessageBox.YesAll , \
defaultButton=QtGui.QMessageBox.No)
else:
result = QtGui.QMessageBox.question(self, "Delete tracks", \
"PERMAMENTLY delete the selected tracks?", \
buttons=QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, \
defaultButton=QtGui.QMessageBox.No)
if result != QtGui.QMessageBox.Yes and result != QtGui.QMessageBox.YesAll:
return
# delete tracks from bottom to keep the right indices
for s, e in reversed(rowsranges):
tt.model().removeRows(s,e, trackstoo=(result == QtGui.QMessageBox.YesAll))
def trackNew(self):
index = self.trackstable.selectionModel().currentIndex()
model = self.trackstable.model()
if not model.insertRow(index.row()+1, index.parent()):
return
#self.updateActions()
#for column in range(model.columnCount(index.parent())):
# child = model.index(index.row()+1, column, index.parent())
# model.setData(child, "[No lst]", QtCore.Qt.EditRole)
def trackRating(self, rr):
tt = self.trackstable
dbmodel = tt.model().dbmodel
rows = tt.model().getSelection(tt.selectedIndexes())
tt.model().rating(rows, rr)
def trackToggleNew(self):
tt = self.trackstable
dbmodel = tt.model().dbmodel
rows = tt.model().getSelection(tt.selectedIndexes())
tt.model().toggleNew(rows)
def trackMerge(self, rows, torow):
index = self.trackstable.selectionModel().currentIndex()
model = self.trackstable.model()
model.mergetracks(rows, torow)
def trackDetachedCopy(self):
rows = self.tracks.getSelection(self.trackstable.selectedIndexes())
assert(len(rows) == 1)
self.tracks.detachedcopy(rows[0])
def trackRelink(self, tid):
"""link selected grouptrack to the track given by the id"""
rows = self.tracks.getSelection(self.trackstable.selectedIndexes())
assert(len(rows) == 1)
self.tracks.relink(rows[0], tid)
def tracksContextMenu(self, point):
point.setX(point.x() + self.trackstable.verticalHeader().width())
point.setY(point.y() + self.trackstable.horizontalHeader().height())
self.menuTrack.exec_(self.trackstable.mapToGlobal(point))
def filterSetTo(self, rule=""):
# work around action triggred
if not type(rule) is str:
rule = ""
self.filterline.setText(rule)
self.filterSet()
def filterHistoryUpdateMenu(self):
self.menuFilterHistory.clear()
for rule in reversed(self.filterhistory):
receiver = lambda rule=rule: self.filterSetTo(rule)
self.menuFilterHistory.addAction(rule, receiver)
def filterSet(self):#, *args, **kvargs):
if self.nowfiltering:
return
# get values from controls
try:
self.nowfiltering = True
rule = self.filterline.text().strip().lower()
if rule and (not self.filterhistory or self.filterhistory[-1] != rule):
if rule in self.filterhistory:
self.filterhistory.remove(rule)
# limit the size of the history to 20 entries
if len(self.filterhistory) >= 19:
self.filterhistory = self.filterhistory[-19:]
self.filterhistory.append(rule)
if not self.filterrecall.isEnabled():
self.filterrecall.setEnabled(True)
grp = group.Group.namefromcaption(self.groupbox.currentText())
maxrows = int(self.pagemaxtracksline.text())
page = int(self.pagepageline.text())
self.tracks.setfilter(rule=rule, group=grp, maxrows=maxrows, page=page)
if self.tracks.rowCount():
pass # TODO maybe remember the rule if the search yielded any results
finally:
self.pagebuttons()
self.nowfiltering = False
def modelfeedback(self, name, value):
'''
process feedback from the underlying model(s)
see also Feedback class
messages are passed in the form of the name and value
the name is the common name of the control or command
the value is the value to be set
the feedback should not cause any updates so the nowfiltering is set to true
(nowfiltering causes that filterSet doesn't work)
'''
setlock = False
try:
if not self.nowfiltering:
self.nowfiltering = True
setlock = True
if name == "group": # by m/gm/setData
self.groupFocus(int(value))
elif name == "statusupdate":
self.statusupdate()
elif name == "pagesset":
self.pagesset()
#elif name == "total":
# self.total = int(value)
# self.statusupdate()
elif name == "page": # by m/m/setfilter
self.pagepageline.setText(value)
#elif name == "rule":
# self.filterline.setText(value)
#elif name == "found":
# self.found = int(value)
# self.pagesset()
#elif name == "new":
# self.new = (int(value))
# self.statusupdate()
elif name == "max": # by m/m/setfilter
self.pagemaxtracksline.setText(value)
elif name == "resize": # by u/tm/sort and setfilter
self.trackstable.resizeColumnsToContents()
self.trackstable.resizeRowsToContents()
elif name == "sortbycol": # by m/m/setfilter
cc = (int(value))
sign = cc > 0
cc = cc - 1 if sign else - 1 - cc
try:
self.trackstable.horizontalHeader().blockSignals(True)
#self.trackstable.blockSignals(True)
self.trackstable.horizontalHeader().setSortIndicator(cc,
QtCore.Qt.AscendingOrder if sign else QtCore.Qt.DescendingOrder)
finally:
#self.trackstable.blockSignals(False)
self.trackstable.horizontalHeader().blockSignals(False)
else:
print("Unknown feedback received", name, value)
finally:
if setlock:
self.nowfiltering = False
def quit(self):
self.close()