Plugins: albumart.3.py

#Copyright 2005 Eduardo Gonzalez, Niklas Janlert, Antonio Riva
#Amazon API code by Mark Pilgrim
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation

# Last Modified: Mon 2008-05-05 14:54:27 (-0400)
# Updated for new Amazon API by Jeremy Cantrell <jmcantrell@gmail.com>

import os
import sys
import urllib
import threading
from cStringIO import StringIO
import gtk
import gobject
import pango
import util
import qltk
import config

from plugins.songsmenu import SongsMenuPlugin

if sys.version_info < (2, 4): from sets import Set as set

from pyaws import ecs

class AlbumArtWindow(gtk.Window):
    def __init__(self, songs):
        gtk.Window.__init__(self)
        self.set_border_width(12)
        self.set_title("AlbumArt")
        self.set_default_size(650, 350)

        #TreeView stuff
        self.liststore = liststore = gtk.ListStore(object, str)
        treeview = gtk.TreeView(liststore)
        treeview.set_headers_visible(False)
        selection = treeview.get_selection()
        selection.set_mode(gtk.SELECTION_SINGLE)
        selection.connect("changed", self.__preview)


        self.url = url = gtk.Entry()
        url.set_text(songs[0]("artist") + " " + songs[0]("album"))

        urlButton = gtk.Button("Search")
        urlButton.connect("clicked", self.__start_search, url,liststore)
        url.connect("key-release-event", self.key_start_search, url,liststore)


        urlBox= gtk.HBox()
        urlBox.pack_start(url, expand=True, fill=True)
        urlBox.pack_start(urlButton, expand=False, fill=False)


        rend = gtk.CellRendererPixbuf()
        def cell_data(column, cell, model, iter):
            cell.set_property("pixbuf", model[iter][0]["thumb"])
        tvcol1 = gtk.TreeViewColumn("Pixbuf", rend)
        tvcol1.set_cell_data_func(rend, cell_data)
        tvcol1.set_sizing(gtk.TREE_VIEW_COLUMN_GROW_ONLY)
        rend.set_property('xpad', 2)
        rend.set_property('ypad', 2)
        rend.set_property('width', 56)
        rend.set_property('height', 56)
        treeview.append_column(tvcol1)

        rend = gtk.CellRendererText()
        rend.set_property("ellipsize", pango.ELLIPSIZE_END)
        tvcol2 = gtk.TreeViewColumn("Info", rend, markup=1)
        treeview.append_column(tvcol2)

        sw = gtk.ScrolledWindow()
        sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
        sw.set_shadow_type(gtk.SHADOW_IN)
        sw.add(treeview)

        #Image frame and save button
        self.image = image = gtk.Image()
        frame = gtk.Frame()
        frame.set_shadow_type(gtk.SHADOW_IN)
        frame.add(image)

        vbox = gtk.VBox(spacing=5)
        vbox.pack_start(frame)
        self.button = button = gtk.Button(stock=gtk.STOCK_SAVE)
        button.set_sensitive(False)
        def save_cb(button, combo):
            model, path = selection.get_selected()
            data = model[path][0]["cover_data"]
            fname = self.__get_fname(songs, combo)
            self.__save_cover(data, fname)
        combo = gtk.combo_box_new_text()
        try: set_fn = config.get("plugins", "cover_fn")
        except: set_fn = ".folder.jpg"
        active = -1
        for i, fn in enumerate([".folder.jpg", "folder.jpg", "cover.jpg"]):
            combo.append_text(fn)
            if fn == set_fn: active = i
        if active == -1:
            combo.append_text(set_fn)
            combo.set_active(len(combo.get_model()) - 1)
        else: combo.set_active(active)
        button.connect("clicked", save_cb, combo)
        bbox = gtk.HButtonBox()
        bbox.pack_start(combo)
        bbox.pack_start(button, expand=False, fill=False)
        bbox.set_layout(gtk.BUTTONBOX_SPREAD)
        vbox.pack_start(bbox, expand=False, fill=False)


        hpaned = gtk.HPaned()
        hpaned.pack1(sw)
        hpaned.pack2(vbox)
        hpaned.set_position(300)

        vbox= gtk.VBox()
        vbox.pack_start(urlBox, expand=False, fill=False)
        vbox.pack_start(hpaned, expand=True, fill=True)
        self.add(vbox)


        thread = threading.Thread(target=self.__search, args=(songs,))
        thread.setDaemon(True)
        thread.start()

        self.show_all()

    def key_start_search(self, widget,event, entry,liststore):
        if(event.keyval==65293):
            self.__start_search( widget, entry,liststore)


    def __start_search(self, widget, entry,liststore):
        liststore.clear()
        entry_text = entry.get_text()
        print "Search: %s\n" % entry_text
        thread = threading.Thread(target=self.__search_string, args=(entry_text,))
        thread.setDaemon(True)
        thread.start()

    def __search_string(self, query):
        ecs.setLicenseKey("0RKH4ZH1JCFZHMND91G2")
        try:
            query = query.encode("latin1", 'replace')
            bags = ecs.ItemSearch(query, SearchIndex='Music',
                    ResponseGroup='Images,Small')
        except ecs.AWSException, msg:
            dialog = qltk.Message(gtk.MESSAGE_ERROR, None, "Search error", msg)
            dialog.connect('response', self.__destroy_cb)
            gobject.idle_add(dialog.show)
        except UnicodeEncodeError, msg:
            dialog = qltk.Message(gtk.MESSAGE_ERROR, None, "Encoding error", 
                                  msg)
            dialog.connect('response', self.__destroy_cb)
            gobject.idle_add(dialog.show)
        else:
            # Just keep the top 10 matches
            for bag in bags:
                gobject.idle_add(self.__add_bag, self.liststore, bag)


    def __search(self, songs):
        query = songs[0]("artist") + " " + songs[0]("album")
        self.__search_string(query)

    def __destroy_cb(self, widget, *args):
        widget.destroy()
        #self.destroy()

    def __add_bag(self, model, bag):
        # Text part
        title = util.escape(getattr(bag, "Title", ""))
        artist = (getattr(bag, "Artists", None) and 
                  getattr(bag.Artists, "Artist", None) or "")
        if isinstance(artist, list):
            artist = ", ".join(artist)
        artist = util.escape(artist)
        if hasattr(bag, "ReleaseDate"):
            date = "(%s)" %util.escape(bag.ReleaseDate)
        else:
            date = ""
        markup = "<i><b>%s</b></i> %s\n%s" %(title, date, artist)

        item = {"bag": bag, "thumb": None, "thumb_data": ""}
        iter = model.append([item, markup])

        # Image part
        if getattr(bag, 'SmallImage', None):
            urlinfo = urllib.urlopen(bag.SmallImage.URL)
            sock = urlinfo.fp._sock
            sock.setblocking(0)
            data = StringIO()

        loader = gtk.gdk.PixbufLoader()
        loader.connect("closed", self.__got_thumb_cb, data, item, model, iter)

        gobject.io_add_watch(
            sock, gobject.IO_IN | gobject.IO_ERR | gobject.IO_HUP, 
            self.__copy_image, loader, data)

    def __got_thumb_cb(self, loader, data, item, model, iter):
        cover = loader.get_pixbuf()
        if cover.get_width() > 1:
            w = h = 48
            cover = cover.scale_simple(w, h, gtk.gdk.INTERP_NEAREST)
            thumb = gtk.gdk.Pixbuf(
                gtk.gdk.COLORSPACE_RGB, True, 8, w + 2, h + 2)
            thumb.fill(0x000000ff)
            cover.copy_area(0, 0, w, h, thumb, 1, 1)
            item["thumb"] = thumb
            item["thumb_data"] = data.getvalue()
            model.row_changed(model.get_path(iter), iter)

    def __preview(self, selection):
        model, path = selection.get_selected()
        item = model[path][0]
        self.image.hide()
        self.button.set_sensitive(False)

        if item["thumb"]: # If there exists no thumbnail, then nothing bigger.
            if "cover" not in item:
                self.__get_cover(item, item["bag"].LargeImage.URL)
            else:
                self.image.set_from_pixbuf(item["cover"])
                self.image.show()
                self.button.set_sensitive(True)

    def __get_cover(self, item, url):
        data = StringIO()
        urlinfo = urllib.urlopen(url)
        sock = urlinfo.fp._sock
        sock.setblocking(0)
        loader = gtk.gdk.PixbufLoader()
        gobject.io_add_watch(
            sock, gobject.IO_IN | gobject.IO_ERR | gobject.IO_HUP, 
            self.__copy_image, loader, data)
        loader.connect("closed", self.__got_cover_cb, data, item, url)
        def update(loader, x, y, w, h, image):
            if (w, h) > (1, 1):
                image.set_from_pixbuf(loader.get_pixbuf())
                image.show()
        loader.connect("area-updated", update, self.image)

    def __got_cover_cb(self, loader, data, item, url):
        cover = loader.get_pixbuf()
        # For some reason we get a 1x1 image if the given size didn't exist
        if cover.get_width() > 1:
            item["cover"] = cover
            item["cover_data"] = data.getvalue()
            self.image.set_from_pixbuf(item["cover"])
            self.button.set_sensitive(True)
        elif url == item["bag"].LargeImage.URL:
            self.__get_cover(item, item["bag"].MediumImage.URL)
        else:
            item["cover"] = item["thumb"]
            item["cover_data"] = item["thumb_data"]
            self.image.set_from_pixbuf(item["cover"])
            self.button.set_sensitive(True)

    def __copy_image(self, src, condition, loader, data):
        if condition in (gobject.IO_ERR, gobject.IO_HUP):
            loader.close()
            src.close()
            return False
        else: # Read
            buf = src.recv(1024)
            if buf:
                loader.write(buf)
                data.write(buf)
                return True # Run again
            else:
                loader.close()
                src.close()
                return False

    def __save_cover(self, data, fname):
        if os.path.exists(fname) and not qltk.ConfirmAction(None, 
            "File exists", "The file <b>%s</b> already exists."
            "\n\nOverwrite?" %util.escape(fname)).run():
            return

        f = open(fname, "w")
        f.write(data)
        f.close()
        self.destroy()

    def __get_fname(self, songs, combo):
        append = combo.get_model()[(combo.get_active(),)][0]
        dirname = songs[0]("~dirname")
        fname = os.path.join(dirname, append)
        #print "Will save to", fname
        config.set("plugins", "cover_fn", append)
        return fname

class DownloadAlbumArt(SongsMenuPlugin):
    PLUGIN_ID = "Download Album art"
    PLUGIN_NAME = _("Download Album Art")
    PLUGIN_DESC = "Downloads album covers from Amazon.com"
    PLUGIN_ICON = gtk.STOCK_FIND
    PLUGIN_VERSION = "0.25"

    def PluginPreferences(parent):
        b = gtk.Button("Visit Amazon.com")
        b.connect('clicked', lambda s: util.website('http://www.amazon.com/'))
        return b
    PluginPreferences = staticmethod(PluginPreferences)

    plugin_album = AlbumArtWindow