--- /dev/null
+#! @PYTHON@
+### -*- mode: python; coding: utf-8 -*-
+###
+### Manage and update cover art for a music collection
+###
+### (c) 2014 Mark Wooding
+###
+
+###----- Licensing notice ---------------------------------------------------
+###
+### This file is part of the `autoys' audio tools collection.
+###
+### `autoys' is free software; you can redistribute it and/or modify
+### it under the terms of the GNU General Public License as published by
+### the Free Software Foundation; either version 2 of the License, or
+### (at your option) any later version.
+###
+### `autoys' is distributed in the hope that it will be useful,
+### but WITHOUT ANY WARRANTY; without even the implied warranty of
+### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+### GNU General Public License for more details.
+###
+### You should have received a copy of the GNU General Public License
+### along with `autoys'; if not, write to the Free Software Foundation,
+### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+###--------------------------------------------------------------------------
+### External dependencies.
+
+## Language features.
+from __future__ import with_statement
+
+## Standard Python libraries.
+from cStringIO import StringIO
+import errno as E
+import json as JS
+import os as OS; ENV = OS.environ
+import sys as SYS
+import urllib as U
+import urllib2 as U2
+
+## GTK and friends.
+import cairo as XR
+import gobject as G
+import gtk as GTK
+GDK = GTK.gdk
+
+###--------------------------------------------------------------------------
+### Theoretically tweakable parameters.
+
+THUMBSZ = 96
+
+###--------------------------------------------------------------------------
+### The image cache.
+
+class ImageCache (object):
+ """
+ I maintain a cache of CacheableImage objects.
+
+ I evict images which haven't been used recently if the total size of the
+ image data I'm holding is larger than the threshold in my `THRESH'
+ attribute.
+ """
+
+ ## Useful attributes:
+ ## _total = total size of image data in the cache, in bytes
+ ## _first, _last = head and tail of a linked list of CacheableImage objects
+ ##
+ ## We make use of the link attributes _first and _next of CacheableImage
+ ## objects.
+
+ ## Notionally configurable parameters.
+ THRESH = 128*1024*1024
+
+ def __init__(me):
+ """Initialize an ImageCache object. The cache is initially empty."""
+ me._total = 0
+ me._first = me._last = None
+
+ def add(me, img):
+ """Add IMG to the cache, possibly evicting old images."""
+
+ ## Update the cache size, and maybe evict images if we're over budget.
+ me._total += img.size
+ while me._first and me._total > me.THRESH: me._first.evict()
+
+ ## Link the new image into the list.
+ img._prev = me._last
+ img._next = None
+ if me._last: me._last._next = img
+ else: me._first = img
+ me._last = img
+
+ def rm(me, img):
+ """
+ Remove IMG from the cache.
+
+ This is usually a response to an eviction notice received by the image.
+ """
+
+ ## Unlink the image.
+ if img._prev: img._prev._next = img._next
+ else: me._first = img._next
+ if img._next: img._next._prev = img._prev
+ else: img._last = img._prev
+
+ ## Update the cache usage.
+ me._total -= img.size
+
+## We only need one cache, in practice, and here it is.
+CACHE = ImageCache()
+
+class CacheableImage (object):
+ """
+ I represent an image which can be retained in the ImageCache.
+
+ I'm an abstract class. Subclasses are expected to implement a method
+ `_acquire' which fetches the image's data from wherever it comes from and
+ returns it, as a Gdk Pixbuf object.
+
+ Cacheable images may also retain a thumbnail which is retained
+ until explicitly discarded.
+ """
+
+ ## Useful attributes:
+ ## _pixbuf = the pixbuf of the acquired image, or None
+ ## _thumb = the pixbuf of the thumbnail, or None
+ ## _next, _prev = forward and backward links in the ImageCache list
+
+ def __init__(me):
+ """Initialize the image."""
+ me._pixbuf = None
+ me._thumb = None
+ me._prev = me._next = None
+
+ @property
+ def pixbuf(me):
+ """
+ Return the underlying image data, as a Gdk Pixbuf object.
+
+ The image data is acquired if necessary, and cached for later reuse.
+ """
+ if not me._pixbuf:
+ me._pixbuf = me._acquire()
+ me.size = me._pixbuf.get_pixels_array().nbytes
+ CACHE.add(me)
+ return me._pixbuf
+
+ def evict(me):
+ """Discard the image data. This is usually a request by the cache."""
+ me._pixbuf = None
+ CACHE.rm(me)
+
+ def flush(me):
+ """
+ Discard the image data and thumbnail.
+
+ They will be regenerated again on demand.
+ """
+ me.evict()
+ me._thumb = None
+
+ @property
+ def thumbnail(me):
+ """Return a Thumbnail object for the image."""
+ if not me._thumb: me._thumb = Thumbnail(me)
+ return me._thumb
+
+class Thumbnail (object):
+ """
+ I represent a reduced-size view of an image, suitable for showing in a big
+ gallery.
+
+ My `pixbuf' attribute stores a Gdk Pixbuf of the thumbnail image.
+ """
+
+ def __init__(me, img):
+ """
+ Initialize the Thumbnail.
+
+ The thumbnail will contain a reduced-size view of the CacheableImage IMG.
+ """
+ pix = img.pixbuf
+ wd, ht = pix.get_width(), pix.get_height()
+ m = max(wd, ht)
+ if m <= THUMBSZ:
+ me.pixbuf = pix
+ else:
+ twd, tht = [(x*THUMBSZ + m//2)//m for x in [wd, ht]]
+ me.pixbuf = pix.scale_simple(twd, tht, GDK.INTERP_HYPER)
+
+###--------------------------------------------------------------------------
+### Various kinds of image.
+
+class NullImage (CacheableImage):
+ """
+ I represent a placeholder image.
+
+ I'm usually used because the proper image you actually wanted is
+ unavailable for some reason.
+ """
+
+ ## Useful attributes:
+ ## _size = size of the (square) image, in pixels
+ ## _text = the text to display in the image.
+
+ def __init__(me, size, text):
+ """
+ Construct a new NullImage.
+
+ The image will be a square, SIZE pixels along each side, and will display
+ the given TEXT.
+ """
+ CacheableImage.__init__(me)
+ me._size = size
+ me._text = text
+
+ def _acquire(me):
+ """Render the placeholder image."""
+
+ ## Set up a drawing surface and context.
+ surf = XR.ImageSurface(XR.FORMAT_ARGB32, me._size, me._size)
+ xr = XR.Context(surf)
+
+ ## Choose an appropriate background colour and fill it in.
+ xr.set_source_rgb(0.3, 0.3, 0.3)
+ xr.paint()
+
+ ## Choose an appropriately nondescript font and foreground colour.
+ xr.select_font_face('sans-serif',
+ XR.FONT_SLANT_NORMAL, XR.FONT_WEIGHT_BOLD)
+ xr.set_source_rgb(0.8, 0.8, 0.8)
+
+ ## Figure out how big the text is going to be, and therefore how to scale
+ ## it so that it fills the available space pleasingly.
+ xb, yb, wd, ht, xa, ya = xr.text_extents(me._text)
+ m = max(wd, ht)
+ z = me._size/float(m) * 2.0/3.0
+ xr.scale(z, z)
+
+ ## Render the text in the middle of the image.
+ xr.move_to(3.0*m/4.0 - wd/2.0 - xb, 3.0*m/4.0 - ht/2.0 - yb)
+ xr.show_text(me._text)
+
+ ## We're done drawing. Collect the image and capture it as a Pixbuf so
+ ## that everyone else can use it.
+ surf.flush()
+ pix = GDK.pixbuf_new_from_data(surf.get_data(),
+ GDK.COLORSPACE_RGB, True, 8,
+ me._size, me._size, surf.get_stride())
+ return pix
+
+class FileImage (CacheableImage):
+ """
+ I represent an image fetched from a (local disk) file.
+ """
+
+ ## Useful attributes:
+ ## _file = filename to read image data from
+
+ def __init__(me, file):
+ """Initialize a FileImage which reads its image data from FILE."""
+ CacheableImage.__init__(me)
+ me._file = file
+
+ def _acquire(me):
+ """Acquire the image data."""
+ return GDK.pixbuf_new_from_file(me._file)
+
+###--------------------------------------------------------------------------
+### Miscellaneous utilities.
+
+def fetch_url(url):
+ """Fetch the resource named by URL, returning its content as a string."""
+ out = StringIO()
+ with U.urlopen(url) as u:
+ while True:
+ stuff = u.read(16384)
+ if not stuff: break
+ out.write(stuff)
+ return out.getvalue()
+
+def fix_background(w):
+ """Hack the style of the window W so that it shows white-on-black."""
+ style = w.get_style().copy()
+ style.base[GTK.STATE_NORMAL] = BLACK
+ style.bg[GTK.STATE_NORMAL] = BLACK
+ style.text[GTK.STATE_NORMAL] = WHITE
+ w.set_style(style)
+
+###--------------------------------------------------------------------------
+### The windows.
+
+class BaseCoverViewer (GTK.ScrolledWindow):
+ """
+ I represent a viewer for a collection of cover images, shown as thumbnails.
+
+ The image objects should have the following attributes.
+
+ img The actual image, as a CacheableImage.
+
+ text Some text to associate with the image, as a Python
+ string.
+
+ I will store an `iterator' in the image object's `it' attribute, which will
+ let others identify it later to the underlying Gtk machinery.
+
+ Subclasses should implement two methods:
+
+ activate(COVER) The COVER has been activated by the user (e.g.,
+ double-clicked).
+
+ select(COVER) The COVER has been selected by the user (e.g.,
+ clicked) in a temporary manner; if COVER is None,
+ then a previously selected cover has become
+ unselected.
+ """
+
+ ## Useful attributes:
+ ## iv = an IconView widget used to show the thumbnails
+ ## list = a ListStore object used to keep track of the cover images; each
+ ## item is a list of the form [PIXBUF, TEXT, COVER], where the PIXBUF
+ ## and TEXT are extracted from the cover object in the obvious way
+
+ def __init__(me):
+ """Initialize a BaseCoverViewer."""
+
+ ## Initialize myself, as a scrollable thingy.
+ GTK.ScrolledWindow.__init__(me)
+ me.set_policy(GTK.POLICY_AUTOMATIC, GTK.POLICY_AUTOMATIC)
+
+ ## Set up an IconView to actually show the cover thumbnails.
+ me.iv = GTK.IconView()
+ me.iv.connect('item-activated',
+ lambda iv, p: me.activate(me._frompath(p)))
+ me.iv.connect('selection-changed', me._select)
+ me.iv.set_pixbuf_column(0)
+ me.iv.set_text_column(1)
+ me.iv.set_orientation(GTK.ORIENTATION_VERTICAL)
+ me.iv.set_item_width(THUMBSZ + 32)
+ fix_background(me.iv)
+ me.add(me.iv)
+
+ ## Clear the list ready for cover images to be added.
+ me.reset()
+
+ def reset(me):
+ """
+ Clear the viewer of cover images.
+
+ This does /not/ clear the `it' attribute of previously attached cover
+ object.
+ """
+ me.list = GTK.ListStore(GDK.Pixbuf, G.TYPE_STRING, G.TYPE_PYOBJECT)
+ me.iv.set_model(me.list)
+ me.iv.unselect_all()
+
+ def addcover(me, cov):
+ """
+ Add the cover image COV to the viewer.
+
+ `COV.it' is filled in with the object's iterator.
+ """
+ cov.it = me.list.append([cov.img.thumbnail.pixbuf, cov.text, cov])
+
+ def _frompath(me, path):
+ """Convert a PATH to a cover image, and return it."""
+ return me.list[path][2]
+
+ def _select(me, iv):
+ """Handle a selection event, calling the subclass `select' method."""
+ sel = me.iv.get_selected_items()
+ if len(sel) != 1: me.select(None)
+ else: me.select(me._frompath(sel[0]))
+
+class SearchCover (object):
+ """
+ A base class for images in the SearchViewer window.
+ """
+ def __init__(me, img, width = None, height = None, marker = ''):
+ """
+ Initialize a SearchCover object.
+
+ The IMG is a CacheableImage of some kind. If the WIDTH and HEIGHT are
+ omitted, the image data will be acquired and both dimensions calculated
+ (since, after all, if we have to go to the bother of fetching the image,
+ we may as well get an accurate size).
+ """
+ me.img = img
+ if width is None or height is None:
+ pix = img.pixbuf
+ width = pix.get_width()
+ height = pix.get_height()
+ me.text = '%d×%d%s' % (width, height, marker)
+
+class SearchViewer (BaseCoverViewer):
+ """
+ I'm a BaseCoverViewer subclass for showing search results.
+
+ I'll be found within a CoverChooser window, showing the thumbnails
+ resulting from a search. I need to keep track of my parent CoverChooser,
+ so that I can tell it to show a large version of a selected image.
+ """
+
+ ## Useful attributes:
+ ## _chooser = the containing CoverChooser object
+
+ def __init__(me, chooser):
+ """
+ Initialize the SearchViewer, associating it with its parent CoverChooser.
+ """
+ BaseCoverViewer.__init__(me)
+ me._chooser = chooser
+
+ def switch(me, current):
+ """
+ Switch to a different album chosen in the CoverChooser.
+
+ CURRENT is either None, in which case the viewer is simply cleared, or
+ the current cover image (some CacheableImage object) for the newly chosen
+ album, which should be shown as the initial selection.
+ """
+ me.reset()
+ if current:
+ cov = SearchCover(current, marker = '*')
+ me.addcover(cov)
+ me.iv.select_path(me.list.get_path(cov.it))
+
+ def activate(me, cov):
+ """Inform the CoverChooser that the user activated COV."""
+ me._chooser.activated(cov)
+
+ def select(me, cov):
+ """Inform the CoverChooser that the user selected COV."""
+ me._chooser.selected(cov)
+
+class RemoteImage (CacheableImage):
+ """
+ I represent an image whose data can be fetched over the network.
+ """
+
+ ## Useful attributes:
+ ## _url = the URL to use to fetch the image
+ ## _ref = the referrer to set when fetching the image
+ ## _data = the image content from the server
+ ## _format = a PixbufFormat object describing the image format
+ ##
+ ## On first acquire, we fetch the image data from the server the hard way,
+ ## but we retain this indefinitely, even if the pixbuf is evicted as a
+ ## result of the cache filling. The idea is that JPEG files (say) are
+ ## rather smaller than uncompressed pixbufs, and it's better to use up
+ ## local memory storing a JPEG than to have to fetch the whole thing over
+ ## the network again.
+
+ ## A dummy image used in place of the real thing if we encounter an error.
+ ERRIMG = NullImage(256, '!')
+
+ def __init__(me, url, ref = None):
+ """
+ Initialize the RemoteImage object.
+
+ Image data will be fetched from URL; if a REF is provided (and is not
+ None), then it will be presented as the `referer' when fetching the
+ image.
+ """
+ CacheableImage.__init__(me)
+ me._url = url
+ me._ref = ref
+ me._data = None
+
+ def _fetch(me):
+ """
+ Fetch the image data from the server, if necessary.
+
+ On success, the raw image data is stored in the `_data' attribute. Many
+ things can go wrong, though.
+ """
+
+ ## If we already have the image data, then use what we've got already.
+ if me._data: return
+
+ ## Fetch the image data from the server.
+ d = StringIO()
+ rq = U2.Request(me._url)
+ if me._ref: rq.add_header('Referer', me._ref)
+ rs = U2.urlopen(rq)
+ while True:
+ stuff = rs.read(16384)
+ if not stuff: break
+ d.write(stuff)
+ me._data = d.getvalue()
+
+ ## Try to figure out what kind of image this is. With a bit of luck, we
+ ## can figure this out by spooning a bit of image data into a
+ ## PixbufLoader.
+ ld = GDK.PixbufLoader()
+ try:
+ o = 0
+ n = len(me._data)
+ while True:
+ if o >= n: raise ValueError, 'not going to work'
+ l = min(n, o + 16384)
+ ld.write(me._data[o:l])
+ o = l
+ f = ld.get_format()
+ if f: break
+ me._format = f
+
+ ## If this is a GIF then bail now. They look terrible.
+ if 'image/gif' in f['mime_types']:
+ me._data = None
+ raise ValueError, 'boycotting GIF image'
+
+ finally:
+ ## Tidy up: we don't want the loader any more.
+ try: ld.close()
+ except G.GError: pass
+
+ def _acquire(me):
+ """
+ Return a decoded image from the image data.
+
+ If this isn't going to work, return a dummy image.
+ """
+ try:
+ me._fetch()
+ ld = GDK.PixbufLoader()
+ try: ld.write(me._data)
+ finally: ld.close()
+ return ld.get_pixbuf()
+ except Exception, e:
+ print e
+ return me.ERRIMG.pixbuf
+
+ @property
+ def ext(me):
+ """Return a file extension for the image, in case we want to save it."""
+ ## If we can use `.jpg' then do that; otherwise, take whatever Gdk-Pixbuf
+ ## suggests.
+ exts = me._format['extensions']
+ for i in ['jpg']:
+ if i in exts: return i
+ return exts[0]
+
+class SearchImage (RemoteImage):
+ """
+ I represent an image found by searching the web.
+ """
+
+ ## Useful attributes:
+ ## _tburl = the thumbnail url
+
+ def __init__(me, url, ref, tburl):
+ """
+ Initialize a SearchImage object.
+
+ The URL and REF arguments are as for the base RemoteImage object; TBURL
+ is the location of a thumbnail image which (so the thinking goes) will be
+ smaller and hence faster to fetch than the main one.
+ """
+ RemoteImage.__init__(me, url, ref)
+ me._tburl = tburl
+
+ @property
+ def thumbnail(me):
+ """Fetch a thumbnail separately, using the thumbnail URL provided."""
+ if not me._thumb: me._thumb = Thumbnail(RemoteImage(me._tburl))
+ return me._thumb
+
+class SearchResult (SearchCover):
+ """
+ I represent information about an image found while searching the web.
+
+ I'm responsible for parsing information about individual search hits from
+ the result.
+ """
+ def __init__(me, r):
+ """Initialize a SearchResult, given a decoded JSON fragment R."""
+ i = r['image']
+ w = int(i['width'])
+ h = int(i['height'])
+ url = r['link']
+ ref = i['contextLink']
+ tburl = i['thumbnailLink']
+ SearchCover.__init__(me, SearchImage(url, ref, tburl),
+ width = w, height = h)
+
+class SearchFail (Exception):
+ """An exception found while trying to search for images."""
+ pass
+
+class CoverChooser (object):
+ """
+ I represent a window for choosing one of a number of cover art images.
+
+ I allow the user to choose one of a number of alternative images for an
+ album, and to search the Internet for more options.
+
+ I work on behalf of some other client object; I am responsible for
+ collecting the user's ultimate choice, but that responsibility ends when I
+ tell my client which image the user picked.
+
+ During my lifetime, I can be used to choosing images for different purposes
+ (possibly on behalf of different clients), though I can only work on one
+ thing at a time. I switch between jobs when `update' is called; see the
+ documentation of that method for details of the protocol.
+
+ I try to arrange that there's at most one instance of me, in the variable
+ `CHOOSER'.
+ """
+
+ ## Important attributes:
+ ## query = the entry widget for typing search terms
+ ## sv = the search viewer pane showing thumbnails of search results
+ ## img = the image preview pane showing a selected image at full size
+ ## win = our top-level window
+ ## view = the object which invoked us
+ ## which = the client's `which' parameter
+ ## current = the currently chosen image
+
+ ## This is a bit grim because search APIs and keys.
+ SEARCHURL = None
+ SEARCHID = '016674315927968770913:8blyelgp3wu'
+ REFERER = 'https://www.distorted.org.uk/~mdw/coverart'
+
+ @classmethod
+ def set_apikey(cls, apikey):
+ """Inform the class that it can use APIKEY to authorize its search."""
+ cls.SEARCHURL = \
+ 'https://www.googleapis.com/customsearch/v1?' \
+ 'key=%s&cx=%s&searchType=image&q=' % (apikey, cls.SEARCHID)
+
+ def __init__(me):
+ """Initialize the window, but don't try to show it yet."""
+
+ ## Make a window.
+ me.win = GTK.Window()
+
+ ## The window layout is like this.
+ ##
+ ## -----------------------------------
+ ## | [... ] [Search] |
+ ## |-----------------------------------|
+ ## | thumbs | |
+ ## | . | |
+ ## | . | image |
+ ## | . | |
+ ## | | preview |
+ ## | | |
+ ## | | |
+ ## | | |
+ ## | | |
+ ## -----------------------------------
+
+ ## Main layout box, with search stuff at the top and selection stuff
+ ## below.
+ box = GTK.VBox()
+
+ ## First, fill in the search stuff.
+ top = GTK.HBox()
+ me.query = GTK.Entry()
+ top.pack_start(me.query, True, True, 2)
+ srch = GTK.Button('_Search')
+ srch.set_flags(GTK.CAN_DEFAULT)
+ srch.connect('clicked', me.search)
+ top.pack_start(srch, False, False, 2)
+ box.pack_start(top, False, False, 2)
+
+ ## Now the thumbnail viewer and preview below.
+ panes = GTK.HPaned()
+ me.sv = SearchViewer(me)
+ panes.pack1(me.sv, False, True)
+ scr = GTK.ScrolledWindow()
+ scr.set_policy(GTK.POLICY_AUTOMATIC, GTK.POLICY_AUTOMATIC)
+ evb = GTK.EventBox()
+ me.img = GTK.Image()
+ evb.add(me.img)
+ fix_background(evb)
+ scr.add_with_viewport(evb)
+ panes.pack2(scr, True, True)
+ panes.set_position(THUMBSZ + 64)
+ box.pack_start(panes, True, True, 0)
+ me.win.add(box)
+
+ ## Finally, configure some signal handlers.
+ me.win.connect('destroy', me.destroyed)
+ me.win.set_default_size(800, 550)
+
+ ## Set the default button. (Gtk makes us wait until the button has a
+ ## top-level window to live in.)
+ srch.grab_default()
+
+ def update(me, view, which, dir, current):
+ """
+ Update the CoverChooser to choose a different album's cover image.
+
+ The VIEW is the client object. We will later call its `replace' method,
+ passing it WHICH and the newly chosen image (as a RemoteImage object).
+ WHICH is simply remembered as a context value for `update'. DIR is the
+ path to the album whose cover is to be chosen, used for constructing a
+ suitable search string. CURRENT is some kind of CacheableImage object
+ representing the currently chosen image we may be replacing.
+ """
+ me.view = view
+ me.which = which
+ me.current = current
+ me.img.clear()
+ me.sv.switch(current)
+ me.query.set_text(me.makequery(dir))
+ me.win.show_all()
+
+ def search(me, w):
+ """
+ Instigate a web search for a replacement image.
+
+ W is the widget which was frobbed to invoke the search, but it's not very
+ interesting.
+ """
+
+ ## Collect the search query.
+ q = me.query.get_text()
+
+ ## Try to ask a search provider for some likely images.
+ try:
+
+ ## We won't get far if we've not been given an API key.
+ if me.SEARCHURL is None: raise SearchFail('no search key')
+
+ ## Collect the search result.
+ try:
+ rq = U2.Request(me.SEARCHURL + U.quote_plus(q), None,
+ { 'Referer': me.REFERER })
+ rs = U2.urlopen(rq)
+ except U2.URLError, e:
+ raise SearchFail(e.reason)
+ result = JS.load(rs)
+
+ ## Clear out all of the images from the last search, leaving only the
+ ## incumbent choice, and then add the new images from the search
+ ## results.
+ me.sv.switch(me.current)
+ for r in result['items']:
+ try: me.sv.addcover(SearchResult(r))
+ except (U2.URLError, U2.HTTPError): pass
+
+ ## Maybe that didn't work.
+ except SearchFail, e:
+ print e.args[0]
+
+ def makequery(me, path):
+ """Construct a default search query string for the chosen album."""
+ bits = path.split(OS.path.sep)
+ return ' '.join(['"%s"' % p for p in bits[-2:]])
+
+ def selected(me, cov):
+ """
+ Show a full-size version of COV in the preview pane.
+
+ Called by the SearchViewer when a thumbnail is selected.
+ """
+ if cov: me.img.set_from_pixbuf(cov.img.pixbuf)
+ else: me.img.clear()
+
+ def activated(me, cov):
+ """
+ Inform our client that COV has been chosen as the replacement image.
+
+ Called by the SearchViewer when a thumbnail is activated.
+ """
+ if isinstance(cov, SearchCover): me.view.replace(me.which, cov.img)
+
+ def destroyed(me, w):
+ """
+ Our widget has been destroyed.
+
+ We're going away, so clear out the reference to us.
+ """
+ global CHOOSER
+ CHOOSER = None
+
+## There's currently no chooser.
+CHOOSER = None
+
+class ViewCover (object):
+ """
+ I represent an album cover image found already in the filesystem.
+
+ I can be found in MainViewer windows.
+ """
+
+ ## Useful attributes:
+ ## text = the text (directory name) associated with the cover
+ ## path = the full pathname to this directory
+ ## leaf = the basename of the cover image, or None
+
+ ## An error image, for use when there isn't a usable image.
+ NULLIMG = NullImage(THUMBSZ, '?')
+
+ def __init__(me, dir, path, leaf):
+ """
+ Initialize a new image.
+
+ DIR is the directory containing the image, relative to the root of the
+ search; it's presented to the user to help them distinguish the similar
+ icons (or identical ones, if multiple directories lack cover images).
+ PATH is the full pathname to the directory, and is used when installing a
+ replacement cover. LEAF is the basename of the cover image in that
+ directory, or None if there currently isn't an image there.
+ """
+ me.text = dir
+ me.path = path
+ me.leaf = leaf
+ if me.leaf:
+ me.img = me.covimg = FileImage(OS.path.join(me.path, me.leaf))
+ else:
+ me.img = me.NULLIMG
+ me.covimg = None
+
+class MainViewer (BaseCoverViewer):
+ """
+ I'm a top-level cover viewer, showing thumbnails for the albums I can find
+ in the search tree.
+ """
+
+ ## Useful attributes:
+ ## root = the root of the directory tree to manage
+
+ def __init__(me, root):
+ """
+ Initialize a viewer for choosing cover art in the tree headed by ROOT.
+ """
+ BaseCoverViewer.__init__(me)
+ me.root = root
+ me.walk('')
+
+ def walk(me, dir):
+ """
+ Walk the directory tree from DIR down, adding icons for cover art I find
+ (or don't find).
+ """
+
+ ## Assume this is a leaf directory for now.
+ leafp = True
+
+ ## Figure out the actual pathname we're looking at.
+ b = OS.path.join(me.root, dir)
+
+ ## The name of any image file we find.
+ imgfile = None
+
+ ## Work through the items in the directory.
+ for l in sorted(OS.listdir(b)):
+
+ if OS.path.isdir(OS.path.join(b, l)):
+ ## If this item is a directory, then we're not leaf, but need to
+ ## descend recursively.
+ leafp = False
+ me.walk(OS.path.join(dir, l))
+ else:
+ ## If this smells like a cover image then remember it. (If there are
+ ## multiple plausible options, just remember one more or less
+ ## arbitrarily.)
+ base, ext = OS.path.splitext(l)
+ if base == 'cover' and ext in ['.jpg', '.png', '.gif']: imgfile = l
+
+ ## If this is a leaf directory, hopefully representing an album rather
+ ## than an artist or higher-level grouping, then add an icon representing
+ ## it, including any cover image that we found.
+ if leafp:
+ me.addcover(ViewCover(dir, OS.path.join(me.root, dir), imgfile))
+
+ def select(me, cov):
+ """The user selected a cover icon, but we don't care."""
+ pass
+
+ def activate(me, cov):
+ """
+ A cover icon was activated.
+
+ Allow the user to choose a replacement cover.
+ """
+ global CHOOSER
+ if not CHOOSER:
+ CHOOSER = CoverChooser()
+ CHOOSER.update(me, cov, cov.text, cov.covimg)
+
+ def replace(me, cov, img):
+ """
+ Replace the cover COV by the newly chosen image IMG.
+
+ This is called by the CoverChooser.
+ """
+ leaf = 'cover.%s' % img.ext
+ out = OS.path.join(cov.path, leaf)
+ new = out + '.new'
+ with open(new, 'wb') as f:
+ f.write(img._data)
+ OS.rename(new, out)
+ if cov.leaf not in [None, leaf]:
+ OS.unlink(OS.path.join(cov.path, cov.leaf))
+ ncov = ViewCover(cov.text, cov.path, leaf)
+ ncov.it = cov.it
+ me.list[ncov.it] = [ncov.img.thumbnail.pixbuf, ncov.text, ncov]
+ me.activate(ncov)
+
+###--------------------------------------------------------------------------
+### Main program.
+
+if __name__ == '__main__':
+
+ ## Try to find an API key for searching.
+ CONFROOT = ENV.get('XDG_CONFIG_HOME', None)
+ if CONFROOT is None:
+ CONFROOT = OS.path.join(ENV['HOME'], '.config')
+ CONFDIR = OS.path.join(CONFROOT, 'autoys')
+ try:
+ f = open(OS.path.join(CONFDIR, 'apikey'))
+ except IOError, e:
+ if e.errno == E.ENOENT: pass
+ else: raise
+ else:
+ with f:
+ apikey = f.readline().strip()
+ CoverChooser.set_apikey(apikey)
+
+ ## Set things up.
+ ROOT = SYS.argv[1]
+ LOOP = G.MainLoop()
+ BLACK = GDK.Color(0, 0, 0)
+ WHITE = GDK.Color(65535, 65535, 65535)
+
+ ## Make a top-level window showing a MainView and display it.
+ WIN = GTK.Window()
+ VIEW = MainViewer(ROOT)
+ WIN.add(VIEW)
+ WIN.set_default_size(814, 660)
+ WIN.set_title('coverart')
+ WIN.connect('destroy', lambda _: LOOP.quit())
+ WIN.show_all()
+
+ ## Carry on until there's nothing left to do.
+ LOOP.run()
+
+###----- That's all, folks --------------------------------------------------
~mdw / autoys / blobdiff