coverart_controllers.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.

from datetime import date
from collections import OrderedDict
from collections import namedtuple

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

from coverart_browser_prefs import CoverLocale
from coverart_browser_prefs import GSetting
from coverart_utils import create_pixbuf_from_file_at_size
from coverart_utils import GenreConfiguredSpriteSheet
from coverart_utils import ConfiguredSpriteSheet
from coverart_utils import get_stock_size
from coverart_utils import CaseInsensitiveDict
from coverart_utils import Theme
import rb


MenuNodeT = namedtuple('MenuNode', 'label menutype typevalue')


def MenuNode(label, menutype=None, typevalue=None):
    return MenuNodeT(label, menutype, typevalue)


class OptionsController(GObject.Object):
    # properties
    options = GObject.property(type=object, default=None)
    current_key = GObject.property(type=str, default=None)
    update_image = GObject.property(type=bool, default=False)
    enabled = GObject.property(type=bool, default=True)

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

        # connect the variations on the current key to the controllers action
        self.connect('notify::current-key', self._do_action)

    def get_current_key_index(self):
        return self.options.index(self.current_key)

    def option_selected(self, key):
        if key != self.current_key:
            # update the current value
            self.current_key = key

    def _do_action(self, *args):
        self.do_action()

    def do_action(self):
        pass

    def get_current_image(self):
        return None

    def get_current_description(self):
        return self.current_key

    def update_images(self, *args):
        pass

    def create_spritesheet(self, plugin, sheet, typestr):
        '''
        helper function to create a specific spritesheet
        '''
        if sheet:
            del sheet

        return ConfiguredSpriteSheet(plugin, typestr, get_stock_size())

    def create_button_image(self, plugin, image, icon_name):
        '''
        helper function to create a button image
        '''
        if image:
            del image

        path = 'img/' + Theme(self.plugin).current + '/'

        return create_pixbuf_from_file_at_size(
            rb.find_plugin_file(self.plugin, path + icon_name),
            *get_stock_size())


class PlaylistPopupController(OptionsController):
    def __init__(self, plugin, album_model):
        super(PlaylistPopupController, self).__init__()

        self._album_model = album_model

        shell = plugin.shell
        self.plugin = plugin

        # get the library name and initialize the superclass with it
        self._library_name = shell.props.library_source.props.name

        # get the queue name
        self._queue_name = shell.props.queue_source.props.name

        if " (" in self._queue_name:
            self._queue_name = self._queue_name[0:self._queue_name.find(" (")]

        self._spritesheet = None
        self._update_options(shell)

        # get the playlist model so we can monitor changes
        playlist_model = shell.props.display_page_model

        # connect signals to update playlists
        playlist_model.connect('row-inserted', self._update_options, shell)
        playlist_model.connect('row-deleted', self._update_options, shell)
        playlist_model.connect('row-changed', self._update_options, shell)

    def update_images(self, *args):
        self._spritesheet = self.create_spritesheet(self.plugin,
                                                    self._spritesheet, 'playlist')

        if args[-1]:
            self.update_image = True

    def _update_options(self, *args):
        shell = args[-1]
        self.update_images(False)

        playlist_manager = shell.props.playlist_manager
        still_exists = self.current_key == self._library_name or \
                       self.current_key == self._queue_name

        # retrieve the options
        values = OrderedDict()

        # library and play queue sources
        values[self._library_name] = None
        values[self._queue_name] = shell.props.queue_source

        # playlists
        playlists_entries = playlist_manager.get_playlists()

        for playlist in playlists_entries:
            if playlist.props.is_local:
                name = playlist.props.name
                values[name] = playlist

                still_exists = still_exists or name == self.current_key

        self.values = values
        self.options = list(values.keys())

        self.current_key = self.current_key if still_exists else \
            self._library_name

    def do_action(self):
        playlist = self.values[self.current_key]

        if not playlist:
            self._album_model.remove_filter('model')
        else:
            self._album_model.replace_filter('model',
                                             playlist.get_query_model())

    def get_current_image(self):
        playlist = self.values[self.current_key]

        if self.current_key == self._library_name:
            image = self._spritesheet['music']
        elif self._queue_name in self.current_key:
            image = self._spritesheet['queue']
        elif isinstance(playlist, RB.StaticPlaylistSource):
            image = self._spritesheet['playlist']
        else:
            image = self._spritesheet['smart']

        return image


class GenrePopupController(OptionsController):
    # properties
    new_genre_icon = GObject.property(type=bool, default=False)

    def __init__(self, plugin, album_model):
        super(GenrePopupController, self).__init__()

        cl = CoverLocale()
        cl.switch_locale(cl.Locale.LOCALE_DOMAIN)

        self._album_model = album_model

        shell = plugin.shell
        self.plugin = plugin

        # create a new property model for the genres
        genres_model = RB.RhythmDBPropertyModel.new(shell.props.db,
                                                    RB.RhythmDBPropType.GENRE)

        query = shell.props.library_source.props.base_query_model
        genres_model.props.query_model = query

        # initial genre
        self._initial_genre = _('All Genres')

        self._spritesheet = None
        self._default_image = None
        self._unrecognised_image = None

        self._connect_properties()
        self._connect_signals(query, genres_model)

        # generate initial popup
        self._update_options(genres_model)

    def update_images(self, *args):
        if self._spritesheet:
            del self._spritesheet

        self._spritesheet = GenreConfiguredSpriteSheet(self.plugin,
                                                       'genre', get_stock_size())
        self._default_image = self.create_button_image(self.plugin,
                                                       self._default_image, 'default_genre.png')
        self._unrecognised_image = self.create_button_image(self.plugin,
                                                            self._unrecognised_image, 'unrecognised_genre.png')

        if args[-1]:
            self.update_image = True

    def _connect_signals(self, query, genres_model):
        # connect signals to update genres
        self.connect('notify::new-genre-icon', self._update_options, genres_model)
        query.connect('row-inserted', self._update_options, genres_model)
        query.connect('row-deleted', self._update_options, genres_model)
        query.connect('row-changed', self._update_options, genres_model)

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

        setting.bind(gs.PluginKey.NEW_GENRE_ICON, self, 'new_genre_icon',
                     Gio.SettingsBindFlags.GET)

    def _update_options(self, *args):
        genres_model = args[-1]

        self.update_images(False)

        still_exists = False

        # retrieve the options
        options = []
        row_num = 0
        for row in genres_model:
            if row_num == 0:
                cl = CoverLocale()
                cl.switch_locale(cl.Locale.LOCALE_DOMAIN)
                genre = _('All Genres')
                row_num = row_num + 1
            else:
                genre = row[0]

            options.append(genre)

            still_exists = still_exists or genre == self.current_key

        self.options = options

        self.current_key = self.current_key if still_exists else \
            self._initial_genre

    def do_action(self):
        '''
        called when genre popup menu item chosen
        return None if the first entry in popup returned
        '''
        if self.current_key == self._initial_genre:
            self._album_model.remove_filter('genre')
        else:
            self._album_model.replace_filter('genre', self.current_key)

    def get_current_image(self):
        test_genre = self.current_key.lower()

        if test_genre == self._initial_genre.lower():
            image = self._default_image
        else:
            image = self._find_alternates(test_genre)

            if image == self._unrecognised_image and \
                            test_genre in self._spritesheet:
                image = self._spritesheet[test_genre]

        return image

    def _find_alternates(self, test_genre):
        # the following genre checks are required
        # 1. if we have user defined genres
        # 2. then check locale specific system genres
        # 3. then check local specific alternates
        # 4. then check if we system genres

        # where necessary check if any of the genres are a substring
        # of test_genre - check in reverse order so that we
        # test largest strings first (prevents spurious matches with
        # short strings)
        # N.B. we use RB.search_fold since the strings can be
        # in a mixture of cases, both unicode (normalized or not) and str
        # and as usual python cannot mix and match these types.


        test_genre = RB.search_fold(test_genre)

        ret, sprite = self._match_genres(test_genre, self._spritesheet.GENRE_USER)
        if ret:
            return sprite

        for genre in sorted(self._spritesheet.locale_names,
                            key=lambda b: (-len(b), b)):
            if RB.search_fold(genre) in test_genre:
                return self._spritesheet[self._spritesheet.locale_names[genre]]

        # next check locale alternates
        ret, sprite = self._match_genres(test_genre, self._spritesheet.GENRE_LOCALE)
        if ret:
            return sprite

        ret, sprite = self._match_genres(test_genre, self._spritesheet.GENRE_SYSTEM)
        if ret:
            return sprite

        # check if any of the default genres are a substring
        # of test_genre - check in reverse order so that we
        # test largest strings first (prevents spurious matches with
        # short strings)
        for genre in sorted(self._spritesheet.names,
                            key=lambda b: (-len(b), b)):
            if RB.search_fold(genre) in test_genre:
                return self._spritesheet[genre]

        # if no matches then default to unrecognised image
        return self._unrecognised_image

    def _match_genres(self, test_genre, genre_type):
        case_search = CaseInsensitiveDict(
            dict((k.name, v) for k, v in self._spritesheet.genre_alternate.items()
                 if k.genre_type == genre_type))

        if test_genre in case_search:
            return (True, self._spritesheet[case_search[test_genre]])
        else:
            return (False, None)


    def get_current_description(self):
        cl = CoverLocale()
        cl.switch_locale(cl.Locale.LOCALE_DOMAIN)
        if self.current_key == self._initial_genre:
            return _('All Genres')
        else:
            return self.current_key


class SortPopupController(OptionsController):
    def __init__(self, plugin, viewmgr):
        super(SortPopupController, self).__init__()

        self._viewmgr = viewmgr
        self.plugin = plugin
        # sorts dictionary
        cl = CoverLocale()
        cl.switch_locale(cl.Locale.LOCALE_DOMAIN)

        self.values = OrderedDict([(_('Sort by album name'), 'name'),
                                   (_('Sort by album artist'), 'artist'),
                                   (_('Sort by year'), 'year'),
                                   (_('Sort by rating'), 'rating')])

        self.options = list(self.values.keys())

        # get the current sort key and initialise the superclass
        gs = GSetting()
        source_settings = gs.get_setting(gs.Path.PLUGIN)
        value = source_settings[gs.PluginKey.SORT_BY]

        self._spritesheet = None
        self.update_images(False)

        self.current_key = list(self.values.keys())[
            list(self.values.values()).index(value)]

    def update_images(self, *args):
        self._spritesheet = self.create_spritesheet(self.plugin,
                                                    self._spritesheet, 'sort')

        if args[-1]:
            self.update_image = True

    def do_action(self):
        sort = self.values[self.current_key]

        gs = GSetting()
        settings = gs.get_setting(gs.Path.PLUGIN)
        settings[gs.PluginKey.SORT_BY] = sort

        self._viewmgr.current_view.get_default_manager().emit('sort', "album")

    def get_current_image(self):
        sort = self.values[self.current_key]
        return self._spritesheet[sort]


class ArtistSortPopupController(OptionsController):
    def __init__(self, plugin, viewmgr):
        super(ArtistSortPopupController, self).__init__()

        self._viewmgr = viewmgr
        self.plugin = plugin
        # sorts dictionary
        cl = CoverLocale()
        cl.switch_locale(cl.Locale.LOCALE_DOMAIN)

        self.values = OrderedDict([(_('Sort by album name'), 'name_artist'),
                                   (_('Sort by year'), 'year_artist'),
                                   (_('Sort by rating'), 'rating_artist')])

        self.options = list(self.values.keys())

        # get the current sort key and initialise the superclass
        gs = GSetting()
        source_settings = gs.get_setting(gs.Path.PLUGIN)
        value = source_settings[gs.PluginKey.SORT_BY_ARTIST]

        if value not in list(self.values.values()):
            print("here")
            value = 'name_artist'
            source_settings[gs.PluginKey.SORT_BY_ARTIST] = value

        self._spritesheet = None
        self.update_images(False)

        self.current_key = list(self.values.keys())[
            list(self.values.values()).index(value)]
        print(self.current_key)

    def update_images(self, *args):
        self._spritesheet = self.create_spritesheet(self.plugin,
                                                    self._spritesheet, 'sort_artist')

        if args[-1]:
            self.update_image = True

    def do_action(self):
        sort = self.values[self.current_key]

        gs = GSetting()
        settings = gs.get_setting(gs.Path.PLUGIN)
        settings[gs.PluginKey.SORT_BY_ARTIST] = sort

        self._viewmgr.current_view.get_default_manager().emit('sort', "artist")

    def get_current_image(self):
        sort = self.values[self.current_key]
        return self._spritesheet[sort]


class PropertiesMenuController(OptionsController):
    favourites = GObject.property(type=bool, default=False)
    follow = GObject.property(type=bool, default=False)

    def __init__(self, plugin, source):
        super(PropertiesMenuController, self).__init__()

        self._source = source
        self.plugin = plugin
        self._connect_properties()
        # sorts dictionary
        cl = CoverLocale()
        cl.switch_locale(cl.Locale.LOCALE_DOMAIN)
        # options
        self.values = OrderedDict()
        self.values[MenuNode(_('Download all covers'))] = 'download'
        self.values[MenuNode(_('Play random album'))] = 'random'
        self.values[MenuNode(_('Follow playing song'), 'check',
                             (True if self.follow else False))] = 'follow'
        self.values[MenuNode('separator1', 'separator')] = ''
        self.values[MenuNode(_('Use favourites only'), 'check',
                             (True if self.favourites else False))] = 'favourite'
        self.values[MenuNode('separator2', 'separator')] = ''
        self.values[MenuNode(_('Browser Preferences'))] = 'browser prefs'
        self.values[MenuNode(_('Search Preferences'))] = 'search prefs'

        self.options = list(self.values.keys())

        self.update_images(False)

        if self.favourites:
            self._source.propertiesbutton_callback('favourite')

        if self.follow:
            self._source.propertiesbutton_callback('follow')

        self.current_key = None

    def _connect_properties(self):
        gs = GSetting()
        setting = gs.get_setting(gs.Path.PLUGIN)
        setting.bind(
            gs.PluginKey.USE_FAVOURITES,
            self,
            'favourites',
            Gio.SettingsBindFlags.DEFAULT)
        setting.bind(
            gs.PluginKey.FOLLOWING,
            self,
            'follow',
            Gio.SettingsBindFlags.DEFAULT)

    def _change_key(self, dict, old, new):
        for i in range(len(dict)):
            k, v = dict.popitem(False)
            dict[new if old == k else k] = v

    def update_images(self, *args):
        self._image = self.create_button_image(self.plugin,
                                               None, 'properties.png')

        if args[-1]:
            self.update_image = True

    def do_action(self):
        if self.current_key:
            key = [node for node in self.values if node.label == self.current_key]

            if self.current_key == _('Use favourites only'):
                self.favourites = not self.favourites

            if self.current_key == _('Follow playing song'):
                self.follow = not self.follow

            self._source.propertiesbutton_callback(self.values[key[0]])
            self.current_key = None

    def get_current_image(self):
        return self._image

    def get_current_description(self):
        return _('Properties')


class DecadePopupController(OptionsController):
    def __init__(self, plugin, album_model):
        super(DecadePopupController, self).__init__()

        self._album_model = album_model
        self.plugin = plugin

        self._spritesheet = None

        # decade options
        cl = CoverLocale()
        cl.switch_locale(cl.Locale.LOCALE_DOMAIN)

        self.values = OrderedDict()

        self.values[_('All Decades')] = [-1, 'All Decades']
        # '20s' as in the decade 2010
        self.values[_('20s')] = [2020, '20s']
        #'10s' as in the decade 2010
        self.values[_('10s')] = [2010, '10s']
        #'00s' as in the decade 2000
        self.values[_('00s')] = [2000, '00s']
        #'90s' as in the decade 1990
        self.values[_('90s')] = [1990, '90s']
        #'80s' as in the decade 1980
        self.values[_('80s')] = [1980, '80s']
        #'70s' as in the decade 1970
        self.values[_('70s')] = [1970, '70s']
        #'60s' as in the decade 1960
        self.values[_('60s')] = [1960, '60s']
        #'50s' as in the decade 1950
        self.values[_('50s')] = [1950, '50s']
        #'40s' as in the decade 1940
        self.values[_('40s')] = [1940, '40s']
        #'30s' as in the decade 1930
        self.values[_('30s')] = [1930, '30s']
        #'Older' as in 'older than the year 1930'
        self.values[_('Older')] = [-1, 'Older']

        self.options = list(self.values.keys())

        # if we aren't on the 20s yet, remove it
        if date.today().year < 2020:
            self.options.remove(_('20s'))

        # define a initial decade an set the initial key
        self._initial_decade = self.options[0]
        self.update_images(False)

        self.current_key = self._initial_decade

    def update_images(self, *args):
        self._spritesheet = self.create_spritesheet(self.plugin,
                                                    self._spritesheet, 'decade')

        if args[-1]:
            self.update_image = True

    def do_action(self):
        if self.current_key == self._initial_decade:
            self._album_model.remove_filter('decade')
        else:
            self._album_model.replace_filter('decade',
                                             self.values[self.current_key][0])

    def get_current_image(self):
        decade = self.values[self.current_key][1]
        return self._spritesheet[decade]

    def get_current_description(self):
        return self.current_key


class SortOrderToggleController(OptionsController):
    toolbar_type = "album"

    def __init__(self, plugin, viewmgr):
        super(SortOrderToggleController, self).__init__()

        self._viewmgr = viewmgr
        self.plugin = plugin

        # options
        self.values = OrderedDict([(_('Sort in descending order'), False),
                                   (_('Sort in ascending order'), True)])
        self.options = list(self.values.keys())

        self._images = []

        # set the current key
        self.gs = GSetting()
        self.settings = self.gs.get_setting(self.gs.Path.PLUGIN)
        self.key = self.get_key()
        sort_order = self.settings[self.key]
        self.current_key = list(self.values.keys())[
            list(self.values.values()).index(sort_order)]
        self.update_images(False)

    def get_key(self):
        return self.gs.PluginKey.SORT_ORDER

    def update_images(self, *args):
        # initialize images
        if len(self._images) > 0:
            del self._images[:]

        self._images.append(self.create_button_image(self.plugin,
                                                     None, 'arrow_down.png'))
        self._images.append(self.create_button_image(self.plugin,
                                                     None, 'arrow_up.png'))

        if args[-1]:
            self.update_image = True

    def do_action(self):
        sort_order = self.values[self.current_key]
        self.settings[self.key] = sort_order
        self._viewmgr.current_view.get_default_manager().emit('sort', self.toolbar_type)

    def get_current_image(self):
        return self._images[self.get_current_key_index()]


class ArtistSortOrderToggleController(SortOrderToggleController):
    toolbar_type = "artist"

    def __init__(self, plugin, model):
        super(ArtistSortOrderToggleController, self).__init__(plugin, model)

    def get_key(self):
        return self.gs.PluginKey.SORT_ORDER_ARTIST


class AlbumSearchEntryController(OptionsController):
    # properties
    search_text = GObject.property(type=str, default='')

    def __init__(self, album_model):
        super(AlbumSearchEntryController, self).__init__()

        self._album_model = album_model
        self._filter_type = 'all'

        # options
        self.values = OrderedDict()
        self.values[_('Search all fields')] = 'all'
        self.values[_('Search album artists')] = 'album_artist'
        self.values[_('Search track artists')] = 'artist'
        self.values[_('Search composers')] = 'composers'
        self.values[_('Search albums')] = 'album_name'
        self.values[_('Search titles')] = 'track'

        self.options = list(self.values.keys())
        self.current_key = list(self.values.keys())[0]

        self._typing = False
        self._typing_counter = 0
        self._current_search_text = ""

    def do_action(self):
        # remove old filter
        self._album_model.remove_filter(self._filter_type, False)

        # assign the new filter
        self._filter_type = self.values[self.current_key]

        self.do_search(self.search_text, True)

    def _search_typing(self, *args):
        self._typing_counter = self._typing_counter + 1

        if self._typing_counter >= 4 and self._typing:
            self._typing = False
            self._change_filter(self._current_search_text, False)

        return self._typing

    def _change_filter(self, search_text, force):
        # self.search_text = search_text
        self._current_search_text = search_text

        if search_text:
            self._album_model.replace_filter(self._filter_type,
                                             search_text)
        elif not force:
            self._album_model.remove_filter(self._filter_type)

    def do_search(self, search_text, force=False):
        '''
        if self.search_text != search_text or force:
            self.search_text = search_text

            if search_text:
                self._album_model.replace_filter(self._filter_type,
                    search_text)
            elif not force:
                self._album_model.remove_filter(self._filter_type)

        '''
        # self.search_text = search_text
        if force:
            self._typing_counter = 99
            self._typing = False
            self._change_filter(search_text, force)
            return

        if self._current_search_text != search_text:

            #self.search_text = search_text
            self._current_search_text = search_text
            self._typing_counter = 0

            if not self._typing:
                self._typing = True

                Gdk.threads_add_timeout(GLib.PRIORITY_DEFAULT_IDLE, 100,
                                        self._search_typing)


class AlbumQuickSearchController(object):
    def __init__(self, album_manager):
        self._album_manager = album_manager

    def connect_quick_search(self, quick_search):
        quick_search.connect('quick-search', self._on_quick_search)
        quick_search.connect('arrow-pressed', self._on_arrow_pressed)
        quick_search.connect('hide', self._on_hide)

    def _on_quick_search(self, quick_search, search_text, *args):
        album = self._album_manager.model.find_first_visible('album_name',
                                                             search_text)

        if album:
            path = self._album_manager.model.get_path(album)
            self._album_manager.current_view.select_and_scroll_to_path(path)

    def _on_arrow_pressed(self, quick_search, key, *args):
        current = self._album_manager.current_view.get_selected_objects()[0]
        search_text = quick_search.get_text()
        album = None

        if key == Gdk.KEY_Up:
            album = self._album_manager.model.find_first_visible(
                'album_name', search_text, current, True)
        elif key == Gdk.KEY_Down:
            album = self._album_manager.model.find_first_visible(
                'album_name', search_text, current)

        if album:
            path = self._album_manager.model.get_path(album)
            self._album_manager.current_view.select_and_scroll_to_path(path)

    def _on_hide(self, quick_search, *args):
        self._album_manager.current_view.grab_focus()


class ViewController(OptionsController):
    def __init__(self, shell, viewmgr):
        super(ViewController, self).__init__()

        self._viewmgr = viewmgr

        from coverart_browser_source import Views

        views = Views(shell)

        self.values = OrderedDict()
        for view_name in views.get_view_names():
            self.values[views.get_menu_name(view_name)] = view_name
            print(view_name)

        self.options = list(self.values.keys())
        viewmgr.connect('new-view', self.on_notify_view_name)

    def on_notify_view_name(self, *args):
        for key in self.options:
            if self.values[key] == self._viewmgr.view_name:
                self.current_key = key

    def do_action(self):
        if self._viewmgr.view_name != self.values[self.current_key]:
            self._viewmgr.view_name = self.values[self.current_key]