/home/foss/Downloads/coverart-browser/coverart_artistview.py

# -*- Mode: python; coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
#
# Copyright (C) 2012 - fossfreedom
# Copyright (C) 2012 - Agustin Carrasco
#
# This program 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, or (at your option)
# any later version.
#
# This program 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 this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA.

import os
import tempfile
import shutil

from gi.repository import Gdk
from gi.repository import Gtk
from gi.repository import GLib
from gi.repository import GObject
from gi.repository import Gio
from gi.repository import GdkPixbuf
from gi.repository import RB

from coverart_browser_prefs import GSetting
from coverart_album import Album
from coverart_album import AlbumsModel
from coverart_album import CoverManager
from coverart_widgets import AbstractView
from coverart_utils import SortedCollection
from coverart_widgets import PanedCollapsible
from coverart_toolbar import ToolbarObject
from coverart_utils import idle_iterator
from coverart_utils import dumpstack
from coverart_utils import create_pixbuf_from_file_at_size
from coverart_extdb import CoverArtExtDB
import coverart_rb3compat as rb3compat
from coverart_rb3compat import Menu
import rb


def create_temporary_copy(path):
    temp_dir = tempfile.gettempdir()
    filename = tempfile.mktemp()
    temp_path = os.path.join(temp_dir, filename)
    shutil.copy2(path, temp_path)
    return temp_path


ARTIST_LOAD_CHUNK = 50


class Artist(GObject.Object):
    '''
    An album. It's conformed from one or more tracks, and many of it's
    information is deduced from them.

    :param name: `str` name of the artist.
    :param cover: `Cover` cover for this artist.
    '''
    # signals
    __gsignals__ = {
        'modified': (GObject.SIGNAL_RUN_FIRST, None, ()),
        'emptied': (GObject.SIGNAL_RUN_LAST, None, ()),
        'cover-updated': (GObject.SIGNAL_RUN_LAST, None, ())
    }

    __hash__ = GObject.__hash__

    def __init__(self, name, cover):
        super(Artist, self).__init__()

        self.name = name
        self._cover = None
        self.cover = cover

        self._signals_id = {}

    @property
    def cover(self):
        return self._cover

    @cover.setter
    def cover(self, new_cover):
        #if self._cover:
        #    self._cover.disconnect(self._cover_resized_id)

        self._cover = new_cover
        #self._cover_resized_id = self._cover.connect('resized',
        #    lambda *args: self.emit('cover-updated'))

        self.emit('cover-updated')

    def create_ext_db_key(self):
        '''
        Returns an `RB.ExtDBKey` 
        '''
        key = RB.ExtDBKey.create_lookup('artist', self.name)
        return key


class ArtistsModel(GObject.Object):
    '''
    Model that contains artists, keeps them sorted, filtered and provides an
    external `Gtk.TreeModel` interface to use as part of a Gtk interface.

    The `Gtk.TreeModel` haves the following structure:
    column 0 -> string containing the artist name
    column 1 -> pixbuf of the artist's cover.
    column 2 -> instance of the artist or album itself.
    column 3 -> boolean that indicates if the row should be shown
    column 4 -> blank text column to pad the view correctly
    column 5 -> markup containing formatted text
    column 6 -> blank text for the expander column
    '''
    # signals
    __gsignals__ = {
        'update-path': (GObject.SIGNAL_RUN_LAST, None, (object,)),
        'visual-updated': ((GObject.SIGNAL_RUN_LAST, None, (object, object)))
    }

    # list of columns names and positions on the TreeModel
    columns = {'tooltip': 0, 'pixbuf': 1,
               'artist_album': 2, 'show': 3,
               'empty': 4, 'markup': 5, 'expander': 6}

    def __init__(self, album_manager):
        super(ArtistsModel, self).__init__()

        self.album_manager = album_manager
        self._iters = {}
        self._albumiters = {}
        self._artists = SortedCollection(
            key=lambda artist: getattr(artist, 'name'))

        self._tree_store = Gtk.TreeStore(str, GdkPixbuf.Pixbuf, object,
                                         bool, str, str, str)

        # sorting idle call
        self._sort_process = None

        # create the filtered store that's used with the view
        self._filtered_store = self._tree_store.filter_new()
        self._filtered_store.set_visible_column(ArtistsModel.columns['show'])

        self._tree_sort = Gtk.TreeModelSort(model=self._filtered_store)
        #self._tree_sort.set_default_sort_func(lambda *unused: 0)       
        self._tree_sort.set_sort_func(0, self._compare, None)

        self._connect_signals()

    def _connect_signals(self):
        self.connect('update-path', self._on_update_path)
        self.album_manager.model.connect('filter-changed', self._on_album_filter_changed)

    def _on_album_filter_changed(self, *args):
        if len(self._iters) == 0:
            return

        artists = list(set(row[AlbumsModel.columns['album']].artist for row in self.album_manager.model.store))

        for artist in self._iters:
            self.show(artist, artist in artists)

    def _compare(self, model, row1, row2, user_data):

        if not model.iter_has_child(row1) or \
                not model.iter_has_child(row2):
            return 0

        sort_column = 0
        value1 = RB.search_fold(model.get_value(row1, sort_column))
        value2 = RB.search_fold(model.get_value(row2, sort_column))
        if value1 < value2:
            return -1
        elif value1 == value2:
            return 0
        else:
            return 1

    @property
    def store(self):
        #return self._filtered_store
        return self._tree_sort

    def add(self, artist):
        '''
        Add an artist to the model.

        :param artist: `Artist` to be added to the model.
        '''
        # generate necessary values
        values = self._generate_artist_values(artist)
        # insert the values
        pos = self._artists.insert(artist)
        tree_iter = self._tree_store.insert(None, pos, values)
        child_iter = self._tree_store.insert(tree_iter, pos, values)  # dummy child row so that the expand is available
        # connect signals
        ids = (artist.connect('modified', self._artist_modified),
               artist.connect('cover-updated', self._cover_updated),
               artist.connect('emptied', self.remove))

        if not artist.name in self._iters:
            self._iters[artist.name] = {}
        self._iters[artist.name] = {'artist_album': artist,
                                    'iter': tree_iter, 'dummy_iter': child_iter, 'ids': ids}
        return tree_iter

    def _emit_signal(self, tree_iter, signal):
        # we get the filtered path and iter since that's what the outside world
        # interacts with
        tree_path = self._filtered_store.convert_child_path_to_path(
            self._tree_store.get_path(tree_iter))

        if tree_path:
            # if there's no path, the album doesn't show on the filtered model
            # so no one needs to know
            tree_iter = self._filtered_store.get_iter(tree_path)

            self.emit(signal, tree_path, tree_iter)

    def remove(self, *args):
        print("artist remove")

    def _cover_updated(self, artist):
        tree_iter = self._iters[artist.name]['iter']

        if self._tree_store.iter_is_valid(tree_iter):
            # only update if the iter is valid
            pixbuf = artist.cover.pixbuf

            self._tree_store.set_value(tree_iter, self.columns['pixbuf'],
                                       pixbuf)

            self._emit_signal(tree_iter, 'visual-updated')

    def _artist_modified(self, *args):
        print("artist modified")

    def _on_update_path(self, widget, treepath):
        '''
           called when update-path signal is called
        '''
        artist = self.get_from_path(treepath)
        albums = self.album_manager.model.get_all()
        self.add_album_to_artist(artist, albums)

    def add_album_to_artist(self, artist, albums):
        '''
        Add an album to the artist in the model.

        :param artist: `Artist` for the album to be added to (i.e. the parent)
        :param album: array of `Album` which are the children of the Artist
        
        '''
        # get the artist iter
        artist_iter = self._iters[artist.name]['iter']

        # now remove the dummy_iter - if this fails, we've removed this 
        # before and have no need to add albums

        if 'dummy_iter' in self._iters[artist.name]:
            self._iters[artist.name]['album'] = []

        for album in albums:
            if artist.name == album.artist and not (album in self._albumiters):
                # now for all matching albums that were found lets add to the model

                # generate necessary values
                values = self._generate_album_values(album)
                # insert the values
                tree_iter = self._tree_store.append(artist_iter, values)
                self._albumiters[album] = {}
                self._albumiters[album]['iter'] = tree_iter
                self._iters[artist.name]['album'].append(tree_iter)

                # connect signals
                ids = (album.connect('modified', self._album_modified),
                       album.connect('cover-updated', self._album_coverupdate),
                       album.connect('emptied', self._album_emptied))

                self._albumiters[album]['ids'] = ids

        if 'dummy_iter' in self._iters[artist.name]:
            self._tree_store.remove(self._iters[artist.name]['dummy_iter'])
            del self._iters[artist.name]['dummy_iter']

        self.sort()  # ensure the added albums are sorted correctly

    def _album_modified(self, album):
        print("album modified")
        print(album)
        if not (album in self._albumiters):
            print("not found in albumiters")
            return

        tree_iter = self._albumiters[album]['iter']

        if self._tree_store.iter_is_valid(tree_iter):
            # only update if the iter is valid
            # generate and update values
            tooltip, pixbuf, album, show, blank, markup, empty = \
                self._generate_album_values(album)

            self._tree_store.set(tree_iter, self.columns['tooltip'], tooltip,
                                 self.columns['markup'], markup, self.columns['show'], show)

            self.sort()  # ensure the added albums are sorted correctly

    def _album_emptied(self, album):
        '''
        Removes this album from the model.

        :param album: `Album` to be removed from the model.
        '''
        print('album emptied')
        print(album)
        print(album.artist)
        if not (album in self._albumiters):
            print("not found in albumiters")
            return

        artist = self.get(album.artist)
        album_iter = self._albumiters[album]['iter']

        self._iters[album.artist]['album'].remove(album_iter)
        self._tree_store.remove(album_iter)

        # disconnect signals
        for sig_id in self._albumiters[album]['ids']:
            album.disconnect(sig_id)

        del self._albumiters[album]

        # test if there are any more albums for this artist otherwise just cleanup
        if len(self._iters[album.artist]['album']) == 0:
            self.remove(artist)
            self._on_album_filter_changed(_)

    def _album_coverupdate(self, album):
        tooltip, pixbuf, album, show, blank, markup, empty = self._generate_album_values(album)
        self._tree_store.set_value(self._albumiters[album]['iter'],
                                   self.columns['pixbuf'], pixbuf)

    def _generate_artist_values(self, artist):
        tooltip = artist.name
        pixbuf = artist.cover.pixbuf
        show = True

        return tooltip, pixbuf, artist, show, '', \
               GLib.markup_escape_text(tooltip), ''

    def _generate_album_values(self, album):
        tooltip = album.name
        pixbuf = album.cover.pixbuf.scale_simple(48, 48, GdkPixbuf.InterpType.BILINEAR)
        show = True

        rating = album.rating
        if int(rating) > 0:
            rating = u'\u2605' * int(rating)
        else:
            rating = ''

        year = ' (' + str(album.real_year) + ')'

        track_count = album.track_count
        if track_count == 1:
            detail = rb3compat.unicodedecode(_(' with 1 track'), 'UTF-8')
        else:
            detail = rb3compat.unicodedecode(_(' with %d tracks') %
                                             track_count, 'UTF-8')

        duration = album.duration / 60

        if duration == 1:
            detail += rb3compat.unicodedecode(_(' and a duration of 1 minute'), 'UTF-8')
        else:
            detail += rb3compat.unicodedecode(_(' and a duration of %d minutes') %
                                              duration, 'UTF-8')

        tooltip = rb3compat.unicodestr(tooltip, 'utf-8')
        tooltip = rb3compat.unicodeencode(tooltip, 'utf-8')
        import cgi

        formatted = '<b><i>' + \
                    cgi.escape(rb3compat.unicodedecode(tooltip, 'utf-8')) + \
                    '</i></b>' + \
                    year + \
                    ' ' + rating + \
                    '\n<small>' + \
                    GLib.markup_escape_text(detail) + \
                    '</small>'

        return tooltip, pixbuf, album, show, '', formatted, ''

    def remove(self, artist):
        '''
        Removes this artist from the model.

        :param artist: `Artist` to be removed from the model.
        '''
        self._artists.remove(artist)
        self._tree_store.remove(self._iters[artist.name]['iter'])

        del self._iters[artist.name]

    def contains(self, artist_name):
        '''
        Indicates if the model contains a specific artist.

        :param artist_name: `str` name of the artist.
        '''
        return artist_name in self._iters

    def get(self, artist_name):
        '''
        Returns the requested Artist.

        :param artist_name: `str` name of the artist.
        '''
        return self._iters[artist_name]['artist_album']

    def get_albums(self, artist_name):
        '''
        Returns the displayed albums for the requested artist

        :param artist_name: `str` name of the artist.
        '''

        albums = []

        artist_iter = self._iters[artist_name]['iter']
        next_iter = self._tree_store.iter_children(artist_iter)

        while next_iter != None:
            albums.append(self._tree_store[next_iter][self.columns['artist_album']])
            next_iter = self._tree_store.iter_next(next_iter)
        #if 'album' in self._iters[artist_name]:
        #    for album_iter in self._iters[artist_name]['album']:
        #        path = self._tree_store.get_path(album_iter)
        #        if path:
        #        tree_path = self._filtered_store.convert_child_path_to_path(
        #            )
        #        albums.append(self.get_from_path(tree_path))

        return albums

    def get_all(self):
        '''
        Returns a collection of all the artists in this model.
        '''
        return self._artists

    def get_from_path(self, path):
        '''
        Returns the Artist or Album referenced by a `Gtk.TreeModelSort` path.

        :param path: `Gtk.TreePath` referencing the artist.
        '''
        return self.store[path][self.columns['artist_album']]

    def get_path(self, artist):
        print(artist.name)
        print(self._iters[artist.name]['iter'])
        return self._tree_store.get_path(
            self._iters[artist.name]['iter'])

    def get_from_ext_db_key(self, key):
        '''
        Returns the requested artist.

        :param key: ext_db_key
        '''
        # get the album name and artist
        name = key.get_field('artist')

        # first check if there's a direct match
        artist = self.get(name) if self.contains(name) else None
        return artist

    def show(self, artist_name, show):
        '''
        filters/unfilters an artist, making it visible to the publicly available model's
        `Gtk.TreeModel`

        :param artist: str containing the name of the artist to show or hide.
        :param show: `bool` indcating whether to show(True) or hide(False) the
            artist.
        '''
        artist_iter = self._iters[artist_name]['iter']

        if self._tree_store.iter_is_valid(artist_iter):
            self._tree_store.set_value(artist_iter, self.columns['show'], show)


    def sort(self):

        albums = SortedCollection(key=lambda album: getattr(album, 'name'))

        gs = GSetting()
        source_settings = gs.get_setting(gs.Path.PLUGIN)
        key = source_settings[gs.PluginKey.SORT_BY_ARTIST]
        order = source_settings[gs.PluginKey.SORT_ORDER_ARTIST]

        sort_keys = {
            'name_artist': ('album_sort', 'album_sort'),
            'year_artist': ('real_year', 'calc_year_sort'),
            'rating_artist': ('rating', 'album_sort')
        }

        props = sort_keys[key]

        def key_function(album):
            keys = [getattr(album, prop) for prop in props]
            return keys

        # remember the current sort then remove the sort order
        # because sorting will only work in unsorted lists
        sortSettings = self.store.get_sort_column_id()

        self.store.set_sort_column_id(-1, Gtk.SortType.ASCENDING)

        for artist in self._iters:
            albums.clear()
            albums.key = key_function

            if 'album' in self._iters[artist] and len(self._iters[artist]['album']) > 1:
                # we only need to sort an artists albums if there is more than one album

                # sort all the artists albums
                for album_iter in self._iters[artist]['album']:
                    albums.insert(self._tree_store[album_iter][self.columns['artist_album']])

                if not order:
                    albums = reversed(albums)

                # now we iterate through the sorted artist albums.  Look and swap iters
                # according to where they are in the tree store

                artist_iter = self._iters[artist]['iter']
                next_iter = self._tree_store.iter_children(artist_iter)

                for album in albums:
                    if self._tree_store[next_iter][self.columns['artist_album']] != album:
                        self._tree_store.swap(next_iter, self._albumiters[album]['iter'])
                        next_iter = self._albumiters[album]['iter']
                    next_iter = self._tree_store.iter_next(next_iter)

        # now we have finished sorting, reapply the sort
        self.store.set_sort_column_id(*sortSettings)


class ArtistCellRenderer(Gtk.CellRendererPixbuf):
    def __init__(self):
        super(ArtistCellRenderer, self).__init__()

    def do_render(self, cr, widget,
                  background_area,
                  cell_area,
                  flags):
        newpix = self.props.pixbuf  #.copy()
        #newpix = newpix.scale_simple(48,48,GdkPixbuf.InterpType.BILINEAR)

        Gdk.cairo_set_source_pixbuf(cr, newpix, 0, 0)
        cr.paint()


class ArtistLoader(GObject.Object):
    '''
    Loads Artists - updating the model accordingly.

    :param artist_manager: `artist_manager` responsible for this loader.
    '''
    # signals
    __gsignals__ = {
        'artists-load-finished': (GObject.SIGNAL_RUN_LAST, None, (object,)),
        'model-load-finished': (GObject.SIGNAL_RUN_LAST, None, ())
    }

    def __init__(self, artist_manager, album_manager):
        super(ArtistLoader, self).__init__()

        self.shell = artist_manager.shell
        self._connect_signals()
        self._album_manager = album_manager
        self._artist_manager = artist_manager

        self.model = artist_manager.model

    def load_artists(self):
        print ("load_artists")
        albums = self._album_manager.model.get_all()
        model = list(set(album.artist for album in albums))

        self._load_artists(iter(model), artists={}, model=model,
                           total=len(model), progress=0.)

    @idle_iterator
    def _load_artists(self):
        def process(row, data):
            # allocate the artist
            artist = Artist(row, self._artist_manager.cover_man.unknown_cover)

            data['artists'][row] = artist

        def after(data):
            # update the progress
            data['progress'] += ARTIST_LOAD_CHUNK

            self._album_manager.progress = data['progress'] / data['total']

        def error(exception):
            print('Error processing entries: ' + str(exception))

        def finish(data):
            self._album_manager.progress = 1
            self.emit('artists-load-finished', data['artists'])

        return ARTIST_LOAD_CHUNK, process, after, error, finish

    @idle_iterator
    def _load_model(self):
        def process(artist, data):
            # add  the artists to the model
            self._artist_manager.model.add(artist)

        def after(data):
            data['progress'] += ARTIST_LOAD_CHUNK

            # update the progress
            self._album_manager.progress = 1 - data['progress'] / data['total']

        def error(exception):
            dumpstack("Something awful happened!")
            print('Error(2) while adding artists to the model: ' + str(exception))

        def finish(data):
            self._album_manager.progress = 1
            self.emit('model-load-finished')
            print ("finished")
            #return False

        return ARTIST_LOAD_CHUNK, process, after, error, finish

    def _connect_signals(self):
        # connect signals for updating the albums
        #self.entry_changed_id = self._album_manager.db.connect('entry-changed',
        #    self._entry_changed_callback)
        pass

    def do_artists_load_finished(self, artists):
        self._load_model(iter(list(artists.values())), total=len(artists), progress=0.)
        self._album_manager.model.connect('album-added', self._on_album_added)

    def _on_album_added(self, album_model, album):
        '''
          called when album-manager album-added signal is invoked
        '''
        print(album.artist)
        if self._artist_manager.model.contains(album.artist):
            print("contains artist")
            artist = self._artist_manager.model.get(album.artist)
            self._artist_manager.model.add_album_to_artist(artist, [album])
        else:
            print("new artist")
            artist = Artist(album.artist, self._artist_manager.cover_man.unknown_cover)
            self._artist_manager.model.add(artist)


class ArtistCoverManager(CoverManager):
    force_lastfm_check = True

    def __init__(self, plugin, artist_manager):
        self.cover_db = CoverArtExtDB(name='artist-art')

        super(ArtistCoverManager, self).__init__(plugin, artist_manager)

        self.cover_size = 72

        # create unknown cover and shadow for covers
        self.create_unknown_cover(plugin)

    def create_unknown_cover(self, plugin):
        # create the unknown cover
        self.unknown_cover = self.create_cover(
            rb.find_plugin_file(plugin, 'img/microphone.png'))

        super(ArtistCoverManager, self).create_unknown_cover(plugin)

    def update_pixbuf_cover(self, coverobject, pixbuf):
        # if it's a pixbuf, assign it to all the artist for the artist
        key = RB.ExtDBKey.create_storage('artist', coverobject.name)

        self.cover_db.store(key, RB.ExtDBSourceType.USER_EXPLICIT,
                            pixbuf)


class ArtistManager(GObject.Object):
    '''
    Main construction that glues together the different managers, the loader
    and the model. It takes care of initializing all the system.

    :param plugin: `Peas.PluginInfo` instance.
    :param current_view: `ArtistView` where the Artists are shown.
    '''
    # singleton instance
    instance = None

    # properties
    progress = GObject.property(type=float, default=0)

    # signals
    __gsignals__ = {
        'sort': (GObject.SIGNAL_RUN_LAST, None, (object,))
    }

    def __init__(self, plugin, album_manager, shell):
        super(ArtistManager, self).__init__()

        self.db = plugin.shell.props.db
        self.shell = shell
        self.plugin = plugin

        self.cover_man = ArtistCoverManager(plugin, self)
        self.cover_man.album_manager = album_manager

        self.model = ArtistsModel(album_manager)
        self.loader = ArtistLoader(self, album_manager)

        # connect signals
        self._connect_signals()

    def _connect_signals(self):
        '''
        Connects the manager to all the needed signals for it to work.
        '''
        self.loader.connect('model-load-finished', self._load_finished_callback)
        self.connect('sort', self._sort_artist)

    def _sort_artist(self, widget, param):
        toolbar_type = param

        if not toolbar_type or toolbar_type == "artist":
            self.model.sort()

    def _load_finished_callback(self, *args):
        self.cover_man.load_covers()


class ArtistShowingPolicy(GObject.Object):
    '''
    Policy that mostly takes care of how and when things should be showed on
    the view that makes use of the `AlbumsModel`.
    '''

    def __init__(self, flow_view):
        super(ArtistShowingPolicy, self).__init__()

        self._flow_view = flow_view
        self.counter = 0
        self._has_initialised = False

    def initialise(self, album_manager):
        if self._has_initialised:
            return

        self._has_initialised = True
        self._album_manager = album_manager
        self._model = album_manager.model


class ArtistView(Gtk.TreeView, AbstractView):
    __gtype_name__ = "ArtistView"

    name = 'artistview'
    icon_automatic = GObject.property(type=bool, default=True)
    panedposition = PanedCollapsible.Paned.COLLAPSE

    __gsignals__ = {
        'update-toolbar': (GObject.SIGNAL_RUN_LAST, None, ())
    }


    def __init__(self, *args, **kwargs):
        super(ArtistView, self).__init__(*args, **kwargs)

        self._external_plugins = None
        self.gs = GSetting()
        self.show_policy = ArtistShowingPolicy(self)
        self.view = self
        self._has_initialised = False
        self._last_row_was_artist = False

    def initialise(self, source):
        if self._has_initialised:
            return

        self._has_initialised = True

        self.view_name = "artist_view"
        super(ArtistView, self).initialise(source)
        self.album_manager = source.album_manager
        self.shell = source.shell
        self.props.has_tooltip = True

        self.set_enable_tree_lines(True)

        col = Gtk.TreeViewColumn('       ', Gtk.CellRendererText(), text=6)
        self.append_column(col)

        pixbuf = Gtk.CellRendererPixbuf()
        col = Gtk.TreeViewColumn(_('Covers'), pixbuf, pixbuf=1)

        self.append_column(col)

        col = Gtk.TreeViewColumn(_('Artist'), Gtk.CellRendererText(), markup=5)
        self._artist_col = col
        col.set_clickable(True)
        col.set_sort_column_id(0)
        col.set_sort_indicator(True)
        col.connect('clicked', self._artist_sort_clicked)
        self.append_column(col)
        col = Gtk.TreeViewColumn('', Gtk.CellRendererText(), text=4)
        self.append_column(col)  # dummy column to expand horizontally

        self.artist_manager = self.album_manager.artist_man
        self.artist_manager.model.store.set_sort_column_id(0, Gtk.SortType.ASCENDING)
        self.set_model(self.artist_manager.model.store)

        # setup iconview drag&drop support
        # first drag and drop on the coverart view to receive coverart
        self.enable_model_drag_dest([], Gdk.DragAction.COPY)
        self.drag_dest_add_image_targets()
        self.drag_dest_add_text_targets()
        self.connect('drag-drop', self.on_drag_drop)
        self.connect('drag-data-received',
                     self.on_drag_data_received)

        # lastly support drag-drop from coverart to devices/nautilus etc
        # n.b. enabling of drag-source is controlled by the selection-changed to ensure
        # we dont allow drag from artists
        self.connect('drag-begin', self.on_drag_begin)
        self._targets = Gtk.TargetList.new([Gtk.TargetEntry.new("text/uri-list", 0, 0)])

        # N.B. values taken from rhythmbox v2.97 widgets/rb_entry_view.c
        self._targets.add_uri_targets(1)
        self.connect("drag-data-get", self.on_drag_data_get)

        # define artist specific popup menu
        self.artist_popup_menu = Menu(self.plugin, self.shell)
        self.artist_popup_menu.load_from_file('ui/coverart_artist_pop_rb2.ui',
                                              'ui/coverart_artist_pop_rb3.ui')
        signals = \
            {'play_album_menu_item': self.source.play_album_menu_item_callback,
             'queue_album_menu_item': self.source.queue_album_menu_item_callback,
             'add_to_playing_menu_item': self.source.add_playlist_menu_item_callback,
             'new_playlist': self.source.add_playlist_menu_item_callback,
             'artist_cover_search_menu_item': self.cover_search_menu_item_callback
            }

        self.artist_popup_menu.connect_signals(signals)
        self.artist_popup_menu.connect('pre-popup', self.pre_popup_menu_callback)

        # connect properties and signals
        self._connect_properties()
        self._connect_signals()

    def _connect_properties(self):
        setting = self.gs.get_setting(self.gs.Path.PLUGIN)
        setting.bind(self.gs.PluginKey.ICON_AUTOMATIC, self,
                     'icon_automatic', Gio.SettingsBindFlags.GET)

    def _connect_signals(self):
        self.connect('row-activated', self._row_activated)
        self.connect('row-expanded', self._row_expanded)
        self.connect('button-press-event', self._row_click)
        self.get_selection().connect('changed', self._selection_changed)
        self.connect('query-tooltip', self._query_tooltip)

    def _artist_sort_clicked(self, *args):
        # in the absence of an apparent way to remove the unsorted default_sort_func
        # find out if we are now in an unsorted state - if we are
        # throw another clicked event so that we remain sorted.
        value, order = self.artist_manager.model.store.get_sort_column_id()

        if order == None:
            self._artist_col.emit('clicked')

    def cover_search_menu_item_callback(self, *args):
        self.artist_manager.cover_man.search_covers(self.get_selected_objects(just_artist=True),
                                                    callback=self.source.update_request_status_bar)

    def _query_tooltip(self, widget, x, y, key, tooltip):

        try:
            winx, winy = self.convert_widget_to_bin_window_coords(x, y)
            treepath, treecolumn, cellx, celly = self.get_path_at_pos(winx, winy)
            active_object = self.artist_manager.model.get_from_path(treepath)

            #active_object=self.artist_manager.model.store[treepath][self.artist_manager.model.columns['artist_album']]

            if isinstance(active_object, Artist) and \
                            treecolumn.get_title() == _('Covers') and \
                            active_object.cover.original != self.artist_manager.cover_man.unknown_cover.original:
                # we display the tooltip if the row is an artist and the column
                # is actually the artist cover itself
                pixbuf = GdkPixbuf.Pixbuf.new_from_file(active_object.cover.original)

                src_width = pixbuf.get_width()
                src_height = pixbuf.get_height()

                factor = min(float(256) / float(src_width), float(256) / float(src_height))
                new_width = int(src_width * factor + 0.5)
                new_height = int(src_height * factor + 0.5)

                pixbuf = create_pixbuf_from_file_at_size(
                    active_object.cover.original, new_width, new_height)

                tooltip.set_icon(pixbuf)
                return True
            else:
                return False

        except:
            pass

    def _row_expanded(self, treeview, treeiter, treepath):
        '''
        event called when clicking the expand icon on the treeview
        '''
        self._row_activated(treeview, treepath, _)

    def _row_activated(self, treeview, treepath, treeviewcolumn):
        '''
        event called when double clicking on the tree-view or by keyboard ENTER
        '''
        active_object = self.artist_manager.model.get_from_path(treepath)
        if isinstance(active_object, Artist):
            self.artist_manager.model.emit('update-path', treepath)
        else:
            #we need to play this album
            self.source.play_selected_album(self.source.favourites)

    def pre_popup_menu_callback(self, *args):
        '''
          callback when artist popup menu is about to be displayed
        '''

        state, sensitive = self.shell.props.shell_player.get_playing()
        if not state:
            sensitive = False

        #self.popup_menu.get_menu_object('add_to_playing_menu_item')
        self.artist_popup_menu.set_sensitive('add_to_playing_menu_item', sensitive)

        self.source.playlist_menu_item_callback()

    def _row_click(self, widget, event):
        '''
        event called when clicking on a row
        '''
        print ('_row_click')

        try:
            treepath, treecolumn, cellx, celly = self.get_path_at_pos(event.x, event.y)
        except:
            return

        active_object = self.artist_manager.model.get_from_path(treepath)

        if not isinstance(active_object, Album):
            self.source.artist_info.emit('selected', active_object.name, None)
            if self.icon_automatic:
                # reset counter so that we get correct double click action for albums
                self.source.click_count = 0

            if treecolumn != self.get_expander_column():
                if self.row_expanded(treepath) and event.button == 1 and self._last_row_was_artist:
                    self.collapse_row(treepath)
                else:
                    self.expand_row(treepath, False)

                self._last_row_was_artist = True

                if event.button == 3:
                    # on right click
                    # display popup

                    self.artist_popup_menu.popup(self.source, 'popup_menu', 3,
                                                 Gtk.get_current_event_time())
            print ('_row click artist exit')
            return

        if event.button == 1:
            # on click
            # to expand the entry view
            ctrl = event.state & Gdk.ModifierType.CONTROL_MASK
            shift = event.state & Gdk.ModifierType.SHIFT_MASK

            if self.icon_automatic and not self._last_row_was_artist:
                self.source.click_count += 1 if not ctrl and not shift else 0

            if self.source.click_count == 1:
                Gdk.threads_add_timeout(GLib.PRIORITY_DEFAULT_IDLE, 250,
                                        self.source.show_hide_pane, active_object)

        elif event.button == 3:
            # on right click
            # display popup

            self.popup.popup(self.source, 'popup_menu', 3,
                             Gtk.get_current_event_time())

        self._last_row_was_artist = False

        print ('_row_click album exit')
        return

    def get_view_icon_name(self):
        return "artistview.png"

    def _selection_changed(self, *args):
        selected = self.get_selected_objects(just_artist=True)

        print(selected)
        if len(selected) == 0:
            self.source.entry_view.clear()
            return

        if isinstance(selected[0], Artist):
            print("selected artist")
            self.unset_rows_drag_source()  # turn off drag-drop for artists

            self.source.entryviewpane.update_cover(selected[0],
                                                   self.artist_manager)
        else:
            print("selected album")
            self.source.update_with_selection()
            # now turnon drag-drop for album.
            self.enable_model_drag_source(Gdk.ModifierType.BUTTON1_MASK,
                [], Gdk.DragAction.COPY)
            self.drag_source_set_target_list(self._targets)

    def switch_to_coverpane(self, cover_search_pane):
        '''
        called from the source to update the coverpane when
        it is switched from the track pane
        This overrides the base method
        '''

        selected = self.get_selected_objects(just_artist=True)

        if selected:
            manager = self.get_default_manager()
            self.source.entryviewpane.cover_search(selected[0],
                                                   manager)

    def get_selected_objects(self, just_artist=False):
        '''
        finds what has been selected

        returns an array of `Album`
        '''
        selection = self.get_selection()
        model, treeiter = selection.get_selected()
        if treeiter:
            active_object = model.get_value(treeiter, ArtistsModel.columns['artist_album'])
            if isinstance(active_object, Album):
                # have chosen an album then just return that album
                return [active_object]
            else:
                # must have chosen an artist - return all albums for the artist by default
                # or just the artist itself
                if not just_artist:
                    return self.artist_manager.model.get_albums(active_object.name)
                else:
                    return [active_object]
        return []

    def switch_to_view(self, source, album):
        self.initialise(source)
        self.show_policy.initialise(source.album_manager)

        self.scroll_to_album(album)

    def scroll_to_album(self, album):
        if album:
            print("switch to artist view")
            print(album)
            artist = self.artist_manager.model.get(album.artist)
            path = self.artist_manager.model.get_path(artist)
            print(artist)
            print(path)
            path = self.artist_manager.model.store.convert_child_path_to_path(path)
            print(path)
            if path:
                self.scroll_to_cell(path, self._artist_col)
                self.expand_row(path, False)
                self.set_cursor(path)

    def do_update_toolbar(self, *args):
        self.source.toolbar_manager.set_enabled(False, ToolbarObject.SORT_BY)
        self.source.toolbar_manager.set_enabled(False, ToolbarObject.SORT_ORDER)
        self.source.toolbar_manager.set_enabled(True, ToolbarObject.SORT_BY_ARTIST)
        self.source.toolbar_manager.set_enabled(True, ToolbarObject.SORT_ORDER_ARTIST)

    def on_drag_drop(self, widget, context, x, y, time):
        '''
        Callback called when a drag operation finishes over the view
        of the source. It decides if the dropped item can be processed as
        an image to use as a cover.
        '''

        # stop the propagation of the signal (deactivates superclass callback)
        widget.stop_emission_by_name('drag-drop')

        # obtain the path of the icon over which the drag operation finished
        drop_info = self.get_dest_row_at_pos(x, y)
        path = None
        if drop_info:
            path, position = drop_info

        result = path is not None

        if result:
            target = self.drag_dest_find_target(context, None)
            widget.drag_get_data(context, target, time)

        return result

    def on_drag_data_received(self, widget, drag_context, x, y, data, info,
                              time):
        '''
        Callback called when the drag source has prepared the data (pixbuf)
        for us to use.
        '''

        # stop the propagation of the signal (deactivates superclass callback)
        widget.stop_emission_by_name('drag-data-received')

        # get the artist and the info and ask the loader to update the cover
        path, position = self.get_dest_row_at_pos(x, y)
        artist_album = widget.get_model()[path][2]

        pixbuf = data.get_pixbuf()

        if isinstance(artist_album, Album):
            manager = self.album_manager
        else:
            manager = self.artist_manager

        if pixbuf:
            manager.cover_man.update_cover(artist_album, pixbuf)
        else:
            uri = data.get_text()
            manager.cover_man.update_cover(artist_album, uri=uri)

        # call the context drag_finished to inform the source about it
        drag_context.finish(True, False, time)

    def on_drag_data_get(self, widget, drag_context, data, info, time):
        '''
        Callback called when the drag destination (playlist) has
        requested what album (icon) has been dragged
        '''

        uris = []
        for album in widget.get_selected_objects():
            for track in album.get_tracks():
                uris.append(track.location)

        data.set_uris(uris)
        # stop the propagation of the signal (deactivates superclass callback)
        widget.stop_emission_by_name('drag-data-get')

    def on_drag_begin(self, widget, context):
        '''
        Callback called when the drag-drop from coverview has started
        Changes the drag icon as appropriate
        '''
        album_number = len(widget.get_selected_objects())

        if album_number == 1:
            item = Gtk.STOCK_DND
        else:
            item = Gtk.STOCK_DND_MULTIPLE

        widget.drag_source_set_icon_stock(item)
        widget.stop_emission_by_name('drag-begin')

    def get_default_manager(self):
        '''
        the default manager for this view is the artist_manager
        '''
        return self.artist_manager