nephilim/plugins/AlbumCover.py

   1 #
   2 #    Copyright (C) 2009 Anton Khirnov <wyskas@gmail.com>
   3 #
   4 #    Nephilim is free software: you can redistribute it and/or modify
   5 #    it under the terms of the GNU General Public License as published by
   6 #    the Free Software Foundation, either version 3 of the License, or
   7 #    (at your option) any later version.
   8 #
   9 #    Nephilim is distributed in the hope that it will be useful,
  10 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 #    GNU General Public License for more details.
  13 #
  14 #    You should have received a copy of the GNU General Public License
  15 #    along with Nephilim.  If not, see <http://www.gnu.org/licenses/>.
  16 #
  17
  18 from PyQt4        import QtGui, QtCore, QtNetwork
  19 from PyQt4.QtCore import QVariant
  20
  21 import os
  22
  23 from ..plugin import Plugin
  24 from ..       import common
  25 from ..       import icons
  26
  27
  28 class AlbumCoverWidget(QtGui.QLabel):
  29     "cover - QPixmap or None"
  30     cover           = None
  31     "is there a (non-default) cover loaded?"
  32     cover_loaded    = False
  33     "plugin object"
  34     plugin          = None
  35     "logger"
  36     logger          = None
  37
  38     _menu           = None   # popup menu
  39
  40     def __init__(self, plugin):
  41         QtGui.QLabel.__init__(self)
  42         self.plugin = plugin
  43         self.logger = plugin.logger
  44         self.setAlignment(QtCore.Qt.AlignCenter)
  45
  46         # popup menu
  47         self._menu = QtGui.QMenu('album')
  48         self._menu.addAction('&Select cover file...', self.plugin.select_cover)
  49         self._menu.addAction('&Refresh cover.', self.plugin.refresh)
  50         self._menu.addAction('&View in a separate window.', self.__view_cover)
  51         self._menu.addAction('Save cover &as...', self.__save_cover)
  52         self._menu.addAction('&Clear cover.', self.__clear_cover)
  53
  54     def contextMenuEvent(self, event):
  55         event.accept()
  56         self._menu.popup(event.globalPos())
  57
  58     def set_cover(self, song, cover):
  59         """Set cover for current song."""
  60         self.logger.info('Setting cover')
  61         if not cover or cover.isNull():
  62             self.cover        = None
  63             self.cover_loaded = False
  64             self.setPixmap(QtGui.QPixmap(':icons/nephilim.png'))
  65             self.plugin.cover_changed.emit(QtGui.QPixmap())
  66             return
  67
  68         if song != self.plugin.mpclient.current_song():
  69             return
  70
  71         self.cover = cover
  72         self.cover_loaded = True
  73         self.setPixmap(self.cover.scaled(self.size(), QtCore.Qt.KeepAspectRatio, QtCore.Qt.SmoothTransformation))
  74         self.plugin.cover_changed.emit(self.cover)
  75         self.logger.info('Cover set.')
  76
  77     def __view_cover(self):
  78         if not self.cover_loaded:
  79             return
  80         win = QtGui.QLabel(self, QtCore.Qt.Window)
  81         win.setScaledContents(True)
  82         win.setPixmap(self.cover)
  83         win.show()
  84
  85     def __save_cover(self):
  86         if not self.cover_loaded:
  87             return
  88         cover = self.cover
  89         file = QtGui.QFileDialog.getSaveFileName(None, '', QtCore.QDir.homePath())
  90         if file:
  91             self.plugin.save_cover_file(cover, file)
  92
  93     def __clear_cover(self):
  94         self.plugin.delete_cover_file()
  95         self.set_cover(None, None)
  96         self.plugin.refresh()
  97
  98 class AlbumCover(Plugin):
  99     # public, constant
 100     info = 'Display the album cover of the currently playing album.'
 101
 102     # public, read-only
 103     o = None
 104
 105     # private
 106     DEFAULTS  = {'coverdir' : '${musicdir}/${songdir}', 'covername' : '.cover_%s_${artist}_${album}'%common.APPNAME,
 107                  'fetchers': ['local', 'Last.fm'], 'store' : True}
 108     "implemented fetchers"
 109     available_fetchers = None
 110     "enabled fetchers, those with higher priority first"
 111     __fetchers        = None
 112     "number of returned results from last refresh() call"
 113     __results         = None
 114     "index/priority of current cover"
 115     __index           = None
 116     "metadata paths"
 117     __cover_dir      = None
 118     __cover_path     = None
 119
 120     # SIGNALS
 121     cover_changed = QtCore.pyqtSignal(QtGui.QPixmap)
 122
 123     #### private ####
 124     def __init__(self, parent, mpclient, name):
 125         Plugin.__init__(self, parent, mpclient, name)
 126
 127         self.__fetchers         = []
 128         self.available_fetchers = [self.FetcherLocal, self.FetcherLastfm]
 129
 130     def __new_cover_fetched(self, song, cover):
 131         self.logger.info('Got new cover.')
 132         self.__results += 1
 133
 134         i = self.__fetchers.index(self.sender())
 135         if cover and i < self.__index:
 136             if self.settings.value(self.name + '/store').toBool():
 137                 self.save_cover_file(cover)
 138             self.__index = i
 139             return self.o.set_cover(song, cover)
 140         elif self.__results >= len(self.__fetchers) and not self.o.cover_loaded:
 141             self.o.set_cover(song, None)
 142
 143     def __abort_fetch(self):
 144         """Aborts all fetches currently in progress."""
 145         for fetcher in self.__fetchers:
 146             fetcher.abort()
 147
 148     class SettingsWidgetAlbumCover(Plugin.SettingsWidget):
 149         coverdir    = None
 150         covername   = None
 151         store       = None
 152         fetcherlist = None
 153
 154         def __init__(self, plugin):
 155             Plugin.SettingsWidget.__init__(self, plugin)
 156             self.settings.beginGroup(self.plugin.name)
 157
 158             # store covers groupbox
 159             self.store = QtGui.QGroupBox('Store covers.')
 160             self.store.setToolTip('Should %s store its own copy of covers?'%common.APPNAME)
 161             self.store.setCheckable(True)
 162             self.store.setChecked(self.settings.value('store').toBool())
 163             self.store.setLayout(QtGui.QGridLayout())
 164
 165             # paths to covers
 166             self.coverdir  = QtGui.QLineEdit(self.settings.value('coverdir').toString())
 167             self.coverdir.setToolTip('Where should %s store covers.\n'
 168                                      '${musicdir} will be expanded to path to MPD music library (as set by user)\n'
 169                                      '${songdir} will be expanded to path to the song (relative to ${musicdir}\n'
 170                                      'other tags same as in covername'
 171                                       %common.APPNAME)
 172             self.covername = QtGui.QLineEdit(self.settings.value('covername').toString())
 173             self.covername.setToolTip('Filename for %s cover files.\n'
 174                                       'All tags supported by MPD will be expanded to their\n'
 175                                       'values for current song, e.g. ${title}, ${track}, ${artist},\n'
 176                                       '${album}, ${genre} etc.'%common.APPNAME)
 177             self.store.layout().addWidget(QtGui.QLabel('Cover directory'), 0, 0)
 178             self.store.layout().addWidget(self.coverdir, 0, 1)
 179             self.store.layout().addWidget(QtGui.QLabel('Cover filename'), 1, 0)
 180             self.store.layout().addWidget(self.covername, 1, 1)
 181
 182             # sites list
 183             fetchers         = self.settings.value('fetchers').toStringList()
 184             self.fetcherlist = QtGui.QListWidget(self)
 185             self.fetcherlist.setDragDropMode(QtGui.QAbstractItemView.InternalMove)
 186             for site in fetchers:
 187                 it = QtGui.QListWidgetItem(site)
 188                 it.setCheckState(QtCore.Qt.Checked)
 189                 self.fetcherlist.addItem(it)
 190             for site in self.plugin.available_fetchers:
 191                 if not site.name in fetchers:
 192                     it = QtGui.QListWidgetItem(site.name)
 193                     it.setCheckState(QtCore.Qt.Unchecked)
 194                     self.fetcherlist.addItem(it)
 195
 196             self.setLayout(QtGui.QVBoxLayout())
 197             self.layout().addWidget(self.store)
 198             self._add_widget(self.fetcherlist, label = 'Fetchers', tooltip = 'A list of sources used for fetching covers.\n'
 199                                                                     'Use drag and drop to change their priority.')
 200
 201             self.settings.endGroup()
 202
 203         def save_settings(self):
 204             self.settings.beginGroup(self.plugin.name)
 205             self.settings.setValue('coverdir', QVariant(self.coverdir.text()))
 206             self.settings.setValue('covername', QVariant(self.covername.text()))
 207             self.settings.setValue('store', QVariant(self.store.isChecked()))
 208
 209             fetchers = []
 210             for i in range(self.fetcherlist.count()):
 211                 it = self.fetcherlist.item(i)
 212                 if it.checkState() == QtCore.Qt.Checked:
 213                     fetchers.append(it.text())
 214             self.settings.setValue('fetchers', QVariant(fetchers))
 215             self.settings.endGroup()
 216             self.plugin.refresh_fetchers()
 217             self.plugin.refresh()
 218
 219     class FetcherLastfm(common.MetadataFetcher):
 220         name = 'Last.fm'
 221
 222         def fetch(self, song):
 223             if not 'artist' in song or 'album' in song:
 224                 return self.finish()
 225             url = QtCore.QUrl('http://ws.audioscrobbler.com/2.0/')
 226             url.setQueryItems([('api_key', 'beedb2a8a0178b8059cd6c7e57fbe428'),
 227                                ('method',  'album.getInfo'),
 228                                ('artist',  song['artist']),
 229                                ('album',   song['album']),
 230                                ('mbid',    song['?MUSICBRAINZ_ALBUMID'])])
 231             self.fetch2(song, url)
 232             self.rep.finished.connect(self.__handle_search_res)
 233
 234         def __handle_search_res(self):
 235             url = None
 236             xml = QtCore.QXmlStreamReader(self.rep)
 237
 238             while not xml.atEnd():
 239                 token = xml.readNext()
 240                 if token == QtCore.QXmlStreamReader.StartElement:
 241                     if xml.name() == 'image' and xml.attributes().value('size') == 'extralarge':
 242                         url = QtCore.QUrl() # the url is already percent-encoded
 243                         try:
 244                             url.setEncodedUrl(xml.readElementText())
 245                         except TypeError:   #no text
 246                             url = None
 247             if xml.hasError():
 248                 self.logger.error('Error parsing seach results: %s'%xml.errorString())
 249
 250             if not url:
 251                 self.logger.info('Didn\'t find the URL in %s search results.'%self.name)
 252                 return self.finish()
 253             self.logger.info('Found %s song URL: %s.'%(self.name, url))
 254
 255             self.rep = self.nam.get(QtNetwork.QNetworkRequest(url))
 256             self.rep.finished.connect(self.__handle_cover)
 257
 258         def __handle_cover(self):
 259             data = self.rep.readAll()
 260             pixmap = QtGui.QPixmap()
 261             if pixmap.loadFromData(data):
 262                 self.finish(pixmap)
 263             self.finish()
 264
 265     class FetcherLocal(QtCore.QObject):
 266         """This fetcher tries to find cover files in the same directory as
 267            current song."""
 268         #public, read-only
 269         name     = 'local'
 270         logger   = None
 271         settings = None
 272
 273         # SIGNALS
 274         finished = QtCore.pyqtSignal('song', 'metadata')
 275
 276         def __init__(self, plugin):
 277             QtCore.QObject.__init__(self, plugin)
 278             self.logger = plugin.logger
 279             self.settings = QtCore.QSettings()
 280
 281         def fetch(self, song):
 282             self.logger.info('Trying to guess local cover name.')
 283             # guess cover name
 284             covers = ['cover', 'album', 'front']
 285
 286             exts = []
 287             for ext in QtGui.QImageReader().supportedImageFormats():
 288                 exts.append('*.%s'%str(ext))
 289
 290             filter = []
 291             for cover in covers:
 292                 for ext in exts:
 293                     filter.append('*.%s%s'%(cover,ext))
 294
 295             dirname, filename = common.generate_metadata_path(song, '$musicdir/$songdir', '')
 296             dir = QtCore.QDir(dirname)
 297             if not dir:
 298                 self.logger.error('Error opening directory %s.'%dirname)
 299                 return self.finished.emit(song, None)
 300
 301             dir.setNameFilters(filter)
 302             files = dir.entryList()
 303             if files:
 304                 cover = QtGui.QPixmap(dir.filePath(files[0]))
 305                 if not cover.isNull():
 306                     self.logger.info('Found a cover: %s'%dir.filePath(files[0]))
 307                     return self.finished.emit(song, cover)
 308
 309             # if this failed, try any supported image
 310             dir.setNameFilters(exts)
 311             files = dir.entryList()
 312             if files:
 313                 cover = QtGui.QPixmap(dir.filePath(files[0]))
 314                 if not cover.isNull():
 315                     self.logger.info('Found a cover: %s'%dir.filePath(files[0]))
 316                     return self.finished.emit(song, cover)
 317             self.logger.info('No matching cover found')
 318             self.finished.emit(song, None)
 319
 320         def abort(self):
 321             pass
 322
 323     #### public ####
 324     def _load(self):
 325         self.o = AlbumCoverWidget(self)
 326         self.mpclient.song_changed.connect(self.refresh)
 327         self.refresh_fetchers()
 328         self.refresh()
 329     def _unload(self):
 330         self.o = None
 331         self.mpclient.song_changed.disconnect(self.refresh)
 332
 333     def refresh(self):
 334         self.logger.info('Autorefreshing cover.')
 335         self.__results = 0
 336         self.__index   = len(self.__fetchers)
 337         self.o.cover_loaded = False
 338         song = self.mpclient.current_song()
 339         if not song:
 340             self.__cover_dir  = ''
 341             self.__cover_path = ''
 342             return self.o.set_cover(None, None)
 343
 344         (self.__cover_dir, self.__cover_path) = common.generate_metadata_path(song,
 345                                                                             self.settings.value(self.name + '/coverdir').toString(),
 346                                                                             self.settings.value(self.name + '/covername').toString())
 347         try:
 348             self.logger.info('Trying to read cover from file %s.'%self.__cover_path)
 349             cover = QtGui.QPixmap(self.__cover_path)
 350             if not cover.isNull():
 351                 return self.o.set_cover(song, cover)
 352         except IOError, e:
 353             self.logger.info('Error reading cover file: %s.'%e)
 354
 355         for fetcher in self.__fetchers:
 356             fetcher.fetch(song)
 357
 358     def refresh_fetchers(self):
 359         """Refresh the list of available fetchers."""
 360         self.__fetchers = []
 361         # append fetchers in order they are stored in settings
 362         for name in self.settings.value('%s/fetchers'%self.name).toStringList():
 363             for site in self.available_fetchers:
 364                 if site.name == name:
 365                     self.__fetchers.append(site(self))
 366                     self.__fetchers[-1].finished.connect(self.__new_cover_fetched)
 367
 368     def save_cover_file(self, cover, path = None):
 369         """Save cover to a file specified in path.
 370            If path is None, then a default value is used."""
 371         self.logger.info('Saving cover...')
 372         try:
 373             if not path:
 374                 path = self.__cover_path
 375             cover.save(path, 'png')
 376             self.logger.info('Cover successfully saved.')
 377         except IOError, e:
 378             self.logger.error('Error writing cover: %s', e)
 379
 380     def delete_cover_file(self, song = None):
 381         """Delete a cover file for song. If song is not specified
 382            current song is used."""
 383         if not song:
 384             path = self.__cover_path
 385         else:
 386             path = common.generate_metadata_path(song, self.settings.value(self.name + '/coverdir').toString(),
 387                                                self.settings.value(self.name + '/covername').toString())
 388         if not QtCore.QFile.remove(path):
 389             self.logger.error('Error removing file %s.'%path)
 390
 391     def select_cover(self):
 392         """Prompt user to manually select cover file for current song."""
 393         song = self.mpclient.current_song()
 394         if not song:
 395             return
 396         self.__abort_fetch()
 397
 398         file = QtGui.QFileDialog.getOpenFileName(None,
 399                 'Select album cover for %s - %s'%(song['?artist'], song['?album']),
 400                 self.__cover_dir, '')
 401         if not file:
 402             return
 403
 404         cover = QtGui.QPixmap(file)
 405         if cover.isNull():
 406             self.logger.error('Error opening cover file.')
 407             return
 408
 409         if self.settings.value(self.name + '/store').toBool():
 410             self.save_cover_file(cover)
 411         self.o.set_cover(song, cover)
 412
 413     def cover(self):
 414         if not self.o:
 415             return None
 416         return self.o.cover if self.o.cover_loaded else None
 417
 418     def _get_dock_widget(self):
 419         return self._create_dock(self.o)
 420
 421     def get_settings_widget(self):
 422         return self.SettingsWidgetAlbumCover(self)
 423
 424