coverart_covericonview.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 gettext

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 Pango
from gi.repository import PangoCairo
from gi.repository import GdkPixbuf

from coverart_widgets import EnhancedIconView
from coverart_browser_prefs import GSetting
from coverart_browser_prefs import CoverLocale
from coverart_album import AlbumsModel
from coverart_widgets import AbstractView
from coverart_widgets import PanedCollapsible
import rb


PLAY_SIZE_X = 30
PLAY_SIZE_Y = 30


class CellRendererThumb(Gtk.CellRendererPixbuf):
    markup = GObject.property(type=str, default="")

    def __init__(self, font_description, cell_area_source):
        super(CellRendererThumb, self).__init__()
        self.font_description = font_description
        self.cell_area_source = cell_area_source

    def do_render(self, cr, widget,
                  background_area,
                  cell_area,
                  flags):

        x_offset = cell_area.x + 1
        y_offset = cell_area.y + 1
        # first paint the cover
        pixbuf = self.props.pixbuf.scale_simple(cell_area.width - 2, cell_area.height - 2,
                                                GdkPixbuf.InterpType.NEAREST)
        Gdk.cairo_set_source_pixbuf(cr, pixbuf, x_offset, y_offset)
        cr.paint()

        alpha = 0.40

        if ((flags & Gtk.CellRendererState.PRELIT) == Gtk.CellRendererState.PRELIT):
            # if the cursor is over the cell then slightly dim
            alpha -= 0.15

            if self.cell_area_source.hover_pixbuf:
                # if a hover pixbuf is given then paint this as well either just above the cover album info
                # of at the bottom of the cell area if album info is not within the cover area
                full, calc_x_offset, calc_y_offset = self.cell_area_source.calc_play_icon_offset(x_offset, y_offset)

                Gdk.cairo_set_source_pixbuf(cr,
                                            self.cell_area_source.hover_pixbuf,
                                            calc_x_offset,
                                            calc_y_offset - PLAY_SIZE_Y)
                cr.paint()

        if not (self.cell_area_source.display_text and self.cell_area_source.display_text_pos == False):
            return

        # the rest of the routine paints the contents of text within a cover if specified

        # PANGO LAYOUT
        layout_width = cell_area.width - 2
        pango_layout = PangoCairo.create_layout(cr)
        pango_layout.set_markup(self.markup, -1)
        pango_layout.set_alignment(self.cell_area_source.text_alignment)
        pango_layout.set_font_description(self.font_description)
        pango_layout.set_width(int(layout_width * Pango.SCALE))
        pango_layout.set_wrap(Pango.WrapMode.WORD_CHAR)
        wi, he = pango_layout.get_pixel_size()

        rect_offset = y_offset + (int((2.0 * self.cell_area_source.cover_size) / 3.0))
        rect_height = int(self.cell_area_source.cover_size / 3.0)

        if he > rect_height:
            pango_layout.set_ellipsize(Pango.EllipsizeMode.END)
            pango_layout.set_height(int((self.cell_area_source.cover_size / 3.0) * Pango.SCALE))
            wi, he = pango_layout.get_pixel_size()

        # RECTANGLE
        cr.set_source_rgba(0.0, 0.0, 0.0, alpha)
        cr.set_line_width(0)
        cr.rectangle(x_offset,
                     rect_offset,
                     cell_area.width - 1,
                     rect_height - 1)
        cr.fill()

        # DRAW FONT
        cr.set_source_rgba(1.0, 1.0, 1.0, 1.0)
        cr.move_to(x_offset,
                   y_offset
                   + 2.0 * self.cell_area_source.cover_size / 3.0
                   + (((self.cell_area_source.cover_size / 3.0) - he) / 2.0)
        )
        PangoCairo.show_layout(cr, pango_layout)


class AlbumArtCellArea(Gtk.CellAreaBox):
    font_family = GObject.property(type=str, default="Sans")
    font_size = GObject.property(type=int, default=10)
    cover_size = GObject.property(type=int, default=0)
    display_text_pos = GObject.property(type=bool, default=False)
    display_text = GObject.property(type=bool, default=False)
    add_shadow = GObject.property(type=bool, default=False)
    hover_pixbuf = GObject.property(type=object, default=None)
    text_alignment = GObject.property(type=int, default=1)

    def __init__(self, ):
        super(AlbumArtCellArea, self).__init__()

        self.font_description = Pango.FontDescription.new()
        self.font_description.set_family(self.font_family)
        self.font_description.set_size(int(self.font_size * Pango.SCALE))

        self._connect_properties()

        # Add own cellrenderer
        renderer_thumb = CellRendererThumb(self.font_description, self)

        self.pack_start(renderer_thumb, False, False, False)
        self.attribute_connect(renderer_thumb, "pixbuf", AlbumsModel.columns['pixbuf'])
        self.attribute_connect(renderer_thumb, "markup", AlbumsModel.columns['markup'])
        self.props.spacing = 2

    def _connect_properties(self):
        gs = GSetting()
        setting = gs.get_setting(gs.Path.PLUGIN)

        setting.bind(gs.PluginKey.COVER_SIZE, self, 'cover-size',
                     Gio.SettingsBindFlags.GET)

        setting.bind(gs.PluginKey.DISPLAY_TEXT_POS, self, 'display-text-pos',
                     Gio.SettingsBindFlags.GET)

        setting.bind(gs.PluginKey.DISPLAY_TEXT, self, 'display-text',
                     Gio.SettingsBindFlags.GET)

        setting.bind(gs.PluginKey.ADD_SHADOW, self, 'add-shadow',
                     Gio.SettingsBindFlags.GET)

        setting.bind(gs.PluginKey.TEXT_ALIGNMENT, self, 'text-alignment',
                     Gio.SettingsBindFlags.GET)


    def calc_play_icon_offset(self, initial_x_offset, initial_y_offset):
        '''
        calculates the x & y offset for the play hover icon
        :param initial_x_offset: current x_offset
        :param initial_y_offset: current y_offset
        :return: bool, x & y offset where bool is the full cover position
        '''
        full_cover = False
        if not (self.display_text and self.display_text_pos == False):
            y_offset = initial_y_offset + self.cover_size - 10
            full_cover = True
        else:
            y_offset = initial_y_offset + (int((2.0 * self.cover_size) / 3.0))

        x_offset = initial_x_offset
        if self.add_shadow:
            x_offset = initial_x_offset + 10
            y_offset = y_offset - 10

        return full_cover, x_offset, y_offset


class AlbumShowingPolicy(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, cover_view):
        super(AlbumShowingPolicy, self).__init__()

        self._cover_view = cover_view  # this will need to be reworked for all views
        self._visible_paths = None
        self._has_initialised = False

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

        self._album_manager = album_manager
        self._model = album_manager.model
        self._connect_signals()
        self._has_initialised = True

    def _connect_signals(self):
        self._cover_view.props.vadjustment.connect('value-changed',
                                                   self._viewport_changed)
        self._model.connect('album-updated', self._album_updated)
        self._model.connect('visual-updated', self._album_updated)

    def _viewport_changed(self, *args):
        visible_range = self._cover_view.get_visible_range()

        if visible_range:
            init, end = visible_range

            # i have to use the tree iter instead of the path to iterate since
            # for some reason path.next doesn't work with the filtermodel
            tree_iter = self._model.store.get_iter(init)

            self._visible_paths = []

            while init and init != end:
                self._visible_paths.append(init)

                tree_iter = self._model.store.iter_next(tree_iter)
                init = self._model.store.get_path(tree_iter)

            self._visible_paths.append(end)

    def _album_updated(self, model, album_path, album_iter):
        # get the currently showing paths
        if not self._visible_paths:
            self._viewport_changed()

        if (album_path and self._visible_paths) and album_path in self._visible_paths:
            # if our path is on the viewport, emit the signal to update it
            self._cover_view.queue_draw()


class CoverIconView(EnhancedIconView, AbstractView):
    __gtype_name__ = "CoverIconView"

    icon_spacing = GObject.property(type=int, default=0)
    icon_padding = GObject.property(type=int, default=0)
    icon_automatic = GObject.property(type=bool, default=True)

    display_text_enabled = GObject.property(type=bool, default=False)
    display_text_pos = GObject.property(type=bool, default=False)
    name = 'coverview'
    panedposition = PanedCollapsible.Paned.COLLAPSE
    text_alignment = GObject.property(type=int, default=1)

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

    def __init__(self, *args, **kwargs):
        super(CoverIconView, self).__init__(cell_area=AlbumArtCellArea(), *args, **kwargs)

        self.gs = GSetting()
        # custom text renderer
        self._text_renderer = None
        self.show_policy = AlbumShowingPolicy(self)
        self.view = self
        self._has_initialised = False
        self._last_path = None
        self._calc_motion_step = 0
        self.set_selection_mode(Gtk.SelectionMode.MULTIPLE)
        self.object_column = AlbumsModel.columns['album']

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

        self._has_initialised = True

        self.view_name = "covers_view"
        super(CoverIconView, self).initialise(source)

        self.shell = source.shell
        self.album_manager = source.album_manager

        # 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)
        self.source.paned.connect("expanded", self.bottom_expander_expanded_callback)

        # lastly support drag-drop from coverart to devices/nautilus etc
        self.connect('drag-begin', self.on_drag_begin)
        self.enable_model_drag_source(Gdk.ModifierType.BUTTON1_MASK,
            [], Gdk.DragAction.COPY)
        # targets = Gtk.TargetList.new([Gtk.TargetEntry.new("application/x-rhythmbox-entry", 0, 0),
        # Gtk.TargetEntry.new("text/uri-list", 0, 1) ])
        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
        targets.add_uri_targets(1)

        self.drag_source_set_target_list(targets)
        self.connect("drag-data-get", self.on_drag_data_get)

        # set the model to the view
        # self.set_pixbuf_column(AlbumsModel.columns['pixbuf'])
        self.set_model(self.album_manager.model.store)

        # setup view to monitor mouse movements
        self.add_events(Gdk.EventMask.POINTER_MOTION_MASK)

        self.hover_pixbufs = {
            'button_play': None,
            'button_play_hover': None,
            'button_playpause': None,
            'button_playpause_hover': None,
            'button_queue': None,
            'button_queue_hover': None,
        }

        for pixbuf_type in self.hover_pixbufs:
            filename = 'img/' + pixbuf_type + '.png'
            filename = rb.find_plugin_file(self.plugin, filename)
            self.hover_pixbufs[pixbuf_type] = GdkPixbuf.Pixbuf.new_from_file_at_size(filename,
                                                                                     PLAY_SIZE_X,
                                                                                     PLAY_SIZE_Y)

        self._connect_properties()
        self._connect_signals()

        self._activate_markup()
        self.on_notify_icon_padding()
        self.on_notify_icon_spacing()

    def _connect_properties(self):
        setting = self.gs.get_setting(self.gs.Path.PLUGIN)
        setting.bind(
            self.gs.PluginKey.ICON_SPACING,
            self,
            'icon_spacing',
            Gio.SettingsBindFlags.GET)
        setting.bind(
            self.gs.PluginKey.ICON_PADDING,
            self,
            'icon_padding',
            Gio.SettingsBindFlags.GET)

        setting.bind(self.gs.PluginKey.DISPLAY_TEXT, self,
                     'display_text_enabled', Gio.SettingsBindFlags.GET)

        setting.bind(self.gs.PluginKey.ICON_AUTOMATIC, self,
                     'icon_automatic', Gio.SettingsBindFlags.GET)

        setting.bind(self.gs.PluginKey.DISPLAY_TEXT_POS, self,
                     'display-text-pos', Gio.SettingsBindFlags.GET)

        setting.bind(self.gs.PluginKey.TEXT_ALIGNMENT, self,
                     'text-alignment', Gio.SettingsBindFlags.GET)

    def _connect_signals(self):
        self.connect("item-clicked", self.item_clicked_callback)
        self.connect("selection-changed", self.selectionchanged_callback)
        self.connect("item-activated", self.item_activated_callback)
        self.connect('notify::icon-spacing',
                     self.on_notify_icon_spacing)
        self.connect('notify::icon-padding',
                     self.on_notify_icon_padding)
        self.connect('notify::display-text-enabled',
                     self._activate_markup)
        self.connect('notify::display-text-pos',
                     self._activate_markup)
        self.connect('notify::text-alignment',
                     self._create_and_configure_renderer)
        self.connect("motion-notify-event", self.on_pointer_motion)

        self.add_events(Gdk.EventMask.SCROLL_MASK)
        self.connect("scroll-event", self.on_scroll_event)

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

    def resize_icon(self, cover_size):
        '''
        Callback called when to resize the icon
        [common to all views]
        '''
        self.set_item_width(cover_size)

    def on_scroll_event(self, widget, scroll_event):
        if scroll_event.state & Gdk.ModifierType.CONTROL_MASK:
            settings = self.gs.get_setting(self.gs.Path.PLUGIN)
            cover_size = settings[self.gs.PluginKey.COVER_SIZE]
            if scroll_event.direction == Gdk.ScrollDirection.UP:
                if cover_size <= 195:
                    settings[self.gs.PluginKey.COVER_SIZE] = cover_size + 5
            elif scroll_event.direction == Gdk.ScrollDirection.DOWN:
                if cover_size >= 55:
                    settings[self.gs.PluginKey.COVER_SIZE] = cover_size - 5
            elif scroll_event.direction == Gdk.ScrollDirection.SMOOTH:
                delta = scroll_event.delta_y
                print (delta)
                if delta < 0 and cover_size <= 195: # negative delta means scroll up
                    settings[self.gs.PluginKey.COVER_SIZE] = cover_size - int(delta * 5)
                if delta > 0 and cover_size >= 55: # positive delta means scroll down
                    settings[self.gs.PluginKey.COVER_SIZE] = cover_size - int(delta * 5)

            GLib.idle_add(self.queue_draw)

            return True

    def on_drag_drop(self, widget, context, x, y, time):
        '''
        Callback called when a drag operation finishes over the cover 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
        path, pos = widget.get_dest_item_at_pos(x, y)
        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 album and the info and ask the loader to update the cover
        path, pos = widget.get_dest_item_at_pos(x, y)
        album = widget.get_model()[path][2]

        pixbuf = data.get_pixbuf()

        if pixbuf:
            self.album_manager.cover_man.update_cover(album, pixbuf)
        else:
            uri = data.get_text()
            self.album_manager.cover_man.update_cover(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)

        sel = 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 _cover_play_hotspot(self, path, in_vacinity=False):
        if path:
            valid, rect = self.get_cell_rect(path, None)  # rect of widget coords

            cursor_x, cursor_y = self.get_pointer()  # returns widget coords
            c_x = cursor_x - rect.x - (self.icon_padding / 2) - (self.icon_spacing / 2)
            c_y = cursor_y - rect.y - (self.icon_padding / 2) - (self.icon_spacing / 2)

            sizing = (rect.width / 3) if in_vacinity else 0

            full, x_offset, y_offset = self.props.cell_area.calc_play_icon_offset(0, 0)
            if full and c_y > y_offset:
                return False

            y_offset = y_offset - PLAY_SIZE_Y

            if (y_offset - PLAY_SIZE_Y) < 0:
                return False

            if c_x < (PLAY_SIZE_X + sizing + x_offset) and \
                            c_y < (PLAY_SIZE_Y + sizing + y_offset) and \
                            c_x > x_offset and \
                            c_y > (y_offset - sizing):
                return True

                # c_y 0 value at top - largest at bottom of the cover
        return False

    def on_pointer_motion(self, widget, event):
        self._current_mouse_x = event.x
        self._current_mouse_y = event.y

        if self._calc_motion_step == 0:
            self._calc_motion_step = 1
            Gdk.threads_add_timeout(GLib.PRIORITY_DEFAULT_IDLE, 100,
                                    self._calculate_hotspot)
        else:
            path = self.get_path_at_pos(self._current_mouse_x,
                                        self._current_mouse_y)

            if not self._last_path or self._last_path != path:
                self._display_icon(None, self._last_path)

    def _display_icon(self, icon, path):
        self.props.cell_area.hover_pixbuf = icon
        if path and self.props.window:
            valid, rect = self.get_cell_rect(path, None)
            self.props.window.invalidate_rect(rect, True)

        self.queue_draw()

    def _calculate_hotspot(self, *args):

        path = self.get_path_at_pos(self._current_mouse_x,
                                    self._current_mouse_y)

        # if the current path was not the same as the last path then
        # reset the counter
        if not self._last_path or self._last_path != path:
            self._display_icon(None, self._last_path)
            self._last_path = path
            self._calc_motion_step = 0
            return False

        self._calc_motion_step = self._calc_motion_step + 1

        # if havent yet reached the requisite number of steps then
        # let the thread roll to the next increment
        if self._calc_motion_step < 8:
            return True

        if not self._cover_play_hotspot(path, in_vacinity=True):
            # we are not near the hot-spot so decrement the counter
            # hoping next time around we are near
            self._calc_motion_step = self._calc_motion_step - 1
            self._display_icon(None, self._last_path)
            return True

        # from  here on in, we are going to display a hotspot icon
        # so lets decide which one

        (_, playing) = self.shell.props.shell_player.get_playing()

        calc_path = -1
        if playing:
            entry = self.shell.props.shell_player.get_playing_entry()
            album = self.album_manager.model.get_from_dbentry(entry)
            calc_path = self.album_manager.model.get_path(album)

        if playing and calc_path == path:
            icon = 'button_playpause'
        elif playing:
            icon = 'button_queue'
        else:
            icon = 'button_play'

        # now we've got the icon - lets double check that we are
        # actually hovering exactly on the hotspot because the icon will visually change

        exact_hotspot = self._cover_play_hotspot(path)
        if exact_hotspot:
            icon = icon + '_hover'

        hover = self.hover_pixbufs[icon]

        self._display_icon(hover, path)
        self._calc_motion_step = self._calc_motion_step - 1

        return True

    def item_clicked_callback(self, iconview, event, path):
        '''
        Callback called when the user clicks somewhere on the cover_view.
        Along with source "show_hide_pane", takes care of showing/hiding the bottom
        pane after a second click on a selected album.
        '''

        # first test if we've clicked on the cover-play icon
        if self._cover_play_hotspot(path):
            (_, playing) = self.shell.props.shell_player.get_playing()

            # first see if anything is playing...
            if playing:
                entry = self.shell.props.shell_player.get_playing_entry()
                album = self.album_manager.model.get_from_dbentry(entry)

                # if the current playing entry corresponds to the album
                # we are hovering over then we are requesting to pause
                if self.album_manager.model.get_from_path(path) == album:
                    self._last_path = path
                    self.shell.props.shell_player.pause()
                    self.on_pointer_motion(self, event)
                    return

            # this must be a new album so we are asking just
            # to play this new album ... just need a short interval
            # for the selection event to kick in first
            def delay(*args):
                if playing:  # if we are playing then queue up the next album
                    self.source.queue_selected_album(None, self.source.favourites)
                    album = self.get_selected_objects()[0]
                    cl = CoverLocale()
                    cl.switch_locale(cl.Locale.LOCALE_DOMAIN)
                    message = gettext.gettext('Album has added to list of playing albums')
                    self.display_notification(album.name,
                                              message,
                                              album.cover.original)
                else:  # otherwise just play it
                    self._last_path = path
                    self.source.play_selected_album(self.source.favourites)

                icon = 'button_play_hover'
                self.props.cell_area.hover_pixbuf = \
                    self.hover_pixbufs[icon]

            Gdk.threads_add_timeout(GLib.PRIORITY_DEFAULT_IDLE, 250,
                                    delay, None)

            return

        # to expand the entry view
        ctrl = event.state & Gdk.ModifierType.CONTROL_MASK
        shift = event.state & Gdk.ModifierType.SHIFT_MASK

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

        if self.source.click_count == 1:
            album = self.album_manager.model.get_from_path(path) \
                if path else None
            Gdk.threads_add_timeout(GLib.PRIORITY_DEFAULT_IDLE, 250,
                                    self.source.show_hide_pane, album)

    def item_activated_callback(self, iconview, path):
        '''
        Callback called when the cover view is double clicked or space-bar
        is pressed. It plays the selected album
        '''
        self.source.play_selected_album(self.source.favourites)

        return True

    def on_notify_icon_padding(self, *args):
        '''
        Callback called when the icon-padding gsetting value is changed
        '''
        self.set_item_padding(self.icon_padding)

    def on_notify_icon_spacing(self, *args):
        '''
        Callback called when the icon-spacing gsetting value is changed
        '''
        self.set_row_spacing(self.icon_spacing)
        self.set_column_spacing(self.icon_spacing)

    def _create_and_configure_renderer(self, *args):
        if not self._text_renderer:
            # Add own cellrenderer
            self._text_renderer = Gtk.CellRendererText()

        self._text_renderer.props.alignment = self.text_alignment
        self._text_renderer.props.wrap_mode = Pango.WrapMode.WORD
        if self.text_alignment == 1:
            self._text_renderer.props.xalign = 0.5
        elif self.text_alignment == 0:
            self._text_renderer.props.xalign = 0
        else:
            self._text_renderer.props.xalign = 1

        self._text_renderer.props.yalign = 0
        self._text_renderer.props.width = \
            self.album_manager.cover_man.cover_size
        self._text_renderer.props.wrap_width = \
            self.album_manager.cover_man.cover_size

    def _activate_markup(self, *args):
        '''
        Utility method to activate/deactivate the markup text on the
        cover view.
        '''
        if self.display_text_enabled and self.display_text_pos:
            if not self._text_renderer:
                # create and configure the custom cell renderer
                self._create_and_configure_renderer()

            # set the renderer
            self.pack_end(self._text_renderer, False)
            self.add_attribute(self._text_renderer,
                               'markup', AlbumsModel.columns['markup'])
        elif self._text_renderer:
            # remove the cell renderer
            self.props.cell_area.remove(self._text_renderer)

        if self.display_text_enabled:
            self.set_tooltip_column(-1)  # turnoff tooltips
        else:
            self.set_tooltip_column(AlbumsModel.columns['tooltip'])

    def bottom_expander_expanded_callback(self, paned, expand):
        '''
        Callback connected to expanded signal of the paned GtkExpander
        '''
        if expand:
            # accommodate the viewport if there's an album selected
            if self.source.last_selected_album:
                def scroll_to_album(*args):
                    # accommodate the viewport if there's an album selected
                    path = self.album_manager.model.get_path(
                        self.source.last_selected_album)

                    self.scroll_to_path(path, False, 0, 0)

                    return False

                Gdk.threads_add_idle(GObject.PRIORITY_DEFAULT_IDLE,
                                     scroll_to_album, None)


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

        self.scroll_to_album(album)

    def grab_focus(self):
        super(EnhancedIconView, self).grab_focus()