AlbumCover: saner design.

1 files changed, 88 insertions, 105 deletions

diff --git a/nephilim/plugins/AlbumCover.py b/nephilim/plugins/AlbumCover.py
index 3cf54aa..65e648f 100644
--- a/nephilim/plugins/AlbumCover.py
+++ b/nephilim/plugins/AlbumCover.py
@@ -9,168 +9,151 @@ from ..clPlugin import Plugin
 from ..misc     import ORGNAME, APPNAME, expand_tags
 
 # FETCH MODES
-AC_NO_FETCH = 0
+AC_NO_FETCH        = 0
 AC_FETCH_LOCAL_DIR = 1
-AC_FETCH_INTERNET = 2
+AC_FETCH_AMAZON    = 2
 
 class wgAlbumCover(QtGui.QLabel):
     " container for the image"
-    img            = None
-    imgLoaded      = False
+    cover          = None
+    cover_loaded   = False
     p              = None
     cover_dirname  = None
     cover_filepath = None
     menu           = None
+
     def __init__(self, p):
-        QtGui.QWidget.__init__(self)
+        QtGui.QLabel.__init__(self)
         self.p = p
         self.setAlignment(QtCore.Qt.AlignCenter)
 
         # popup menu
         self.menu = QtGui.QMenu("album")
         select_file_action = self.menu.addAction('Select cover file...')
-        self.connect(select_file_action, QtCore.SIGNAL('triggered()'), self.select_cover_file)
+        self.connect(select_file_action, QtCore.SIGNAL('triggered()'), self.fetch_local_manual)
         fetch_amazon_action = self.menu.addAction('Fetch cover from Amazon.')
-        self.connect(fetch_amazon_action, QtCore.SIGNAL('triggered()'), self.fetch_amazon)
+        self.connect(fetch_amazon_action, QtCore.SIGNAL('triggered()'), self.fetch_amazon_manual)
 
     def mousePressEvent(self, event):
         if event.button() == QtCore.Qt.RightButton:
             self.menu.popup(event.globalPos())
 
-    def select_cover_file(self):
-        try:
-            song = self.p.mpclient.getCurrentSong()
-            file = QtGui.QFileDialog.getOpenFileName(self
-                , "Select album cover for %s - %s"%(song.getArtist(), song.getAlbum())
-                , self.cover_dirname
-                , ""
-            )
-            if file:
-                shutil.copy(file, self.cover_filepath)
-            else:
-                return
-        except IOError:
-            logging.info("Error setting cover file.")
-        self.refresh()
+
+    def set_cover(self, cover):
+        if not cover or cover.isNull():
+            self.cover_loaded = False
+            self.setPixmap(QtGui.QPixmap('gfx/no-cd-cover.png'))
+            return
+
+        self.cover = cover
+        self.setPixmap(cover.scaled(self.size(), QtCore.Qt.KeepAspectRatio, QtCore.Qt.SmoothTransformation))
 
     def get_cover(self):
-        if self.imgLoaded:
-            return self.pixmap()
+        if self.cover_loaded:
+            return self.cover
         return None
 
-    def refresh(self, params = None):
+    def refresh(self):
         logging.info("refreshing cover")
         song = self.p.mpclient.getCurrentSong()
         if not song:
             self.clear()
-            self.update()
+            self.cover_loaded = False
             return
 
-        dirname  = unicode(self.p.settings.value(self.p.getName() + '/coverdir').toString())
+        dirname  = self.p.settings.value(self.p.getName() + '/coverdir').toString()
         self.cover_dirname = expand_tags(dirname, (self.p.winMain, song))
-        filebase = unicode(self.p.settings.value(self.p.getName() + '/covername').toString())
-        self.cover_filepath = os.path.join(self.cover_dirname, song.expand_tags(filebase).replace(os.path.sep, '_'))
-        self.fetchCover(song)
-
-    def fetchCover(self, song):
-        """Fetch cover (from internet or local dir)"""
-        # set default cover
+        filebase = self.p.settings.value(self.p.getName() + '/covername').toString()
+        self.cover_filepath = '%s/%s'%(self.cover_dirname,
+                                       expand_tags(filebase, (self.p.winMain, song)).replace(os.path.sep, '_'))
+        self.fetch_cover(song)
 
+    def fetch_cover(self, song):
         if not os.path.exists(self.cover_filepath):
-            success = False
-            for i in [0, 1]:
+            for i in (0, 1):
                 src = self.p.settings.value(self.p.getName() + '/method%i'%i).toInt()[0]
-                if src != AC_NO_FETCH:
-                    if self.fetchCoverSrc(song, src):
-                        success = True
-                        break
-            if not success:
-                self.imgLoaded = False
-                self.setPixmap(QtGui.QPixmap('gfx/no-cd-cover.png').scaled(self.size(), QtCore.Qt.KeepAspectRatio,
-                                                                           QtCore.Qt.SmoothTransformation))
-                return
+                if src == AC_FETCH_LOCAL_DIR:
+                    cover = self.fetch_local(song)
+                elif src == AC_FETCH_AMAZON:
+                    cover = self.fetch_amazon(song)
+                else:
+                    cover = QtGui.QPixmap()
 
-        try:
-            self.setPixmap(QtGui.QPixmap(self.cover_filepath).scaled(self.size(), QtCore.Qt.KeepAspectRatio,
-                                                                     QtCore.Qt.SmoothTransformation))
-            self.imgLoaded = True
-            logging.info("cover set!")
-        except IOError:
-            logging.warning("Error loading album cover" + self.cover_filepath)
+                if cover and not cover.isNull():
+                    break
+        else:
+            cover = QtGui.QPixmap(self.cover_filepath)
+
+        self.set_cover(cover)
+
+    def fetch_local_manual(self):
+        song = self.p.mpclient.getCurrentSong()
+        if not song:
+            return
 
-        self.update()
+        file = QtGui.QFileDialog.getOpenFileName(self,
+               'Select album cover for %s - %s'%(song.getArtist(), song.getAlbum()),
+               self.cover_dirname, '')
+        cover = QtGui.QPixmap(file)
+        if cover.isNull():
+            return
+        self.set_cover(cover)
+        self.cover_loaded = True
 
-    def getLocalACPath(self, song):
-        """Get the local path of an albumcover."""
+    def fetch_local(self, song):
+        # guess cover name
         covers = ['cover', 'album', 'front']
 
-        # fetch gfx extensions
-        exts = QtGui.QImageReader().supportedImageFormats()
-        exts = map(lambda ext: '*.' + unicode(ext), exts)
+        exts = []
+        for ext in QtGui.QImageReader().supportedImageFormats():
+            exts.append(str(ext))
 
-        # fetch cover album titles
         filter = []
         for cover in covers:
             for ext in exts:
-                filter.append(cover.strip() + ext)
+                filter.append('*.%s*.%s'%(cover,ext))
 
         dir = QtCore.QDir(self.cover_dirname)
         if not dir:
             logging.warning('Error opening directory' + self.cover_dirname)
-            return None;
+            return None
+
         dir.setNameFilters(filter)
         files = dir.entryList()
         if files:
-            return unicode(dir.filePath(files[0]))
+            cover = QtGui.QPixmap(dir.filePath(files[0]))
+            if not cover.isNull():
+                return cover
+
         # if this failed, try any supported image
         dir.setNameFilters(exts)
         files = dir.entryList()
         if files:
-            return unicode(dir.filePath(files[0]))
+            return QtGui.QPixmap(dir.filePath(files[0]))
         logging.info("done probing: no matching albumcover found")
         return None
 
-    def fetch_amazon(self):
-        self.fetchCoverSrc(self.p.mpclient.getCurrentSong(), AC_FETCH_INTERNET)
-        self.refresh()
-
-    def fetchCoverSrc(self, song, src):
-        """Fetch the album cover for $song from $src."""
-        if not src in [AC_FETCH_INTERNET, AC_FETCH_LOCAL_DIR]:
-            logging.warning("wgAlbumCover::fetchCover - invalid source "+str(src))
-            return False
-
-        if src == AC_FETCH_INTERNET:
-            # look on the internetz!
-            try:
-                if not song.getArtist() or not song.getAlbum():
-                    return False
-                # get the url from amazon WS
-                coverURL=AmazonAlbumImage(song.getArtist(), song.getAlbum()).fetch()
-                logging.info("fetch from Amazon")
-                if not coverURL:
-                    logging.info("not found on Amazon")
-                    return False
-                # read the url, i.e. retrieve image data
-                img=urllib.urlopen(coverURL)
-                # open file, and write the read of img!
-                f=open(self.cover_filepath,'wb')
-                f.write(img.read())
-                f.close()
-                return True
-            except:
-                logging.info("failed to download cover from Amazon")
-                print_exc()
-                return False
-
-        if src == AC_FETCH_LOCAL_DIR:
-            file=self.getLocalACPath(song)
-            try:
-                shutil.copy(file, self.cover_filepath)
-                return True
-            except:
-                logging.info("Failed to create cover file")
-                return False
+    def fetch_amazon_manual(self):
+        song = self.p.mpclient.getCurrentSong()
+        if not song:
+            return
+        cover = self.fetch_amazon(song)
+        self.set_cover(cover)
+
+    def fetch_amazon(self, song):
+        if not song.getArtist() or not song.getAlbum():
+            return None
+        # get the url from amazon WS
+        coverURL = AmazonAlbumImage(song.getArtist(), song.getAlbum()).fetch()
+        logging.info("fetching from Amazon")
+        if not coverURL:
+            logging.info("not found on Amazon")
+            return None
+
+        img = urllib.urlopen(coverURL)
+        cover = QtGui.QPixmap()
+        cover.loadFromData(img.read())
+        return cover
 
 class AlbumCover(Plugin):
     o = None
@@ -184,7 +167,7 @@ class AlbumCover(Plugin):
         self.addListener('onStateChange', self.refresh)
 
     def _load(self):
-        self.o = wgAlbumCover(self, None)
+        self.o = wgAlbumCover(self)
     def _unload(self):
         self.o = None
     def getInfo(self):